Merge remote-tracking branch 'upstream/master' into rahm

76 files changed, 13570 insertions, 11168 deletions

diff --git a/runtime/doc/api.txt b/runtime/doc/api.txt
index 0daca0de53..c67187d857 100644
--- a/runtime/doc/api.txt
+++ b/runtime/doc/api.txt
@@ -59,7 +59,7 @@ Nvim instance:
     # trailing '&' which is required since Nvim won't process events while
     # running a blocking command):
     #
-    #	:!./hello.rb &
+    #   :!./hello.rb &
     #
     # Or from another shell by setting NVIM_LISTEN_ADDRESS:
     # $ NVIM_LISTEN_ADDRESS=[address] ./hello.rb
@@ -148,9 +148,9 @@ indices, end-inclusive):
 Most API functions are "deferred": they are queued on the main loop and
 processed sequentially with normal input.  So if the editor is waiting for
 user input in a "modal" fashion (e.g. the |hit-enter-prompt|), the request
-will block.  Non-deferred ({fast}) functions such as |nvim_get_mode()| and
+will block.  Non-deferred (fast) functions such as |nvim_get_mode()| and
 |nvim_input()| are served immediately (i.e. without waiting in the input
-queue).  Lua code can use |vim.in_fast_event()| to detect a {fast} context.
+queue).  Lua code can use |vim.in_fast_event()| to detect a fast context.
 
 ==============================================================================
 API metadata						*api-metadata*
@@ -186,7 +186,7 @@ About the `functions` map:
     a type name, e.g. `nvim_buf_get_lines` is the `get_lines` method of
     a Buffer instance. |dev-api|
   - Global functions have the "method=false" flag and are prefixed with just
-    `nvim_`, e.g. `nvim_get_buffers`.
+    `nvim_`, e.g. `nvim_list_bufs`.
 
 							*api-mapping*
 External programs (clients) can use the metadata to discover the API, using
@@ -426,6 +426,14 @@ Two ways to create a floating window:
 
 To close it use |nvim_win_close()| or a command such as |:close|.
 
+To check whether a window is floating, check whether the `relative` option in
+its config is non-empty: >
+
+    if vim.api.nvim_win_get_config(window_id).relative ~= '' then
+      -- window with this window_id is floating
+    end
+>
+
 Buffer text can be highlighted by typical mechanisms (syntax highlighting,
 |api-highlights|). The |hl-NormalFloat| group highlights normal text;
 'winhighlight' can be used as usual to override groups locally. Floats inherit
@@ -434,6 +442,9 @@ to disable various visual features such as the 'number' column.
 
 Currently, floating windows don't support some widgets like scrollbar.
 
+The output of |:mksession| does not include commands for restoring floating
+windows.
+
 Example: create a float with scratch buffer: >
 
     let buf = nvim_create_buf(v:false, v:true)
@@ -452,7 +463,7 @@ Extended marks (extmarks) represent buffer annotations that track text changes
 in the buffer. They can represent cursors, folds, misspelled words, anything
 that needs to track a logical location in the buffer over time. |api-indexing|
 
-Extmark position works like "bar" cursor: it exists between characters. Thus
+Extmark position works like "bar" cursor: it exists between characters. Thus,
 the maximum extmark index on a line is 1 more than the character index: >
 
      f o o b a r      line contents
@@ -468,7 +479,7 @@ extmark position and enter some text, the extmark migrates forward. >
      f o o z|b a r    line (| = cursor)
             4         extmark (after typing "z")
 
-If an extmark is on the last index of a line and you inputs a newline at that
+If an extmark is on the last index of a line and you input a newline at that
 point, the extmark will accordingly migrate to the next line: >
 
      f o o z b a r|   line (| = cursor)
@@ -535,12 +546,12 @@ nvim__get_runtime({pat}, {all}, {*opts})                 *nvim__get_runtime()*
                 Find files in runtime directories
 
                 Attributes: ~
-                    {fast}
+                    |api-fast|
 
                 Parameters: ~
-                    {pat}      pattern of files to search for
-                    {all}      whether to return all matches or only the first
-                    {options}  is_lua: only search lua subdirs
+                    {pat}   pattern of files to search for
+                    {all}   whether to return all matches or only the first
+                    {opts}  is_lua: only search lua subdirs
 
                 Return: ~
                     list of absolute paths to the found files
@@ -594,7 +605,8 @@ nvim__id_float({flt})                                       *nvim__id_float()*
                     its argument.
 
 nvim__inspect_cell({grid}, {row}, {col})                *nvim__inspect_cell()*
-                TODO: Documentation
+                NB: if your UI doesn't use hlstate, this will not return
+                hlstate first time.
 
 nvim__runtime_inspect()                              *nvim__runtime_inspect()*
                 TODO: Documentation
@@ -603,7 +615,7 @@ nvim__screenshot({path})                                  *nvim__screenshot()*
                 TODO: Documentation
 
                 Attributes: ~
-                    {fast}
+                    |api-fast|
 
 nvim__set_hl_ns({ns_id})                                   *nvim__set_hl_ns()*
                 Set active namespace for highlights.
@@ -615,7 +627,7 @@ nvim__set_hl_ns({ns_id})                                   *nvim__set_hl_ns()*
                 cycle.
 
                 Attributes: ~
-                    {fast}
+                    |api-fast|
 
                 Parameters: ~
                     {ns_id}  the namespace to activate
@@ -626,58 +638,11 @@ nvim__stats()                                                  *nvim__stats()*
                 Return: ~
                     Map of various internal stats.
 
-                                                     *nvim_add_user_command()*
-nvim_add_user_command({name}, {command}, {*opts})
-                Create a new user command |user-commands|
-
-                {name} is the name of the new command. The name must begin
-                with an uppercase letter.
-
-                {command} is the replacement text or Lua function to execute.
-
-                Example: >
-                   :call nvim_add_user_command('SayHello', 'echo "Hello world!"', {})
-                   :SayHello
-                   Hello world!
-<
+nvim__unpack({str})                                           *nvim__unpack()*
+                TODO: Documentation
 
-                Parameters: ~
-                    {name}     Name of the new user command. Must begin with
-                               an uppercase letter.
-                    {command}  Replacement command to execute when this user
-                               command is executed. When called from Lua, the
-                               command can also be a Lua function. The
-                               function is called with a single table argument
-                               that contains the following keys:
-                               • args: (string) The args passed to the
-                                 command, if any |<args>|
-                               • bang: (boolean) "true" if the command was
-                                 executed with a ! modifier |<bang>|
-                               • line1: (number) The starting line of the
-                                 command range |<line1>|
-                               • line2: (number) The final line of the command
-                                 range |<line2>|
-                               • range: (number) The number of items in the
-                                 command range: 0, 1, or 2 |<range>|
-                               • count: (number) Any count supplied |<count>|
-                               • reg: (string) The optional register, if
-                                 specified |<reg>|
-                               • mods: (string) Command modifiers, if any
-                                 |<mods>|
-                    {opts}     Optional command attributes. See
-                               |command-attributes| for more details. To use
-                               boolean attributes (such as |:command-bang| or
-                               |:command-bar|) set the value to "true". In
-                               addition to the string options listed in
-                               |:command-complete|, the "complete" key also
-                               accepts a Lua function which works like the
-                               "customlist" completion mode
-                               |:command-completion-customlist|. Additional
-                               parameters:
-                               • desc: (string) Used for listing the command
-                                 when a Lua function is used for {command}.
-                               • force: (boolean, default true) Override any
-                                 previous definition.
+                Attributes: ~
+                    |api-fast|
 
 nvim_call_atomic({calls})                                 *nvim_call_atomic()*
                 Calls many API methods atomically.
@@ -691,6 +656,9 @@ nvim_call_atomic({calls})                                 *nvim_call_atomic()*
                 2. To minimize RPC overhead (roundtrips) of a sequence of many
                    requests.
 
+                Attributes: ~
+                    |RPC| only
+
                 Parameters: ~
                     {calls}  an array of calls, where each call is described
                              by an array with two elements: the request name,
@@ -706,17 +674,21 @@ nvim_call_atomic({calls})                                 *nvim_call_atomic()*
                     be returned.
 
 nvim_chan_send({chan}, {data})                              *nvim_chan_send()*
-                Send data to channel `id` . For a job, it writes it to the
+                Send data to channel `id`. For a job, it writes it to the
                 stdin of the process. For the stdio channel |channel-stdio|,
                 it writes to Nvim's stdout. For an internal terminal instance
-                (|nvim_open_term()|) it writes directly to terimal output. See
-                |channel-bytes| for more information.
+                (|nvim_open_term()|) it writes directly to terminal output.
+                See |channel-bytes| for more information.
 
                 This function writes raw data, not RPC messages. If the
                 channel was created with `rpc=true` then the channel expects
                 RPC messages, use |vim.rpcnotify()| and |vim.rpcrequest()|
                 instead.
 
+                Attributes: ~
+                    |RPC| only
+                    |vim.api| only
+
                 Parameters: ~
                     {chan}  id of the channel
                     {data}  data to write. 8-bit clean: can contain NUL bytes.
@@ -767,12 +739,6 @@ nvim_del_mark({name})                                        *nvim_del_mark()*
                     |nvim_buf_del_mark()|
                     |nvim_get_mark()|
 
-nvim_del_user_command({name})                        *nvim_del_user_command()*
-                Delete a user-defined command.
-
-                Parameters: ~
-                    {name}  Name of the command to delete.
-
 nvim_del_var({name})                                          *nvim_del_var()*
                 Removes a global (g:) variable.
 
@@ -812,7 +778,7 @@ nvim_eval_statusline({str}, {*opts})                  *nvim_eval_statusline()*
                 Evaluates statusline string.
 
                 Attributes: ~
-                    {fast}
+                    |api-fast|
 
                 Parameters: ~
                     {str}   Statusline string (see 'statusline').
@@ -822,10 +788,14 @@ nvim_eval_statusline({str}, {*opts})                  *nvim_eval_statusline()*
                             • maxwidth: (number) Maximum width of statusline.
                             • fillchar: (string) Character to fill blank
                               spaces in the statusline (see 'fillchars').
+                              Treated as single-width even if it isn't.
                             • highlights: (boolean) Return highlight
                               information.
+                            • use_winbar: (boolean) Evaluate winbar instead of
+                              statusline.
                             • use_tabline: (boolean) Evaluate tabline instead
                               of statusline. When |TRUE|, {winid} is ignored.
+                              Mutually exclusive with {use_winbar}.
 
                 Return: ~
                     Dictionary containing statusline information, with these
@@ -846,7 +816,10 @@ nvim_exec_lua({code}, {args})                                *nvim_exec_lua()*
                 inside the chunk. The chunk can return a value.
 
                 Only statements are executed. To evaluate an expression,
-                prefix it with `return` : return my_function(...)
+                prefix it with `return`: return my_function(...)
+
+                Attributes: ~
+                    |RPC| only
 
                 Parameters: ~
                     {code}  Lua code to execute
@@ -855,7 +828,7 @@ nvim_exec_lua({code}, {args})                                *nvim_exec_lua()*
                 Return: ~
                     Return value of Lua code if present or NIL.
 
-nvim_feedkeys({keys}, {mode}, {escape_csi})                  *nvim_feedkeys()*
+nvim_feedkeys({keys}, {mode}, {escape_ks})                   *nvim_feedkeys()*
                 Sends input-keys to Nvim, subject to various quirks controlled
                 by `mode` flags. This is a blocking call, unlike
                 |nvim_input()|.
@@ -863,32 +836,25 @@ nvim_feedkeys({keys}, {mode}, {escape_csi})                  *nvim_feedkeys()*
                 On execution error: does not fail, but updates v:errmsg.
 
                 To input sequences like <C-o> use |nvim_replace_termcodes()|
-                (typically with escape_csi=true) to replace |keycodes|, then
+                (typically with escape_ks=false) to replace |keycodes|, then
                 pass the result to nvim_feedkeys().
 
                 Example: >
                     :let key = nvim_replace_termcodes("<C-o>", v:true, v:false, v:true)
-                    :call nvim_feedkeys(key, 'n', v:true)
+                    :call nvim_feedkeys(key, 'n', v:false)
 <
 
                 Parameters: ~
-                    {keys}        to be typed
-                    {mode}        behavior flags, see |feedkeys()|
-                    {escape_csi}  If true, escape K_SPECIAL/CSI bytes in
-                                  `keys`
+                    {keys}       to be typed
+                    {mode}       behavior flags, see |feedkeys()|
+                    {escape_ks}  If true, escape K_SPECIAL bytes in `keys`
+                                 This should be false if you already used
+                                 |nvim_replace_termcodes()|, and true
+                                 otherwise.
 
                 See also: ~
                     feedkeys()
-                    vim_strsave_escape_csi
-
-nvim_get_all_options_info()                      *nvim_get_all_options_info()*
-                Gets the option information for all options.
-
-                The dictionary has the full option names as keys and option
-                metadata dictionaries as detailed at |nvim_get_option_info|.
-
-                Return: ~
-                    dictionary of all options
+                    vim_strsave_escape_ks
 
 nvim_get_api_info()                                      *nvim_get_api_info()*
                 Returns a 2-tuple (Array), where item 0 is the current channel
@@ -898,7 +864,8 @@ nvim_get_api_info()                                      *nvim_get_api_info()*
                     2-tuple [{channel-id}, {api-metadata}]
 
                 Attributes: ~
-                    {fast}
+                    |api-fast|
+                    |RPC| only
 
 nvim_get_chan_info({chan})                              *nvim_get_chan_info()*
                 Gets information about a channel.
@@ -922,7 +889,7 @@ nvim_get_chan_info({chan})                              *nvim_get_chan_info()*
                     • "pty" (optional) Name of pseudoterminal. On a POSIX
                       system this is a device path like "/dev/pts/1". If the
                       name is unknown, the key will still be present if a pty
-                      is used (e.g. for winpty on Windows).
+                      is used (e.g. for conpty on Windows).
                     • "buffer" (optional) Buffer with connected |terminal|
                       instance.
                     • "client" (optional) Info about the peer (client on the
@@ -953,19 +920,6 @@ nvim_get_color_map()                                    *nvim_get_color_map()*
                 Return: ~
                     Map of color names and RGB values.
 
-nvim_get_commands({*opts})                               *nvim_get_commands()*
-                Gets a map of global (non-buffer-local) Ex commands.
-
-                Currently only |user-commands| are supported, not builtin Ex
-                commands.
-
-                Parameters: ~
-                    {opts}  Optional parameters. Currently only supports
-                            {"builtin":false}
-
-                Return: ~
-                    Map of maps describing commands.
-
 nvim_get_context({*opts})                                 *nvim_get_context()*
                 Gets a map of the current editor state.
 
@@ -1074,66 +1028,16 @@ nvim_get_mode()                                              *nvim_get_mode()*
                     Dictionary { "mode": String, "blocking": Boolean }
 
                 Attributes: ~
-                    {fast}
-
-nvim_get_option({name})                                    *nvim_get_option()*
-                Gets the global value of an option.
-
-                Parameters: ~
-                    {name}  Option name
-
-                Return: ~
-                    Option value (global)
-
-nvim_get_option_info({name})                          *nvim_get_option_info()*
-                Gets the option information for one option
-
-                Resulting dictionary has keys:
-                • name: Name of the option (like 'filetype')
-                • shortname: Shortened name of the option (like 'ft')
-                • type: type of option ("string", "number" or "boolean")
-                • default: The default value for the option
-                • was_set: Whether the option was set.
-                • last_set_sid: Last set script id (if any)
-                • last_set_linenr: line number where option was set
-                • last_set_chan: Channel where option was set (0 for local)
-                • scope: one of "global", "win", or "buf"
-                • global_local: whether win or buf option has a global value
-                • commalist: List of comma separated values
-                • flaglist: List of single char flags
-
-                Parameters: ~
-                    {name}  Option name
-
-                Return: ~
-                    Option Information
-
-nvim_get_option_value({name}, {*opts})               *nvim_get_option_value()*
-                Gets the value of an option. The behavior of this function
-                matches that of |:set|: the local value of an option is
-                returned if it exists; otherwise, the global value is
-                returned. Local values always correspond to the current buffer
-                or window. To get a buffer-local or window-local option for a
-                specific buffer or window, use |nvim_buf_get_option()| or
-                |nvim_win_get_option()|.
-
-                Parameters: ~
-                    {name}  Option name
-                    {opts}  Optional parameters
-                            • scope: One of 'global' or 'local'. Analogous to
-                              |:setglobal| and |:setlocal|, respectively.
-
-                Return: ~
-                    Option value
+                    |api-fast|
 
 nvim_get_proc({pid})                                         *nvim_get_proc()*
-                Gets info describing process `pid` .
+                Gets info describing process `pid`.
 
                 Return: ~
                     Map of process properties, or NIL if process not found.
 
 nvim_get_proc_children({pid})                       *nvim_get_proc_children()*
-                Gets the immediate children of process `pid` .
+                Gets the immediate children of process `pid`.
 
                 Return: ~
                     Array of child process ids, empty if process not found.
@@ -1150,7 +1054,7 @@ nvim_get_runtime_file({name}, {all})                 *nvim_get_runtime_file()*
                 returned then.
 
                 Attributes: ~
-                    {fast}
+                    |api-fast|
 
                 Parameters: ~
                     {name}  pattern of files to search for
@@ -1194,7 +1098,7 @@ nvim_input({keys})                                              *nvim_input()*
                     |api-level| 6.
 
                 Attributes: ~
-                    {fast}
+                    |api-fast|
 
                 Parameters: ~
                     {keys}  to be typed
@@ -1219,7 +1123,7 @@ nvim_input_mouse({button}, {action}, {modifier}, {grid}, {row}, {col})
                     |nvim_input()| has the same limitation.
 
                 Attributes: ~
-                    {fast}
+                    |api-fast|
 
                 Parameters: ~
                     {button}    Mouse button: one of "left", "right",
@@ -1242,8 +1146,8 @@ nvim_input_mouse({button}, {action}, {modifier}, {grid}, {row}, {col})
 nvim_list_bufs()                                            *nvim_list_bufs()*
                 Gets the current list of buffer handles
 
-                Includes unlisted (unloaded/deleted) buffers, like `:ls!` .
-                Use |nvim_buf_is_loaded()| to check if a buffer is loaded.
+                Includes unlisted (unloaded/deleted) buffers, like `:ls!`. Use
+                |nvim_buf_is_loaded()| to check if a buffer is loaded.
 
                 Return: ~
                     List of buffer handles
@@ -1352,7 +1256,7 @@ nvim_paste({data}, {crlf}, {phase})                             *nvim_paste()*
 
                 Errors ('nomodifiable', `vim.paste()` failure, …) are
                 reflected in `err` but do not affect the return value (which
-                is strictly decided by `vim.paste()` ). On error, subsequent
+                is strictly decided by `vim.paste()`). On error, subsequent
                 calls are ignored ("drained") until the next paste is
                 initiated (phase 1 or -1).
 
@@ -1405,7 +1309,7 @@ nvim_replace_termcodes({str}, {from_part}, {do_lt}, {special})
                     {from_part}  Legacy Vim parameter. Usually true.
                     {do_lt}      Also translate <lt>. Ignored if `special` is
                                  false.
-                    {special}    Replace |keycodes|, e.g. <CR> becomes a "\n"
+                    {special}    Replace |keycodes|, e.g. <CR> becomes a "\r"
                                  char.
 
                 See also: ~
@@ -1429,7 +1333,7 @@ nvim_select_popupmenu_item({item}, {insert}, {finish}, {opts})
                     {insert}  Whether the selection should be inserted in the
                               buffer.
                     {finish}  Finish the completion and dismiss the popupmenu.
-                              Implies `insert` .
+                              Implies `insert`.
                     {opts}    Optional parameters. Reserved for future use.
 
                                                       *nvim_set_client_info()*
@@ -1448,6 +1352,9 @@ nvim_set_client_info({name}, {version}, {type}, {methods}, {attributes})
                     "Something is better than nothing". You don't need to
                     include all the fields.
 
+                Attributes: ~
+                    |RPC| only
+
                 Parameters: ~
                     {name}        Short name for the connected client
                     {version}     Dictionary describing the version, with
@@ -1538,25 +1445,58 @@ nvim_set_current_win({window})                        *nvim_set_current_win()*
                 Parameters: ~
                     {window}  Window handle
 
-nvim_set_hl({ns_id}, {name}, {val})                            *nvim_set_hl()*
-                Set a highlight group.
+nvim_set_hl({ns_id}, {name}, {*val})                           *nvim_set_hl()*
+                Sets a highlight group.
 
-                TODO: ns_id = 0, should modify :highlight namespace TODO val
-                should take update vs reset flag
+                Note:
+                    Unlike the `:highlight` command which can update a
+                    highlight group, this function completely replaces the
+                    definition. For example: `nvim_set_hl(0, 'Visual', {})`
+                    will clear the highlight group 'Visual'.
 
-                Parameters: ~
-                    {ns_id}  number of namespace for this highlight
-                    {name}   highlight group name, like ErrorMsg
-                    {val}    highlight definition map, like
-                             |nvim_get_hl_by_name|. in addition the following
-                             keys are also recognized: `default` : don't
-                             override existing definition, like `hi default`
-                             `ctermfg` : sets foreground of cterm color
-                             `ctermbg` : sets background of cterm color
-                             `cterm` : cterm attribute map. sets attributed
-                             for cterm colors. similer to `hi cterm` Note: by
-                             default cterm attributes are same as attributes
-                             of gui color
+                Note:
+                    The fg and bg keys also accept the string values `"fg"` or
+                    `"bg"` which act as aliases to the corresponding
+                    foreground and background values of the Normal group. If
+                    the Normal group has not been defined, using these values
+                    results in an error.
+
+                Parameters: ~
+                    {ns_id}  Namespace id for this highlight
+                             |nvim_create_namespace()|. Use 0 to set a
+                             highlight group globally |:highlight|.
+                    {name}   Highlight group name, e.g. "ErrorMsg"
+                    {val}    Highlight definition map, accepts the following
+                             keys:
+                             • fg (or foreground): color name or "#RRGGBB",
+                               see note.
+                             • bg (or background): color name or "#RRGGBB",
+                               see note.
+                             • sp (or special): color name or "#RRGGBB"
+                             • blend: integer between 0 and 100
+                             • bold: boolean
+                             • standout: boolean
+                             • underline: boolean
+                             • undercurl: boolean
+                             • underdouble: boolean
+                             • underdotted: boolean
+                             • underdashed: boolean
+                             • strikethrough: boolean
+                             • italic: boolean
+                             • reverse: boolean
+                             • nocombine: boolean
+                             • link: name of another highlight group to link
+                               to, see |:hi-link|.
+                             • default: Don't override existing definition
+                               |:hi-default|
+                             • ctermfg: Sets foreground of cterm color
+                               |highlight-ctermfg|
+                             • ctermbg: Sets background of cterm color
+                               |highlight-ctermbg|
+                             • cterm: cterm attribute map, like
+                               |highlight-args|. If not set, cterm attributes
+                               will match those from the attribute map
+                               documented above.
 
 nvim_set_keymap({mode}, {lhs}, {rhs}, {*opts})             *nvim_set_keymap()*
                 Sets a global |mapping| for the given mode.
@@ -1581,34 +1521,15 @@ nvim_set_keymap({mode}, {lhs}, {rhs}, {*opts})             *nvim_set_keymap()*
                             for |:map|.
                     {lhs}   Left-hand-side |{lhs}| of the mapping.
                     {rhs}   Right-hand-side |{rhs}| of the mapping.
-                    {opts}  Optional parameters map. Accepts all
-                            |:map-arguments| as keys excluding |<buffer>| but
-                            including |noremap| and "desc". |desc| can be used
-                            to give a description to keymap. When called from
-                            Lua, also accepts a "callback" key that takes a
-                            Lua function to call when the mapping is executed.
-                            Values are Booleans. Unknown key is an error.
-
-nvim_set_option({name}, {value})                           *nvim_set_option()*
-                Sets the global value of an option.
-
-                Parameters: ~
-                    {name}   Option name
-                    {value}  New option value
-
-                                                     *nvim_set_option_value()*
-nvim_set_option_value({name}, {value}, {*opts})
-                Sets the value of an option. The behavior of this function
-                matches that of |:set|: for global-local options, both the
-                global and local value are set unless otherwise specified with
-                {scope}.
-
-                Parameters: ~
-                    {name}   Option name
-                    {value}  New option value
-                    {opts}   Optional parameters
-                             • scope: One of 'global' or 'local'. Analogous to
-                               |:setglobal| and |:setlocal|, respectively.
+                    {opts}  Optional parameters map: keys are
+                            |:map-arguments|, values are booleans (default
+                            false). Accepts all |:map-arguments| as keys
+                            excluding |<buffer>| but including |noremap| and
+                            "desc". Unknown key is an error. "desc" can be
+                            used to give a description to the mapping. When
+                            called from Lua, also accepts a "callback" key
+                            that takes a Lua function to call when the mapping
+                            is executed.
 
 nvim_set_var({name}, {value})                                 *nvim_set_var()*
                 Sets a global (g:) variable.
@@ -1625,8 +1546,8 @@ nvim_set_vvar({name}, {value})                               *nvim_set_vvar()*
                     {value}  Variable value
 
 nvim_strwidth({text})                                        *nvim_strwidth()*
-                Calculates the number of display cells occupied by `text` .
-                <Tab> counts as one cell.
+                Calculates the number of display cells occupied by `text`.
+                Control characters including <Tab> count as one cell.
 
                 Parameters: ~
                     {text}  Some text
@@ -1637,12 +1558,18 @@ nvim_strwidth({text})                                        *nvim_strwidth()*
 nvim_subscribe({event})                                     *nvim_subscribe()*
                 Subscribes to event broadcasts.
 
+                Attributes: ~
+                    |RPC| only
+
                 Parameters: ~
                     {event}  Event type string
 
 nvim_unsubscribe({event})                                 *nvim_unsubscribe()*
                 Unsubscribes to event broadcasts.
 
+                Attributes: ~
+                    |RPC| only
+
                 Parameters: ~
                     {event}  Event type string
 
@@ -1654,8 +1581,7 @@ Vimscript Functions                                            *api-vimscript*
 nvim_call_dict_function({dict}, {fn}, {args})
                 Calls a VimL |Dictionary-function| with the given arguments.
 
-                On execution error: fails with VimL error, does not update
-                v:errmsg.
+                On execution error: fails with VimL error, updates v:errmsg.
 
                 Parameters: ~
                     {dict}  Dictionary, or String evaluating to a VimL |self|
@@ -1669,8 +1595,7 @@ nvim_call_dict_function({dict}, {fn}, {args})
 nvim_call_function({fn}, {args})                        *nvim_call_function()*
                 Calls a VimL function with the given arguments.
 
-                On execution error: fails with VimL error, does not update
-                v:errmsg.
+                On execution error: fails with VimL error, updates v:errmsg.
 
                 Parameters: ~
                     {fn}    Function to call
@@ -1680,23 +1605,25 @@ nvim_call_function({fn}, {args})                        *nvim_call_function()*
                     Result of the function call
 
 nvim_command({command})                                       *nvim_command()*
-                Executes an ex-command.
+                Executes an Ex command.
 
-                On execution error: fails with VimL error, does not update
-                v:errmsg.
+                On execution error: fails with VimL error, updates v:errmsg.
 
-                Parameters: ~
-                    {command}  Ex-command string
+                Prefer using |nvim_cmd()| or |nvim_exec()| over this. To
+                evaluate multiple lines of Vim script or an Ex command
+                directly, use |nvim_exec()|. To construct an Ex command using
+                a structured format and then execute it, use |nvim_cmd()|. To
+                modify an Ex command before evaluating it, use
+                |nvim_parse_cmd()| in conjunction with |nvim_cmd()|.
 
-                See also: ~
-                    |nvim_exec()|
+                Parameters: ~
+                    {command}  Ex command string
 
 nvim_eval({expr})                                                *nvim_eval()*
                 Evaluates a VimL |expression|. Dictionaries and Lists are
                 recursively expanded.
 
-                On execution error: fails with VimL error, does not update
-                v:errmsg.
+                On execution error: fails with VimL error, updates v:errmsg.
 
                 Parameters: ~
                     {expr}  VimL expression string
@@ -1705,14 +1632,13 @@ nvim_eval({expr})                                                *nvim_eval()*
                     Evaluation result or expanded object
 
 nvim_exec({src}, {output})                                       *nvim_exec()*
-                Executes Vimscript (multiline block of Ex-commands), like
+                Executes Vimscript (multiline block of Ex commands), like
                 anonymous |:source|.
 
                 Unlike |nvim_command()| this function supports heredocs,
                 script-scope (s:), etc.
 
-                On execution error: fails with VimL error, does not update
-                v:errmsg.
+                On execution error: fails with VimL error, updates v:errmsg.
 
                 Parameters: ~
                     {src}     Vimscript code
@@ -1726,13 +1652,14 @@ nvim_exec({src}, {output})                                       *nvim_exec()*
                 See also: ~
                     |execute()|
                     |nvim_command()|
+                    |nvim_cmd()|
 
                                                      *nvim_parse_expression()*
 nvim_parse_expression({expr}, {flags}, {highlight})
                 Parse a VimL expression.
 
                 Attributes: ~
-                    {fast}
+                    |api-fast|
 
                 Parameters: ~
                     {expr}       Expression to parse. Always treated as a
@@ -1827,6 +1754,358 @@ nvim_parse_expression({expr}, {flags}, {highlight})
 
 
 ==============================================================================
+Command Functions                                                *api-command*
+
+                                              *nvim_buf_create_user_command()*
+nvim_buf_create_user_command({buffer}, {name}, {command}, {*opts})
+                Create a new user command |user-commands| in the given buffer.
+
+                Parameters: ~
+                    {buffer}  Buffer handle, or 0 for current buffer.
+
+                See also: ~
+                    nvim_create_user_command
+
+                                                 *nvim_buf_del_user_command()*
+nvim_buf_del_user_command({buffer}, {name})
+                Delete a buffer-local user-defined command.
+
+                Only commands created with |:command-buffer| or
+                |nvim_buf_create_user_command()| can be deleted with this
+                function.
+
+                Parameters: ~
+                    {buffer}  Buffer handle, or 0 for current buffer.
+                    {name}    Name of the command to delete.
+
+nvim_buf_get_commands({buffer}, {*opts})             *nvim_buf_get_commands()*
+                Gets a map of buffer-local |user-commands|.
+
+                Parameters: ~
+                    {buffer}  Buffer handle, or 0 for current buffer
+                    {opts}    Optional parameters. Currently not used.
+
+                Return: ~
+                    Map of maps describing commands.
+
+nvim_cmd({*cmd}, {*opts})                                         *nvim_cmd()*
+                Executes an Ex command.
+
+                Unlike |nvim_command()| this command takes a structured
+                Dictionary instead of a String. This allows for easier
+                construction and manipulation of an Ex command. This also
+                allows for things such as having spaces inside a command
+                argument, expanding filenames in a command that otherwise
+                doesn't expand filenames, etc.
+
+                On execution error: fails with VimL error, updates v:errmsg.
+
+                Parameters: ~
+                    {cmd}   Command to execute. Must be a Dictionary that can
+                            contain the same values as the return value of
+                            |nvim_parse_cmd()| except "addr", "nargs" and
+                            "nextcmd" which are ignored if provided. All
+                            values except for "cmd" are optional.
+                    {opts}  Optional parameters.
+                            • output: (boolean, default false) Whether to
+                              return command output.
+
+                Return: ~
+                    Command output (non-error, non-shell |:!|) if `output` is
+                    true, else empty string.
+
+                See also: ~
+                    |nvim_exec()|
+                    |nvim_command()|
+
+                                                  *nvim_create_user_command()*
+nvim_create_user_command({name}, {command}, {*opts})
+                Create a new user command |user-commands|
+
+                {name} is the name of the new command. The name must begin
+                with an uppercase letter.
+
+                {command} is the replacement text or Lua function to execute.
+
+                Example: >
+                   :call nvim_create_user_command('SayHello', 'echo "Hello world!"', {})
+                   :SayHello
+                   Hello world!
+<
+
+                Parameters: ~
+                    {name}     Name of the new user command. Must begin with
+                               an uppercase letter.
+                    {command}  Replacement command to execute when this user
+                               command is executed. When called from Lua, the
+                               command can also be a Lua function. The
+                               function is called with a single table argument
+                               that contains the following keys:
+                               • args: (string) The args passed to the
+                                 command, if any |<args>|
+                               • fargs: (table) The args split by unescaped
+                                 whitespace (when more than one argument is
+                                 allowed), if any |<f-args>|
+                               • bang: (boolean) "true" if the command was
+                                 executed with a ! modifier |<bang>|
+                               • line1: (number) The starting line of the
+                                 command range |<line1>|
+                               • line2: (number) The final line of the command
+                                 range |<line2>|
+                               • range: (number) The number of items in the
+                                 command range: 0, 1, or 2 |<range>|
+                               • count: (number) Any count supplied |<count>|
+                               • reg: (string) The optional register, if
+                                 specified |<reg>|
+                               • mods: (string) Command modifiers, if any
+                                 |<mods>|
+                               • smods: (table) Command modifiers in a
+                                 structured format. Has the same structure as
+                                 the "mods" key of |nvim_parse_cmd()|.
+                    {opts}     Optional command attributes. See
+                               |command-attributes| for more details. To use
+                               boolean attributes (such as |:command-bang| or
+                               |:command-bar|) set the value to "true". In
+                               addition to the string options listed in
+                               |:command-complete|, the "complete" key also
+                               accepts a Lua function which works like the
+                               "customlist" completion mode
+                               |:command-completion-customlist|. Additional
+                               parameters:
+                               • desc: (string) Used for listing the command
+                                 when a Lua function is used for {command}.
+                               • force: (boolean, default true) Override any
+                                 previous definition.
+                               • preview: (function) Preview callback for
+                                 'inccommand' |:command-preview|
+
+nvim_del_user_command({name})                        *nvim_del_user_command()*
+                Delete a user-defined command.
+
+                Parameters: ~
+                    {name}  Name of the command to delete.
+
+nvim_get_commands({*opts})                               *nvim_get_commands()*
+                Gets a map of global (non-buffer-local) Ex commands.
+
+                Currently only |user-commands| are supported, not builtin Ex
+                commands.
+
+                Parameters: ~
+                    {opts}  Optional parameters. Currently only supports
+                            {"builtin":false}
+
+                Return: ~
+                    Map of maps describing commands.
+
+nvim_parse_cmd({str}, {opts})                               *nvim_parse_cmd()*
+                Parse command line.
+
+                Doesn't check the validity of command arguments.
+
+                Attributes: ~
+                    |api-fast|
+
+                Parameters: ~
+                    {str}   Command line string to parse. Cannot contain "\n".
+                    {opts}  Optional parameters. Reserved for future use.
+
+                Return: ~
+                    Dictionary containing command information, with these
+                    keys:
+                    • cmd: (string) Command name.
+                    • range: (array) Command <range>. Can have 0-2 elements
+                      depending on how many items the range contains. Has no
+                      elements if command doesn't accept a range or if no
+                      range was specified, one element if only a single range
+                      item was specified and two elements if both range items
+                      were specified.
+                    • count: (number) Any |<count>| that was supplied to the
+                      command. -1 if command cannot take a count.
+                    • reg: (number) The optional command |<register>|, if
+                      specified. Empty string if not specified or if command
+                      cannot take a register.
+                    • bang: (boolean) Whether command contains a |<bang>| (!)
+                      modifier.
+                    • args: (array) Command arguments.
+                    • addr: (string) Value of |:command-addr|. Uses short
+                      name.
+                    • nargs: (string) Value of |:command-nargs|.
+                    • nextcmd: (string) Next command if there are multiple
+                      commands separated by a |:bar|. Empty if there isn't a
+                      next command.
+                    • magic: (dictionary) Which characters have special
+                      meaning in the command arguments.
+                      • file: (boolean) The command expands filenames. Which
+                        means characters such as "%", "#" and wildcards are
+                        expanded.
+                      • bar: (boolean) The "|" character is treated as a
+                        command separator and the double quote character (")
+                        is treated as the start of a comment.
+
+                    • mods: (dictionary) |:command-modifiers|.
+                      • filter: (dictionary) |:filter|.
+                        • pattern: (string) Filter pattern. Empty string if
+                          there is no filter.
+                        • force: (boolean) Whether filter is inverted or not.
+
+                      • silent: (boolean) |:silent|.
+                      • emsg_silent: (boolean) |:silent!|.
+                      • unsilent: (boolean) |:unsilent|.
+                      • sandbox: (boolean) |:sandbox|.
+                      • noautocmd: (boolean) |:noautocmd|.
+                      • browse: (boolean) |:browse|.
+                      • confirm: (boolean) |:confirm|.
+                      • hide: (boolean) |:hide|.
+                      • keepalt: (boolean) |:keepalt|.
+                      • keepjumps: (boolean) |:keepjumps|.
+                      • keepmarks: (boolean) |:keepmarks|.
+                      • keeppatterns: (boolean) |:keeppatterns|.
+                      • lockmarks: (boolean) |:lockmarks|.
+                      • noswapfile: (boolean) |:noswapfile|.
+                      • tab: (integer) |:tab|.
+                      • verbose: (integer) |:verbose|. -1 when omitted.
+                      • vertical: (boolean) |:vertical|.
+                      • split: (string) Split modifier string, is an empty
+                        string when there's no split modifier. If there is a
+                        split modifier it can be one of:
+                        • "aboveleft": |:aboveleft|.
+                        • "belowright": |:belowright|.
+                        • "topleft": |:topleft|.
+                        • "botright": |:botright|.
+
+
+==============================================================================
+Options Functions                                                *api-options*
+
+nvim_buf_get_option({buffer}, {name})                  *nvim_buf_get_option()*
+                Gets a buffer option value
+
+                Parameters: ~
+                    {buffer}  Buffer handle, or 0 for current buffer
+                    {name}    Option name
+
+                Return: ~
+                    Option value
+
+nvim_buf_set_option({buffer}, {name}, {value})         *nvim_buf_set_option()*
+                Sets a buffer option value. Passing 'nil' as value deletes the
+                option (only works if there's a global fallback)
+
+                Parameters: ~
+                    {buffer}  Buffer handle, or 0 for current buffer
+                    {name}    Option name
+                    {value}   Option value
+
+nvim_get_all_options_info()                      *nvim_get_all_options_info()*
+                Gets the option information for all options.
+
+                The dictionary has the full option names as keys and option
+                metadata dictionaries as detailed at |nvim_get_option_info|.
+
+                Return: ~
+                    dictionary of all options
+
+nvim_get_option({name})                                    *nvim_get_option()*
+                Gets the global value of an option.
+
+                Parameters: ~
+                    {name}  Option name
+
+                Return: ~
+                    Option value (global)
+
+nvim_get_option_info({name})                          *nvim_get_option_info()*
+                Gets the option information for one option
+
+                Resulting dictionary has keys:
+                • name: Name of the option (like 'filetype')
+                • shortname: Shortened name of the option (like 'ft')
+                • type: type of option ("string", "number" or "boolean")
+                • default: The default value for the option
+                • was_set: Whether the option was set.
+                • last_set_sid: Last set script id (if any)
+                • last_set_linenr: line number where option was set
+                • last_set_chan: Channel where option was set (0 for local)
+                • scope: one of "global", "win", or "buf"
+                • global_local: whether win or buf option has a global value
+                • commalist: List of comma separated values
+                • flaglist: List of single char flags
+
+                Parameters: ~
+                    {name}  Option name
+
+                Return: ~
+                    Option Information
+
+nvim_get_option_value({name}, {*opts})               *nvim_get_option_value()*
+                Gets the value of an option. The behavior of this function
+                matches that of |:set|: the local value of an option is
+                returned if it exists; otherwise, the global value is
+                returned. Local values always correspond to the current buffer
+                or window, unless "buf" or "win" is set in {opts}.
+
+                Parameters: ~
+                    {name}  Option name
+                    {opts}  Optional parameters
+                            • scope: One of "global" or "local". Analogous to
+                              |:setglobal| and |:setlocal|, respectively.
+                            • win: |window-ID|. Used for getting window local
+                              options.
+                            • buf: Buffer number. Used for getting buffer
+                              local options. Implies {scope} is "local".
+
+                Return: ~
+                    Option value
+
+nvim_set_option({name}, {value})                           *nvim_set_option()*
+                Sets the global value of an option.
+
+                Parameters: ~
+                    {name}   Option name
+                    {value}  New option value
+
+                                                     *nvim_set_option_value()*
+nvim_set_option_value({name}, {value}, {*opts})
+                Sets the value of an option. The behavior of this function
+                matches that of |:set|: for global-local options, both the
+                global and local value are set unless otherwise specified with
+                {scope}.
+
+                Note the options {win} and {buf} cannot be used together.
+
+                Parameters: ~
+                    {name}   Option name
+                    {value}  New option value
+                    {opts}   Optional parameters
+                             • scope: One of 'global' or 'local'. Analogous to
+                               |:setglobal| and |:setlocal|, respectively.
+                             • win: |window-ID|. Used for setting window local
+                               option.
+                             • buf: Buffer number. Used for setting buffer
+                               local option.
+
+nvim_win_get_option({window}, {name})                  *nvim_win_get_option()*
+                Gets a window option value
+
+                Parameters: ~
+                    {window}  Window handle, or 0 for current window
+                    {name}    Option name
+
+                Return: ~
+                    Option value
+
+nvim_win_set_option({window}, {name}, {value})         *nvim_win_set_option()*
+                Sets a window option value. Passing 'nil' as value deletes the
+                option(only works if there's a global fallback)
+
+                Parameters: ~
+                    {window}  Window handle, or 0 for current window
+                    {name}    Option name
+                    {value}   Option value
+
+
+==============================================================================
 Buffer Functions                                                  *api-buffer*
 
 
@@ -1852,16 +2131,6 @@ nvim__buf_redraw_range({buffer}, {first}, {last})
 nvim__buf_stats({buffer})                                  *nvim__buf_stats()*
                 TODO: Documentation
 
-                                                 *nvim_buf_add_user_command()*
-nvim_buf_add_user_command({buffer}, {name}, {command}, {*opts})
-                Create a new user command |user-commands| in the given buffer.
-
-                Parameters: ~
-                    {buffer}  Buffer handle, or 0 for current buffer.
-
-                See also: ~
-                    nvim_add_user_command
-
 nvim_buf_attach({buffer}, {send_buffer}, {opts})           *nvim_buf_attach()*
                 Activates buffer-update events on a channel, or as Lua
                 callbacks.
@@ -1877,9 +2146,10 @@ nvim_buf_attach({buffer}, {send_buffer}, {opts})           *nvim_buf_attach()*
                     {buffer}       Buffer handle, or 0 for current buffer
                     {send_buffer}  True if the initial notification should
                                    contain the whole buffer: first
-                                   notification will be `nvim_buf_lines_event`
-                                   . Else the first notification will be
-                                   `nvim_buf_changedtick_event` . Not for Lua
+                                   notification will be
+                                   `nvim_buf_lines_event`. Else the first
+                                   notification will be
+                                   `nvim_buf_changedtick_event`. Not for Lua
                                    callbacks.
                     {opts}         Optional parameters.
                                    • on_lines: Lua callback invoked on change.
@@ -1930,12 +2200,12 @@ nvim_buf_attach({buffer}, {send_buffer}, {opts})           *nvim_buf_attach()*
                                    • on_reload: Lua callback invoked on
                                      reload. The entire buffer content should
                                      be considered changed. Args:
-                                     • the string "detach"
+                                     • the string "reload"
                                      • buffer handle
 
                                    • utf_sizes: include UTF-32 and UTF-16 size
                                      of the replaced region, as args to
-                                     `on_lines` .
+                                     `on_lines`.
                                    • preview: also attach to command preview
                                      (i.e. 'inccommand') events.
 
@@ -1961,6 +2231,9 @@ nvim_buf_call({buffer}, {fun})                               *nvim_buf_call()*
                 This is useful e.g. to call vimL functions that only work with
                 the current buffer/window currently, like |termopen()|.
 
+                Attributes: ~
+                    |vim.api| only
+
                 Parameters: ~
                     {buffer}  Buffer handle, or 0 for current buffer
                     {fun}     Function to call inside the buffer (currently
@@ -1997,18 +2270,6 @@ nvim_buf_del_mark({buffer}, {name})                      *nvim_buf_del_mark()*
                     |nvim_buf_set_mark()|
                     |nvim_del_mark()|
 
-                                                 *nvim_buf_del_user_command()*
-nvim_buf_del_user_command({buffer}, {name})
-                Delete a buffer-local user-defined command.
-
-                Only commands created with |:command-buffer| or
-                |nvim_buf_add_user_command()| can be deleted with this
-                function.
-
-                Parameters: ~
-                    {buffer}  Buffer handle, or 0 for current buffer.
-                    {name}    Name of the command to delete.
-
 nvim_buf_del_var({buffer}, {name})                        *nvim_buf_del_var()*
                 Removes a buffer-scoped (b:) variable
 
@@ -2033,6 +2294,9 @@ nvim_buf_delete({buffer}, {opts})                          *nvim_buf_delete()*
 nvim_buf_detach({buffer})                                  *nvim_buf_detach()*
                 Deactivates buffer-update events on the channel.
 
+                Attributes: ~
+                    |RPC| only
+
                 Parameters: ~
                     {buffer}  Buffer handle, or 0 for current buffer
 
@@ -2053,16 +2317,6 @@ nvim_buf_get_changedtick({buffer})                *nvim_buf_get_changedtick()*
                 Return: ~
                     `b:changedtick` value.
 
-nvim_buf_get_commands({buffer}, {*opts})             *nvim_buf_get_commands()*
-                Gets a map of buffer-local |user-commands|.
-
-                Parameters: ~
-                    {buffer}  Buffer handle, or 0 for current buffer
-                    {opts}    Optional parameters. Currently not used.
-
-                Return: ~
-                    Map of maps describing commands.
-
 nvim_buf_get_keymap({buffer}, {mode})                  *nvim_buf_get_keymap()*
                 Gets a list of buffer-local |mapping| definitions.
 
@@ -2088,7 +2342,7 @@ nvim_buf_get_lines({buffer}, {start}, {end}, {strict_indexing})
                 Parameters: ~
                     {buffer}           Buffer handle, or 0 for current buffer
                     {start}            First line index
-                    {end}              Last line index (exclusive)
+                    {end}              Last line index, exclusive
                     {strict_indexing}  Whether out-of-bounds should be an
                                        error.
 
@@ -2141,15 +2395,30 @@ nvim_buf_get_offset({buffer}, {index})                 *nvim_buf_get_offset()*
                 Return: ~
                     Integer byte offset, or -1 for unloaded buffer.
 
-nvim_buf_get_option({buffer}, {name})                  *nvim_buf_get_option()*
-                Gets a buffer option value
+                                                         *nvim_buf_get_text()*
+nvim_buf_get_text({buffer}, {start_row}, {start_col}, {end_row}, {end_col},
+                  {opts})
+                Gets a range from the buffer.
+
+                This differs from |nvim_buf_get_lines()| in that it allows
+                retrieving only portions of a line.
+
+                Indexing is zero-based. Row indices are end-inclusive, and
+                column indices are end-exclusive.
+
+                Prefer |nvim_buf_get_lines()| when retrieving entire lines.
 
                 Parameters: ~
-                    {buffer}  Buffer handle, or 0 for current buffer
-                    {name}    Option name
+                    {buffer}     Buffer handle, or 0 for current buffer
+                    {start_row}  First line index
+                    {start_col}  Starting column (byte offset) on first line
+                    {end_row}    Last line index, inclusive
+                    {end_col}    Ending column (byte offset) on last line,
+                                 exclusive
+                    {opts}       Optional parameters. Currently unused.
 
                 Return: ~
-                    Option value
+                    Array of lines, or empty array for unloaded buffer.
 
 nvim_buf_get_var({buffer}, {name})                        *nvim_buf_get_var()*
                 Gets a buffer-scoped (b:) variable.
@@ -2185,7 +2454,7 @@ nvim_buf_is_valid({buffer})                              *nvim_buf_is_valid()*
                     true if the buffer is valid, false otherwise.
 
 nvim_buf_line_count({buffer})                          *nvim_buf_line_count()*
-                Gets the buffer line count
+                Returns the number of lines in the given buffer.
 
                 Parameters: ~
                     {buffer}  Buffer handle, or 0 for current buffer
@@ -2225,7 +2494,7 @@ nvim_buf_set_lines({buffer}, {start}, {end}, {strict_indexing}, {replacement})
                 Parameters: ~
                     {buffer}           Buffer handle, or 0 for current buffer
                     {start}            First line index
-                    {end}              Last line index (exclusive)
+                    {end}              Last line index, exclusive
                     {strict_indexing}  Whether out-of-bounds should be an
                                        error.
                     {replacement}      Array of lines to use as replacement
@@ -2261,40 +2530,33 @@ nvim_buf_set_name({buffer}, {name})                      *nvim_buf_set_name()*
                     {buffer}  Buffer handle, or 0 for current buffer
                     {name}    Buffer name
 
-nvim_buf_set_option({buffer}, {name}, {value})         *nvim_buf_set_option()*
-                Sets a buffer option value. Passing 'nil' as value deletes the
-                option (only works if there's a global fallback)
-
-                Parameters: ~
-                    {buffer}  Buffer handle, or 0 for current buffer
-                    {name}    Option name
-                    {value}   Option value
-
                                                          *nvim_buf_set_text()*
 nvim_buf_set_text({buffer}, {start_row}, {start_col}, {end_row}, {end_col},
                   {replacement})
                 Sets (replaces) a range in the buffer
 
-                This is recommended over nvim_buf_set_lines when only
+                This is recommended over |nvim_buf_set_lines()| when only
                 modifying parts of a line, as extmarks will be preserved on
                 non-modified parts of the touched lines.
 
-                Indexing is zero-based and end-exclusive.
+                Indexing is zero-based. Row indices are end-inclusive, and
+                column indices are end-exclusive.
 
-                To insert text at a given index, set `start` and `end` ranges
-                to the same index. To delete a range, set `replacement` to an
-                array containing an empty string, or simply an empty array.
+                To insert text at a given `(row, column)` location, use
+                `start_row = end_row = row` and `start_col = end_col = col`.
+                To delete the text in a range, use `replacement = {}`.
 
-                Prefer nvim_buf_set_lines when adding or deleting entire lines
-                only.
+                Prefer |nvim_buf_set_lines()| if you are only adding or
+                deleting entire lines.
 
                 Parameters: ~
-                    {buffer}        Buffer handle, or 0 for current buffer
-                    {start_row}     First line index
-                    {start_column}  First column
-                    {end_row}       Last line index
-                    {end_column}    Last column
-                    {replacement}   Array of lines to use as replacement
+                    {buffer}       Buffer handle, or 0 for current buffer
+                    {start_row}    First line index
+                    {start_col}    Starting column (byte offset) on first line
+                    {end_row}      Last line index, inclusive
+                    {end_col}      Ending column (byte offset) on last line,
+                                   exclusive
+                    {replacement}  Array of lines to use as replacement
 
 nvim_buf_set_var({buffer}, {name}, {value})               *nvim_buf_set_var()*
                 Sets a buffer-scoped (b:) variable
@@ -2327,7 +2589,7 @@ nvim_buf_add_highlight({buffer}, {ns_id}, {hl_group}, {line}, {col_start},
                 namespace. All highlights in the same namespace can then be
                 cleared with single call to |nvim_buf_clear_namespace()|. If
                 the highlight never will be deleted by an API call, pass
-                `ns_id = -1` .
+                `ns_id = -1`.
 
                 As a shorthand, `ns_id = 0` can be used to create a new
                 namespace for the highlight, the allocated id is then
@@ -2407,8 +2669,8 @@ nvim_buf_get_extmarks({buffer}, {ns_id}, {start}, {end}, {opts})
     nvim_buf_get_extmarks(0, my_ns, [0,0], [-1,-1], {})
 <
 
-                If `end` is less than `start` , traversal works backwards.
-                (Useful with `limit` , to get the first marks prior to a given
+                If `end` is less than `start`, traversal works backwards.
+                (Useful with `limit`, to get the first marks prior to a given
                 position.)
 
                 Example:
@@ -2417,9 +2679,9 @@ nvim_buf_get_extmarks({buffer}, {ns_id}, {start}, {end}, {opts})
     local pos = a.nvim_win_get_cursor(0)
     local ns  = a.nvim_create_namespace('my-plugin')
     -- Create new extmark at line 1, column 1.
-    local m1  = a.nvim_buf_set_extmark(0, ns, 0, 0, 0, {})
+    local m1  = a.nvim_buf_set_extmark(0, ns, 0, 0, {})
     -- Create new extmark at line 3, column 1.
-    local m2  = a.nvim_buf_set_extmark(0, ns, 0, 2, 0, {})
+    local m2  = a.nvim_buf_set_extmark(0, ns, 0, 2, {})
     -- Get extmarks only from line 3.
     local ms  = a.nvim_buf_get_extmarks(0, ns, {2,0}, {2,0}, {})
     -- Get all marks in this buffer + namespace.
@@ -2448,13 +2710,12 @@ nvim_buf_get_extmarks({buffer}, {ns_id}, {start}, {end}, {opts})
 nvim_buf_set_extmark({buffer}, {ns_id}, {line}, {col}, {*opts})
                 Creates or updates an extmark.
 
-                To create a new extmark, pass id=0. The extmark id will be
-                returned. To move an existing mark, pass its id.
-
-                It is also allowed to create a new mark by passing in a
-                previously unused id, but the caller must then keep track of
-                existing and unused ids itself. (Useful over RPC, to avoid
-                waiting for the return value.)
+                By default a new extmark is created when no id is passed in,
+                but it is also possible to create a new mark by passing in a
+                previously unused id or move an existing mark by passing in
+                its id. The caller must then keep track of existing and unused
+                ids itself. (Useful over RPC, to avoid waiting for the return
+                value.)
 
                 Using the optional arguments, it is possible to use this to
                 highlight a range of text, and also to associate virtual text
@@ -2548,6 +2809,44 @@ nvim_buf_set_extmark({buffer}, {ns_id}, {line}, {col}, {*opts})
                               • priority: a priority value for the highlight
                                 group. For example treesitter highlighting
                                 uses a value of 100.
+                              • strict: boolean that indicates extmark should
+                                not be placed if the line or column value is
+                                past the end of the buffer or end of the line
+                                respectively. Defaults to true.
+                              • sign_text: string of length 1-2 used to
+                                display in the sign column. Note: ranges are
+                                unsupported and decorations are only applied
+                                to start_row
+                              • sign_hl_group: name of the highlight group
+                                used to highlight the sign column text. Note:
+                                ranges are unsupported and decorations are
+                                only applied to start_row
+                              • number_hl_group: name of the highlight group
+                                used to highlight the number column. Note:
+                                ranges are unsupported and decorations are
+                                only applied to start_row
+                              • line_hl_group: name of the highlight group
+                                used to highlight the whole line. Note: ranges
+                                are unsupported and decorations are only
+                                applied to start_row
+                              • cursorline_hl_group: name of the highlight
+                                group used to highlight the line when the
+                                cursor is on the same line as the mark and
+                                'cursorline' is enabled. Note: ranges are
+                                unsupported and decorations are only applied
+                                to start_row
+                              • conceal: string which should be either empty
+                                or a single character. Enable concealing
+                                similar to |:syn-conceal|. When a character is
+                                supplied it is used as |:syn-cchar|.
+                                "hl_group" is used as highlight for the cchar
+                                if provided, otherwise it defaults to
+                                |hl-Conceal|.
+                              • ui_watched: boolean that indicates the mark
+                                should be drawn by a UI. When set, the UI will
+                                receive win_extmark events. Note: the mark is
+                                positioned by virt_text attributes. Can be
+                                used together with virt_text.
 
                 Return: ~
                     Id of the created/updated extmark
@@ -2605,6 +2904,9 @@ nvim_set_decoration_provider({ns_id}, {opts})
                 `vim.rpcnotify` should be OK, but `vim.rpcrequest` is quite
                 dubious for the moment.
 
+                Attributes: ~
+                    |vim.api| only
+
                 Parameters: ~
                     {ns_id}  Namespace id from |nvim_create_namespace()|
                     {opts}   Callbacks invoked during redraw:
@@ -2628,6 +2930,9 @@ Window Functions                                                  *api-window*
 nvim_win_call({window}, {fun})                               *nvim_win_call()*
                 Calls a function with window as temporary current window.
 
+                Attributes: ~
+                    |vim.api| only
+
                 Parameters: ~
                     {window}  Window handle, or 0 for current window
                     {fun}     Function to call inside the window (currently
@@ -2698,16 +3003,6 @@ nvim_win_get_number({window})                          *nvim_win_get_number()*
                 Return: ~
                     Window number
 
-nvim_win_get_option({window}, {name})                  *nvim_win_get_option()*
-                Gets a window option value
-
-                Parameters: ~
-                    {window}  Window handle, or 0 for current window
-                    {name}    Option name
-
-                Return: ~
-                    Option value
-
 nvim_win_get_position({window})                      *nvim_win_get_position()*
                 Gets the window position in display cells. First position is
                 zero.
@@ -2751,7 +3046,7 @@ nvim_win_hide({window})                                      *nvim_win_hide()*
                 |:hide| with a |window-ID|).
 
                 Like |:hide| the buffer becomes hidden unless another window
-                is editing it, or 'bufhidden' is `unload` , `delete` or `wipe`
+                is editing it, or 'bufhidden' is `unload`, `delete` or `wipe`
                 as opposed to |:close| or |nvim_win_close|, which will close
                 the buffer.
 
@@ -2782,29 +3077,20 @@ nvim_win_set_buf({window}, {buffer})                      *nvim_win_set_buf()*
 
 nvim_win_set_cursor({window}, {pos})                   *nvim_win_set_cursor()*
                 Sets the (1,0)-indexed cursor position in the window.
-                |api-indexing|
+                |api-indexing| This scrolls the window even if it is not the
+                current one.
 
                 Parameters: ~
                     {window}  Window handle, or 0 for current window
                     {pos}     (row, col) tuple representing the new position
 
 nvim_win_set_height({window}, {height})                *nvim_win_set_height()*
-                Sets the window height. This will only succeed if the screen
-                is split horizontally.
+                Sets the window height.
 
                 Parameters: ~
                     {window}  Window handle, or 0 for current window
                     {height}  Height as a count of rows
 
-nvim_win_set_option({window}, {name}, {value})         *nvim_win_set_option()*
-                Sets a window option value. Passing 'nil' as value deletes the
-                option(only works if there's a global fallback)
-
-                Parameters: ~
-                    {window}  Window handle, or 0 for current window
-                    {name}    Option name
-                    {value}   Option value
-
 nvim_win_set_var({window}, {name}, {value})               *nvim_win_set_var()*
                 Sets a window-scoped (w:) variable
 
@@ -2967,9 +3253,10 @@ nvim_open_win({buffer}, {enter}, {*config})                  *nvim_open_win()*
                                   ">", "", "", "", "<" ] will only make
                                   vertical borders but not horizontal ones. By
                                   default, `FloatBorder` highlight is used,
-                                  which links to `VertSplit` when not defined.
-                                  It could also be specified by character: [
-                                  {"+", "MyCorner"}, {"x", "MyBorder"} ].
+                                  which links to `WinSeparator` when not
+                                  defined. It could also be specified by
+                                  character: [ {"+", "MyCorner"}, {"x",
+                                  "MyBorder"} ].
 
                               • noautocmd: If true then no buffer-related
                                 autocommand events such as |BufEnter|,
@@ -2999,7 +3286,7 @@ nvim_win_set_config({window}, {*config})               *nvim_win_set_config()*
                 layouts).
 
                 When reconfiguring a floating window, absent option keys will
-                not be changed. `row` / `col` and `relative` must be
+                not be changed. `row`/`col` and `relative` must be
                 reconfigured together.
 
                 Parameters: ~
@@ -3078,6 +3365,282 @@ nvim_tabpage_set_var({tabpage}, {name}, {value})
 
 
 ==============================================================================
+Autocmd Functions                                                *api-autocmd*
+
+nvim_clear_autocmds({*opts})                           *nvim_clear_autocmds()*
+                Clear all autocommands that match the corresponding {opts}. To
+                delete a particular autocmd, see |nvim_del_autocmd|.
+
+                Parameters: ~
+                    {opts}  Parameters
+                            • event: (string|table) Examples:
+                              • event: "pat1"
+                              • event: { "pat1" }
+                              • event: { "pat1", "pat2", "pat3" }
+
+                            • pattern: (string|table)
+                              • pattern or patterns to match exactly.
+                                • For example, if you have `*.py` as that
+                                  pattern for the autocmd, you must pass
+                                  `*.py` exactly to clear it. `test.py` will
+                                  not match the pattern.
+
+                              • defaults to clearing all patterns.
+                              • NOTE: Cannot be used with {buffer}
+
+                            • buffer: (bufnr)
+                              • clear only |autocmd-buflocal| autocommands.
+                              • NOTE: Cannot be used with {pattern}
+
+                            • group: (string|int) The augroup name or id.
+                              • NOTE: If not passed, will only delete autocmds not in any group.
+
+nvim_create_augroup({name}, {*opts})                   *nvim_create_augroup()*
+                Create or get an autocommand group |autocmd-groups|.
+
+                To get an existing group id, do: >
+                    local id = vim.api.nvim_create_augroup("MyGroup", {
+                        clear = false
+                    })
+<
+
+                Parameters: ~
+                    {name}  String: The name of the group
+                    {opts}  Dictionary Parameters
+                            • clear (bool) optional: defaults to true. Clear
+                              existing commands if the group already exists
+                              |autocmd-groups|.
+
+                Return: ~
+                    Integer id of the created group.
+
+                See also: ~
+                    |autocmd-groups|
+
+nvim_create_autocmd({event}, {*opts})                  *nvim_create_autocmd()*
+                Create an |autocommand|
+
+                The API allows for two (mutually exclusive) types of actions
+                to be executed when the autocommand triggers: a callback
+                function (Lua or Vimscript), or a command (like regular
+                autocommands).
+
+                Example using callback: >
+                    -- Lua function
+                    local myluafun = function() print("This buffer enters") end
+
+                    -- Vimscript function name (as a string)
+                    local myvimfun = "g:MyVimFunction"
+
+                    vim.api.nvim_create_autocmd({"BufEnter", "BufWinEnter"}, {
+                      pattern = {"*.c", "*.h"},
+                      callback = myluafun,  -- Or myvimfun
+                    })
+<
+
+                Lua functions receive a table with information about the
+                autocmd event as an argument. To use a function which itself
+                accepts another (optional) parameter, wrap the function in a
+                lambda:
+>
+    -- Lua function with an optional parameter.
+    -- The autocmd callback would pass a table as argument but this
+    -- function expects number|nil
+    local myluafun = function(bufnr) bufnr = bufnr or vim.api.nvim_get_current_buf() end
+
+    vim.api.nvim_create_autocmd({"BufEnter", "BufWinEnter"}, {
+      pattern = {"*.c", "*.h"},
+      callback = function() myluafun() end,
+    })
+<
+
+                Example using command: >
+                    vim.api.nvim_create_autocmd({"BufEnter", "BufWinEnter"}, {
+                      pattern = {"*.c", "*.h"},
+                      command = "echo 'Entering a C or C++ file'",
+                    })
+<
+
+                Example values for pattern: >
+                  pattern = "*.py"
+                  pattern = { "*.py", "*.pyi" }
+<
+
+                Example values for event: >
+                  "BufWritePre"
+                  {"CursorHold", "BufWritePre", "BufWritePost"}
+<
+
+                Parameters: ~
+                    {event}  (string|array) The event or events to register
+                             this autocommand
+                    {opts}   Dictionary of autocommand options:
+                             • group (string|integer) optional: the
+                               autocommand group name or id to match against.
+                             • pattern (string|array) optional: pattern or
+                               patterns to match against |autocmd-pattern|.
+                             • buffer (integer) optional: buffer number for
+                               buffer local autocommands |autocmd-buflocal|.
+                               Cannot be used with {pattern}.
+                             • desc (string) optional: description of the
+                               autocommand.
+                             • callback (function|string) optional: if a
+                               string, the name of a Vimscript function to
+                               call when this autocommand is triggered.
+                               Otherwise, a Lua function which is called when
+                               this autocommand is triggered. Cannot be used
+                               with {command}. Lua callbacks can return true
+                               to delete the autocommand; in addition, they
+                               accept a single table argument with the
+                               following keys:
+                               • id: (number) the autocommand id
+                               • event: (string) the name of the event that
+                                 triggered the autocommand |autocmd-events|
+                               • group: (number|nil) the autocommand group id,
+                                 if it exists
+                               • match: (string) the expanded value of
+                                 |<amatch>|
+                               • buf: (number) the expanded value of |<abuf>|
+                               • file: (string) the expanded value of
+                                 |<afile>|
+                               • data: (any) arbitrary data passed to
+                                 |nvim_exec_autocmds()|
+
+                             • command (string) optional: Vim command to
+                               execute on event. Cannot be used with
+                               {callback}
+                             • once (boolean) optional: defaults to false. Run
+                               the autocommand only once |autocmd-once|.
+                             • nested (boolean) optional: defaults to false.
+                               Run nested autocommands |autocmd-nested|.
+
+                Return: ~
+                    Integer id of the created autocommand.
+
+                See also: ~
+                    |autocommand|
+                    |nvim_del_autocmd()|
+
+nvim_del_augroup_by_id({id})                        *nvim_del_augroup_by_id()*
+                Delete an autocommand group by id.
+
+                To get a group id one can use |nvim_get_autocmds()|.
+
+                NOTE: behavior differs from |augroup-delete|. When deleting a
+                group, autocommands contained in this group will also be
+                deleted and cleared. This group will no longer exist.
+
+                Parameters: ~
+                    {id}  Integer The id of the group.
+
+                See also: ~
+                    |nvim_del_augroup_by_name()|
+                    |nvim_create_augroup()|
+
+nvim_del_augroup_by_name({name})                  *nvim_del_augroup_by_name()*
+                Delete an autocommand group by name.
+
+                NOTE: behavior differs from |augroup-delete|. When deleting a
+                group, autocommands contained in this group will also be
+                deleted and cleared. This group will no longer exist.
+
+                Parameters: ~
+                    {name}  String The name of the group.
+
+                See also: ~
+                    |autocommand-groups|
+
+nvim_del_autocmd({id})                                    *nvim_del_autocmd()*
+                Delete an autocommand by id.
+
+                NOTE: Only autocommands created via the API have an id.
+
+                Parameters: ~
+                    {id}  Integer The id returned by nvim_create_autocmd
+
+                See also: ~
+                    |nvim_create_autocmd()|
+
+nvim_exec_autocmds({event}, {*opts})                    *nvim_exec_autocmds()*
+                Execute all autocommands for {event} that match the
+                corresponding {opts} |autocmd-execute|.
+
+                Parameters: ~
+                    {event}  (String|Array) The event or events to execute
+                    {opts}   Dictionary of autocommand options:
+                             • group (string|integer) optional: the
+                               autocommand group name or id to match against.
+                               |autocmd-groups|.
+                             • pattern (string|array) optional: defaults to
+                               "*" |autocmd-pattern|. Cannot be used with
+                               {buffer}.
+                             • buffer (integer) optional: buffer number
+                               |autocmd-buflocal|. Cannot be used with
+                               {pattern}.
+                             • modeline (bool) optional: defaults to true.
+                               Process the modeline after the autocommands
+                               |<nomodeline>|.
+                             • data (any): arbitrary data to send to the
+                               autocommand callback. See
+                               |nvim_create_autocmd()| for details.
+
+                See also: ~
+                    |:doautocmd|
+
+nvim_get_autocmds({*opts})                               *nvim_get_autocmds()*
+                Get all autocommands that match the corresponding {opts}.
+
+                These examples will get autocommands matching ALL the given
+                criteria: >
+                  -- Matches all criteria
+                  autocommands = vim.api.nvim_get_autocmds({
+                    group = "MyGroup",
+                    event = {"BufEnter", "BufWinEnter"},
+                    pattern = {"*.c", "*.h"}
+                  })
+
+                  -- All commands from one group
+                  autocommands = vim.api.nvim_get_autocmds({
+                    group = "MyGroup",
+                  })
+<
+
+                NOTE: When multiple patterns or events are provided, it will
+                find all the autocommands that match any combination of them.
+
+                Parameters: ~
+                    {opts}  Dictionary with at least one of the following:
+                            • group (string|integer): the autocommand group
+                              name or id to match against.
+                            • event (string|array): event or events to match
+                              against |autocmd-events|.
+                            • pattern (string|array): pattern or patterns to
+                              match against |autocmd-pattern|.
+
+                Return: ~
+                    Array of autocommands matching the criteria, with each
+                    item containing the following fields:
+                    • id (number): the autocommand id (only when defined with
+                      the API).
+                    • group (integer): the autocommand group id.
+                    • group_name (string): the autocommand group name.
+                    • desc (string): the autocommand description.
+                    • event (string): the autocommand event.
+                    • command (string): the autocommand command. Note: this
+                      will be empty if a callback is set.
+                    • callback (function|string|nil): Lua function or name of
+                      a Vim script function which is executed when this
+                      autocommand is triggered.
+                    • once (boolean): whether the autocommand is only run
+                      once.
+                    • pattern (string): the autocommand pattern. If the
+                      autocommand is buffer local |autocmd-buffer-local|:
+                    • buflocal (boolean): true if the autocommand is buffer
+                      local.
+                    • buffer (number): the buffer number.
+
+
+==============================================================================
 UI Functions                                                          *api-ui*
 
 nvim_ui_attach({width}, {height}, {options})                *nvim_ui_attach()*
@@ -3093,6 +3656,9 @@ nvim_ui_attach({width}, {height}, {options})                *nvim_ui_attach()*
                     A requests 80x40 but client B requests 200x100, the global
                     screen has size 80x40.
 
+                Attributes: ~
+                    |RPC| only
+
                 Parameters: ~
                     {width}    Requested screen columns
                     {height}   Requested screen rows
@@ -3103,6 +3669,9 @@ nvim_ui_detach()                                            *nvim_ui_detach()*
 
                 Removes the client from the list of UIs. |nvim_list_uis()|
 
+                Attributes: ~
+                    |RPC| only
+
                                                     *nvim_ui_pum_set_bounds()*
 nvim_ui_pum_set_bounds({width}, {height}, {row}, {col})
                 Tells Nvim the geometry of the popumenu, to align floating
@@ -3116,6 +3685,9 @@ nvim_ui_pum_set_bounds({width}, {height}, {row}, {col})
                 nor be anchored to exact grid corners, so one can set
                 floating-point numbers to the popup menu geometry.
 
+                Attributes: ~
+                    |RPC| only
+
                 Parameters: ~
                     {width}   Popupmenu width.
                     {height}  Popupmenu height.
@@ -3126,15 +3698,24 @@ nvim_ui_pum_set_height({height})                    *nvim_ui_pum_set_height()*
                 Tells Nvim the number of elements displaying in the popumenu,
                 to decide <PageUp> and <PageDown> movement.
 
+                Attributes: ~
+                    |RPC| only
+
                 Parameters: ~
                     {height}  Popupmenu height, must be greater than zero.
 
 nvim_ui_set_option({name}, {value})                     *nvim_ui_set_option()*
                 TODO: Documentation
 
+                Attributes: ~
+                    |RPC| only
+
 nvim_ui_try_resize({width}, {height})                   *nvim_ui_try_resize()*
                 TODO: Documentation
 
+                Attributes: ~
+                    |RPC| only
+
                                                    *nvim_ui_try_resize_grid()*
 nvim_ui_try_resize_grid({grid}, {width}, {height})
                 Tell Nvim to resize a grid. Triggers a grid_resize event with
@@ -3143,6 +3724,9 @@ nvim_ui_try_resize_grid({grid}, {width}, {height})
 
                 On invalid grid handle, fails with error.
 
+                Attributes: ~
+                    |RPC| only
+
                 Parameters: ~
                     {grid}    The handle of the grid to be changed.
                     {width}   The new requested width.
diff --git a/runtime/doc/arabic.txt b/runtime/doc/arabic.txt
index 5d3bf7a761..0df861111c 100644
--- a/runtime/doc/arabic.txt
+++ b/runtime/doc/arabic.txt
@@ -175,7 +175,7 @@ o  Enable Arabic settings [short-cut]
 	 vertical separator like "l" or "𝖨" may be used.  It may also be
 	 hidden by changing its color to the foreground color: >
 		:set fillchars=vert:l
-		:hi VertSplit ctermbg=White
+		:hi WinSeparator ctermbg=White
 <	Note that this is a workaround, not a proper solution.
 
    If, on the other hand, you'd like to be verbose and explicit and
diff --git a/runtime/doc/autocmd.txt b/runtime/doc/autocmd.txt
index 46d9a3b57a..59e5c078a3 100644
--- a/runtime/doc/autocmd.txt
+++ b/runtime/doc/autocmd.txt
@@ -40,10 +40,10 @@ effects.  Be careful not to destroy your text.
 2. Defining autocommands				*autocmd-define*
 
 							*:au* *:autocmd*
-:au[tocmd] [group] {event} {pat} [++once] [++nested] {cmd}
+:au[tocmd] [group] {event} {aupat} [++once] [++nested] {cmd}
 			Add {cmd} to the list of commands that Vim will
 			execute automatically on {event} for a file matching
-			{pat} |autocmd-pattern|.
+			{aupat} |autocmd-pattern|.
 			Note: A quote character is seen as argument to the
 			:autocmd and won't start a comment.
 			Nvim always adds {cmd} after existing autocommands so
@@ -69,6 +69,7 @@ Or use `:execute`: >
 	:augroup mine | exe "au! BufRead *" | augroup END
 	:augroup mine | exe "au BufRead * set tw=70" | augroup END
 
+<							*autocmd-expand*
 Note that special characters (e.g., "%", "<cword>") in the ":autocmd"
 arguments are not expanded when the autocommand is defined.  These will be
 expanded when the Event is recognized, and the {cmd} is executed.  The only
@@ -119,19 +120,19 @@ prompt.  When one command outputs two messages this can happen anyway.
 ==============================================================================
 3. Removing autocommands				*autocmd-remove*
 
-:au[tocmd]! [group] {event} {pat} [++once] [++nested] {cmd}
+:au[tocmd]! [group] {event} {aupat} [++once] [++nested] {cmd}
 			Remove all autocommands associated with {event} and
-			{pat}, and add the command {cmd}.
+			{aupat}, and add the command {cmd}.
 			See |autocmd-once| for [++once].
 			See |autocmd-nested| for [++nested].
 
-:au[tocmd]! [group] {event} {pat}
+:au[tocmd]! [group] {event} {aupat}
 			Remove all autocommands associated with {event} and
-			{pat}.
+			{aupat}.
 
-:au[tocmd]! [group] * {pat}
-			Remove all autocommands associated with {pat} for all
-			events.
+:au[tocmd]! [group] * {aupat}
+			Remove all autocommands associated with {aupat} for
+			all events.
 
 :au[tocmd]! [group] {event}
 			Remove ALL autocommands for {event}.
@@ -151,12 +152,12 @@ with ":augroup"); otherwise, Vim uses the group defined with [group].
 ==============================================================================
 4. Listing autocommands					*autocmd-list*
 
-:au[tocmd] [group] {event} {pat}
+:au[tocmd] [group] {event} {aupat}
 			Show the autocommands associated with {event} and
-			{pat}.
+			{aupat}.
 
-:au[tocmd] [group] * {pat}
-			Show the autocommands associated with {pat} for all
+:au[tocmd] [group] * {aupat}
+			Show the autocommands associated with {aupat} for all
 			events.
 
 :au[tocmd] [group] {event}
@@ -275,14 +276,14 @@ BufRead or BufReadPost		When starting to edit a new buffer, after
 				processing modelines.  See |BufWinEnter| to do
 				something after processing modelines.
 				Also triggered:
-				- when writing an unnamed buffer such that the
-				  buffer gets a name
+				- when writing an unnamed buffer in a way that
+				  the buffer gets a name
 				- after successfully recovering a file
 				- for the "filetypedetect" group when
 				  executing ":filetype detect"
 				Not triggered:
-				- for ":r file"
-				- if the file doesn't exist
+				- for the `:read file` command
+				- when the file doesn't exist
 							*BufReadCmd*
 BufReadCmd			Before starting to edit a new buffer.  Should
 				read the file into the buffer. |Cmd-event|
@@ -499,10 +500,10 @@ CursorMoved			After the cursor was moved in Normal or Visual
 				mode or to another window.  Also when the text
 				of the cursor line has been changed, e.g. with
 				"x", "rx" or "p".
-				Not triggered when there is typeahead, while
-				executing a script file, when an operator is
-				pending, or when moving to another window while
-				remaining at the same cursor position.
+				Not always triggered when there is typeahead,
+				while executing commands in a script file, or
+				when an operator is pending. Always triggered
+				when moving to another window.
 				For an example see |match-parens|.
 				Note: Cannot be skipped with |:noautocmd|.
 				Careful: This is triggered very often, don't
@@ -525,12 +526,32 @@ DirChanged			After the |current-directory| was changed.
 					"global"  to trigger on `:cd`
 					"auto"    to trigger on 'autochdir'.
 				Sets these |v:event| keys:
-				    cwd:   current working directory
-				    scope: "global", "tab", "window"
+				    cwd:            current working directory
+				    scope:          "global", "tabpage", "window"
 				    changed_window: v:true if we fired the event
 				                    switching window (or tab)
 				<afile> is set to the new directory name.
 				Non-recursive (event cannot trigger itself).
+							*DirChangedPre*
+DirChangedPre			When the |current-directory| is going to be
+				changed, as with |DirChanged|.
+				The pattern is like with |DirChanged|.
+				Sets these |v:event| keys:
+				    directory:      new working directory
+				    scope:          "global", "tabpage", "window"
+				    changed_window: v:true if we fired the event
+				                    switching window (or tab)
+				<afile> is set to the new directory name.
+				Non-recursive (event cannot trigger itself).
+							*ExitPre*
+ExitPre				When using `:quit`, `:wq` in a way it makes
+				Vim exit, or using `:qall`, just after
+				|QuitPre|.  Can be used to close any
+				non-essential window.  Exiting may still be
+				cancelled if there is a modified buffer that
+				isn't automatically saved, use |VimLeavePre|
+				for really exiting.
+				See also |QuitPre|, |WinClosed|.
 							*FileAppendCmd*
 FileAppendCmd			Before appending to a file.  Should do the
 				appending to the file.  Use the '[ and ']
@@ -557,15 +578,6 @@ FileChangedRO			Before making the first change to a read-only
 							*E881*
 				If the number of lines changes saving for undo
 				may fail and the change will be aborted.
-							*ExitPre*
-ExitPre				When using `:quit`, `:wq` in a way it makes
-				Vim exit, or using `:qall`, just after
-				|QuitPre|.  Can be used to close any
-				non-essential window.  Exiting may still be
-				cancelled if there is a modified buffer that
-				isn't automatically saved, use |VimLeavePre|
-				for really exiting.
-				See also |QuitPre|, |WinClosed|.
 							*FileChangedShell*
 FileChangedShell		When Vim notices that the modification time of
 				a file has changed since editing started.
@@ -663,15 +675,19 @@ FuncUndefined			When a user function is used but it isn't
 				alternative is to use an autoloaded function.
 				See |autoload-functions|.
 							*UIEnter*
-UIEnter				After a UI connects via |nvim_ui_attach()|,
-				after VimEnter.  Can be used for GUI-specific
-				configuration.
+UIEnter				After a UI connects via |nvim_ui_attach()|, or
+				after builtin TUI is started, after |VimEnter|.
 				Sets these |v:event| keys:
-				    chan
+				    chan: 0 for builtin TUI
+				          1 for |--embed|
+				          |channel-id| of the UI otherwise
 							*UILeave*
-UILeave				After a UI disconnects from Nvim.
+UILeave				After a UI disconnects from Nvim, or after
+				builtin TUI is stopped, after |VimLeave|.
 				Sets these |v:event| keys:
-				    chan
+				    chan: 0 for builtin TUI
+				          1 for |--embed|
+				          |channel-id| of the UI otherwise
 							*InsertChange*
 InsertChange			When typing <Insert> while in Insert or
 				Replace mode.  The |v:insertmode| variable
@@ -711,13 +727,14 @@ MenuPopup			Just before showing the popup menu (under the
 				right mouse button).  Useful for adjusting the
 				menu for what is under the cursor or mouse
 				pointer.
-				The pattern is matched against a single
-				character representing the mode:
+				The pattern is matched against one or two
+				characters representing the mode:
 					n	Normal
 					v	Visual
 					o	Operator-pending
 					i	Insert
 					c	Command line
+					tl	Terminal
 							*ModeChanged*
 ModeChanged			After changing the mode. The pattern is
 				matched against `'old_mode:new_mode'`, for
@@ -855,7 +872,7 @@ ShellCmdPost			After executing a shell command with |:!cmd|,
 							*Signal*
 Signal				After Nvim receives a signal. The pattern is
 				matched against the signal name. Only
-				"SIGUSR1" is supported.  Example: >
+				"SIGUSR1" and "SIGWINCH" are supported.  Example: >
 				    autocmd Signal SIGUSR1 call some#func()
 <							*ShellFilterPost*
 ShellFilterPost			After executing a shell command with
@@ -1064,27 +1081,36 @@ WinLeave			Before leaving a window.  If the window to be
 				executes the BufLeave autocommands before the
 				WinLeave autocommands (but not for ":new").
 				Not used for ":qa" or ":q" when exiting Vim.
-				After WinClosed.
+				Before WinClosed.
 							*WinNew*
 WinNew				When a new window was created.  Not done for
 				the first window, when Vim has just started.
 				Before WinEnter.
-							*WinScrolled*
-WinScrolled			After scrolling the viewport of the current
-				window.
 
+							*WinScrolled*
+WinScrolled			After scrolling the content of a window or
+				resizing a window.
+				The pattern is matched against the
+				|window-ID|.  Both <amatch> and <afile> are
+				set to the |window-ID|.
+				Non-recursive (the event cannot trigger
+				itself).  However, if the command causes the
+				window to scroll or change size another
+				WinScrolled event will be triggered later.
+				Does not trigger when the command is added,
+				only after the first scroll or resize.
 
 ==============================================================================
-6. Patterns					*autocmd-pattern* *{pat}*
+6. Patterns					*autocmd-pattern* *{aupat}*
 
-The {pat} argument can be a comma separated list.  This works as if the
-command was given with each pattern separately.  Thus this command: >
+The {aupat} argument of `:autocmd` can be a comma-separated list.  This works
+as if the command was given with each pattern separately.  Thus this command: >
 	:autocmd BufRead *.txt,*.info set et
 Is equivalent to: >
 	:autocmd BufRead *.txt set et
 	:autocmd BufRead *.info set et
 
-The file pattern {pat} is tested for a match against the file name in one of
+The file pattern {aupat} is tested for a match against the file name in one of
 two ways:
 1. When there is no '/' in the pattern, Vim checks for a match against only
    the tail part of the file name (without its leading directory path).
@@ -1395,7 +1421,7 @@ Examples for reading and writing compressed files: >
   :  autocmd BufReadPre,FileReadPre	*.gz set bin
   :  autocmd BufReadPost,FileReadPost	*.gz '[,']!gunzip
   :  autocmd BufReadPost,FileReadPost	*.gz set nobin
-  :  autocmd BufReadPost,FileReadPost	*.gz execute ":doautocmd BufReadPost " . expand("%:r")
+  :  autocmd BufReadPost,FileReadPost	*.gz execute ":doautocmd BufReadPost " .. expand("%:r")
   :  autocmd BufWritePost,FileWritePost	*.gz !mv <afile> <afile>:r
   :  autocmd BufWritePost,FileWritePost	*.gz !gzip <afile>:r
 
@@ -1494,7 +1520,7 @@ To insert the current date and time in a *.html file when writing it: >
   :  else
   :    let l = line("$")
   :  endif
-  :  exe "1," . l . "g/Last modified: /s/Last modified: .*/Last modified: " .
+  :  exe "1," .. l .. "g/Last modified: /s/Last modified: .*/Last modified: " ..
   :  \ strftime("%Y %b %d")
   :endfun
 
diff --git a/runtime/doc/builtin.txt b/runtime/doc/builtin.txt
new file mode 100644
index 0000000000..df5a636070
--- /dev/null
+++ b/runtime/doc/builtin.txt
@@ -0,0 +1,9087 @@
+*builtin.txt*	Nvim
+
+
+		  VIM REFERENCE MANUAL	  by Bram Moolenaar
+
+
+Builtin functions				*builtin-functions*
+
+1. Overview				|builtin-function-list|
+2. Details				|builtin-function-details|
+3. Matching a pattern in a String	|string-match|
+
+==============================================================================
+1. Overview					*builtin-function-list*
+
+Use CTRL-] on the function name to jump to the full explanation.
+
+USAGE				RESULT	DESCRIPTION	~
+
+abs({expr})			Float or Number  absolute value of {expr}
+acos({expr})			Float	arc cosine of {expr}
+add({object}, {item})		List/Blob   append {item} to {object}
+and({expr}, {expr})		Number	bitwise AND
+api_info()			Dict	api metadata
+append({lnum}, {text})		Number	append {text} below line {lnum}
+appendbufline({expr}, {lnum}, {text})
+				Number	append {text} below line {lnum}
+					in buffer {expr}
+argc([{winid}])			Number	number of files in the argument list
+argidx()			Number	current index in the argument list
+arglistid([{winnr} [, {tabnr}]]) Number	argument list id
+argv({nr} [, {winid}])		String	{nr} entry of the argument list
+argv([-1, {winid}])		List	the argument list
+asin({expr})			Float	arc sine of {expr}
+assert_beeps({cmd})		Number	assert {cmd} causes a beep
+assert_equal({exp}, {act} [, {msg}])
+				Number	assert {exp} is equal to {act}
+assert_equalfile({fname-one}, {fname-two} [, {msg}])
+				Number	assert file contents are equal
+assert_exception({error} [, {msg}])
+				Number	assert {error} is in v:exception
+assert_fails({cmd} [, {error}])	Number	assert {cmd} fails
+assert_false({actual} [, {msg}])
+				Number	assert {actual} is false
+assert_inrange({lower}, {upper}, {actual} [, {msg}])
+				Number	assert {actual} is inside the range
+assert_match({pat}, {text} [, {msg}])
+				Number	assert {pat} matches {text}
+assert_nobeep({cmd})		Number	assert {cmd} does not cause a beep
+assert_notequal({exp}, {act} [, {msg}])
+				Number	assert {exp} is not equal {act}
+assert_notmatch({pat}, {text} [, {msg}])
+				Number	assert {pat} not matches {text}
+assert_report({msg})		Number	report a test failure
+assert_true({actual} [, {msg}])	Number	assert {actual} is true
+atan({expr})			Float	arc tangent of {expr}
+atan2({expr1}, {expr2})		Float	arc tangent of {expr1} / {expr2}
+browse({save}, {title}, {initdir}, {default})
+				String	put up a file requester
+browsedir({title}, {initdir})	String	put up a directory requester
+bufadd({name})			Number	add a buffer to the buffer list
+bufexists({expr})		Number	|TRUE| if buffer {expr} exists
+buflisted({expr})		Number	|TRUE| if buffer {expr} is listed
+bufload({expr})			Number	load buffer {expr} if not loaded yet
+bufloaded({expr})		Number	|TRUE| if buffer {expr} is loaded
+bufname([{expr}])		String	Name of the buffer {expr}
+bufnr([{expr} [, {create}]])	Number	Number of the buffer {expr}
+bufwinid({expr})		Number	|window-ID| of buffer {expr}
+bufwinnr({expr})		Number	window number of buffer {expr}
+byte2line({byte})		Number	line number at byte count {byte}
+byteidx({expr}, {nr})		Number	byte index of {nr}'th char in {expr}
+byteidxcomp({expr}, {nr})	Number	byte index of {nr}'th char in {expr}
+call({func}, {arglist} [, {dict}])
+				any	call {func} with arguments {arglist}
+ceil({expr})			Float	round {expr} up
+changenr()			Number	current change number
+chanclose({id} [, {stream}])	Number	Closes a channel or one of its streams
+chansend({id}, {data})		Number	Writes {data} to channel
+char2nr({expr} [, {utf8}])	Number	ASCII/UTF-8 value of first char in {expr}
+charcol({expr})			Number	column number of cursor or mark
+charidx({string}, {idx} [, {countcc}])
+				Number	char index of byte {idx} in {string}
+chdir({dir})			String	change current working directory
+cindent({lnum})			Number	C indent for line {lnum}
+clearmatches([{win}])		none	clear all matches
+col({expr})			Number	column byte index of cursor or mark
+complete({startcol}, {matches}) none	set Insert mode completion
+complete_add({expr})		Number	add completion match
+complete_check()		Number	check for key typed during completion
+complete_info([{what}])		Dict	get current completion information
+confirm({msg} [, {choices} [, {default} [, {type}]]])
+				Number	number of choice picked by user
+copy({expr})			any	make a shallow copy of {expr}
+cos({expr})			Float	cosine of {expr}
+cosh({expr})			Float	hyperbolic cosine of {expr}
+count({comp}, {expr} [, {ic} [, {start}]])
+				Number	count how many {expr} are in {comp}
+cscope_connection([{num}, {dbpath} [, {prepend}]])
+				Number	checks existence of cscope connection
+ctxget([{index}])		Dict	return the |context| dict at {index}
+ctxpop()			none	pop and restore |context| from the
+					|context-stack|
+ctxpush([{types}])		none	push the current |context| to the
+					|context-stack|
+ctxset({context} [, {index}])	none	set |context| at {index}
+ctxsize()			Number	return |context-stack| size
+cursor({lnum}, {col} [, {off}])
+				Number	move cursor to {lnum}, {col}, {off}
+cursor({list})			Number	move cursor to position in {list}
+debugbreak({pid})		Number	interrupt process being debugged
+deepcopy({expr} [, {noref}])	any	make a full copy of {expr}
+delete({fname} [, {flags}])	Number	delete the file or directory {fname}
+deletebufline({buf}, {first} [, {last}])
+				Number	delete lines from buffer {buf}
+dictwatcheradd({dict}, {pattern}, {callback})
+				Start watching a dictionary
+dictwatcherdel({dict}, {pattern}, {callback})
+				Stop watching a dictionary
+did_filetype()			Number	|TRUE| if FileType autocommand event used
+diff_filler({lnum})		Number	diff filler lines about {lnum}
+diff_hlID({lnum}, {col})	Number	diff highlighting at {lnum}/{col}
+digraph_get({chars})		String	get the digraph of {chars}
+digraph_getlist([{listall}])	List	get all |digraph|s
+digraph_set({chars}, {digraph})	Boolean	register |digraph|
+digraph_setlist({digraphlist})	Boolean	register multiple |digraph|s
+empty({expr})			Number	|TRUE| if {expr} is empty
+environ()			Dict	return environment variables
+escape({string}, {chars})	String	escape {chars} in {string} with '\'
+eval({string})			any	evaluate {string} into its value
+eventhandler()			Number	|TRUE| if inside an event handler
+executable({expr})		Number	1 if executable {expr} exists
+execute({command})		String	execute and capture output of {command}
+exepath({expr})			String	full path of the command {expr}
+exists({expr})			Number	|TRUE| if {expr} exists
+extend({expr1}, {expr2} [, {expr3}])
+				List/Dict insert items of {expr2} into {expr1}
+exp({expr})			Float	exponential of {expr}
+expand({expr} [, {nosuf} [, {list}]])
+				any	expand special keywords in {expr}
+expandcmd({expr})		String	expand {expr} like with `:edit`
+feedkeys({string} [, {mode}])	Number	add key sequence to typeahead buffer
+filereadable({file})		Number	|TRUE| if {file} is a readable file
+filewritable({file})		Number	|TRUE| if {file} is a writable file
+filter({expr1}, {expr2})	List/Dict  remove items from {expr1} where
+					{expr2} is 0
+finddir({name} [, {path} [, {count}]])
+				String	find directory {name} in {path}
+findfile({name} [, {path} [, {count}]])
+				String	find file {name} in {path}
+flatten({list} [, {maxdepth}])	List	flatten {list} up to {maxdepth} levels
+float2nr({expr})		Number	convert Float {expr} to a Number
+floor({expr})			Float	round {expr} down
+fmod({expr1}, {expr2})		Float	remainder of {expr1} / {expr2}
+fnameescape({fname})		String	escape special characters in {fname}
+fnamemodify({fname}, {mods})	String	modify file name
+foldclosed({lnum})		Number	first line of fold at {lnum} if closed
+foldclosedend({lnum})		Number	last line of fold at {lnum} if closed
+foldlevel({lnum})		Number	fold level at {lnum}
+foldtext()			String	line displayed for closed fold
+foldtextresult({lnum})		String	text for closed fold at {lnum}
+fullcommand({name})		String	get full command from {name}
+funcref({name} [, {arglist}] [, {dict}])
+				Funcref	reference to function {name}
+function({name} [, {arglist}] [, {dict}])
+				Funcref	named reference to function {name}
+garbagecollect([{atexit}])	none	free memory, breaking cyclic references
+get({list}, {idx} [, {def}])	any	get item {idx} from {list} or {def}
+get({dict}, {key} [, {def}])	any	get item {key} from {dict} or {def}
+get({func}, {what})		any	get property of funcref/partial {func}
+getbufinfo([{buf}])		List	information about buffers
+getbufline({buf}, {lnum} [, {end}])
+				List	lines {lnum} to {end} of buffer {buf}
+getbufvar({buf}, {varname} [, {def}])
+				any	variable {varname} in buffer {buf}
+getchangelist([{buf}])		List	list of change list items
+getchar([expr])			Number or String
+					get one character from the user
+getcharmod()			Number	modifiers for the last typed character
+getcharpos({expr})		List	position of cursor, mark, etc.
+getcharsearch()			Dict	last character search
+getcharstr([expr])		String	get one character from the user
+getcmdcompltype()		String	return the type of the current
+					command-line completion
+getcmdline()			String	return the current command-line
+getcmdpos()			Number	return cursor position in command-line
+getcmdscreenpos()		Number	return cursor screen position in
+					command-line
+getcmdtype()			String	return current command-line type
+getcmdwintype()			String	return current command-line window type
+getcompletion({pat}, {type} [, {filtered}])
+				List	list of cmdline completion matches
+getcurpos([{winnr}])		List	position of the cursor
+getcursorcharpos([{winnr}])	List	character position of the cursor
+getcwd([{winnr} [, {tabnr}]])	String	get the current working directory
+getenv({name})			String	return environment variable
+getfontname([{name}])		String	name of font being used
+getfperm({fname})		String	file permissions of file {fname}
+getfsize({fname})		Number	size in bytes of file {fname}
+getftime({fname})		Number	last modification time of file
+getftype({fname})		String	description of type of file {fname}
+getjumplist([{winnr} [, {tabnr}]])
+				List	list of jump list items
+getline({lnum})			String	line {lnum} of current buffer
+getline({lnum}, {end})		List	lines {lnum} to {end} of current buffer
+getloclist({nr})		List	list of location list items
+getloclist({nr}, {what})	Dict	get specific location list properties
+getmarklist([{buf}])		List	list of global/local marks
+getmatches([{win}])		List	list of current matches
+getmousepos()			Dict	last known mouse position
+getpid()			Number	process ID of Vim
+getpos({expr})			List	position of cursor, mark, etc.
+getqflist()			List	list of quickfix items
+getqflist({what})		Dict	get specific quickfix list properties
+getreg([{regname} [, 1 [, {list}]]])
+				String or List   contents of a register
+getreginfo([{regname}])		Dict	information about a register
+getregtype([{regname}])		String	type of a register
+gettabinfo([{expr}])		List	list of tab pages
+gettabvar({nr}, {varname} [, {def}])
+				any	variable {varname} in tab {nr} or {def}
+gettabwinvar({tabnr}, {winnr}, {name} [, {def}])
+				any	{name} in {winnr} in tab page {tabnr}
+gettagstack([{nr}])		Dict	get the tag stack of window {nr}
+getwininfo([{winid}])		List	list of info about each window
+getwinpos([{timeout}])		List	X and Y coord in pixels of the Vim window
+getwinposx()			Number	X coord in pixels of Vim window
+getwinposy()			Number	Y coord in pixels of Vim window
+getwinvar({nr}, {varname} [, {def}])
+				any	variable {varname} in window {nr}
+glob({expr} [, {nosuf} [, {list} [, {alllinks}]]])
+				any	expand file wildcards in {expr}
+glob2regpat({expr})		String	convert a glob pat into a search pat
+globpath({path}, {expr} [, {nosuf} [, {list} [, {alllinks}]]])
+				String	do glob({expr}) for all dirs in {path}
+has({feature})			Number	|TRUE| if feature {feature} supported
+has_key({dict}, {key})		Number	|TRUE| if {dict} has entry {key}
+haslocaldir([{winnr} [, {tabnr}]])
+				Number	|TRUE| if the window executed |:lcd| or
+					the tab executed |:tcd|
+hasmapto({what} [, {mode} [, {abbr}]])
+				Number	|TRUE| if mapping to {what} exists
+histadd({history}, {item})	String	add an item to a history
+histdel({history} [, {item}])	String	remove an item from a history
+histget({history} [, {index}])	String	get the item {index} from a history
+histnr({history})		Number	highest index of a history
+hlexists({name})		Number	|TRUE| if highlight group {name} exists
+hlID({name})			Number	syntax ID of highlight group {name}
+hostname()			String	name of the machine Vim is running on
+iconv({expr}, {from}, {to})	String	convert encoding of {expr}
+indent({lnum})			Number	indent of line {lnum}
+index({object}, {expr} [, {start} [, {ic}]])
+				Number	index in {object} where {expr} appears
+input({prompt} [, {text} [, {completion}]])
+				String	get input from the user
+inputlist({textlist})		Number	let the user pick from a choice list
+inputrestore()			Number	restore typeahead
+inputsave()			Number	save and clear typeahead
+inputsecret({prompt} [, {text}])
+				String	like input() but hiding the text
+insert({object}, {item} [, {idx}])
+				List	insert {item} in {object} [before {idx}]
+interrupt()			none	interrupt script execution
+invert({expr})			Number	bitwise invert
+isdirectory({directory})	Number	|TRUE| if {directory} is a directory
+isinf({expr})			Number	determine if {expr} is infinity value
+					(positive or negative)
+islocked({expr})		Number	|TRUE| if {expr} is locked
+isnan({expr})			Number	|TRUE| if {expr} is NaN
+id({expr})			String	identifier of the container
+items({dict})			List	key-value pairs in {dict}
+jobpid({id})			Number	Returns pid of a job.
+jobresize({id}, {width}, {height})
+				Number	Resize pseudo terminal window of a job
+jobstart({cmd} [, {opts}])	Number	Spawns {cmd} as a job
+jobstop({id})			Number	Stops a job
+jobwait({ids} [, {timeout}])	Number	Wait for a set of jobs
+join({list} [, {sep}])		String	join {list} items into one String
+json_decode({expr})		any	Convert {expr} from JSON
+json_encode({expr})		String	Convert {expr} to JSON
+keys({dict})			List	keys in {dict}
+len({expr})			Number	the length of {expr}
+libcall({lib}, {func}, {arg})	String	call {func} in library {lib} with {arg}
+libcallnr({lib}, {func}, {arg})	Number	idem, but return a Number
+line({expr} [, {winid}])	Number	line nr of cursor, last line or mark
+line2byte({lnum})		Number	byte count of line {lnum}
+lispindent({lnum})		Number	Lisp indent for line {lnum}
+list2str({list} [, {utf8}])	String	turn numbers in {list} into a String
+localtime()			Number	current time
+log({expr})			Float	natural logarithm (base e) of {expr}
+log10({expr})			Float	logarithm of Float {expr} to base 10
+luaeval({expr} [, {expr}])	any	evaluate |Lua| expression
+map({expr1}, {expr2})		List/Dict  change each item in {expr1} to {expr}
+maparg({name} [, {mode} [, {abbr} [, {dict}]]])
+				String or Dict
+					rhs of mapping {name} in mode {mode}
+mapcheck({name} [, {mode} [, {abbr}]])
+				String	check for mappings matching {name}
+match({expr}, {pat} [, {start} [, {count}]])
+				Number	position where {pat} matches in {expr}
+matchadd({group}, {pattern} [, {priority} [, {id} [, {dict}]]])
+				Number	highlight {pattern} with {group}
+matchaddpos({group}, {pos} [, {priority} [, {id} [, {dict}]]])
+				Number	highlight positions with {group}
+matcharg({nr})			List	arguments of |:match|
+matchdelete({id} [, {win}])	Number	delete match identified by {id}
+matchend({expr}, {pat} [, {start} [, {count}]])
+				Number	position where {pat} ends in {expr}
+matchfuzzy({list}, {str} [, {dict}])
+				List	fuzzy match {str} in {list}
+matchfuzzypos({list}, {str} [, {dict}])
+				List	fuzzy match {str} in {list}
+matchlist({expr}, {pat} [, {start} [, {count}]])
+				List	match and submatches of {pat} in {expr}
+matchstr({expr}, {pat} [, {start} [, {count}]])
+				String	{count}'th match of {pat} in {expr}
+matchstrpos({expr}, {pat} [, {start} [, {count}]])
+				List	{count}'th match of {pat} in {expr}
+max({expr})			Number	maximum value of items in {expr}
+menu_get({path} [, {modes}])	List	description of |menus| matched by {path}
+min({expr})			Number	minimum value of items in {expr}
+mkdir({name} [, {path} [, {prot}]])
+				Number	create directory {name}
+mode([expr])			String	current editing mode
+msgpackdump({list} [, {type}])	List/Blob  dump objects to msgpack
+msgpackparse({data})		List	parse msgpack to a list of objects
+nextnonblank({lnum})		Number	line nr of non-blank line >= {lnum}
+nr2char({expr} [, {utf8}])	String	single char with ASCII/UTF-8 value {expr}
+nvim_...({args}...)		any	call nvim |api| functions
+or({expr}, {expr})		Number	bitwise OR
+pathshorten({expr} [, {len}])	String	shorten directory names in a path
+perleval({expr})		any	evaluate |perl| expression
+pow({x}, {y})			Float	{x} to the power of {y}
+prevnonblank({lnum})		Number	line nr of non-blank line <= {lnum}
+printf({fmt}, {expr1}...)	String	format text
+prompt_getprompt({buf})		String	get prompt text
+prompt_setcallback({buf}, {expr}) none	set prompt callback function
+prompt_setinterrupt({buf}, {text}) none	set prompt interrupt function
+prompt_setprompt({buf}, {text}) none	set prompt text
+pum_getpos()			Dict	position and size of pum if visible
+pumvisible()			Number	whether popup menu is visible
+pyeval({expr})			any	evaluate |Python| expression
+py3eval({expr})			any	evaluate |python3| expression
+pyxeval({expr})			any	evaluate |python_x| expression
+rand([{expr}])			Number	get pseudo-random number
+range({expr} [, {max} [, {stride}]])
+				List	items from {expr} to {max}
+readdir({dir} [, {expr}])	List	file names in {dir} selected by {expr}
+readfile({fname} [, {type} [, {max}]])
+				List	get list of lines from file {fname}
+reduce({object}, {func} [, {initial}])
+				any	reduce {object} using {func}
+reg_executing()			String	get the executing register name
+reg_recorded()			String	get the last recorded register name
+reg_recording()			String	get the recording register name
+reltime([{start} [, {end}]])	List	get time value
+reltimefloat({time})		Float	turn the time value into a Float
+reltimestr({time})		String	turn time value into a String
+remove({list}, {idx} [, {end}])	any/List
+					remove items {idx}-{end} from {list}
+remove({blob}, {idx} [, {end}])	Number/Blob
+					remove bytes {idx}-{end} from {blob}
+remove({dict}, {key})		any	remove entry {key} from {dict}
+rename({from}, {to})		Number	rename (move) file from {from} to {to}
+repeat({expr}, {count})		String	repeat {expr} {count} times
+resolve({filename})		String	get filename a shortcut points to
+reverse({list})			List	reverse {list} in-place
+round({expr})			Float	round off {expr}
+rubyeval({expr})		any	evaluate |Ruby| expression
+rpcnotify({channel}, {event} [, {args}...])
+				Sends an |RPC| notification to {channel}
+rpcrequest({channel}, {method} [, {args}...])
+				Sends an |RPC| request to {channel}
+screenattr({row}, {col})	Number	attribute at screen position
+screenchar({row}, {col})	Number	character at screen position
+screenchars({row}, {col})	List	List of characters at screen position
+screencol()			Number	current cursor column
+screenpos({winid}, {lnum}, {col}) Dict	screen row and col of a text character
+screenrow()			Number	current cursor row
+screenstring({row}, {col})	String	characters at screen position
+search({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]])
+				Number	search for {pattern}
+searchcount([{options}])	Dict	Get or update the last search count
+searchdecl({name} [, {global} [, {thisblock}]])
+				Number	search for variable declaration
+searchpair({start}, {middle}, {end} [, {flags} [, {skip} [...]]])
+				Number	search for other end of start/end pair
+searchpairpos({start}, {middle}, {end} [, {flags} [, {skip} [...]]])
+				List	search for other end of start/end pair
+searchpos({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]])
+				List	search for {pattern}
+serverlist()			String	get a list of available servers
+setbufline({expr}, {lnum}, {text})
+				Number	set line {lnum} to {text} in buffer
+					{expr}
+setbufvar({buf}, {varname}, {val})	set {varname} in buffer {buf} to {val}
+setcharpos({expr}, {list})	Number	set the {expr} position to {list}
+setcharsearch({dict})		Dict	set character search from {dict}
+setcmdpos({pos})		Number	set cursor position in command-line
+setcursorcharpos({list})	Number	move cursor to position in {list}
+setenv({name}, {val})		none	set environment variable
+setfperm({fname}, {mode}	Number	set {fname} file permissions to {mode}
+setline({lnum}, {line})		Number	set line {lnum} to {line}
+setloclist({nr}, {list} [, {action}])
+				Number	modify location list using {list}
+setloclist({nr}, {list}, {action}, {what})
+				Number	modify specific location list props
+setmatches({list} [, {win}])	Number	restore a list of matches
+setpos({expr}, {list})		Number	set the {expr} position to {list}
+setqflist({list} [, {action}])	Number	modify quickfix list using {list}
+setqflist({list}, {action}, {what})
+				Number	modify specific quickfix list props
+setreg({n}, {v} [, {opt}])	Number	set register to value and type
+settabvar({nr}, {varname}, {val})	set {varname} in tab page {nr} to {val}
+settabwinvar({tabnr}, {winnr}, {varname}, {val})    set {varname} in window
+					{winnr} in tab page {tabnr} to {val}
+settagstack({nr}, {dict} [, {action}])
+				Number	modify tag stack using {dict}
+setwinvar({nr}, {varname}, {val})	set {varname} in window {nr} to {val}
+sha256({string})		String	SHA256 checksum of {string}
+shellescape({string} [, {special}])
+				String	escape {string} for use as shell
+					command argument
+shiftwidth([{col}])		Number	effective value of 'shiftwidth'
+sign_define({name} [, {dict}])	Number	define or update a sign
+sign_define({list})		List	define or update a list of signs
+sign_getdefined([{name}])	List	get a list of defined signs
+sign_getplaced([{buf} [, {dict}]])
+				List	get a list of placed signs
+sign_jump({id}, {group}, {buf})
+				Number	jump to a sign
+sign_place({id}, {group}, {name}, {buf} [, {dict}])
+				Number	place a sign
+sign_placelist({list})		List	place a list of signs
+sign_undefine([{name}])		Number	undefine a sign
+sign_undefine({list})		List	undefine a list of signs
+sign_unplace({group} [, {dict}])
+				Number	unplace a sign
+sign_unplacelist({list})	List	unplace a list of signs
+simplify({filename})		String	simplify filename as much as possible
+sin({expr})			Float	sine of {expr}
+sinh({expr})			Float	hyperbolic sine of {expr}
+sockconnect({mode}, {address} [, {opts}])
+				Number	Connects to socket
+sort({list} [, {func} [, {dict}]])
+				List	sort {list}, using {func} to compare
+soundfold({word})		String	sound-fold {word}
+spellbadword()			String	badly spelled word at cursor
+spellsuggest({word} [, {max} [, {capital}]])
+				List	spelling suggestions
+split({expr} [, {pat} [, {keepempty}]])
+				List	make |List| from {pat} separated {expr}
+sqrt({expr})			Float	square root of {expr}
+srand([{expr}])			List	get seed for |rand()|
+stdioopen({dict})		Number	open stdio in a headless instance.
+stdpath({what})			String/List  returns the standard path(s) for {what}
+str2float({expr} [, {quoted}])	Float	convert String to Float
+str2list({expr} [, {utf8}])	List	convert each character of {expr} to
+					ASCII/UTF-8 value
+str2nr({expr} [, {base} [, {quoted}]])
+				Number	convert String to Number
+strchars({expr} [, {skipcc}])	Number	character length of the String {expr}
+strcharpart({str}, {start} [, {len}])
+				String	{len} characters of {str} at
+					character {start}
+strdisplaywidth({expr} [, {col}]) Number display length of the String {expr}
+strftime({format} [, {time}])	String	format time with a specified format
+strgetchar({str}, {index})	Number	get char {index} from {str}
+stridx({haystack}, {needle} [, {start}])
+				Number	index of {needle} in {haystack}
+string({expr})			String	String representation of {expr} value
+strlen({expr})			Number	length of the String {expr}
+strpart({str}, {start} [, {len} [, {chars}]])
+				String	{len} bytes/chars of {str} at
+					byte {start}
+strptime({format}, {timestring})
+				Number	Convert {timestring} to unix timestamp
+strridx({haystack}, {needle} [, {start}])
+				Number	last index of {needle} in {haystack}
+strtrans({expr})		String	translate string to make it printable
+strwidth({expr})		Number	display cell length of the String {expr}
+submatch({nr} [, {list}])	String or List
+					specific match in ":s" or substitute()
+substitute({expr}, {pat}, {sub}, {flags})
+				String	all {pat} in {expr} replaced with {sub}
+swapinfo({fname})		Dict	information about swap file {fname}
+swapname({buf})			String	swap file of buffer {buf}
+synID({lnum}, {col}, {trans})	Number	syntax ID at {lnum} and {col}
+synIDattr({synID}, {what} [, {mode}])
+				String	attribute {what} of syntax ID {synID}
+synIDtrans({synID})		Number	translated syntax ID of {synID}
+synconcealed({lnum}, {col})	List	info about concealing
+synstack({lnum}, {col})	List	stack of syntax IDs at {lnum} and {col}
+system({cmd} [, {input}])	String	output of shell command/filter {cmd}
+systemlist({cmd} [, {input}])	List	output of shell command/filter {cmd}
+tabpagebuflist([{arg}])		List	list of buffer numbers in tab page
+tabpagenr([{arg}])		Number	number of current or last tab page
+tabpagewinnr({tabarg} [, {arg}])
+				Number	number of current window in tab page
+taglist({expr} [, {filename}])	List	list of tags matching {expr}
+tagfiles()			List	tags files used
+tan({expr})			Float	tangent of {expr}
+tanh({expr})			Float	hyperbolic tangent of {expr}
+tempname()			String	name for a temporary file
+test_garbagecollect_now()	none	free memory right now for testing
+timer_info([{id}])		List	information about timers
+timer_pause({id}, {pause})	none	pause or unpause a timer
+timer_start({time}, {callback} [, {options}])
+				Number	create a timer
+timer_stop({timer})		none	stop a timer
+timer_stopall()			none	stop all timers
+tolower({expr})			String	the String {expr} switched to lowercase
+toupper({expr})			String	the String {expr} switched to uppercase
+tr({src}, {fromstr}, {tostr})	String	translate chars of {src} in {fromstr}
+					to chars in {tostr}
+trim({text} [, {mask} [, {dir}]])
+				String	trim characters in {mask} from {text}
+trunc({expr})			Float	truncate Float {expr}
+type({name})			Number	type of variable {name}
+undofile({name})		String	undo file name for {name}
+undotree()			List	undo file tree
+uniq({list} [, {func} [, {dict}]])
+				List	remove adjacent duplicates from a list
+values({dict})			List	values in {dict}
+virtcol({expr})			Number	screen column of cursor or mark
+visualmode([expr])		String	last visual mode used
+wait({timeout}, {condition} [, {interval}])
+				Number	Wait until {condition} is satisfied
+wildmenumode()			Number	whether 'wildmenu' mode is active
+win_execute({id}, {command} [, {silent}])
+				String	execute {command} in window {id}
+win_findbuf({bufnr})		List	find windows containing {bufnr}
+win_getid([{win} [, {tab}]])	Number	get |window-ID| for {win} in {tab}
+win_gettype([{nr}])		String	type of window {nr}
+win_gotoid({expr})		Number	go to |window-ID| {expr}
+win_id2tabwin({expr})		List	get tab and window nr from |window-ID|
+win_id2win({expr})		Number	get window nr from |window-ID|
+win_move_separator({nr})	Number	move window vertical separator
+win_move_statusline({nr})	Number	move window status line
+win_screenpos({nr})		List	get screen position of window {nr}
+win_splitmove({nr}, {target} [, {options}])
+				Number	move window {nr} to split of {target}
+winbufnr({nr})			Number	buffer number of window {nr}
+wincol()			Number	window column of the cursor
+windowsversion()		String	MS-Windows OS version
+winheight({nr})			Number	height of window {nr}
+winlayout([{tabnr}])		List	layout of windows in tab {tabnr}
+winline()			Number	window line of the cursor
+winnr([{expr}])			Number	number of current window
+winrestcmd()			String	returns command to restore window sizes
+winrestview({dict})		none	restore view of current window
+winsaveview()			Dict	save view of current window
+winwidth({nr})			Number	width of window {nr}
+wordcount()			Dict	get byte/char/word statistics
+writefile({object}, {fname} [, {flags}])
+				Number	write |Blob| or |List| of lines to file
+xor({expr}, {expr})		Number	bitwise XOR
+
+==============================================================================
+2. Details					*builtin-function-details*
+
+Not all functions are here, some have been moved to a help file covering the
+specific functionality.
+
+abs({expr})							*abs()*
+		Return the absolute value of {expr}.  When {expr} evaluates to
+		a |Float| abs() returns a |Float|.  When {expr} can be
+		converted to a |Number| abs() returns a |Number|.  Otherwise
+		abs() gives an error message and returns -1.
+		Examples: >
+			echo abs(1.456)
+<			1.456  >
+			echo abs(-5.456)
+<			5.456  >
+			echo abs(-4)
+<			4
+
+		Can also be used as a |method|: >
+			Compute()->abs()
+
+acos({expr})							*acos()*
+		Return the arc cosine of {expr} measured in radians, as a
+		|Float| in the range of [0, pi].
+		{expr} must evaluate to a |Float| or a |Number| in the range
+		[-1, 1].
+		Returns NaN if {expr} is outside the range [-1, 1].  Returns
+ 		0.0 if {expr} is not a |Float| or a |Number|.
+		Examples: >
+			:echo acos(0)
+<			1.570796 >
+			:echo acos(-0.5)
+<			2.094395
+
+		Can also be used as a |method|: >
+			Compute()->acos()
+
+add({object}, {expr})					*add()*
+		Append the item {expr} to |List| or |Blob| {object}.  Returns
+		the resulting |List| or |Blob|.  Examples: >
+			:let alist = add([1, 2, 3], item)
+			:call add(mylist, "woodstock")
+<		Note that when {expr} is a |List| it is appended as a single
+		item.  Use |extend()| to concatenate |Lists|.
+		When {object} is a |Blob| then {expr} must be a number.
+		Use |insert()| to add an item at another position.
+		Returns 1 if {object} is not a |List| or a |Blob|.
+
+		Can also be used as a |method|: >
+			mylist->add(val1)->add(val2)
+
+and({expr}, {expr})					*and()*
+		Bitwise AND on the two arguments.  The arguments are converted
+		to a number.  A List, Dict or Float argument causes an error.
+		Example: >
+			:let flag = and(bits, 0x80)
+<		Can also be used as a |method|: >
+			:let flag = bits->and(0x80)
+
+api_info()						*api_info()*
+		Returns Dictionary of |api-metadata|.
+
+		View it in a nice human-readable format: >
+		       :lua print(vim.inspect(vim.fn.api_info()))
+
+append({lnum}, {text})					*append()*
+		When {text} is a |List|: Append each item of the |List| as a
+		text line below line {lnum} in the current buffer.
+		Otherwise append {text} as one text line below line {lnum} in
+		the current buffer.
+		{lnum} can be zero to insert a line before the first one.
+		{lnum} is used like with |getline()|.
+		Returns 1 for failure ({lnum} out of range or out of memory),
+		0 for success.  Example: >
+			:let failed = append(line('$'), "# THE END")
+			:let failed = append(0, ["Chapter 1", "the beginning"])
+
+<		Can also be used as a |method| after a List: >
+			mylist->append(lnum)
+
+appendbufline({buf}, {lnum}, {text})			*appendbufline()*
+		Like |append()| but append the text in buffer {expr}.
+
+		This function works only for loaded buffers. First call
+		|bufload()| if needed.
+
+		For the use of {buf}, see |bufname()|.
+
+		{lnum} is used like with |append()|.  Note that using |line()|
+		would use the current buffer, not the one appending to.
+		Use "$" to append at the end of the buffer.
+
+		On success 0 is returned, on failure 1 is returned.
+
+		If {buf} is not a valid buffer or {lnum} is not valid, an
+		error message is given. Example: >
+			:let failed = appendbufline(13, 0, "# THE START")
+<
+		Can also be used as a |method| after a List: >
+			mylist->appendbufline(buf, lnum)
+
+argc([{winid}])					*argc()*
+		The result is the number of files in the argument list.  See
+		|arglist|.
+		If {winid} is not supplied, the argument list of the current
+		window is used.
+		If {winid} is -1, the global argument list is used.
+		Otherwise {winid} specifies the window of which the argument
+		list is used: either the window number or the window ID.
+		Returns -1 if the {winid} argument is invalid.
+
+							*argidx()*
+argidx()	The result is the current index in the argument list.  0 is
+		the first file.  argc() - 1 is the last one.  See |arglist|.
+
+							*arglistid()*
+arglistid([{winnr} [, {tabnr}]])
+		Return the argument list ID.  This is a number which
+		identifies the argument list being used.  Zero is used for the
+		global argument list.  See |arglist|.
+		Returns -1 if the arguments are invalid.
+
+		Without arguments use the current window.
+		With {winnr} only use this window in the current tab page.
+		With {winnr} and {tabnr} use the window in the specified tab
+		page.
+		{winnr} can be the window number or the |window-ID|.
+
+							*argv()*
+argv([{nr} [, {winid}]])
+		The result is the {nr}th file in the argument list.  See
+		|arglist|.  "argv(0)" is the first one.  Example: >
+	:let i = 0
+	:while i < argc()
+	:  let f = escape(fnameescape(argv(i)), '.')
+	:  exe 'amenu Arg.' .. f .. ' :e ' .. f .. '<CR>'
+	:  let i = i + 1
+	:endwhile
+<		Without the {nr} argument, or when {nr} is -1, a |List| with
+		the whole |arglist| is returned.
+
+		The {winid} argument specifies the window ID, see |argc()|.
+		For the Vim command line arguments see |v:argv|.
+
+		Returns an empty string if {nr}th argument is not present in
+		the argument list.  Returns an empty List if the {winid}
+		argument is invalid.
+
+asin({expr})						*asin()*
+		Return the arc sine of {expr} measured in radians, as a |Float|
+		in the range of [-pi/2, pi/2].
+		{expr} must evaluate to a |Float| or a |Number| in the range
+		[-1, 1].
+		Returns NaN if {expr} is outside the range [-1, 1].  Returns
+		0.0 if {expr} is not a |Float| or a |Number|.
+		Examples: >
+			:echo asin(0.8)
+<			0.927295 >
+			:echo asin(-0.5)
+<			-0.523599
+
+		Can also be used as a |method|: >
+			Compute()->asin()
+
+
+assert_ functions are documented here: |assert-functions-details|
+
+
+atan({expr})						*atan()*
+		Return the principal value of the arc tangent of {expr}, in
+		the range [-pi/2, +pi/2] radians, as a |Float|.
+		{expr} must evaluate to a |Float| or a |Number|.
+		Returns 0.0 if {expr} is not a |Float| or a |Number|.
+		Examples: >
+			:echo atan(100)
+<			1.560797 >
+			:echo atan(-4.01)
+<			-1.326405
+
+		Can also be used as a |method|: >
+			Compute()->atan()
+
+atan2({expr1}, {expr2})					*atan2()*
+		Return the arc tangent of {expr1} / {expr2}, measured in
+		radians, as a |Float| in the range [-pi, pi].
+		{expr1} and {expr2} must evaluate to a |Float| or a |Number|.
+		Returns 0.0 if {expr1} or {expr2} is not a |Float| or a
+		|Number|.
+		Examples: >
+			:echo atan2(-1, 1)
+<			-0.785398 >
+			:echo atan2(1, -1)
+<			2.356194
+
+		Can also be used as a |method|: >
+			Compute()->atan2(1)
+
+							*browse()*
+browse({save}, {title}, {initdir}, {default})
+		Put up a file requester.  This only works when "has("browse")"
+		returns |TRUE| (only in some GUI versions).
+		The input fields are:
+		    {save}	when |TRUE|, select file to write
+		    {title}	title for the requester
+		    {initdir}	directory to start browsing in
+		    {default}	default file name
+		An empty string is returned when the "Cancel" button is hit,
+		something went wrong, or browsing is not possible.
+
+							*browsedir()*
+browsedir({title}, {initdir})
+		Put up a directory requester.  This only works when
+		"has("browse")" returns |TRUE| (only in some GUI versions).
+		On systems where a directory browser is not supported a file
+		browser is used.  In that case: select a file in the directory
+		to be used.
+		The input fields are:
+		    {title}	title for the requester
+		    {initdir}	directory to start browsing in
+		When the "Cancel" button is hit, something went wrong, or
+		browsing is not possible, an empty string is returned.
+
+bufadd({name})						*bufadd()*
+		Add a buffer to the buffer list with String {name}.
+		If a buffer for file {name} already exists, return that buffer
+		number.  Otherwise return the buffer number of the newly
+		created buffer.  When {name} is an empty string then a new
+		buffer is always created.
+		The buffer will not have 'buflisted' set and not be loaded
+		yet.  To add some text to the buffer use this: >
+			let bufnr = bufadd('someName')
+			call bufload(bufnr)
+			call setbufline(bufnr, 1, ['some', 'text'])
+<		Returns 0 on error.
+		Can also be used as a |method|: >
+			let bufnr = 'somename'->bufadd()
+
+bufexists({buf})					*bufexists()*
+		The result is a Number, which is |TRUE| if a buffer called
+		{buf} exists.
+		If the {buf} argument is a number, buffer numbers are used.
+		Number zero is the alternate buffer for the current window.
+
+		If the {buf} argument is a string it must match a buffer name
+		exactly.  The name can be:
+		- Relative to the current directory.
+		- A full path.
+		- The name of a buffer with 'buftype' set to "nofile".
+		- A URL name.
+		Unlisted buffers will be found.
+		Note that help files are listed by their short name in the
+		output of |:buffers|, but bufexists() requires using their
+		long name to be able to find them.
+		bufexists() may report a buffer exists, but to use the name
+		with a |:buffer| command you may need to use |expand()|.  Esp
+		for MS-Windows 8.3 names in the form "c:\DOCUME~1"
+		Use "bufexists(0)" to test for the existence of an alternate
+		file name.
+
+		Can also be used as a |method|: >
+			let exists = 'somename'->bufexists()
+
+buflisted({buf})					*buflisted()*
+		The result is a Number, which is |TRUE| if a buffer called
+		{buf} exists and is listed (has the 'buflisted' option set).
+		The {buf} argument is used like with |bufexists()|.
+
+		Can also be used as a |method|: >
+			let listed = 'somename'->buflisted()
+
+bufload({buf})						*bufload()*
+		Ensure the buffer {buf} is loaded.  When the buffer name
+		refers to an existing file then the file is read.  Otherwise
+		the buffer will be empty.  If the buffer was already loaded
+		then there is no change.
+		If there is an existing swap file for the file of the buffer,
+		there will be no dialog, the buffer will be loaded anyway.
+		The {buf} argument is used like with |bufexists()|.
+
+		Can also be used as a |method|: >
+			eval 'somename'->bufload()
+
+bufloaded({buf})					*bufloaded()*
+		The result is a Number, which is |TRUE| if a buffer called
+		{buf} exists and is loaded (shown in a window or hidden).
+		The {buf} argument is used like with |bufexists()|.
+
+		Can also be used as a |method|: >
+			let loaded = 'somename'->bufloaded()
+
+bufname([{buf}])						*bufname()*
+		The result is the name of a buffer.  Mostly as it is displayed
+		by the `:ls` command, but not using special names such as
+		"[No Name]".
+		If {buf} is omitted the current buffer is used.
+		If {buf} is a Number, that buffer number's name is given.
+		Number zero is the alternate buffer for the current window.
+		If {buf} is a String, it is used as a |file-pattern| to match
+		with the buffer names.  This is always done like 'magic' is
+		set and 'cpoptions' is empty.  When there is more than one
+		match an empty string is returned.
+		"" or "%" can be used for the current buffer, "#" for the
+		alternate buffer.
+		A full match is preferred, otherwise a match at the start, end
+		or middle of the buffer name is accepted.  If you only want a
+		full match then put "^" at the start and "$" at the end of the
+		pattern.
+		Listed buffers are found first.  If there is a single match
+		with a listed buffer, that one is returned.  Next unlisted
+		buffers are searched for.
+		If the {buf} is a String, but you want to use it as a buffer
+		number, force it to be a Number by adding zero to it: >
+			:echo bufname("3" + 0)
+<		Can also be used as a |method|: >
+			echo bufnr->bufname()
+
+<		If the buffer doesn't exist, or doesn't have a name, an empty
+		string is returned. >
+	bufname("#")		alternate buffer name
+	bufname(3)		name of buffer 3
+	bufname("%")		name of current buffer
+	bufname("file2")	name of buffer where "file2" matches.
+<
+							*bufnr()*
+bufnr([{buf} [, {create}]])
+		The result is the number of a buffer, as it is displayed by
+		the `:ls` command.  For the use of {buf}, see |bufname()|
+		above.
+		If the buffer doesn't exist, -1 is returned.  Or, if the
+		{create} argument is present and TRUE, a new, unlisted,
+		buffer is created and its number is returned.
+		bufnr("$") is the last buffer: >
+			:let last_buffer = bufnr("$")
+<		The result is a Number, which is the highest buffer number
+		of existing buffers.  Note that not all buffers with a smaller
+		number necessarily exist, because ":bwipeout" may have removed
+		them.  Use bufexists() to test for the existence of a buffer.
+
+		Can also be used as a |method|: >
+			echo bufref->bufnr()
+
+bufwinid({buf})						*bufwinid()*
+		The result is a Number, which is the |window-ID| of the first
+		window associated with buffer {buf}.  For the use of {buf},
+		see |bufname()| above.  If buffer {buf} doesn't exist or
+		there is no such window, -1 is returned.  Example: >
+
+	echo "A window containing buffer 1 is " .. (bufwinid(1))
+<
+		Only deals with the current tab page.
+
+		Can also be used as a |method|: >
+			FindBuffer()->bufwinid()
+
+bufwinnr({buf})						*bufwinnr()*
+		Like |bufwinid()| but return the window number instead of the
+		|window-ID|.
+		If buffer {buf} doesn't exist or there is no such window, -1
+		is returned.  Example: >
+
+	echo "A window containing buffer 1 is " .. (bufwinnr(1))
+
+<		The number can be used with |CTRL-W_w| and ":wincmd w"
+		|:wincmd|.
+
+		Can also be used as a |method|: >
+			FindBuffer()->bufwinnr()
+
+byte2line({byte})					*byte2line()*
+		Return the line number that contains the character at byte
+		count {byte} in the current buffer.  This includes the
+		end-of-line character, depending on the 'fileformat' option
+		for the current buffer.  The first character has byte count
+		one.
+		Also see |line2byte()|, |go| and |:goto|.
+
+		Returns -1 if the {byte} value is invalid.
+
+		Can also be used as a |method|: >
+			GetOffset()->byte2line()
+
+byteidx({expr}, {nr})					*byteidx()*
+		Return byte index of the {nr}'th character in the String
+		{expr}.  Use zero for the first character, it then returns
+		zero.
+		If there are no multibyte characters the returned value is
+		equal to {nr}.
+		Composing characters are not counted separately, their byte
+		length is added to the preceding base character.  See
+		|byteidxcomp()| below for counting composing characters
+		separately.
+		Example : >
+			echo matchstr(str, ".", byteidx(str, 3))
+<		will display the fourth character.  Another way to do the
+		same: >
+			let s = strpart(str, byteidx(str, 3))
+			echo strpart(s, 0, byteidx(s, 1))
+<		Also see |strgetchar()| and |strcharpart()|.
+
+		If there are less than {nr} characters -1 is returned.
+		If there are exactly {nr} characters the length of the string
+		in bytes is returned.
+
+		Can also be used as a |method|: >
+			GetName()->byteidx(idx)
+
+byteidxcomp({expr}, {nr})					*byteidxcomp()*
+		Like byteidx(), except that a composing character is counted
+		as a separate character.  Example: >
+			let s = 'e' .. nr2char(0x301)
+			echo byteidx(s, 1)
+			echo byteidxcomp(s, 1)
+			echo byteidxcomp(s, 2)
+<		The first and third echo result in 3 ('e' plus composing
+		character is 3 bytes), the second echo results in 1 ('e' is
+		one byte).
+
+		Can also be used as a |method|: >
+			GetName()->byteidxcomp(idx)
+
+call({func}, {arglist} [, {dict}])			*call()* *E699*
+		Call function {func} with the items in |List| {arglist} as
+		arguments.
+		{func} can either be a |Funcref| or the name of a function.
+		a:firstline and a:lastline are set to the cursor line.
+		Returns the return value of the called function.
+		{dict} is for functions with the "dict" attribute.  It will be
+		used to set the local variable "self". |Dictionary-function|
+
+		Can also be used as a |method|: >
+			GetFunc()->call([arg, arg], dict)
+
+ceil({expr})							*ceil()*
+		Return the smallest integral value greater than or equal to
+		{expr} as a |Float| (round up).
+		{expr} must evaluate to a |Float| or a |Number|.
+		Examples: >
+			echo ceil(1.456)
+<			2.0  >
+			echo ceil(-5.456)
+<			-5.0  >
+			echo ceil(4.0)
+<			4.0
+
+		Returns 0.0 if {expr} is not a |Float| or a |Number|.
+
+		Can also be used as a |method|: >
+			Compute()->ceil()
+
+changenr()						*changenr()*
+		Return the number of the most recent change.  This is the same
+		number as what is displayed with |:undolist| and can be used
+		with the |:undo| command.
+		When a change was made it is the number of that change.  After
+		redo it is the number of the redone change.  After undo it is
+		one less than the number of the undone change.
+		Returns 0 if the undo list is empty.
+
+chanclose({id} [, {stream}])				*chanclose()*
+		Close a channel or a specific stream associated with it.
+		For a job, {stream} can be one of "stdin", "stdout",
+		"stderr" or "rpc" (closes stdin/stdout for a job started
+		with `"rpc":v:true`) If {stream} is omitted, all streams
+		are closed. If the channel is a pty, this will then close the
+		pty master, sending SIGHUP to the job process.
+		For a socket, there is only one stream, and {stream} should be
+		ommited.
+
+chansend({id}, {data})					*chansend()*
+		Send data to channel {id}. For a job, it writes it to the
+		stdin of the process. For the stdio channel |channel-stdio|,
+		it writes to Nvim's stdout.  Returns the number of bytes
+		written if the write succeeded, 0 otherwise.
+		See |channel-bytes| for more information.
+
+		{data} may be a string, string convertible, |Blob|, or a list.
+		If {data} is a list, the items will be joined by newlines; any
+		newlines in an item will be sent as NUL. To send a final
+		newline, include a final empty string. Example: >
+			:call chansend(id, ["abc", "123\n456", ""])
+< 		will send "abc<NL>123<NUL>456<NL>".
+
+		chansend() writes raw data, not RPC messages.  If the channel
+		was created with `"rpc":v:true` then the channel expects RPC
+		messages, use |rpcnotify()| and |rpcrequest()| instead.
+
+
+char2nr({string} [, {utf8}])					*char2nr()*
+		Return Number value of the first char in {string}.
+		Examples: >
+			char2nr(" ")		returns 32
+			char2nr("ABC")		returns 65
+			char2nr("á")		returns 225
+			char2nr("á"[0])		returns 195
+			char2nr("\<M-x>")	returns 128
+<		Non-ASCII characters are always treated as UTF-8 characters.
+		{utf8} is ignored, it exists only for backwards-compatibility.
+		A combining character is a separate character.
+		|nr2char()| does the opposite.
+
+		Returns 0 if {string} is not a |String|.
+
+		Can also be used as a |method|: >
+			GetChar()->char2nr()
+<
+							*charcol()*
+charcol({expr})	Same as |col()| but returns the character index of the column
+		position given with {expr} instead of the byte position.
+
+		Example:
+		With the cursor on '세' in line 5 with text "여보세요": >
+			charcol('.')		returns 3
+			col('.')		returns 7
+
+<		Can also be used as a |method|: >
+			GetPos()->col()
+<
+							*charidx()*
+charidx({string}, {idx} [, {countcc}])
+		Return the character index of the byte at {idx} in {string}.
+		The index of the first character is zero.
+		If there are no multibyte characters the returned value is
+		equal to {idx}.
+		When {countcc} is omitted or |FALSE|, then composing characters
+		are not counted separately, their byte length is
+		added to the preceding base character.
+		When {countcc} is |TRUE|, then composing characters are
+		counted as separate characters.
+		Returns -1 if the arguments are invalid or if {idx} is greater
+		than the index of the last byte in {string}.  An error is
+		given if the first argument is not a string, the second
+		argument is not a number or when the third argument is present
+		and is not zero or one.
+		See |byteidx()| and |byteidxcomp()| for getting the byte index
+		from the character index.
+		Examples: >
+			echo charidx('áb́ć', 3)		returns 1
+			echo charidx('áb́ć', 6, 1)	returns 4
+			echo charidx('áb́ć', 16)		returns -1
+<
+		Can also be used as a |method|: >
+			GetName()->charidx(idx)
+
+chdir({dir})						*chdir()*
+		Change the current working directory to {dir}.  The scope of
+		the directory change depends on the directory of the current
+		window:
+			- If the current window has a window-local directory
+			  (|:lcd|), then changes the window local directory.
+			- Otherwise, if the current tabpage has a local
+			  directory (|:tcd|) then changes the tabpage local
+			  directory.
+			- Otherwise, changes the global directory.
+		If successful, returns the previous working directory.  Pass
+		this to another chdir() to restore the directory.
+		On failure, returns an empty string.
+
+		Example: >
+			let save_dir = chdir(newdir)
+			if save_dir
+			   " ... do some work
+			   call chdir(save_dir)
+			endif
+<
+cindent({lnum})						*cindent()*
+		Get the amount of indent for line {lnum} according the C
+		indenting rules, as with 'cindent'.
+		The indent is counted in spaces, the value of 'tabstop' is
+		relevant.  {lnum} is used just like in |getline()|.
+		When {lnum} is invalid -1 is returned.
+		See |C-indenting|.
+
+		Can also be used as a |method|: >
+			GetLnum()->cindent()
+
+clearmatches([{win}])					*clearmatches()*
+ 		Clears all matches previously defined for the current window
+ 		by |matchadd()| and the |:match| commands.
+		If {win} is specified, use the window with this number or
+		window ID instead of the current window.
+
+		Can also be used as a |method|: >
+			GetWin()->clearmatches()
+<
+							*col()*
+col({expr})	The result is a Number, which is the byte index of the column
+		position given with {expr}.  The accepted positions are:
+		    .	    the cursor position
+		    $	    the end of the cursor line (the result is the
+			    number of bytes in the cursor line plus one)
+		    'x	    position of mark x (if the mark is not set, 0 is
+			    returned)
+		    v       In Visual mode: the start of the Visual area (the
+			    cursor is the end).  When not in Visual mode
+			    returns the cursor position.  Differs from |'<| in
+			    that it's updated right away.
+		Additionally {expr} can be [lnum, col]: a |List| with the line
+		and column number. Most useful when the column is "$", to get
+		the last column of a specific line.  When "lnum" or "col" is
+		out of range then col() returns zero.
+		To get the line number use |line()|.  To get both use
+		|getpos()|.
+		For the screen column position use |virtcol()|.  For the
+		character position use |charcol()|.
+		Note that only marks in the current file can be used.
+		Examples: >
+			col(".")		column of cursor
+			col("$")		length of cursor line plus one
+			col("'t")		column of mark t
+			col("'" .. markname)	column of mark markname
+<		The first column is 1.  Returns 0 if {expr} is invalid.
+		For an uppercase mark the column may actually be in another
+		buffer.
+		For the cursor position, when 'virtualedit' is active, the
+		column is one higher if the cursor is after the end of the
+		line.  This can be used to obtain the column in Insert mode: >
+			:imap <F2> <C-O>:let save_ve = &ve<CR>
+				\<C-O>:set ve=all<CR>
+				\<C-O>:echo col(".") .. "\n" <Bar>
+				\let &ve = save_ve<CR>
+
+<		Can also be used as a |method|: >
+			GetPos()->col()
+<
+
+complete({startcol}, {matches})			*complete()* *E785*
+		Set the matches for Insert mode completion.
+		Can only be used in Insert mode.  You need to use a mapping
+		with CTRL-R = (see |i_CTRL-R|).  It does not work after CTRL-O
+		or with an expression mapping.
+		{startcol} is the byte offset in the line where the completed
+		text start.  The text up to the cursor is the original text
+		that will be replaced by the matches.  Use col('.') for an
+		empty string.  "col('.') - 1" will replace one character by a
+		match.
+		{matches} must be a |List|.  Each |List| item is one match.
+		See |complete-items| for the kind of items that are possible.
+		"longest" in 'completeopt' is ignored.
+		Note that the after calling this function you need to avoid
+		inserting anything that would cause completion to stop.
+		The match can be selected with CTRL-N and CTRL-P as usual with
+		Insert mode completion.  The popup menu will appear if
+		specified, see |ins-completion-menu|.
+		Example: >
+	inoremap <F5> <C-R>=ListMonths()<CR>
+
+	func! ListMonths()
+	  call complete(col('.'), ['January', 'February', 'March',
+		\ 'April', 'May', 'June', 'July', 'August', 'September',
+		\ 'October', 'November', 'December'])
+	  return ''
+	endfunc
+<		This isn't very useful, but it shows how it works.  Note that
+		an empty string is returned to avoid a zero being inserted.
+
+		Can also be used as a |method|, the base is passed as the
+		second argument: >
+			GetMatches()->complete(col('.'))
+
+complete_add({expr})				*complete_add()*
+		Add {expr} to the list of matches.  Only to be used by the
+		function specified with the 'completefunc' option.
+		Returns 0 for failure (empty string or out of memory),
+		1 when the match was added, 2 when the match was already in
+		the list.
+		See |complete-functions| for an explanation of {expr}.  It is
+		the same as one item in the list that 'omnifunc' would return.
+
+		Can also be used as a |method|: >
+			GetMoreMatches()->complete_add()
+
+complete_check()				*complete_check()*
+		Check for a key typed while looking for completion matches.
+		This is to be used when looking for matches takes some time.
+		Returns |TRUE| when searching for matches is to be aborted,
+		zero otherwise.
+		Only to be used by the function specified with the
+		'completefunc' option.
+
+
+complete_info([{what}])				*complete_info()*
+		Returns a |Dictionary| with information about Insert mode
+		completion.  See |ins-completion|.
+		The items are:
+		   mode		Current completion mode name string.
+				See |complete_info_mode| for the values.
+		   pum_visible	|TRUE| if popup menu is visible.
+				See |pumvisible()|.
+		   items	List of completion matches.  Each item is a
+				dictionary containing the entries "word",
+				"abbr", "menu", "kind", "info" and "user_data".
+				See |complete-items|.
+		   selected	Selected item index.  First index is zero.
+				Index is -1 if no item is selected (showing
+				typed text only, or the last completion after
+				no item is selected when using the <Up> or
+				<Down> keys)
+		   inserted	Inserted string. [NOT IMPLEMENT YET]
+
+							*complete_info_mode*
+		mode values are:
+		   ""		     Not in completion mode
+		   "keyword"	     Keyword completion |i_CTRL-X_CTRL-N|
+		   "ctrl_x"	     Just pressed CTRL-X |i_CTRL-X|
+		   "scroll"	     Scrolling with |i_CTRL-X_CTRL-E| or
+				     |i_CTRL-X_CTRL-Y|
+		   "whole_line"	     Whole lines |i_CTRL-X_CTRL-L|
+		   "files"	     File names |i_CTRL-X_CTRL-F|
+		   "tags"	     Tags |i_CTRL-X_CTRL-]|
+		   "path_defines"    Definition completion |i_CTRL-X_CTRL-D|
+		   "path_patterns"   Include completion |i_CTRL-X_CTRL-I|
+		   "dictionary"	     Dictionary |i_CTRL-X_CTRL-K|
+		   "thesaurus"	     Thesaurus |i_CTRL-X_CTRL-T|
+		   "cmdline"	     Vim Command line |i_CTRL-X_CTRL-V|
+		   "function"	     User defined completion |i_CTRL-X_CTRL-U|
+		   "omni"	     Omni completion |i_CTRL-X_CTRL-O|
+		   "spell"	     Spelling suggestions |i_CTRL-X_s|
+		   "eval"	     |complete()| completion
+		   "unknown"	     Other internal modes
+
+		If the optional {what} list argument is supplied, then only
+		the items listed in {what} are returned.  Unsupported items in
+		{what} are silently ignored.
+
+		To get the position and size of the popup menu, see
+		|pum_getpos()|. It's also available in |v:event| during the
+		|CompleteChanged| event.
+
+		Returns an empty |Dictionary| on error.
+
+		Examples: >
+			" Get all items
+			call complete_info()
+			" Get only 'mode'
+			call complete_info(['mode'])
+			" Get only 'mode' and 'pum_visible'
+			call complete_info(['mode', 'pum_visible'])
+
+<		Can also be used as a |method|: >
+			GetItems()->complete_info()
+<
+						*confirm()*
+confirm({msg} [, {choices} [, {default} [, {type}]]])
+		confirm() offers the user a dialog, from which a choice can be
+		made.  It returns the number of the choice.  For the first
+		choice this is 1.
+
+		{msg} is displayed in a dialog with {choices} as the
+		alternatives.  When {choices} is missing or empty, "&OK" is
+		used (and translated).
+		{msg} is a String, use '\n' to include a newline.  Only on
+		some systems the string is wrapped when it doesn't fit.
+
+		{choices} is a String, with the individual choices separated
+		by '\n', e.g. >
+			confirm("Save changes?", "&Yes\n&No\n&Cancel")
+<		The letter after the '&' is the shortcut key for that choice.
+		Thus you can type 'c' to select "Cancel".  The shortcut does
+		not need to be the first letter: >
+			confirm("file has been modified", "&Save\nSave &All")
+<		For the console, the first letter of each choice is used as
+		the default shortcut key.  Case is ignored.
+
+		The optional {type} String argument gives the type of dialog.
+		It can be one of these values: "Error", "Question", "Info",
+		"Warning" or "Generic".  Only the first character is relevant.
+		When {type} is omitted, "Generic" is used.
+
+		The optional {type} argument gives the type of dialog.  This
+		is only used for the icon of the Win32 GUI.  It can be one of
+		these values: "Error", "Question", "Info", "Warning" or
+		"Generic".  Only the first character is relevant.
+		When {type} is omitted, "Generic" is used.
+
+		If the user aborts the dialog by pressing <Esc>, CTRL-C,
+		or another valid interrupt key, confirm() returns 0.
+
+		An example: >
+		   let choice = confirm("What do you want?",
+					\ "&Apples\n&Oranges\n&Bananas", 2)
+		   if choice == 0
+			echo "make up your mind!"
+		   elseif choice == 3
+			echo "tasteful"
+		   else
+			echo "I prefer bananas myself."
+		   endif
+<		In a GUI dialog, buttons are used.  The layout of the buttons
+		depends on the 'v' flag in 'guioptions'.  If it is included,
+		the buttons are always put vertically.  Otherwise,  confirm()
+		tries to put the buttons in one horizontal line.  If they
+		don't fit, a vertical layout is used anyway.  For some systems
+		the horizontal layout is always used.
+
+		Can also be used as a |method|in: >
+			BuildMessage()->confirm("&Yes\n&No")
+<
+							*copy()*
+copy({expr})	Make a copy of {expr}.  For Numbers and Strings this isn't
+		different from using {expr} directly.
+		When {expr} is a |List| a shallow copy is created.  This means
+		that the original |List| can be changed without changing the
+		copy, and vice versa.  But the items are identical, thus
+		changing an item changes the contents of both |Lists|.
+		A |Dictionary| is copied in a similar way as a |List|.
+		Also see |deepcopy()|.
+		Can also be used as a |method|: >
+			mylist->copy()
+
+cos({expr})						*cos()*
+		Return the cosine of {expr}, measured in radians, as a |Float|.
+		{expr} must evaluate to a |Float| or a |Number|.
+		Returns 0.0 if {expr} is not a |Float| or a |Number|.
+		Examples: >
+			:echo cos(100)
+<			0.862319 >
+			:echo cos(-4.01)
+<			-0.646043
+
+		Can also be used as a |method|: >
+			Compute()->cos()
+
+cosh({expr})						*cosh()*
+		Return the hyperbolic cosine of {expr} as a |Float| in the range
+		[1, inf].
+		{expr} must evaluate to a |Float| or a |Number|.
+		Returns 0.0 if {expr} is not a |Float| or a |Number|.
+		Examples: >
+			:echo cosh(0.5)
+<			1.127626 >
+			:echo cosh(-0.5)
+<			-1.127626
+
+		Can also be used as a |method|: >
+			Compute()->cosh()
+
+count({comp}, {expr} [, {ic} [, {start}]])			*count()*
+		Return the number of times an item with value {expr} appears
+		in |String|, |List| or |Dictionary| {comp}.
+
+		If {start} is given then start with the item with this index.
+		{start} can only be used with a |List|.
+
+		When {ic} is given and it's |TRUE| then case is ignored.
+
+		When {comp} is a string then the number of not overlapping
+		occurrences of {expr} is returned. Zero is returned when
+		{expr} is an empty string.
+
+		Can also be used as a |method|: >
+			mylist->count(val)
+<
+							*cscope_connection()*
+cscope_connection([{num} , {dbpath} [, {prepend}]])
+		Checks for the existence of a |cscope| connection.  If no
+		parameters are specified, then the function returns:
+			0, if there are no cscope connections;
+			1, if there is at least one cscope connection.
+
+		If parameters are specified, then the value of {num}
+		determines how existence of a cscope connection is checked:
+
+		{num}	Description of existence check
+		-----	------------------------------
+		0	Same as no parameters (e.g., "cscope_connection()").
+		1	Ignore {prepend}, and use partial string matches for
+			{dbpath}.
+		2	Ignore {prepend}, and use exact string matches for
+			{dbpath}.
+		3	Use {prepend}, use partial string matches for both
+			{dbpath} and {prepend}.
+		4	Use {prepend}, use exact string matches for both
+			{dbpath} and {prepend}.
+
+		Note: All string comparisons are case sensitive!
+
+		Examples.  Suppose we had the following (from ":cs show"): >
+
+  # pid    database name			prepend path
+  0 27664  cscope.out				/usr/local
+<
+		Invocation					Return Val ~
+		----------					---------- >
+		cscope_connection()					1
+		cscope_connection(1, "out")				1
+		cscope_connection(2, "out")				0
+		cscope_connection(3, "out")				0
+		cscope_connection(3, "out", "local")			1
+		cscope_connection(4, "out")				0
+		cscope_connection(4, "out", "local")			0
+		cscope_connection(4, "cscope.out", "/usr/local")	1
+<
+
+ctxget([{index}])					*ctxget()*
+		Returns a |Dictionary| representing the |context| at {index}
+		from the top of the |context-stack| (see |context-dict|).
+		If {index} is not given, it is assumed to be 0 (i.e.: top).
+
+ctxpop()						*ctxpop()*
+		Pops and restores the |context| at the top of the
+		|context-stack|.
+
+ctxpush([{types}])					*ctxpush()*
+		Pushes the current editor state (|context|) on the
+		|context-stack|.
+		If {types} is given and is a |List| of |String|s, it specifies
+		which |context-types| to include in the pushed context.
+		Otherwise, all context types are included.
+
+ctxset({context} [, {index}])				*ctxset()*
+		Sets the |context| at {index} from the top of the
+		|context-stack| to that represented by {context}.
+		{context} is a Dictionary with context data (|context-dict|).
+		If {index} is not given, it is assumed to be 0 (i.e.: top).
+
+ctxsize()						*ctxsize()*
+		Returns the size of the |context-stack|.
+
+cursor({lnum}, {col} [, {off}])				*cursor()*
+cursor({list})
+		Positions the cursor at the column (byte count) {col} in the
+		line {lnum}.  The first column is one.
+
+		When there is one argument {list} this is used as a |List|
+		with two, three or four item:
+			[{lnum}, {col}]
+			[{lnum}, {col}, {off}]
+			[{lnum}, {col}, {off}, {curswant}]
+		This is like the return value of |getpos()| or |getcurpos()|,
+		but without the first item.
+
+		To position the cursor using the character count, use
+		|setcursorcharpos()|.
+
+		Does not change the jumplist.
+		If {lnum} is greater than the number of lines in the buffer,
+		the cursor will be positioned at the last line in the buffer.
+		If {lnum} is zero, the cursor will stay in the current line.
+		If {col} is greater than the number of bytes in the line,
+		the cursor will be positioned at the last character in the
+		line.
+		If {col} is zero, the cursor will stay in the current column.
+		If {curswant} is given it is used to set the preferred column
+		for vertical movement.  Otherwise {col} is used.
+
+		When 'virtualedit' is used {off} specifies the offset in
+		screen columns from the start of the character.  E.g., a
+		position within a <Tab> or after the last character.
+		Returns 0 when the position could be set, -1 otherwise.
+
+		Can also be used as a |method|: >
+			GetCursorPos()->cursor()
+
+deepcopy({expr} [, {noref}])				*deepcopy()* *E698*
+		Make a copy of {expr}.  For Numbers and Strings this isn't
+		different from using {expr} directly.
+		When {expr} is a |List| a full copy is created.  This means
+		that the original |List| can be changed without changing the
+		copy, and vice versa.  When an item is a |List|, a copy for it
+		is made, recursively.  Thus changing an item in the copy does
+		not change the contents of the original |List|.
+
+		When {noref} is omitted or zero a contained |List| or
+		|Dictionary| is only copied once.  All references point to
+		this single copy.  With {noref} set to 1 every occurrence of a
+		|List| or |Dictionary| results in a new copy.  This also means
+		that a cyclic reference causes deepcopy() to fail.
+								*E724*
+		Nesting is possible up to 100 levels.  When there is an item
+		that refers back to a higher level making a deep copy with
+		{noref} set to 1 will fail.
+		Also see |copy()|.
+
+		Can also be used as a |method|: >
+			GetObject()->deepcopy()
+
+delete({fname} [, {flags}])				*delete()*
+		Without {flags} or with {flags} empty: Deletes the file by the
+		name {fname}.
+
+		This also works when {fname} is a symbolic link.  The symbolic
+		link itself is deleted, not what it points to.
+
+		When {flags} is "d": Deletes the directory by the name
+		{fname}.  This fails when directory {fname} is not empty.
+
+		When {flags} is "rf": Deletes the directory by the name
+		{fname} and everything in it, recursively.  BE CAREFUL!
+		Note: on MS-Windows it is not possible to delete a directory
+		that is being used.
+
+		The result is a Number, which is 0/false if the delete
+		operation was successful and -1/true when the deletion failed
+		or partly failed.
+
+		Can also be used as a |method|: >
+			GetName()->delete()
+
+deletebufline({buf}, {first} [, {last}])		*deletebufline()*
+		Delete lines {first} to {last} (inclusive) from buffer {buf}.
+		If {last} is omitted then delete line {first} only.
+		On success 0 is returned, on failure 1 is returned.
+
+		This function works only for loaded buffers. First call
+		|bufload()| if needed.
+
+		For the use of {buf}, see |bufname()| above.
+
+		{first} and {last} are used like with |getline()|. Note that
+		when using |line()| this refers to the current buffer. Use "$"
+		to refer to the last line in buffer {buf}.
+
+		Can also be used as a |method|: >
+			GetBuffer()->deletebufline(1)
+<
+dictwatcheradd({dict}, {pattern}, {callback})		      *dictwatcheradd()*
+		Adds a watcher to a dictionary. A dictionary watcher is
+		identified by three components:
+
+		- A dictionary({dict});
+		- A key pattern({pattern}).
+		- A function({callback}).
+
+		After this is called, every change on {dict} and on keys
+		matching {pattern} will result in {callback} being invoked.
+
+		For example, to watch all global variables: >
+			silent! call dictwatcherdel(g:, '*', 'OnDictChanged')
+			function! OnDictChanged(d,k,z)
+			  echomsg string(a:k) string(a:z)
+			endfunction
+			call dictwatcheradd(g:, '*', 'OnDictChanged')
+<
+		For now {pattern} only accepts very simple patterns that can
+		contain a '*' at the end of the string, in which case it will
+		match every key that begins with the substring before the '*'.
+		That means if '*' is not the last character of {pattern}, only
+		keys that are exactly equal as {pattern} will be matched.
+
+		The {callback} receives three arguments:
+
+		- The dictionary being watched.
+		- The key which changed.
+		- A dictionary containing the new and old values for the key.
+
+		The type of change can be determined by examining the keys
+		present on the third argument:
+
+		- If contains both `old` and `new`, the key was updated.
+		- If it contains only `new`, the key was added.
+		- If it contains only `old`, the key was deleted.
+
+		This function can be used by plugins to implement options with
+		validation and parsing logic.
+
+dictwatcherdel({dict}, {pattern}, {callback})		      *dictwatcherdel()*
+		Removes a watcher added  with |dictwatcheradd()|. All three
+		arguments must match the ones passed to |dictwatcheradd()| in
+		order for the watcher to be successfully deleted.
+
+							*did_filetype()*
+did_filetype()	Returns |TRUE| when autocommands are being executed and the
+		FileType event has been triggered at least once.  Can be used
+		to avoid triggering the FileType event again in the scripts
+		that detect the file type. |FileType|
+		Returns |FALSE| when `:setf FALLBACK` was used.
+		When editing another file, the counter is reset, thus this
+		really checks if the FileType event has been triggered for the
+		current buffer.  This allows an autocommand that starts
+		editing another buffer to set 'filetype' and load a syntax
+		file.
+
+diff_filler({lnum})					*diff_filler()*
+		Returns the number of filler lines above line {lnum}.
+		These are the lines that were inserted at this point in
+		another diff'ed window.  These filler lines are shown in the
+		display but don't exist in the buffer.
+		{lnum} is used like with |getline()|.  Thus "." is the current
+		line, "'m" mark m, etc.
+		Returns 0 if the current window is not in diff mode.
+
+		Can also be used as a |method|: >
+			GetLnum()->diff_filler()
+
+diff_hlID({lnum}, {col})				*diff_hlID()*
+		Returns the highlight ID for diff mode at line {lnum} column
+		{col} (byte index).  When the current line does not have a
+		diff change zero is returned.
+		{lnum} is used like with |getline()|.  Thus "." is the current
+		line, "'m" mark m, etc.
+		{col} is 1 for the leftmost column, {lnum} is 1 for the first
+		line.
+		The highlight ID can be used with |synIDattr()| to obtain
+		syntax information about the highlighting.
+
+		Can also be used as a |method|: >
+			GetLnum()->diff_hlID(col)
+<
+
+digraph_get({chars})					*digraph_get()* *E1214*
+		Return the digraph of {chars}.  This should be a string with
+		exactly two characters.  If {chars} are not just two
+		characters, or the digraph of {chars} does not exist, an error
+		is given and an empty string is returned.
+
+		Also see |digraph_getlist()|.
+
+		Examples: >
+		" Get a built-in digraph
+		:echo digraph_get('00')		" Returns '∞'
+
+		" Get a user-defined digraph
+		:call digraph_set('aa', 'あ')
+		:echo digraph_get('aa')		" Returns 'あ'
+<
+		Can also be used as a |method|: >
+			GetChars()->digraph_get()
+<
+
+digraph_getlist([{listall}])				*digraph_getlist()*
+		Return a list of digraphs.  If the {listall} argument is given
+		and it is TRUE, return all digraphs, including the default
+		digraphs.  Otherwise, return only user-defined digraphs.
+
+		Also see |digraph_get()|.
+
+		Examples: >
+		" Get user-defined digraphs
+		:echo digraph_getlist()
+
+		" Get all the digraphs, including default digraphs
+		:echo digraph_getlist(1)
+<
+		Can also be used as a |method|: >
+			GetNumber()->digraph_getlist()
+<
+
+digraph_set({chars}, {digraph})				*digraph_set()*
+		Add digraph {chars} to the list.  {chars} must be a string
+		with two characters.  {digraph} is a string with one UTF-8
+		encoded character.  *E1215*
+		Be careful, composing characters are NOT ignored.  This
+		function is similar to |:digraphs| command, but useful to add
+		digraphs start with a white space.
+
+		The function result is v:true if |digraph| is registered.  If
+		this fails an error message is given and v:false is returned.
+
+		If you want to define multiple digraphs at once, you can use
+		|digraph_setlist()|.
+
+		Example: >
+			call digraph_set('  ', 'あ')
+<
+		Can be used as a |method|: >
+			GetString()->digraph_set('あ')
+<
+
+digraph_setlist({digraphlist})				*digraph_setlist()*
+		Similar to |digraph_set()| but this function can add multiple
+		digraphs at once.  {digraphlist} is a list composed of lists,
+		where each list contains two strings with {chars} and
+		{digraph} as in |digraph_set()|. *E1216*
+		Example: >
+		    call digraph_setlist([['aa', 'あ'], ['ii', 'い']])
+<
+		It is similar to the following: >
+		    for [chars, digraph] in [['aa', 'あ'], ['ii', 'い']]
+			  call digraph_set(chars, digraph)
+		    endfor
+<		Except that the function returns after the first error,
+		following digraphs will not be added.
+
+		Can be used as a |method|: >
+		    GetList()->digraph_setlist()
+<
+
+empty({expr})						*empty()*
+		Return the Number 1 if {expr} is empty, zero otherwise.
+		- A |List| or |Dictionary| is empty when it does not have any
+		  items.
+		- A |String| is empty when its length is zero.
+		- A |Number| and |Float| are empty when their value is zero.
+		- |v:false| and |v:null| are empty, |v:true| is not.
+		- A |Blob| is empty when its length is zero.
+
+		Can also be used as a |method|: >
+			mylist->empty()
+
+environ()						*environ()*
+		Return all of environment variables as dictionary. You can
+		check if an environment variable exists like this: >
+			:echo has_key(environ(), 'HOME')
+<		Note that the variable name may be CamelCase; to ignore case
+		use this: >
+			:echo index(keys(environ()), 'HOME', 0, 1) != -1
+
+escape({string}, {chars})				*escape()*
+		Escape the characters in {chars} that occur in {string} with a
+		backslash.  Example: >
+			:echo escape('c:\program files\vim', ' \')
+<		results in: >
+			c:\\program\ files\\vim
+<		Also see |shellescape()| and |fnameescape()|.
+
+		Can also be used as a |method|: >
+			GetText()->escape(' \')
+<
+							*eval()*
+eval({string})	Evaluate {string} and return the result.  Especially useful to
+		turn the result of |string()| back into the original value.
+		This works for Numbers, Floats, Strings, Blobs and composites
+		of them.  Also works for |Funcref|s that refer to existing
+		functions.
+
+		Can also be used as a |method|: >
+			argv->join()->eval()
+
+eventhandler()						*eventhandler()*
+		Returns 1 when inside an event handler.  That is that Vim got
+		interrupted while waiting for the user to type a character,
+		e.g., when dropping a file on Vim.  This means interactive
+		commands cannot be used.  Otherwise zero is returned.
+
+executable({expr})					*executable()*
+		This function checks if an executable with the name {expr}
+		exists.  {expr} must be the name of the program without any
+		arguments.
+		executable() uses the value of $PATH and/or the normal
+		searchpath for programs.		*PATHEXT*
+		On MS-Windows the ".exe", ".bat", etc. can optionally be
+		included.  Then the extensions in $PATHEXT are tried.  Thus if
+		"foo.exe" does not exist, "foo.exe.bat" can be found.  If
+		$PATHEXT is not set then ".exe;.com;.bat;.cmd" is used.  A dot
+		by itself can be used in $PATHEXT to try using the name
+		without an extension.  When 'shell' looks like a Unix shell,
+		then the name is also tried without adding an extension.
+		On MS-Windows it only checks if the file exists and is not a
+		directory, not if it's really executable.
+		On Windows an executable in the same directory as Vim is
+		always found (it is added to $PATH at |startup|).
+		The result is a Number:
+			1	exists
+			0	does not exist
+			-1	not implemented on this system
+		|exepath()| can be used to get the full path of an executable.
+
+		Can also be used as a |method|: >
+			GetCommand()->executable()
+
+execute({command} [, {silent}])				*execute()*
+		Execute {command} and capture its output.
+		If {command} is a |String|, returns {command} output.
+		If {command} is a |List|, returns concatenated outputs.
+		Examples: >
+			echo execute('echon "foo"')
+<			foo >
+			echo execute(['echon "foo"', 'echon "bar"'])
+<			foobar
+
+		The optional {silent} argument can have these values:
+			""		no `:silent` used
+			"silent"	`:silent` used
+			"silent!"	`:silent!` used
+		The default is "silent".  Note that with "silent!", unlike
+		`:redir`, error messages are dropped.
+
+		To get a list of lines use |split()| on the result: >
+			execute('args')->split("\n")
+
+<		This function is not available in the |sandbox|.
+		Note: If nested, an outer execute() will not observe output of
+		the inner calls.
+		Note: Text attributes (highlights) are not captured.
+		To execute a command in another window than the current one
+		use `win_execute()`.
+
+		Can also be used as a |method|: >
+			GetCommand()->execute()
+
+exepath({expr})						*exepath()*
+		Returns the full path of {expr} if it is an executable and
+		given as a (partial or full) path or is found in $PATH.
+		Returns empty string otherwise.
+		If {expr} starts with "./" the |current-directory| is used.
+
+		Can also be used as a |method|: >
+			GetCommand()->exepath()
+<
+							*exists()*
+exists({expr})	The result is a Number, which is |TRUE| if {expr} is
+		defined, zero otherwise.
+
+		For checking for a supported feature use |has()|.
+		For checking if a file exists use |filereadable()|.
+
+		The {expr} argument is a string, which contains one of these:
+			varname		internal variable (see
+			dict.key	|internal-variables|).  Also works
+			list[i]		for |curly-braces-names|, |Dictionary|
+					entries, |List| items, etc.
+					Beware that evaluating an index may
+					cause an error message for an invalid
+					expression.  E.g.: >
+					   :let l = [1, 2, 3]
+					   :echo exists("l[5]")
+<					   0 >
+					   :echo exists("l[xx]")
+<					   E121: Undefined variable: xx
+					   0
+			&option-name	Vim option (only checks if it exists,
+					not if it really works)
+			+option-name	Vim option that works.
+			$ENVNAME	environment variable (could also be
+					done by comparing with an empty
+					string)
+			*funcname	built-in function (see |functions|)
+					or user defined function (see
+					|user-function|). Also works for a
+					variable that is a Funcref.
+			:cmdname	Ex command: built-in command, user
+					command or command modifier |:command|.
+					Returns:
+					1  for match with start of a command
+					2  full match with a command
+					3  matches several user commands
+					To check for a supported command
+					always check the return value to be 2.
+			:2match		The |:2match| command.
+			:3match		The |:3match| command.
+			#event		autocommand defined for this event
+			#event#pattern	autocommand defined for this event and
+					pattern (the pattern is taken
+					literally and compared to the
+					autocommand patterns character by
+					character)
+			#group		autocommand group exists
+			#group#event	autocommand defined for this group and
+					event.
+			#group#event#pattern
+					autocommand defined for this group,
+					event and pattern.
+			##event		autocommand for this event is
+					supported.
+
+		Examples: >
+			exists("&mouse")
+			exists("$HOSTNAME")
+			exists("*strftime")
+			exists("*s:MyFunc")
+			exists("*MyFunc")
+			exists("bufcount")
+			exists(":Make")
+			exists("#CursorHold")
+			exists("#BufReadPre#*.gz")
+			exists("#filetypeindent")
+			exists("#filetypeindent#FileType")
+			exists("#filetypeindent#FileType#*")
+			exists("##ColorScheme")
+<		There must be no space between the symbol (&/$/*/#) and the
+		name.
+		There must be no extra characters after the name, although in
+		a few cases this is ignored.  That may become stricter in the
+		future, thus don't count on it!
+		Working example: >
+			exists(":make")
+<		NOT working example: >
+			exists(":make install")
+
+<		Note that the argument must be a string, not the name of the
+		variable itself.  For example: >
+			exists(bufcount)
+<		This doesn't check for existence of the "bufcount" variable,
+		but gets the value of "bufcount", and checks if that exists.
+
+		Can also be used as a |method|: >
+			Varname()->exists()
+
+exp({expr})						*exp()*
+		Return the exponential of {expr} as a |Float| in the range
+		[0, inf].
+		{expr} must evaluate to a |Float| or a |Number|.
+		Returns 0.0 if {expr} is not a |Float| or a |Number|.
+		Examples: >
+			:echo exp(2)
+<			7.389056 >
+			:echo exp(-1)
+<			0.367879
+
+		Can also be used as a |method|: >
+			Compute()->exp()
+
+debugbreak({pid})					*debugbreak()*
+		Specifically used to interrupt a program being debugged.  It
+		will cause process {pid} to get a SIGTRAP.  Behavior for other
+		processes is undefined. See |terminal-debugger|.
+		{Sends a SIGINT to a process {pid} other than MS-Windows}
+
+		Returns |TRUE| if successfully interrupted the program.
+		Otherwise returns |FALSE|.
+
+		Can also be used as a |method|: >
+			GetPid()->debugbreak()
+
+expand({string} [, {nosuf} [, {list}]])				*expand()*
+		Expand wildcards and the following special keywords in 
+		{string}.  'wildignorecase' applies.
+
+		If {list} is given and it is |TRUE|, a List will be returned.
+		Otherwise the result is a String and when there are several
+		matches, they are separated by <NL> characters.
+
+		If the expansion fails, the result is an empty string.  A name
+		for a non-existing file is not included, unless {string} does
+		not start with '%', '#' or '<', see below.
+
+		When {string} starts with '%', '#' or '<', the expansion is
+		done like for the |cmdline-special| variables with their
+		associated modifiers.  Here is a short overview:
+
+			%		current file name
+			#		alternate file name
+			#n		alternate file name n
+			<cfile>		file name under the cursor
+			<afile>		autocmd file name
+			<abuf>		autocmd buffer number (as a String!)
+			<amatch>	autocmd matched name
+			<sfile>		sourced script file or function name
+			<slnum>		sourced script line number or function
+					line number
+			<sflnum>	script file line number, also when in
+					a function
+			<SID>		"<SNR>123_"  where "123" is the
+					current script ID  |<SID>|
+			<cword>		word under the cursor
+			<cWORD>		WORD under the cursor
+			<client>	the {clientid} of the last received
+					message
+		Modifiers:
+			:p		expand to full path
+			:h		head (last path component removed)
+			:t		tail (last path component only)
+			:r		root (one extension removed)
+			:e		extension only
+
+		Example: >
+			:let &tags = expand("%:p:h") .. "/tags"
+<		Note that when expanding a string that starts with '%', '#' or
+		'<', any following text is ignored.  This does NOT work: >
+			:let doesntwork = expand("%:h.bak")
+<		Use this: >
+			:let doeswork = expand("%:h") .. ".bak"
+<		Also note that expanding "<cfile>" and others only returns the
+		referenced file name without further expansion.  If "<cfile>"
+		is "~/.cshrc", you need to do another expand() to have the
+		"~/" expanded into the path of the home directory: >
+			:echo expand(expand("<cfile>"))
+<
+		There cannot be white space between the variables and the
+		following modifier.  The |fnamemodify()| function can be used
+		to modify normal file names.
+
+		When using '%' or '#', and the current or alternate file name
+		is not defined, an empty string is used.  Using "%:p" in a
+		buffer with no name, results in the current directory, with a
+		'/' added.
+
+		When {string} does not start with '%', '#' or '<', it is
+		expanded like a file name is expanded on the command line.
+		'suffixes' and 'wildignore' are used, unless the optional
+		{nosuf} argument is given and it is |TRUE|.
+		Names for non-existing files are included.  The "**" item can
+		be used to search in a directory tree.  For example, to find
+		all "README" files in the current directory and below: >
+			:echo expand("**/README")
+<
+		expand() can also be used to expand variables and environment
+		variables that are only known in a shell.  But this can be
+		slow, because a shell may be used to do the expansion.  See
+		|expr-env-expand|.
+		The expanded variable is still handled like a list of file
+		names.  When an environment variable cannot be expanded, it is
+		left unchanged.  Thus ":echo expand('$FOOBAR')" results in
+		"$FOOBAR".
+
+		See |glob()| for finding existing files.  See |system()| for
+		getting the raw output of an external command.
+
+		Can also be used as a |method|: >
+			Getpattern()->expand()
+
+expandcmd({string})					*expandcmd()*
+		Expand special items in String {string} like what is done for
+		an Ex command such as `:edit`.  This expands special keywords,
+		like with |expand()|, and environment variables, anywhere in
+		{string}.  "~user" and "~/path" are only expanded at the
+		start.
+		Returns the expanded string.  Example: >
+			:echo expandcmd('make %<.o')
+
+<		Can also be used as a |method|: >
+			GetCommand()->expandcmd()
+<
+extend({expr1}, {expr2} [, {expr3}])			*extend()*
+		{expr1} and {expr2} must be both |Lists| or both
+		|Dictionaries|.
+
+		If they are |Lists|: Append {expr2} to {expr1}.
+		If {expr3} is given insert the items of {expr2} before the
+		item with index {expr3} in {expr1}.  When {expr3} is zero
+		insert before the first item.  When {expr3} is equal to
+		len({expr1}) then {expr2} is appended.
+		Examples: >
+			:echo sort(extend(mylist, [7, 5]))
+			:call extend(mylist, [2, 3], 1)
+<		When {expr1} is the same List as {expr2} then the number of
+		items copied is equal to the original length of the List.
+		E.g., when {expr3} is 1 you get N new copies of the first item
+		(where N is the original length of the List).
+		Use |add()| to concatenate one item to a list.  To concatenate
+		two lists into a new list use the + operator: >
+			:let newlist = [1, 2, 3] + [4, 5]
+<
+		If they are |Dictionaries|:
+		Add all entries from {expr2} to {expr1}.
+		If a key exists in both {expr1} and {expr2} then {expr3} is
+		used to decide what to do:
+		{expr3} = "keep": keep the value of {expr1}
+		{expr3} = "force": use the value of {expr2}
+		{expr3} = "error": give an error message		*E737*
+		When {expr3} is omitted then "force" is assumed.
+
+		{expr1} is changed when {expr2} is not empty.  If necessary
+		make a copy of {expr1} first.
+		{expr2} remains unchanged.
+		When {expr1} is locked and {expr2} is not empty the operation
+		fails.
+		Returns {expr1}.  Returns 0 on error.
+
+		Can also be used as a |method|: >
+			mylist->extend(otherlist)
+
+feedkeys({string} [, {mode}])				*feedkeys()*
+		Characters in {string} are queued for processing as if they
+		come from a mapping or were typed by the user.
+
+		By default the string is added to the end of the typeahead
+		buffer, thus if a mapping is still being executed the
+		characters come after them.  Use the 'i' flag to insert before
+		other characters, they will be executed next, before any
+		characters from a mapping.
+
+		The function does not wait for processing of keys contained in
+		{string}.
+
+		To include special keys into {string}, use double-quotes
+		and "\..." notation |expr-quote|. For example,
+		feedkeys("\<CR>") simulates pressing of the <Enter> key. But
+		feedkeys('\<CR>') pushes 5 characters.
+		The |<Ignore>| keycode may be used to exit the
+		wait-for-character without doing anything.
+
+		{mode} is a String, which can contain these character flags:
+		'm'	Remap keys. This is default.  If {mode} is absent,
+			keys are remapped.
+		'n'	Do not remap keys.
+		't'	Handle keys as if typed; otherwise they are handled as
+			if coming from a mapping.  This matters for undo,
+			opening folds, etc.
+		'i'	Insert the string instead of appending (see above).
+		'x'	Execute commands until typeahead is empty.  This is
+			similar to using ":normal!".  You can call feedkeys()
+			several times without 'x' and then one time with 'x'
+			(possibly with an empty {string}) to execute all the
+			typeahead.  Note that when Vim ends in Insert mode it
+			will behave as if <Esc> is typed, to avoid getting
+			stuck, waiting for a character to be typed before the
+			script continues.
+			Note that if you manage to call feedkeys() while
+			executing commands, thus calling it recursively, then
+			all typehead will be consumed by the last call.
+		'!'	When used with 'x' will not end Insert mode. Can be
+			used in a test when a timer is set to exit Insert mode
+			a little later.  Useful for testing CursorHoldI.
+
+		Return value is always 0.
+
+		Can also be used as a |method|: >
+			GetInput()->feedkeys()
+
+filereadable({file})					*filereadable()*
+		The result is a Number, which is |TRUE| when a file with the
+		name {file} exists, and can be read.  If {file} doesn't exist,
+		or is a directory, the result is |FALSE|.  {file} is any
+		expression, which is used as a String.
+		If you don't care about the file being readable you can use
+		|glob()|.
+		{file} is used as-is, you may want to expand wildcards first: >
+			echo filereadable('~/.vimrc')
+			0
+			echo filereadable(expand('~/.vimrc'))
+			1
+
+<		Can also be used as a |method|: >
+			GetName()->filereadable()
+
+filewritable({file})					*filewritable()*
+		The result is a Number, which is 1 when a file with the
+		name {file} exists, and can be written.  If {file} doesn't
+		exist, or is not writable, the result is 0.  If {file} is a
+		directory, and we can write to it, the result is 2.
+
+		Can also be used as a |method|: >
+			GetName()->filewriteable()
+
+filter({expr1}, {expr2})					*filter()*
+		{expr1} must be a |List|, |Blob|, or a |Dictionary|.
+		For each item in {expr1} evaluate {expr2} and when the result
+		is zero remove the item from the |List| or |Dictionary|. For a
+		|Blob| each byte is removed.
+
+		{expr2} must be a |string| or |Funcref|.
+
+		If {expr2} is a |string|, inside {expr2} |v:val| has the value
+		of the current item.  For a |Dictionary| |v:key| has the key
+		of the current item and for a |List| |v:key| has the index of
+		the current item.  For a |Blob| |v:key| has the index of the
+		current byte.
+
+		Examples: >
+			call filter(mylist, 'v:val !~ "OLD"')
+<		Removes the items where "OLD" appears. >
+			call filter(mydict, 'v:key >= 8')
+<		Removes the items with a key below 8. >
+			call filter(var, 0)
+<		Removes all the items, thus clears the |List| or |Dictionary|.
+
+		Note that {expr2} is the result of expression and is then
+		used as an expression again.  Often it is good to use a
+		|literal-string| to avoid having to double backslashes.
+
+		If {expr2} is a |Funcref| it must take two arguments:
+			1. the key or the index of the current item.
+			2. the value of the current item.
+		The function must return |TRUE| if the item should be kept.
+		Example that keeps the odd items of a list: >
+			func Odd(idx, val)
+			  return a:idx % 2 == 1
+			endfunc
+			call filter(mylist, function('Odd'))
+<		It is shorter when using a |lambda|: >
+			call filter(myList, {idx, val -> idx * val <= 42})
+<		If you do not use "val" you can leave it out: >
+			call filter(myList, {idx -> idx % 2 == 1})
+<
+		The operation is done in-place.  If you want a |List| or
+		|Dictionary| to remain unmodified make a copy first: >
+			:let l = filter(copy(mylist), 'v:val =~ "KEEP"')
+
+<		Returns {expr1}, the |List|, |Blob| or |Dictionary| that was
+		filtered.  When an error is encountered while evaluating
+		{expr2} no further items in {expr1} are processed.  When
+		{expr2} is a Funcref errors inside a function are ignored,
+		unless it was defined with the "abort" flag.
+
+		Can also be used as a |method|: >
+			mylist->filter(expr2)
+
+finddir({name} [, {path} [, {count}]])				*finddir()*
+		Find directory {name} in {path}.  Supports both downwards and
+		upwards recursive directory searches.  See |file-searching|
+		for the syntax of {path}.
+
+		Returns the path of the first found match.  When the found
+		directory is below the current directory a relative path is
+		returned.  Otherwise a full path is returned.
+		If {path} is omitted or empty then 'path' is used.
+
+		If the optional {count} is given, find {count}'s occurrence of
+		{name} in {path} instead of the first one.
+		When {count} is negative return all the matches in a |List|.
+
+		Returns an empty string if the directory is not found.
+
+		This is quite similar to the ex-command `:find`.
+
+		Can also be used as a |method|: >
+			GetName()->finddir()
+
+findfile({name} [, {path} [, {count}]])				*findfile()*
+		Just like |finddir()|, but find a file instead of a directory.
+		Uses 'suffixesadd'.
+		Example: >
+			:echo findfile("tags.vim", ".;")
+<		Searches from the directory of the current file upwards until
+		it finds the file "tags.vim".
+
+		Can also be used as a |method|: >
+			GetName()->findfile()
+
+flatten({list} [, {maxdepth}])					*flatten()*
+		Flatten {list} up to {maxdepth} levels.  Without {maxdepth}
+		the result is a |List| without nesting, as if {maxdepth} is
+		a very large number.
+		The {list} is changed in place, make a copy first if you do
+		not want that.
+								*E900*
+		{maxdepth} means how deep in nested lists changes are made.
+		{list} is not modified when {maxdepth} is 0.
+		{maxdepth} must be positive number.
+
+		If there is an error the number zero is returned.
+
+		Example: >
+			:echo flatten([1, [2, [3, 4]], 5])
+<			[1, 2, 3, 4, 5] >
+			:echo flatten([1, [2, [3, 4]], 5], 1)
+<			[1, 2, [3, 4], 5]
+
+		Can also be used as a |method|: >
+			mylist->flatten()
+<
+float2nr({expr})					*float2nr()*
+		Convert {expr} to a Number by omitting the part after the
+		decimal point.
+		{expr} must evaluate to a |Float| or a Number.
+		Returns 0 if {expr} is not a |Float| or a |Number|.
+		When the value of {expr} is out of range for a |Number| the
+		result is truncated to 0x7fffffff or -0x7fffffff (or when
+		64-bit Number support is enabled, 0x7fffffffffffffff or
+		-0x7fffffffffffffff).  NaN results in -0x80000000 (or when
+		64-bit Number support is enabled, -0x8000000000000000).
+		Examples: >
+			echo float2nr(3.95)
+<			3  >
+			echo float2nr(-23.45)
+<			-23  >
+			echo float2nr(1.0e100)
+<			2147483647  (or 9223372036854775807) >
+			echo float2nr(-1.0e150)
+<			-2147483647 (or -9223372036854775807) >
+			echo float2nr(1.0e-100)
+<			0
+
+		Can also be used as a |method|: >
+			Compute()->float2nr()
+
+floor({expr})							*floor()*
+		Return the largest integral value less than or equal to
+		{expr} as a |Float| (round down).
+		{expr} must evaluate to a |Float| or a |Number|.
+		Returns 0.0 if {expr} is not a |Float| or a |Number|.
+		Examples: >
+			echo floor(1.856)
+<			1.0  >
+			echo floor(-5.456)
+<			-6.0  >
+			echo floor(4.0)
+<			4.0
+
+		Can also be used as a |method|: >
+			Compute()->floor()
+
+fmod({expr1}, {expr2})					*fmod()*
+		Return the remainder of {expr1} / {expr2}, even if the
+		division is not representable.  Returns {expr1} - i * {expr2}
+		for some integer i such that if {expr2} is non-zero, the
+		result has the same sign as {expr1} and magnitude less than
+		the magnitude of {expr2}.  If {expr2} is zero, the value
+		returned is zero.  The value returned is a |Float|.
+		{expr1} and {expr2} must evaluate to a |Float| or a |Number|.
+		Returns 0.0 if {expr1} or {expr2} is not a |Float| or a
+		|Number|.
+		Examples: >
+			:echo fmod(12.33, 1.22)
+<			0.13 >
+			:echo fmod(-12.33, 1.22)
+<			-0.13
+
+		Can also be used as a |method|: >
+			Compute()->fmod(1.22)
+
+fnameescape({string})					*fnameescape()*
+		Escape {string} for use as file name command argument.  All
+		characters that have a special meaning, such as '%' and '|'
+		are escaped with a backslash.
+		For most systems the characters escaped are
+		" \t\n*?[{`$\\%#'\"|!<".  For systems where a backslash
+		appears in a filename, it depends on the value of 'isfname'.
+		A leading '+' and '>' is also escaped (special after |:edit|
+		and |:write|).  And a "-" by itself (special after |:cd|).
+		Returns an empty string on error.
+		Example: >
+			:let fname = '+some str%nge|name'
+			:exe "edit " .. fnameescape(fname)
+<		results in executing: >
+			edit \+some\ str\%nge\|name
+<
+		Can also be used as a |method|: >
+			GetName()->fnameescape()
+
+fnamemodify({fname}, {mods})				*fnamemodify()*
+		Modify file name {fname} according to {mods}.  {mods} is a
+		string of characters like it is used for file names on the
+		command line.  See |filename-modifiers|.
+		Example: >
+			:echo fnamemodify("main.c", ":p:h")
+<		results in: >
+			/home/user/vim/vim/src
+<		If {mods} is empty or an unsupported modifier is used then
+		{fname} is returned.
+		When {fname} is empty then with {mods} ":h" returns ".", so
+		that `:cd` can be used with it.  This is different from
+		expand('%:h') without a buffer name, which returns an empty
+		string.
+		Note: Environment variables don't work in {fname}, use
+		|expand()| first then.
+
+		Can also be used as a |method|: >
+			GetName()->fnamemodify(':p:h')
+
+foldclosed({lnum})					*foldclosed()*
+		The result is a Number.  If the line {lnum} is in a closed
+		fold, the result is the number of the first line in that fold.
+		If the line {lnum} is not in a closed fold, -1 is returned.
+		{lnum} is used like with |getline()|.  Thus "." is the current
+		line, "'m" mark m, etc.
+
+		Can also be used as a |method|: >
+			GetLnum()->foldclosed()
+
+foldclosedend({lnum})					*foldclosedend()*
+		The result is a Number.  If the line {lnum} is in a closed
+		fold, the result is the number of the last line in that fold.
+		If the line {lnum} is not in a closed fold, -1 is returned.
+		{lnum} is used like with |getline()|.  Thus "." is the current
+		line, "'m" mark m, etc.
+
+		Can also be used as a |method|: >
+			GetLnum()->foldclosedend()
+
+foldlevel({lnum})					*foldlevel()*
+		The result is a Number, which is the foldlevel of line {lnum}
+		in the current buffer.  For nested folds the deepest level is
+		returned.  If there is no fold at line {lnum}, zero is
+		returned.  It doesn't matter if the folds are open or closed.
+		When used while updating folds (from 'foldexpr') -1 is
+		returned for lines where folds are still to be updated and the
+		foldlevel is unknown.  As a special case the level of the
+		previous line is usually available.
+		{lnum} is used like with |getline()|.  Thus "." is the current
+		line, "'m" mark m, etc.
+
+		Can also be used as a |method|: >
+			GetLnum()->foldlevel()
+<
+							*foldtext()*
+foldtext()	Returns a String, to be displayed for a closed fold.  This is
+		the default function used for the 'foldtext' option and should
+		only be called from evaluating 'foldtext'.  It uses the
+		|v:foldstart|, |v:foldend| and |v:folddashes| variables.
+		The returned string looks like this: >
+			+-- 45 lines: abcdef
+<		The number of leading dashes depends on the foldlevel.  The
+		"45" is the number of lines in the fold.  "abcdef" is the text
+		in the first non-blank line of the fold.  Leading white space,
+		"//" or "/*" and the text from the 'foldmarker' and
+		'commentstring' options is removed.
+		When used to draw the actual foldtext, the rest of the line
+		will be filled with the fold char from the 'fillchars'
+		setting.
+		Returns an empty string when there is no fold.
+
+foldtextresult({lnum})					*foldtextresult()*
+		Returns the text that is displayed for the closed fold at line
+		{lnum}.  Evaluates 'foldtext' in the appropriate context.
+		When there is no closed fold at {lnum} an empty string is
+		returned.
+		{lnum} is used like with |getline()|.  Thus "." is the current
+		line, "'m" mark m, etc.
+		Useful when exporting folded text, e.g., to HTML.
+
+		Can also be used as a |method|: >
+			GetLnum()->foldtextresult()
+<
+fullcommand({name})						*fullcommand()*
+		Get the full command name from a short abbreviated command
+		name; see |20.2| for details on command abbreviations.
+
+		The string argument {name} may start with a `:` and can
+		include a [range], these are skipped and not returned.
+		Returns an empty string if a command doesn't exist or if it's
+		ambiguous (for user-defined commands).
+
+		For example `fullcommand('s')`, `fullcommand('sub')`,
+		`fullcommand(':%substitute')` all return "substitute".
+
+		Can also be used as a |method|: >
+			GetName()->fullcommand()
+<
+						*funcref()*
+funcref({name} [, {arglist}] [, {dict}])
+		Just like |function()|, but the returned Funcref will lookup
+		the function by reference, not by name.  This matters when the
+		function {name} is redefined later.
+
+		Unlike |function()|, {name} must be an existing user function.
+		It only works for an autoloaded function if it has already
+		been loaded (to avoid mistakenly loading the autoload script
+		when only intending to use the function name, use |function()|
+		instead). {name} cannot be a builtin function.
+		Returns 0 on error.
+
+		Can also be used as a |method|: >
+			GetFuncname()->funcref([arg])
+<
+				       *function()* *E700* *E922* *E923*
+function({name} [, {arglist}] [, {dict}])
+		Return a |Funcref| variable that refers to function {name}.
+		{name} can be a user defined function or an internal function.
+
+		{name} can also be a Funcref or a partial. When it is a
+		partial the dict stored in it will be used and the {dict}
+		argument is not allowed. E.g.: >
+			let FuncWithArg = function(dict.Func, [arg])
+			let Broken = function(dict.Func, [arg], dict)
+<
+		When using the Funcref the function will be found by {name},
+		also when it was redefined later. Use |funcref()| to keep the
+		same function.
+
+		When {arglist} or {dict} is present this creates a partial.
+		That means the argument list and/or the dictionary is stored in
+		the Funcref and will be used when the Funcref is called.
+
+		The arguments are passed to the function in front of other
+		arguments, but after any argument from |method|.  Example: >
+			func Callback(arg1, arg2, name)
+			...
+			let Partial = function('Callback', ['one', 'two'])
+			...
+			call Partial('name')
+<		Invokes the function as with: >
+			call Callback('one', 'two', 'name')
+
+<		The Dictionary is only useful when calling a "dict" function.
+		In that case the {dict} is passed in as "self". Example: >
+			function Callback() dict
+			   echo "called for " .. self.name
+			endfunction
+			...
+			let context = {"name": "example"}
+			let Func = function('Callback', context)
+			...
+			call Func()	" will echo: called for example
+
+<		The argument list and the Dictionary can be combined: >
+			function Callback(arg1, count) dict
+			...
+			let context = {"name": "example"}
+			let Func = function('Callback', ['one'], context)
+			...
+			call Func(500)
+<		Invokes the function as with: >
+			call context.Callback('one', 500)
+<
+		Returns 0 on error.
+
+		Can also be used as a |method|: >
+			GetFuncname()->function([arg])
+
+garbagecollect([{atexit}])				*garbagecollect()*
+		Cleanup unused |Lists| and |Dictionaries| that have circular
+		references.
+
+		There is hardly ever a need to invoke this function, as it is
+		automatically done when Vim runs out of memory or is waiting
+		for the user to press a key after 'updatetime'.  Items without
+		circular references are always freed when they become unused.
+		This is useful if you have deleted a very big |List| and/or
+		|Dictionary| with circular references in a script that runs
+		for a long time.
+
+		When the optional {atexit} argument is one, garbage
+		collection will also be done when exiting Vim, if it wasn't
+		done before.  This is useful when checking for memory leaks.
+
+		The garbage collection is not done immediately but only when
+		it's safe to perform.  This is when waiting for the user to
+		type a character.
+
+get({list}, {idx} [, {default}])			*get()*
+		Get item {idx} from |List| {list}.  When this item is not
+		available return {default}.  Return zero when {default} is
+		omitted.
+		Can also be used as a |method|: >
+			mylist->get(idx)
+get({blob}, {idx} [, {default}])
+		Get byte {idx} from |Blob| {blob}.  When this byte is not
+		available return {default}.  Return -1 when {default} is
+		omitted.
+get({dict}, {key} [, {default}])
+		Get item with key {key} from |Dictionary| {dict}.  When this
+		item is not available return {default}.  Return zero when
+		{default} is omitted.  Useful example: >
+			let val = get(g:, 'var_name', 'default')
+<		This gets the value of g:var_name if it exists, and uses
+		'default' when it does not exist.
+get({func}, {what})
+		Get item {what} from Funcref {func}.  Possible values for
+		{what} are:
+			"name"	The function name
+			"func"	The function
+			"dict"	The dictionary
+			"args"	The list with arguments
+		Returns zero on error.
+
+							*getbufinfo()*
+getbufinfo([{buf}])
+getbufinfo([{dict}])
+		Get information about buffers as a List of Dictionaries.
+
+		Without an argument information about all the buffers is
+		returned.
+
+		When the argument is a |Dictionary| only the buffers matching
+		the specified criteria are returned.  The following keys can
+		be specified in {dict}:
+			buflisted	include only listed buffers.
+			bufloaded	include only loaded buffers.
+			bufmodified	include only modified buffers.
+
+		Otherwise, {buf} specifies a particular buffer to return
+		information for.  For the use of {buf}, see |bufname()|
+		above.  If the buffer is found the returned List has one item.
+		Otherwise the result is an empty list.
+
+		Each returned List item is a dictionary with the following
+		entries:
+			bufnr		Buffer number.
+			changed		TRUE if the buffer is modified.
+			changedtick	Number of changes made to the buffer.
+			hidden		TRUE if the buffer is hidden.
+			lastused	Timestamp in seconds, like
+					|localtime()|, when the buffer was
+					last used.
+			listed		TRUE if the buffer is listed.
+			lnum		Line number used for the buffer when
+					opened in the current window.
+					Only valid if the buffer has been
+					displayed in the window in the past.
+					If you want the line number of the
+					last known cursor position in a given
+					window, use |line()|: >
+						:echo line('.', {winid})
+<
+			linecount	Number of lines in the buffer (only
+					valid when loaded)
+			loaded		TRUE if the buffer is loaded.
+			name		Full path to the file in the buffer.
+			signs		List of signs placed in the buffer.
+					Each list item is a dictionary with
+					the following fields:
+					    id	  sign identifier
+					    lnum  line number
+					    name  sign name
+			variables	A reference to the dictionary with
+					buffer-local variables.
+			windows		List of |window-ID|s that display this
+					buffer
+
+		Examples: >
+			for buf in getbufinfo()
+			    echo buf.name
+			endfor
+			for buf in getbufinfo({'buflisted':1})
+			    if buf.changed
+				....
+			    endif
+			endfor
+<
+		To get buffer-local options use: >
+			getbufvar({bufnr}, '&option_name')
+<
+		Can also be used as a |method|: >
+			GetBufnr()->getbufinfo()
+<
+							*getbufline()*
+getbufline({buf}, {lnum} [, {end}])
+		Return a |List| with the lines starting from {lnum} to {end}
+		(inclusive) in the buffer {buf}.  If {end} is omitted, a
+		|List| with only the line {lnum} is returned.
+
+		For the use of {buf}, see |bufname()| above.
+
+		For {lnum} and {end} "$" can be used for the last line of the
+		buffer.  Otherwise a number must be used.
+
+		When {lnum} is smaller than 1 or bigger than the number of
+		lines in the buffer, an empty |List| is returned.
+
+		When {end} is greater than the number of lines in the buffer,
+		it is treated as {end} is set to the number of lines in the
+		buffer.  When {end} is before {lnum} an empty |List| is
+		returned.
+
+		This function works only for loaded buffers.  For unloaded and
+		non-existing buffers, an empty |List| is returned.
+
+		Example: >
+			:let lines = getbufline(bufnr("myfile"), 1, "$")
+
+<		Can also be used as a |method|: >
+			GetBufnr()->getbufline(lnum)
+
+getbufvar({buf}, {varname} [, {def}])				*getbufvar()*
+		The result is the value of option or local buffer variable
+		{varname} in buffer {buf}.  Note that the name without "b:"
+		must be used.
+		The {varname} argument is a string.
+		When {varname} is empty returns a |Dictionary| with all the
+		buffer-local variables.
+		When {varname} is equal to "&" returns a |Dictionary| with all
+		the buffer-local options.
+		Otherwise, when {varname} starts with "&" returns the value of
+		a buffer-local option.
+		This also works for a global or buffer-local option, but it
+		doesn't work for a global variable, window-local variable or
+		window-local option.
+		For the use of {buf}, see |bufname()| above.
+		When the buffer or variable doesn't exist {def} or an empty
+		string is returned, there is no error message.
+		Examples: >
+			:let bufmodified = getbufvar(1, "&mod")
+			:echo "todo myvar = " .. getbufvar("todo", "myvar")
+
+<		Can also be used as a |method|: >
+			GetBufnr()->getbufvar(varname)
+<
+getchangelist([{buf}])					*getchangelist()*
+		Returns the |changelist| for the buffer {buf}. For the use
+		of {buf}, see |bufname()| above. If buffer {buf} doesn't
+		exist, an empty list is returned.
+
+		The returned list contains two entries: a list with the change
+		locations and the current position in the list.  Each
+		entry in the change list is a dictionary with the following
+		entries:
+			col		column number
+			coladd		column offset for 'virtualedit'
+			lnum		line number
+		If buffer {buf} is the current buffer, then the current
+		position refers to the position in the list. For other
+		buffers, it is set to the length of the list.
+
+		Can also be used as a |method|: >
+			GetBufnr()->getchangelist()
+
+getchar([expr])						*getchar()*
+		Get a single character from the user or input stream.
+		If [expr] is omitted, wait until a character is available.
+		If [expr] is 0, only get a character when one is available.
+			Return zero otherwise.
+		If [expr] is 1, only check if a character is available, it is
+			not consumed.  Return zero if no character available.
+		If you prefer always getting a string use |getcharstr()|.
+
+		Without [expr] and when [expr] is 0 a whole character or
+		special key is returned.  If it is a single character, the
+		result is a Number.  Use |nr2char()| to convert it to a String.
+		Otherwise a String is returned with the encoded character.
+		For a special key it's a String with a sequence of bytes
+		starting with 0x80 (decimal: 128).  This is the same value as
+		the String "\<Key>", e.g., "\<Left>".  The returned value is
+		also a String when a modifier (shift, control, alt) was used
+		that is not included in the character.
+
+		When [expr] is 0 and Esc is typed, there will be a short delay
+		while Vim waits to see if this is the start of an escape
+		sequence.
+
+		When [expr] is 1 only the first byte is returned.  For a
+		one-byte character it is the character itself as a number.
+		Use nr2char() to convert it to a String.
+
+		Use getcharmod() to obtain any additional modifiers.
+
+		When the user clicks a mouse button, the mouse event will be
+		returned.  The position can then be found in |v:mouse_col|,
+		|v:mouse_lnum|, |v:mouse_winid| and |v:mouse_win|.
+		|getmousepos()| can also be used.  Mouse move events will be
+		ignored.
+		This example positions the mouse as it would normally happen: >
+			let c = getchar()
+			if c == "\<LeftMouse>" && v:mouse_win > 0
+			  exe v:mouse_win .. "wincmd w"
+			  exe v:mouse_lnum
+			  exe "normal " .. v:mouse_col .. "|"
+			endif
+<
+		There is no prompt, you will somehow have to make clear to the
+		user that a character has to be typed.  The screen is not
+		redrawn, e.g. when resizing the window.
+
+		There is no mapping for the character.
+		Key codes are replaced, thus when the user presses the <Del>
+		key you get the code for the <Del> key, not the raw character
+		sequence.  Examples: >
+			getchar() == "\<Del>"
+			getchar() == "\<S-Left>"
+<		This example redefines "f" to ignore case: >
+			:nmap f :call FindChar()<CR>
+			:function FindChar()
+			:  let c = nr2char(getchar())
+			:  while col('.') < col('$') - 1
+			:    normal l
+			:    if getline('.')[col('.') - 1] ==? c
+			:      break
+			:    endif
+			:  endwhile
+			:endfunction
+<
+getcharmod()						*getcharmod()*
+		The result is a Number which is the state of the modifiers for
+		the last obtained character with getchar() or in another way.
+		These values are added together:
+			2	shift
+			4	control
+			8	alt (meta)
+			16	meta (when it's different from ALT)
+			32	mouse double click
+			64	mouse triple click
+			96	mouse quadruple click (== 32 + 64)
+			128	command (Macintosh only)
+		Only the modifiers that have not been included in the
+		character itself are obtained.  Thus Shift-a results in "A"
+		without a modifier.  Returns 0 if no modifiers are used.
+
+							*getcharpos()*
+getcharpos({expr})
+		Get the position for String {expr}. Same as |getpos()| but the
+		column number in the returned List is a character index
+		instead of a byte index.
+
+		Example:
+		With the cursor on '세' in line 5 with text "여보세요": >
+			getcharpos('.')		returns [0, 5, 3, 0]
+			getpos('.')		returns [0, 5, 7, 0]
+<
+		Can also be used as a |method|: >
+			GetMark()->getcharpos()
+
+getcharsearch()						*getcharsearch()*
+		Return the current character search information as a {dict}
+		with the following entries:
+
+		    char	character previously used for a character
+				search (|t|, |f|, |T|, or |F|); empty string
+				if no character search has been performed
+		    forward	direction of character search; 1 for forward,
+				0 for backward
+		    until	type of character search; 1 for a |t| or |T|
+				character search, 0 for an |f| or |F|
+				character search
+
+		This can be useful to always have |;| and |,| search
+		forward/backward regardless of the direction of the previous
+		character search: >
+			:nnoremap <expr> ; getcharsearch().forward ? ';' : ','
+			:nnoremap <expr> , getcharsearch().forward ? ',' : ';'
+<		Also see |setcharsearch()|.
+
+
+getcharstr([expr])					*getcharstr()*
+		Get a single character from the user or input stream as a
+		string.
+		If [expr] is omitted, wait until a character is available.
+		If [expr] is 0 or false, only get a character when one is
+			available.  Return an empty string otherwise.
+		If [expr] is 1 or true, only check if a character is
+			available, it is not consumed.  Return an empty string
+			if no character is available.
+		Otherwise this works like |getchar()|, except that a number
+		result is converted to a string.
+
+getcmdcompltype()					*getcmdcompltype()*
+		Return the type of the current command-line completion.
+		Only works when the command line is being edited, thus
+		requires use of |c_CTRL-\_e| or |c_CTRL-R_=|.
+		See |:command-completion| for the return string.
+		Also see |getcmdtype()|, |setcmdpos()| and |getcmdline()|.
+		Returns an empty string when completion is not defined.
+
+getcmdline()						*getcmdline()*
+		Return the current command-line.  Only works when the command
+		line is being edited, thus requires use of |c_CTRL-\_e| or
+		|c_CTRL-R_=|.
+		Example: >
+			:cmap <F7> <C-\>eescape(getcmdline(), ' \')<CR>
+<		Also see |getcmdtype()|, |getcmdpos()| and |setcmdpos()|.
+		Returns an empty string when entering a password or using
+		|inputsecret()|.
+
+getcmdpos()						*getcmdpos()*
+		Return the position of the cursor in the command line as a
+		byte count.  The first column is 1.
+		Only works when editing the command line, thus requires use of
+		|c_CTRL-\_e| or |c_CTRL-R_=| or an expression mapping.
+		Returns 0 otherwise.
+		Also see |getcmdtype()|, |setcmdpos()| and |getcmdline()|.
+
+getcmdscreenpos()					*getcmdscreenpos()*
+		Return the screen position of the cursor in the command line
+		as a byte count.  The first column is 1.
+		Instead of |getcmdpos()|, it adds the prompt position.
+		Only works when editing the command line, thus requires use of
+		|c_CTRL-\_e| or |c_CTRL-R_=| or an expression mapping.
+		Returns 0 otherwise.
+		Also see |getcmdpos()|, |setcmdpos()|.
+
+getcmdtype()						*getcmdtype()*
+		Return the current command-line type. Possible return values
+		are:
+		    :	normal Ex command
+		    >	debug mode command |debug-mode|
+		    /	forward search command
+		    ?	backward search command
+		    @	|input()| command
+		    -	|:insert| or |:append| command
+		    =	|i_CTRL-R_=|
+		Only works when editing the command line, thus requires use of
+		|c_CTRL-\_e| or |c_CTRL-R_=| or an expression mapping.
+		Returns an empty string otherwise.
+		Also see |getcmdpos()|, |setcmdpos()| and |getcmdline()|.
+
+getcmdwintype()						*getcmdwintype()*
+		Return the current |command-line-window| type. Possible return
+		values are the same as |getcmdtype()|. Returns an empty string
+		when not in the command-line window.
+
+getcompletion({pat}, {type} [, {filtered}])		*getcompletion()*
+		Return a list of command-line completion matches. The String
+		{type} argument specifies what for.  The following completion
+		types are supported:
+
+		arglist		file names in argument list
+		augroup		autocmd groups
+		buffer		buffer names
+		behave		:behave suboptions
+		cmdline		|cmdline-completion| result
+		color		color schemes
+		command		Ex command
+		compiler	compilers
+		cscope		|:cscope| suboptions
+		diff_buffer     |:diffget| and |:diffput| completion
+		dir		directory names
+		environment	environment variable names
+		event		autocommand events
+		expression	Vim expression
+		file		file and directory names
+		file_in_path	file and directory names in |'path'|
+		filetype	filetype names |'filetype'|
+		function	function name
+		help		help subjects
+		highlight	highlight groups
+		history		:history suboptions
+		locale		locale names (as output of locale -a)
+		mapclear	buffer argument
+		mapping		mapping name
+		menu		menus
+		messages	|:messages| suboptions
+		option		options
+		packadd		optional package |pack-add| names
+		shellcmd	Shell command
+		sign		|:sign| suboptions
+		syntax		syntax file names |'syntax'|
+		syntime		|:syntime| suboptions
+		tag		tags
+		tag_listfiles	tags, file names
+		user		user names
+		var		user variables
+
+		If {pat} is an empty string, then all the matches are
+		returned.  Otherwise only items matching {pat} are returned.
+		See |wildcards| for the use of special characters in {pat}.
+
+		If the optional {filtered} flag is set to 1, then 'wildignore'
+		is applied to filter the results.  Otherwise all the matches
+		are returned. The 'wildignorecase' option always applies.
+
+		If {type} is "cmdline", then the |cmdline-completion| result is
+		returned.  For example, to complete the possible values after
+		a ":call" command: >
+			echo getcompletion('call ', 'cmdline')
+<
+		If there are no matches, an empty list is returned.  An
+		invalid value for {type} produces an error.
+
+		Can also be used as a |method|: >
+			GetPattern()->getcompletion('color')
+<
+							*getcurpos()*
+getcurpos([{winid}])
+		Get the position of the cursor.  This is like getpos('.'), but
+		includes an extra "curswant" in the list:
+		    [0, lnum, col, off, curswant] ~
+		The "curswant" number is the preferred column when moving the
+		cursor vertically.  Also see |getcursorcharpos()| and
+		|getpos()|.
+		The first "bufnum" item is always zero. The byte position of
+		the cursor is returned in 'col'. To get the character
+		position, use |getcursorcharpos()|.
+
+		The optional {winid} argument can specify the window.  It can
+		be the window number or the |window-ID|.  The last known
+		cursor position is returned, this may be invalid for the
+		current value of the buffer if it is not the current window.
+		If {winid} is invalid a list with zeroes is returned.
+
+ 		This can be used to save and restore the cursor position: >
+ 			let save_cursor = getcurpos()
+ 			MoveTheCursorAround
+ 			call setpos('.', save_cursor)
+<		Note that this only works within the window.  See
+		|winrestview()| for restoring more state.
+
+		Can also be used as a |method|: >
+			GetWinid()->getcurpos()
+<
+							*getcursorcharpos()*
+getcursorcharpos([{winid}])
+		Same as |getcurpos()| but the column number in the returned
+		List is a character index instead of a byte index.
+
+		Example:
+		With the cursor on '보' in line 3 with text "여보세요": >
+			getcursorcharpos()	returns [0, 3, 2, 0, 3]
+			getcurpos()		returns [0, 3, 4, 0, 3]
+<
+		Can also be used as a |method|: >
+			GetWinid()->getcursorcharpos()
+
+getcwd([{winnr} [, {tabnr}]])				*getcwd()*
+		With no arguments, returns the name of the effective
+		|current-directory|. With {winnr} or {tabnr} the working
+		directory of that scope is returned, and 'autochdir' is
+		ignored.
+		Tabs and windows are identified by their respective numbers,
+		0 means current tab or window. Missing tab number implies 0.
+		Thus the following are equivalent: >
+			getcwd(0)
+			getcwd(0, 0)
+<		If {winnr} is -1 it is ignored, only the tab is resolved.
+		{winnr} can be the window number or the |window-ID|.
+		If both {winnr} and {tabnr} are -1 the global working
+		directory is returned.
+		Throw error if the arguments are invalid. |E5000| |E5001| |E5002|
+
+		Can also be used as a |method|: >
+			GetWinnr()->getcwd()
+
+getenv({name})						*getenv()*
+		Return the value of environment variable {name}.  The {name}
+		argument is a string, without a leading '$'.  Example: >
+			myHome = getenv('HOME')
+
+<		When the variable does not exist |v:null| is returned.  That
+		is different from a variable set to an empty string.
+		See also |expr-env|.
+
+		Can also be used as a |method|: >
+			GetVarname()->getenv()
+
+getfontname([{name}])					*getfontname()*
+		Without an argument returns the name of the normal font being
+		used.  Like what is used for the Normal highlight group
+		|hl-Normal|.
+		With an argument a check is done whether String {name} is a
+		valid font name.  If not then an empty string is returned.
+		Otherwise the actual font name is returned, or {name} if the
+		GUI does not support obtaining the real name.
+		Only works when the GUI is running, thus not in your vimrc or
+		gvimrc file.  Use the |GUIEnter| autocommand to use this
+		function just after the GUI has started.
+
+getfperm({fname})					*getfperm()*
+		The result is a String, which is the read, write, and execute
+		permissions of the given file {fname}.
+		If {fname} does not exist or its directory cannot be read, an
+		empty string is returned.
+		The result is of the form "rwxrwxrwx", where each group of
+		"rwx" flags represent, in turn, the permissions of the owner
+		of the file, the group the file belongs to, and other users.
+		If a user does not have a given permission the flag for this
+		is replaced with the string "-".  Examples: >
+			:echo getfperm("/etc/passwd")
+			:echo getfperm(expand("~/.config/nvim/init.vim"))
+<		This will hopefully (from a security point of view) display
+		the string "rw-r--r--" or even "rw-------".
+
+		Can also be used as a |method|: >
+			GetFilename()->getfperm()
+<
+		For setting permissions use |setfperm()|.
+
+getfsize({fname})					*getfsize()*
+		The result is a Number, which is the size in bytes of the
+		given file {fname}.
+		If {fname} is a directory, 0 is returned.
+		If the file {fname} can't be found, -1 is returned.
+		If the size of {fname} is too big to fit in a Number then -2
+		is returned.
+
+		Can also be used as a |method|: >
+			GetFilename()->getfsize()
+
+getftime({fname})					*getftime()*
+		The result is a Number, which is the last modification time of
+		the given file {fname}.  The value is measured as seconds
+		since 1st Jan 1970, and may be passed to strftime().  See also
+		|localtime()| and |strftime()|.
+		If the file {fname} can't be found -1 is returned.
+
+		Can also be used as a |method|: >
+			GetFilename()->getftime()
+
+getftype({fname})					*getftype()*
+		The result is a String, which is a description of the kind of
+		file of the given file {fname}.
+		If {fname} does not exist an empty string is returned.
+		Here is a table over different kinds of files and their
+		results:
+			Normal file		"file"
+			Directory		"dir"
+			Symbolic link		"link"
+			Block device		"bdev"
+			Character device	"cdev"
+			Socket			"socket"
+			FIFO			"fifo"
+			All other		"other"
+		Example: >
+			getftype("/home")
+<		Note that a type such as "link" will only be returned on
+		systems that support it.  On some systems only "dir" and
+		"file" are returned.
+
+		Can also be used as a |method|: >
+			GetFilename()->getftype()
+
+getjumplist([{winnr} [, {tabnr}]])			*getjumplist()*
+		Returns the |jumplist| for the specified window.
+
+		Without arguments use the current window.
+		With {winnr} only use this window in the current tab page.
+		{winnr} can also be a |window-ID|.
+		With {winnr} and {tabnr} use the window in the specified tab
+		page.  If {winnr} or {tabnr} is invalid, an empty list is
+ 		returned.
+
+		The returned list contains two entries: a list with the jump
+		locations and the last used jump position number in the list.
+		Each entry in the jump location list is a dictionary with
+		the following entries:
+			bufnr		buffer number
+			col		column number
+			coladd		column offset for 'virtualedit'
+			filename	filename if available
+			lnum		line number
+
+		Can also be used as a |method|: >
+			GetWinnr()->getjumplist()
+
+<							*getline()*
+getline({lnum} [, {end}])
+		Without {end} the result is a String, which is line {lnum}
+		from the current buffer.  Example: >
+			getline(1)
+<		When {lnum} is a String that doesn't start with a
+		digit, |line()| is called to translate the String into a Number.
+		To get the line under the cursor: >
+			getline(".")
+<		When {lnum} is a number smaller than 1 or bigger than the
+		number of lines in the buffer, an empty string is returned.
+
+		When {end} is given the result is a |List| where each item is
+		a line from the current buffer in the range {lnum} to {end},
+		including line {end}.
+		{end} is used in the same way as {lnum}.
+		Non-existing lines are silently omitted.
+		When {end} is before {lnum} an empty |List| is returned.
+		Example: >
+			:let start = line('.')
+			:let end = search("^$") - 1
+			:let lines = getline(start, end)
+
+<		Can also be used as a |method|: >
+			ComputeLnum()->getline()
+
+<		To get lines from another buffer see |getbufline()|
+
+getloclist({nr} [, {what}])				*getloclist()*
+		Returns a |List| with all the entries in the location list for
+		window {nr}.  {nr} can be the window number or the |window-ID|.
+		When {nr} is zero the current window is used.
+
+		For a location list window, the displayed location list is
+		returned.  For an invalid window number {nr}, an empty list is
+		returned. Otherwise, same as |getqflist()|.
+
+		If the optional {what} dictionary argument is supplied, then
+		returns the items listed in {what} as a dictionary. Refer to
+		|getqflist()| for the supported items in {what}.
+
+		In addition to the items supported by |getqflist()| in {what},
+		the following item is supported by |getloclist()|:
+
+			filewinid 	id of the window used to display files
+					from the location list. This field is
+					applicable only when called from a
+					location list window. See
+					|location-list-file-window| for more
+					details.
+
+		Returns a |Dictionary| with default values if there is no
+		location list for the window {nr}.
+		Returns an empty Dictionary if window {nr} does not exist.
+
+		Examples (See also |getqflist-examples|): >
+			:echo getloclist(3, {'all': 0})
+			:echo getloclist(5, {'filewinid': 0})
+
+
+getmarklist([{buf}])					*getmarklist()*
+		Without the {buf} argument returns a |List| with information
+		about all the global marks. |mark|
+
+		If the optional {buf} argument is specified, returns the
+		local marks defined in buffer {buf}.  For the use of {buf},
+		see |bufname()|.  If {buf} is invalid, an empty list is
+		returned.
+
+		Each item in the returned List is a |Dict| with the following:
+		    mark   name of the mark prefixed by "'"
+		    pos	   a |List| with the position of the mark:
+				[bufnum, lnum, col, off]
+			   Refer to |getpos()| for more information.
+		    file   file name
+
+		Refer to |getpos()| for getting information about a specific
+		mark.
+
+		Can also be used as a |method|: >
+			GetBufnr()->getmarklist()
+
+getmatches([{win}])					*getmatches()*
+		Returns a |List| with all matches previously defined for the
+		current window by |matchadd()| and the |:match| commands.
+		|getmatches()| is useful in combination with |setmatches()|,
+		as |setmatches()| can restore a list of matches saved by
+		|getmatches()|.
+		If {win} is specified, use the window with this number or
+		window ID instead of the current window.  If {win} is invalid,
+		an empty list is returned.
+		Example: >
+			:echo getmatches()
+<			[{'group': 'MyGroup1', 'pattern': 'TODO',
+			'priority': 10, 'id': 1}, {'group': 'MyGroup2',
+			'pattern': 'FIXME', 'priority': 10, 'id': 2}] >
+			:let m = getmatches()
+			:call clearmatches()
+			:echo getmatches()
+<			[] >
+			:call setmatches(m)
+			:echo getmatches()
+<			[{'group': 'MyGroup1', 'pattern': 'TODO',
+			'priority': 10, 'id': 1}, {'group': 'MyGroup2',
+			'pattern': 'FIXME', 'priority': 10, 'id': 2}] >
+			:unlet m
+<
+getmousepos()						*getmousepos()*
+		Returns a Dictionary with the last known position of the
+		mouse.  This can be used in a mapping for a mouse click.  The
+		items are:
+			screenrow	screen row
+			screencol	screen column
+			winid		Window ID of the click
+			winrow		row inside "winid"
+			wincol		column inside "winid"
+			line		text line inside "winid"
+			column		text column inside "winid"
+		All numbers are 1-based.
+
+		If not over a window, e.g. when in the command line, then only
+		"screenrow" and "screencol" are valid, the others are zero.
+
+		When on the status line below a window or the vertical
+		separater right of a window, the "line" and "column" values
+		are zero.
+
+		When the position is after the text then "column" is the
+		length of the text in bytes plus one.
+
+		If the mouse is over a focusable floating window then that
+		window is used.
+
+		When using |getchar()| the Vim variables |v:mouse_lnum|,
+		|v:mouse_col| and |v:mouse_winid| also provide these values.
+
+							*getpid()*
+getpid()	Return a Number which is the process ID of the Vim process.
+		This is a unique number, until Vim exits.
+
+							*getpos()*
+getpos({expr})	Get the position for String {expr}.  For possible values of
+		{expr} see |line()|.  For getting the cursor position see
+		|getcurpos()|.
+		The result is a |List| with four numbers:
+		    [bufnum, lnum, col, off]
+		"bufnum" is zero, unless a mark like '0 or 'A is used, then it
+		is the buffer number of the mark.
+		"lnum" and "col" are the position in the buffer.  The first
+		column is 1.
+		The "off" number is zero, unless 'virtualedit' is used.  Then
+		it is the offset in screen columns from the start of the
+		character.  E.g., a position within a <Tab> or after the last
+		character.
+		Note that for '< and '> Visual mode matters: when it is "V"
+		(visual line mode) the column of '< is zero and the column of
+		'> is a large number.
+		The column number in the returned List is the byte position
+		within the line. To get the character position in the line,
+		use |getcharpos()|.
+		The column number can be very large, e.g. 2147483647, in which
+		case it means "after the end of the line".
+		If {expr} is invalid, returns a list with all zeros.
+		This can be used to save and restore the position of a mark: >
+			let save_a_mark = getpos("'a")
+			...
+			call setpos("'a", save_a_mark)
+<		Also see |getcharpos()|, |getcurpos()| and |setpos()|.
+
+		Can also be used as a |method|: >
+			GetMark()->getpos()
+
+getqflist([{what}])					*getqflist()*
+		Returns a |List| with all the current quickfix errors.  Each
+		list item is a dictionary with these entries:
+			bufnr	number of buffer that has the file name, use
+				bufname() to get the name
+			module	module name
+			lnum	line number in the buffer (first line is 1)
+			end_lnum
+				end of line number if the item is multiline
+			col	column number (first column is 1)
+			end_col	end of column number if the item has range
+			vcol	|TRUE|: "col" is visual column
+				|FALSE|: "col" is byte index
+			nr	error number
+			pattern	search pattern used to locate the error
+			text	description of the error
+			type	type of the error, 'E', '1', etc.
+			valid	|TRUE|: recognized error message
+
+		When there is no error list or it's empty, an empty list is
+		returned. Quickfix list entries with a non-existing buffer
+		number are returned with "bufnr" set to zero (Note: some
+		functions accept buffer number zero for the alternate buffer,
+		you may need to explicitly check for zero).
+
+		Useful application: Find pattern matches in multiple files and
+		do something with them: >
+			:vimgrep /theword/jg *.c
+			:for d in getqflist()
+			:   echo bufname(d.bufnr) ':' d.lnum '=' d.text
+			:endfor
+<
+		If the optional {what} dictionary argument is supplied, then
+		returns only the items listed in {what} as a dictionary. The
+		following string items are supported in {what}:
+			changedtick	get the total number of changes made
+					to the list |quickfix-changedtick|
+			context	get the |quickfix-context|
+			efm	errorformat to use when parsing "lines". If
+				not present, then the 'errorformat' option
+				value is used.
+			id	get information for the quickfix list with
+				|quickfix-ID|; zero means the id for the
+				current list or the list specified by "nr"
+			idx	get information for the quickfix entry at this
+				index in the list specified by 'id' or 'nr'.
+				If set to zero, then uses the current entry.
+				See |quickfix-index|
+			items	quickfix list entries
+			lines	parse a list of lines using 'efm' and return
+				the resulting entries.  Only a |List| type is
+				accepted.  The current quickfix list is not
+				modified. See |quickfix-parse|.
+			nr	get information for this quickfix list; zero
+				means the current quickfix list and "$" means
+				the last quickfix list
+			qfbufnr number of the buffer displayed in the quickfix
+				window. Returns 0 if the quickfix buffer is
+				not present. See |quickfix-buffer|.
+			size	number of entries in the quickfix list
+			title	get the list title |quickfix-title|
+			winid	get the quickfix |window-ID|
+			all	all of the above quickfix properties
+		Non-string items in {what} are ignored. To get the value of a
+		particular item, set it to zero.
+		If "nr" is not present then the current quickfix list is used.
+		If both "nr" and a non-zero "id" are specified, then the list
+		specified by "id" is used.
+		To get the number of lists in the quickfix stack, set "nr" to
+		"$" in {what}. The "nr" value in the returned dictionary
+		contains the quickfix stack size.
+		When "lines" is specified, all the other items except "efm"
+		are ignored.  The returned dictionary contains the entry
+		"items" with the list of entries.
+
+		The returned dictionary contains the following entries:
+			changedtick	total number of changes made to the
+					list |quickfix-changedtick|
+			context	quickfix list context. See |quickfix-context|
+				If not present, set to "".
+			id	quickfix list ID |quickfix-ID|. If not
+				present, set to 0.
+			idx	index of the quickfix entry in the list. If not
+				present, set to 0.
+			items	quickfix list entries. If not present, set to
+				an empty list.
+			nr	quickfix list number. If not present, set to 0
+			qfbufnr	number of the buffer displayed in the quickfix
+				window. If not present, set to 0.
+			size	number of entries in the quickfix list. If not
+				present, set to 0.
+			title	quickfix list title text. If not present, set
+				to "".
+			winid	quickfix |window-ID|. If not present, set to 0
+
+		Examples (See also |getqflist-examples|): >
+			:echo getqflist({'all': 1})
+			:echo getqflist({'nr': 2, 'title': 1})
+			:echo getqflist({'lines' : ["F1:10:L10"]})
+<
+getreg([{regname} [, 1 [, {list}]]])			*getreg()*
+		The result is a String, which is the contents of register
+		{regname}.  Example: >
+			:let cliptext = getreg('*')
+<		When register {regname} was not set the result is an empty
+		string.
+		The {regname} argument must be a string.
+
+		getreg('=') returns the last evaluated value of the expression
+		register.  (For use in maps.)
+		getreg('=', 1) returns the expression itself, so that it can
+		be restored with |setreg()|.  For other registers the extra
+		argument is ignored, thus you can always give it.
+
+		If {list} is present and |TRUE|, the result type is changed
+		to |List|. Each list item is one text line. Use it if you care
+		about zero bytes possibly present inside register: without
+		third argument both NLs and zero bytes are represented as NLs
+		(see |NL-used-for-Nul|).
+		When the register was not set an empty list is returned.
+
+		If {regname} is not specified, |v:register| is used.
+
+		Can also be used as a |method|: >
+			GetRegname()->getreg()
+
+getreginfo([{regname}])					*getreginfo()*
+		Returns detailed information about register {regname} as a
+		Dictionary with the following entries:
+			regcontents	List of lines contained in register
+					{regname}, like
+					|getreg|({regname}, 1, 1).
+			regtype		the type of register {regname}, as in
+					|getregtype()|.
+			isunnamed	Boolean flag, v:true if this register
+					is currently pointed to by the unnamed
+					register.
+			points_to	for the unnamed register, gives the
+					single letter name of the register
+					currently pointed to (see |quotequote|).
+					For example, after deleting a line
+					with `dd`, this field will be "1",
+					which is the register that got the
+					deleted text.
+
+		The {regname} argument is a string.  If {regname} is invalid
+		or not set, an empty Dictionary will be returned.
+		If {regname} is not specified, |v:register| is used.
+		The returned Dictionary can be passed to |setreg()|.
+
+		Can also be used as a |method|: >
+			GetRegname()->getreginfo()
+
+getregtype([{regname}])					*getregtype()*
+		The result is a String, which is type of register {regname}.
+		The value will be one of:
+		    "v"			for |charwise| text
+		    "V"			for |linewise| text
+		    "<CTRL-V>{width}"	for |blockwise-visual| text
+		    ""			for an empty or unknown register
+		<CTRL-V> is one character with value 0x16.
+		The {regname} argument is a string.  If {regname} is not
+		specified, |v:register| is used.
+
+		Can also be used as a |method|: >
+			GetRegname()->getregtype()
+
+gettabinfo([{tabnr}])					*gettabinfo()*
+		If {tabnr} is not specified, then information about all the
+		tab pages is returned as a |List|. Each List item is a
+		|Dictionary|.  Otherwise, {tabnr} specifies the tab page
+		number and information about that one is returned.  If the tab
+		page does not exist an empty List is returned.
+
+		Each List item is a |Dictionary| with the following entries:
+			tabnr		tab page number.
+			variables	a reference to the dictionary with
+					tabpage-local variables
+			windows		List of |window-ID|s in the tab page.
+
+		Can also be used as a |method|: >
+			GetTabnr()->gettabinfo()
+
+gettabvar({tabnr}, {varname} [, {def}])				*gettabvar()*
+		Get the value of a tab-local variable {varname} in tab page
+		{tabnr}. |t:var|
+		Tabs are numbered starting with one.
+		The {varname} argument is a string.  When {varname} is empty a
+		dictionary with all tab-local variables is returned.
+		Note that the name without "t:" must be used.
+		When the tab or variable doesn't exist {def} or an empty
+		string is returned, there is no error message.
+
+		Can also be used as a |method|: >
+			GetTabnr()->gettabvar(varname)
+
+gettabwinvar({tabnr}, {winnr}, {varname} [, {def}])		*gettabwinvar()*
+		Get the value of window-local variable {varname} in window
+		{winnr} in tab page {tabnr}.
+		The {varname} argument is a string.  When {varname} is empty a
+ 		dictionary with all window-local variables is returned.
+		When {varname} is equal to "&" get the values of all
+		window-local options in a |Dictionary|.
+		Otherwise, when {varname} starts with "&" get the value of a
+		window-local option.
+		Note that {varname} must be the name without "w:".
+		Tabs are numbered starting with one.  For the current tabpage
+		use |getwinvar()|.
+		{winnr} can be the window number or the |window-ID|.
+		When {winnr} is zero the current window is used.
+		This also works for a global option, buffer-local option and
+		window-local option, but it doesn't work for a global variable
+		or buffer-local variable.
+		When the tab, window or variable doesn't exist {def} or an
+		empty string is returned, there is no error message.
+		Examples: >
+			:let list_is_on = gettabwinvar(1, 2, '&list')
+			:echo "myvar = " .. gettabwinvar(3, 1, 'myvar')
+<
+		To obtain all window-local variables use: >
+			gettabwinvar({tabnr}, {winnr}, '&')
+
+<		Can also be used as a |method|: >
+			GetTabnr()->gettabwinvar(winnr, varname)
+
+gettagstack([{winnr}])					*gettagstack()*
+		The result is a Dict, which is the tag stack of window {winnr}.
+		{winnr} can be the window number or the |window-ID|.
+		When {winnr} is not specified, the current window is used.
+		When window {winnr} doesn't exist, an empty Dict is returned.
+
+		The returned dictionary contains the following entries:
+			curidx		Current index in the stack. When at
+					top of the stack, set to (length + 1).
+					Index of bottom of the stack is 1.
+			items		List of items in the stack. Each item
+					is a dictionary containing the
+					entries described below.
+			length		Number of entries in the stack.
+
+		Each item in the stack is a dictionary with the following
+		entries:
+			bufnr		buffer number of the current jump
+			from		cursor position before the tag jump.
+					See |getpos()| for the format of the
+					returned list.
+			matchnr		current matching tag number. Used when
+					multiple matching tags are found for a
+					name.
+			tagname		name of the tag
+
+		See |tagstack| for more information about the tag stack.
+
+		Can also be used as a |method|: >
+			GetWinnr()->gettagstack()
+
+getwininfo([{winid}])					*getwininfo()*
+		Returns information about windows as a |List| with Dictionaries.
+
+		If {winid} is given Information about the window with that ID
+		is returned, as a |List| with one item.  If the window does not
+		exist the result is an empty list.
+
+		Without {winid} information about all the windows in all the
+		tab pages is returned.
+
+		Each List item is a |Dictionary| with the following entries:
+			botline		last complete displayed buffer line
+			bufnr		number of buffer in the window
+			height		window height (excluding winbar)
+			loclist		1 if showing a location list
+			quickfix	1 if quickfix or location list window
+			terminal	1 if a terminal window
+			tabnr		tab page number
+			topline		first displayed buffer line
+			variables	a reference to the dictionary with
+					window-local variables
+			width		window width
+			winbar		1 if the window has a toolbar, 0
+					otherwise
+			wincol		leftmost screen column of the window;
+					"col" from |win_screenpos()|
+			textoff		number of columns occupied by any
+					'foldcolumn', 'signcolumn' and line
+					number in front of the text
+			winid		|window-ID|
+			winnr		window number
+			winrow		topmost screen line of the window;
+					"row" from |win_screenpos()|
+
+		Can also be used as a |method|: >
+			GetWinnr()->getwininfo()
+
+getwinpos([{timeout}])					*getwinpos()*
+		The result is a |List| with two numbers, the result of
+		|getwinposx()| and |getwinposy()| combined:
+			[x-pos, y-pos]
+		{timeout} can be used to specify how long to wait in msec for
+		a response from the terminal.  When omitted 100 msec is used.
+
+		Use a longer time for a remote terminal.
+		When using a value less than 10 and no response is received
+		within that time, a previously reported position is returned,
+		if available.  This can be used to poll for the position and
+		do some work in the meantime: >
+			while 1
+			  let res = getwinpos(1)
+			  if res[0] >= 0
+			    break
+			  endif
+			  " Do some work here
+			endwhile
+<
+		Can also be used as a |method|: >
+			GetTimeout()->getwinpos()
+<
+							*getwinposx()*
+getwinposx()	The result is a Number, which is the X coordinate in pixels of
+		the left hand side of the GUI Vim window.  The result will be
+		-1 if the information is not available.
+		The value can be used with `:winpos`.
+
+							*getwinposy()*
+getwinposy()	The result is a Number, which is the Y coordinate in pixels of
+		the top of the GUI Vim window.  The result will be -1 if the
+		information is not available.
+		The value can be used with `:winpos`.
+
+getwinvar({winnr}, {varname} [, {def}])				*getwinvar()*
+		Like |gettabwinvar()| for the current tabpage.
+		Examples: >
+			:let list_is_on = getwinvar(2, '&list')
+			:echo "myvar = " .. getwinvar(1, 'myvar')
+
+<		Can also be used as a |method|: >
+			GetWinnr()->getwinvar(varname)
+<
+glob({expr} [, {nosuf} [, {list} [, {alllinks}]]])		*glob()*
+		Expand the file wildcards in {expr}.  See |wildcards| for the
+		use of special characters.
+
+		Unless the optional {nosuf} argument is given and is |TRUE|,
+		the 'suffixes' and 'wildignore' options apply: Names matching
+		one of the patterns in 'wildignore' will be skipped and
+		'suffixes' affect the ordering of matches.
+		'wildignorecase' always applies.
+
+		When {list} is present and it is |TRUE| the result is a |List|
+		with all matching files. The advantage of using a List is,
+		you also get filenames containing newlines correctly.
+		Otherwise the result is a String and when there are several
+		matches, they are separated by <NL> characters.
+
+		If the expansion fails, the result is an empty String or List.
+
+		You can also use |readdir()| if you need to do complicated
+		things, such as limiting the number of matches.
+
+		A name for a non-existing file is not included.  A symbolic
+		link is only included if it points to an existing file.
+		However, when the {alllinks} argument is present and it is
+		|TRUE| then all symbolic links are included.
+
+		For most systems backticks can be used to get files names from
+		any external command.  Example: >
+			:let tagfiles = glob("`find . -name tags -print`")
+			:let &tags = substitute(tagfiles, "\n", ",", "g")
+<		The result of the program inside the backticks should be one
+		item per line.  Spaces inside an item are allowed.
+
+		See |expand()| for expanding special Vim variables.  See
+		|system()| for getting the raw output of an external command.
+
+		Can also be used as a |method|: >
+			GetExpr()->glob()
+
+glob2regpat({string})					 *glob2regpat()*
+		Convert a file pattern, as used by glob(), into a search
+		pattern.  The result can be used to match with a string that
+		is a file name.  E.g. >
+			if filename =~ glob2regpat('Make*.mak')
+<		This is equivalent to: >
+			if filename =~ '^Make.*\.mak$'
+<		When {string} is an empty string the result is "^$", match an
+		empty string.
+		Note that the result depends on the system.  On MS-Windows
+		a backslash usually means a path separator.
+
+		Can also be used as a |method|: >
+			GetExpr()->glob2regpat()
+<								*globpath()*
+globpath({path}, {expr} [, {nosuf} [, {list} [, {allinks}]]])
+		Perform glob() for String {expr} on all directories in {path}
+		and concatenate the results.  Example: >
+			:echo globpath(&rtp, "syntax/c.vim")
+<
+		{path} is a comma-separated list of directory names.  Each
+		directory name is prepended to {expr} and expanded like with
+		|glob()|.  A path separator is inserted when needed.
+		To add a comma inside a directory name escape it with a
+		backslash.  Note that on MS-Windows a directory may have a
+		trailing backslash, remove it if you put a comma after it.
+		If the expansion fails for one of the directories, there is no
+		error message.
+
+		Unless the optional {nosuf} argument is given and is |TRUE|,
+		the 'suffixes' and 'wildignore' options apply: Names matching
+		one of the patterns in 'wildignore' will be skipped and
+		'suffixes' affect the ordering of matches.
+
+		When {list} is present and it is |TRUE| the result is a |List|
+		with all matching files. The advantage of using a List is, you
+		also get filenames containing newlines correctly. Otherwise
+		the result is a String and when there are several matches,
+		they are separated by <NL> characters.  Example: >
+			:echo globpath(&rtp, "syntax/c.vim", 0, 1)
+<
+		{allinks} is used as with |glob()|.
+
+		The "**" item can be used to search in a directory tree.
+		For example, to find all "README.txt" files in the directories
+		in 'runtimepath' and below: >
+			:echo globpath(&rtp, "**/README.txt")
+<		Upwards search and limiting the depth of "**" is not
+		supported, thus using 'path' will not always work properly.
+
+		Can also be used as a |method|, the base is passed as the
+		second argument: >
+			GetExpr()->globpath(&rtp)
+<
+							*has()*
+has({feature})	Returns 1 if {feature} is supported, 0 otherwise.  The
+		{feature} argument is a feature name like "nvim-0.2.1" or
+		"win32", see below.  See also |exists()|.
+
+		If the code has a syntax error, then Nvim may skip the rest
+		of the line and miss |:endif|. >
+	if has('feature') | let x = this->breaks->without->the->feature | endif
+<
+		Put |:if| and |:endif| on separate lines to avoid the
+		syntax error. >
+	if has('feature')
+	  let x = this->breaks->without->the->feature
+	endif
+<
+		Vim's compile-time feature-names (prefixed with "+") are not
+		recognized because Nvim is always compiled with all possible
+		features. |feature-compile|
+
+		Feature names can be:
+		1.  Nvim version. For example the "nvim-0.2.1" feature means
+		    that Nvim is version 0.2.1 or later: >
+			:if has("nvim-0.2.1")
+
+<		2.  Runtime condition or other pseudo-feature. For example the
+		    "win32" feature checks if the current system is Windows: >
+			:if has("win32")
+<							*feature-list*
+		    List of supported pseudo-feature names:
+			acl		|ACL| support.
+			bsd		BSD system (not macOS, use "mac" for that).
+			clipboard	|clipboard| provider is available.
+			fname_case	Case in file names matters (for Darwin and MS-Windows
+					this is not present).
+			iconv		Can use |iconv()| for conversion.
+			linux		Linux system.
+			mac		MacOS system.
+			nvim		This is Nvim.
+			python3		Legacy Vim |python3| interface. |has-python|
+			pythonx		Legacy Vim |python_x| interface. |has-pythonx|
+			sun		SunOS system.
+			ttyin		input is a terminal (tty).
+			ttyout		output is a terminal (tty).
+			unix		Unix system.
+			*vim_starting*	True during |startup|.
+			win32		Windows system (32 or 64 bit).
+			win64		Windows system (64 bit).
+			wsl		WSL (Windows Subsystem for Linux) system.
+
+							*has-patch*
+		3.  Vim patch. For example the "patch123" feature means that
+		    Vim patch 123 at the current |v:version| was included: >
+			:if v:version > 602 || v:version == 602 && has("patch148")
+
+<		4.  Vim version. For example the "patch-7.4.237" feature means
+		    that Nvim is Vim-compatible to version 7.4.237 or later. >
+			:if has("patch-7.4.237")
+
+
+has_key({dict}, {key})					*has_key()*
+		The result is a Number, which is TRUE if |Dictionary| {dict}
+		has an entry with key {key}.  FALSE otherwise. The {key}
+		argument is a string.
+
+		Can also be used as a |method|: >
+			mydict->has_key(key)
+
+haslocaldir([{winnr} [, {tabnr}]])			*haslocaldir()*
+		The result is a Number, which is 1 when the window has set a
+		local path via |:lcd| or when {winnr} is -1 and the tabpage
+		has set a local path via |:tcd|, otherwise 0.
+
+		Tabs and windows are identified by their respective numbers,
+		0 means current tab or window. Missing argument implies 0.
+		Thus the following are equivalent: >
+			haslocaldir()
+			haslocaldir(0)
+			haslocaldir(0, 0)
+<		With {winnr} use that window in the current tabpage.
+		With {winnr} and {tabnr} use the window in that tabpage.
+		{winnr} can be the window number or the |window-ID|.
+		If {winnr} is -1 it is ignored, only the tab is resolved.
+		Throw error if the arguments are invalid. |E5000| |E5001| |E5002|
+
+		Can also be used as a |method|: >
+			GetWinnr()->haslocaldir()
+
+hasmapto({what} [, {mode} [, {abbr}]])			*hasmapto()*
+		The result is a Number, which is TRUE if there is a mapping
+		that contains {what} in somewhere in the rhs (what it is
+		mapped to) and this mapping exists in one of the modes
+		indicated by {mode}.
+		The arguments {what} and {mode} are strings.
+		When {abbr} is there and it is |TRUE| use abbreviations
+		instead of mappings.  Don't forget to specify Insert and/or
+		Command-line mode.
+		Both the global mappings and the mappings local to the current
+		buffer are checked for a match.
+		If no matching mapping is found FALSE is returned.
+		The following characters are recognized in {mode}:
+			n	Normal mode
+			v	Visual and Select mode
+			x	Visual mode
+			s	Select mode
+			o	Operator-pending mode
+			i	Insert mode
+			l	Language-Argument ("r", "f", "t", etc.)
+			c	Command-line mode
+		When {mode} is omitted, "nvo" is used.
+
+		This function is useful to check if a mapping already exists
+		to a function in a Vim script.  Example: >
+			:if !hasmapto('\ABCdoit')
+			:   map <Leader>d \ABCdoit
+			:endif
+<		This installs the mapping to "\ABCdoit" only if there isn't
+		already a mapping to "\ABCdoit".
+
+		Can also be used as a |method|: >
+			GetRHS()->hasmapto()
+
+histadd({history}, {item})				*histadd()*
+		Add the String {item} to the history {history} which can be
+		one of:					*hist-names*
+			"cmd"	 or ":"	  command line history
+			"search" or "/"   search pattern history
+			"expr"	 or "="   typed expression history
+			"input"  or "@"	  input line history
+			"debug"  or ">"   debug command history
+			empty		  the current or last used history
+		The {history} string does not need to be the whole name, one
+		character is sufficient.
+		If {item} does already exist in the history, it will be
+		shifted to become the newest entry.
+		The result is a Number: TRUE if the operation was successful,
+		otherwise FALSE is returned.
+
+		Example: >
+			:call histadd("input", strftime("%Y %b %d"))
+			:let date=input("Enter date: ")
+<		This function is not available in the |sandbox|.
+
+		Can also be used as a |method|, the base is passed as the
+		second argument: >
+			GetHistory()->histadd('search')
+
+histdel({history} [, {item}])				*histdel()*
+		Clear {history}, i.e. delete all its entries.  See |hist-names|
+		for the possible values of {history}.
+
+		If the parameter {item} evaluates to a String, it is used as a
+		regular expression.  All entries matching that expression will
+		be removed from the history (if there are any).
+		Upper/lowercase must match, unless "\c" is used |/\c|.
+		If {item} evaluates to a Number, it will be interpreted as
+		an index, see |:history-indexing|.  The respective entry will
+		be removed if it exists.
+
+		The result is TRUE for a successful operation, otherwise FALSE
+		is returned.
+
+		Examples:
+		Clear expression register history: >
+			:call histdel("expr")
+<
+		Remove all entries starting with "*" from the search history: >
+			:call histdel("/", '^\*')
+<
+		The following three are equivalent: >
+			:call histdel("search", histnr("search"))
+			:call histdel("search", -1)
+			:call histdel("search", '^' .. histget("search", -1) .. '$')
+<
+		To delete the last search pattern and use the last-but-one for
+		the "n" command and 'hlsearch': >
+			:call histdel("search", -1)
+			:let @/ = histget("search", -1)
+<
+		Can also be used as a |method|: >
+			GetHistory()->histdel()
+
+histget({history} [, {index}])				*histget()*
+		The result is a String, the entry with Number {index} from
+		{history}.  See |hist-names| for the possible values of
+		{history}, and |:history-indexing| for {index}.  If there is
+		no such entry, an empty String is returned.  When {index} is
+		omitted, the most recent item from the history is used.
+
+		Examples:
+		Redo the second last search from history. >
+			:execute '/' .. histget("search", -2)
+
+<		Define an Ex command ":H {num}" that supports re-execution of
+		the {num}th entry from the output of |:history|. >
+			:command -nargs=1 H execute histget("cmd", 0+<args>)
+<
+		Can also be used as a |method|: >
+			GetHistory()->histget()
+
+histnr({history})					*histnr()*
+		The result is the Number of the current entry in {history}.
+		See |hist-names| for the possible values of {history}.
+		If an error occurred, -1 is returned.
+
+		Example: >
+			:let inp_index = histnr("expr")
+
+<		Can also be used as a |method|: >
+			GetHistory()->histnr()
+<
+hlexists({name})					*hlexists()*
+		The result is a Number, which is TRUE if a highlight group
+		called {name} exists.  This is when the group has been
+		defined in some way.  Not necessarily when highlighting has
+		been defined for it, it may also have been used for a syntax
+		item.
+
+		Can also be used as a |method|: >
+			GetName()->hlexists()
+<
+							*hlID()*
+hlID({name})	The result is a Number, which is the ID of the highlight group
+		with name {name}.  When the highlight group doesn't exist,
+		zero is returned.
+		This can be used to retrieve information about the highlight
+		group.  For example, to get the background color of the
+		"Comment" group: >
+	:echo synIDattr(synIDtrans(hlID("Comment")), "bg")
+<
+		Can also be used as a |method|: >
+			GetName()->hlID()
+
+hostname()						*hostname()*
+		The result is a String, which is the name of the machine on
+		which Vim is currently running.  Machine names greater than
+		256 characters long are truncated.
+
+iconv({string}, {from}, {to})				*iconv()*
+		The result is a String, which is the text {string} converted
+		from encoding {from} to encoding {to}.
+		When the conversion completely fails an empty string 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".
+		Note that Vim uses UTF-8 for all Unicode encodings, conversion
+		from/to UCS-2 is automatically changed to use UTF-8.  You
+		cannot use UCS-2 in a string anyway, because of the NUL bytes.
+
+		Can also be used as a |method|: >
+			GetText()->iconv('latin1', 'utf-8')
+<
+							*indent()*
+indent({lnum})	The result is a Number, which is indent of line {lnum} in the
+		current buffer.  The indent is counted in spaces, the value
+		of 'tabstop' is relevant.  {lnum} is used just like in
+		|getline()|.
+		When {lnum} is invalid -1 is returned.
+
+		Can also be used as a |method|: >
+			GetLnum()->indent()
+
+index({object}, {expr} [, {start} [, {ic}]])			*index()*
+		If {object} is a |List| return the lowest index where the item
+		has a value equal to {expr}.  There is no automatic
+		conversion, so the String "4" is different from the Number 4.
+		And the Number 4 is different from the Float 4.0.  The value
+		of 'ignorecase' is not used here, case always matters.
+
+		If {object} is a |Blob| return the lowest index where the byte
+		value is equal to {expr}.
+
+		If {start} is given then start looking at the item with index
+		{start} (may be negative for an item relative to the end).
+		When {ic} is given and it is |TRUE|, ignore case.  Otherwise
+		case must match.
+		-1 is returned when {expr} is not found in {object}.
+		Example: >
+			:let idx = index(words, "the")
+			:if index(numbers, 123) >= 0
+
+<		Can also be used as a |method|: >
+			GetObject()->index(what)
+
+input({prompt} [, {text} [, {completion}]])		*input()*
+input({opts})
+		The result is a String, which is whatever the user typed on
+		the command-line.  The {prompt} argument is either a prompt
+		string, or a blank string (for no prompt).  A '\n' can be used
+		in the prompt to start a new line.
+
+		In the second form it accepts a single dictionary with the
+		following keys, any of which may be omitted:
+
+		Key           Default  Description ~
+		prompt        ""       Same as {prompt} in the first form.
+		default       ""       Same as {text} in the first form.
+		completion    nothing  Same as {completion} in the first form.
+		cancelreturn  ""       The value returned when the dialog is
+		                       cancelled.
+		highlight     nothing  Highlight handler: |Funcref|.
+
+		The highlighting set with |:echohl| is used for the prompt.
+		The input is entered just like a command-line, with the same
+		editing commands and mappings.  There is a separate history
+		for lines typed for input().
+		Example: >
+			:if input("Coffee or beer? ") == "beer"
+			:  echo "Cheers!"
+			:endif
+<
+		If the optional {text} argument is present and not empty, this
+		is used for the default reply, as if the user typed this.
+		Example: >
+			:let color = input("Color? ", "white")
+
+<		The optional {completion} argument specifies the type of
+		completion supported for the input.  Without it completion is
+		not performed.  The supported completion types are the same as
+		that can be supplied to a user-defined command using the
+		"-complete=" argument.  Refer to |:command-completion| for
+		more information.  Example: >
+			let fname = input("File: ", "", "file")
+
+<					*input()-highlight* *E5400* *E5402*
+		The optional `highlight` key allows specifying function which
+		will be used for highlighting user input.  This function
+		receives user input as its only argument and must return
+		a list of 3-tuples [hl_start_col, hl_end_col + 1, hl_group]
+		where
+			hl_start_col is the first highlighted column,
+			hl_end_col is the last highlighted column (+ 1!),
+			hl_group is |:hi| group used for highlighting.
+					      *E5403* *E5404* *E5405* *E5406*
+		Both hl_start_col and hl_end_col + 1 must point to the start
+		of the multibyte character (highlighting must not break
+		multibyte characters), hl_end_col + 1 may be equal to the
+		input length.  Start column must be in range [0, len(input)),
+		end column must be in range (hl_start_col, len(input)],
+		sections must be ordered so that next hl_start_col is greater
+		then or equal to previous hl_end_col.
+
+		Example (try some input with parentheses): >
+			highlight RBP1 guibg=Red ctermbg=red
+			highlight RBP2 guibg=Yellow ctermbg=yellow
+			highlight RBP3 guibg=Green ctermbg=green
+			highlight RBP4 guibg=Blue ctermbg=blue
+			let g:rainbow_levels = 4
+			function! RainbowParens(cmdline)
+			  let ret = []
+			  let i = 0
+			  let lvl = 0
+			  while i < len(a:cmdline)
+			    if a:cmdline[i] is# '('
+			      call add(ret, [i, i + 1, 'RBP' .. ((lvl % g:rainbow_levels) + 1)])
+			      let lvl += 1
+			    elseif a:cmdline[i] is# ')'
+			      let lvl -= 1
+			      call add(ret, [i, i + 1, 'RBP' .. ((lvl % g:rainbow_levels) + 1)])
+			    endif
+			    let i += 1
+			  endwhile
+			  return ret
+			endfunction
+			call input({'prompt':'>','highlight':'RainbowParens'})
+<
+		Highlight function is called at least once for each new
+		displayed input string, before command-line is redrawn.  It is
+		expected that function is pure for the duration of one input()
+		call, i.e. it produces the same output for the same input, so
+		output may be memoized.  Function is run like under |:silent|
+		modifier. If the function causes any errors, it will be
+		skipped for the duration of the current input() call.
+
+		Highlighting is disabled if command-line contains arabic
+		characters.
+
+		NOTE: This function must not be used in a startup file, for
+		the versions that only run in GUI mode (e.g., the Win32 GUI).
+		Note: When input() is called from within a mapping it will
+		consume remaining characters from that mapping, because a
+		mapping is handled like the characters were typed.
+		Use |inputsave()| before input() and |inputrestore()|
+		after input() to avoid that.  Another solution is to avoid
+		that further characters follow in the mapping, e.g., by using
+		|:execute| or |:normal|.
+
+		Example with a mapping: >
+			:nmap \x :call GetFoo()<CR>:exe "/" .. Foo<CR>
+			:function GetFoo()
+			:  call inputsave()
+			:  let g:Foo = input("enter search pattern: ")
+			:  call inputrestore()
+			:endfunction
+
+<		Can also be used as a |method|: >
+			GetPrompt()->input()
+
+inputlist({textlist})					*inputlist()*
+		{textlist} must be a |List| of strings.  This |List| is
+		displayed, one string per line.  The user will be prompted to
+		enter a number, which is returned.
+		The user can also select an item by clicking on it with the
+		mouse, if the mouse is enabled in the command line ('mouse' is
+		"a" or includes "c").  For the first string 0 is returned.
+		When clicking above the first item a negative number is
+		returned.  When clicking on the prompt one more than the
+		length of {textlist} is returned.
+		Make sure {textlist} has less than 'lines' entries, otherwise
+		it won't work.  It's a good idea to put the entry number at
+		the start of the string.  And put a prompt in the first item.
+		Example: >
+			let color = inputlist(['Select color:', '1. red',
+				\ '2. green', '3. blue'])
+
+<		Can also be used as a |method|: >
+			GetChoices()->inputlist()
+
+inputrestore()						*inputrestore()*
+		Restore typeahead that was saved with a previous |inputsave()|.
+		Should be called the same number of times inputsave() is
+		called.  Calling it more often is harmless though.
+		Returns TRUE when there is nothing to restore, FALSE otherwise.
+
+inputsave()						*inputsave()*
+		Preserve typeahead (also from mappings) and clear it, so that
+		a following prompt gets input from the user.  Should be
+		followed by a matching inputrestore() after the prompt.  Can
+		be used several times, in which case there must be just as
+		many inputrestore() calls.
+		Returns TRUE when out of memory, FALSE otherwise.
+
+inputsecret({prompt} [, {text}])			*inputsecret()*
+		This function acts much like the |input()| function with but
+		two exceptions:
+		a) the user's response will be displayed as a sequence of
+		asterisks ("*") thereby keeping the entry secret, and
+		b) the user's response will not be recorded on the input
+		|history| stack.
+		The result is a String, which is whatever the user actually
+		typed on the command-line in response to the issued prompt.
+		NOTE: Command-line completion is not supported.
+
+		Can also be used as a |method|: >
+			GetPrompt()->inputsecret()
+
+insert({object}, {item} [, {idx}])			*insert()*
+		When {object} is a |List| or a |Blob| insert {item} at the start
+		of it.
+
+		If {idx} is specified insert {item} before the item with index
+		{idx}.  If {idx} is zero it goes before the first item, just
+		like omitting {idx}.  A negative {idx} is also possible, see
+		|list-index|.  -1 inserts just before the last item.
+
+		Returns the resulting |List| or |Blob|.  Examples: >
+			:let mylist = insert([2, 3, 5], 1)
+			:call insert(mylist, 4, -1)
+			:call insert(mylist, 6, len(mylist))
+<		The last example can be done simpler with |add()|.
+		Note that when {item} is a |List| it is inserted as a single
+		item.  Use |extend()| to concatenate |Lists|.
+
+		Can also be used as a |method|: >
+			mylist->insert(item)
+
+interrupt()						*interrupt()*
+		Interrupt script execution.  It works more or less like the
+		user typing CTRL-C, most commands won't execute and control
+		returns to the user.  This is useful to abort execution
+		from lower down, e.g. in an autocommand.  Example: >
+		:function s:check_typoname(file)
+		:   if fnamemodify(a:file, ':t') == '['
+		:       echomsg 'Maybe typo'
+		:       call interrupt()
+		:   endif
+		:endfunction
+		:au BufWritePre * call s:check_typoname(expand('<amatch>'))
+
+invert({expr})						*invert()*
+		Bitwise invert.  The argument is converted to a number.  A
+		List, Dict or Float argument causes an error.  Example: >
+			:let bits = invert(bits)
+<		Can also be used as a |method|: >
+			:let bits = bits->invert()
+
+isdirectory({directory})				*isdirectory()*
+		The result is a Number, which is |TRUE| when a directory
+		with the name {directory} exists.  If {directory} doesn't
+		exist, or isn't a directory, the result is |FALSE|.  {directory}
+		is any expression, which is used as a String.
+
+		Can also be used as a |method|: >
+			GetName()->isdirectory()
+
+isinf({expr})						*isinf()*
+		Return 1 if {expr} is a positive infinity, or -1 a negative
+		infinity, otherwise 0. >
+			:echo isinf(1.0 / 0.0)
+<			1 >
+			:echo isinf(-1.0 / 0.0)
+<			-1
+
+		Can also be used as a |method|: >
+			Compute()->isinf()
+
+islocked({expr})					*islocked()* *E786*
+		The result is a Number, which is |TRUE| when {expr} is the
+		name of a locked variable.
+		The string argument {expr} must be the name of a variable,
+		|List| item or |Dictionary| entry, not the variable itself!
+		Example: >
+			:let alist = [0, ['a', 'b'], 2, 3]
+			:lockvar 1 alist
+			:echo islocked('alist')		" 1
+			:echo islocked('alist[1]')	" 0
+
+<		When {expr} is a variable that does not exist you get an error
+		message.  Use |exists()| to check for existence.
+
+		Can also be used as a |method|: >
+			GetName()->islocked()
+
+id({expr})						*id()*
+		Returns a |String| which is a unique identifier of the
+		container type (|List|, |Dict|, |Blob| and |Partial|). It is
+		guaranteed that for the mentioned types `id(v1) ==# id(v2)`
+		returns true iff `type(v1) == type(v2) && v1 is v2`.
+		Note that |v:_null_string|, |v:_null_list|, |v:_null_dict| and
+		|v:_null_blob| have the same `id()` with different types
+		because they are internally represented as NULL pointers.
+		`id()` returns a hexadecimal representanion of the pointers to
+		the containers (i.e. like `0x994a40`), same as `printf("%p",
+		{expr})`, but it is advised against counting on the exact
+		format of the return value.
+
+		It is not guaranteed that `id(no_longer_existing_container)`
+		will not be equal to some other `id()`: new containers may
+		reuse identifiers of the garbage-collected ones.
+
+items({dict})						*items()*
+		Return a |List| with all the key-value pairs of {dict}.  Each
+		|List| item is a list with two items: the key of a {dict}
+		entry and the value of this entry.  The |List| is in arbitrary
+		order.  Also see |keys()| and |values()|.
+		Example: >
+			for [key, value] in items(mydict)
+			   echo key .. ': ' .. value
+			endfor
+
+<		Can also be used as a |method|: >
+			mydict->items()
+
+isnan({expr})						*isnan()*
+		Return |TRUE| if {expr} is a float with value NaN. >
+			echo isnan(0.0 / 0.0)
+<			1
+
+		Can also be used as a |method|: >
+			Compute()->isnan()
+
+jobpid({job})						*jobpid()*
+		Return the PID (process id) of |job-id| {job}.
+
+jobresize({job}, {width}, {height})			*jobresize()*
+		Resize the pseudo terminal window of |job-id| {job} to {width}
+		columns and {height} rows.
+		Fails if the job was not started with `"pty":v:true`.
+
+jobstart({cmd} [, {opts}])				*jobstart()*
+		Spawns {cmd} as a job.
+		If {cmd} is a List it runs directly (no 'shell').
+		If {cmd} is a String it runs in the 'shell', like this: >
+		  :call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}'])
+<		(See |shell-unquoting| for details.)
+
+		Example: >
+		  :call jobstart('nvim -h', {'on_stdout':{j,d,e->append(line('.'),d)}})
+<
+		Returns |job-id| on success, 0 on invalid arguments (or job
+		table is full), -1 if {cmd}[0] or 'shell' is not executable.
+		The returned job-id is a valid |channel-id| representing the
+		job's stdio streams. Use |chansend()| (or |rpcnotify()| and
+		|rpcrequest()| if "rpc" was enabled) to send data to stdin and
+		|chanclose()| to close the streams without stopping the job.
+
+		See |job-control| and |RPC|.
+
+		NOTE: on Windows if {cmd} is a List:
+		  - cmd[0] must be an executable (not a "built-in"). If it is
+		    in $PATH it can be called by name, without an extension: >
+		      :call jobstart(['ping', 'neovim.io'])
+<		    If it is a full or partial path, extension is required: >
+		      :call jobstart(['System32\ping.exe', 'neovim.io'])
+<		  - {cmd} is collapsed to a string of quoted args as expected
+		    by CommandLineToArgvW https://msdn.microsoft.com/bb776391
+		    unless cmd[0] is some form of "cmd.exe".
+
+							*jobstart-env*
+		The job environment is initialized as follows:
+		  $NVIM                is set to |v:servername| of the parent Nvim
+		  $NVIM_LISTEN_ADDRESS is unset
+		  $NVIM_LOG_FILE       is unset
+		  $VIM                 is unset
+		  $VIMRUNTIME          is unset
+		You can set these with the `env` option.
+
+							*jobstart-options*
+		{opts} is a dictionary with these keys:
+		  clear_env:  (boolean) `env` defines the job environment
+			      exactly, instead of merging current environment.
+		  cwd:	      (string, default=|current-directory|) Working
+			      directory of the job.
+		  detach:     (boolean) Detach the job process: it will not be
+			      killed when Nvim exits. If the process exits
+			      before Nvim, `on_exit` will be invoked.
+		  env:	      (dict) Map of environment variable name:value
+			      pairs extending (or replacing with |clear_env|)
+			      the current environment. |jobstart-env|
+		  height:     (number) Height of the `pty` terminal.
+		  |on_exit|:    (function) Callback invoked when the job exits.
+		  |on_stdout|:  (function) Callback invoked when the job emits
+			      stdout data.
+		  |on_stderr|:  (function) Callback invoked when the job emits
+			      stderr data.
+		  overlapped: (boolean) Set FILE_FLAG_OVERLAPPED for the
+			      standard input/output passed to the child process.
+			      Normally you do not need to set this.
+			      (Only available on MS-Windows, On other
+			      platforms, this option is silently ignored.)
+		  pty:	      (boolean) Connect the job to a new pseudo
+			      terminal, and its streams to the master file
+			      descriptor. `on_stdout` receives all output,
+			      `on_stderr` is ignored. |terminal-start|
+		  rpc:	      (boolean) Use |msgpack-rpc| to communicate with
+			      the job over stdio. Then `on_stdout` is ignored,
+			      but `on_stderr` can still be used.
+		  stderr_buffered: (boolean) Collect data until EOF (stream closed)
+			      before invoking `on_stderr`. |channel-buffered|
+		  stdout_buffered: (boolean) Collect data until EOF (stream
+			      closed) before invoking `on_stdout`. |channel-buffered|
+		  stdin:      (string) Either "pipe" (default) to connect the
+			      job's stdin to a channel or "null" to disconnect
+			      stdin.
+		  width:      (number) Width of the `pty` terminal.
+
+		{opts} is passed as |self| dictionary to the callback; the
+		caller may set other keys to pass application-specific data.
+
+		Returns:
+		  - |channel-id| on success
+		  - 0 on invalid arguments
+		  - -1 if {cmd}[0] is not executable.
+		See also |job-control|, |channel|, |msgpack-rpc|.
+
+jobstop({id})						*jobstop()*
+		Stop |job-id| {id} by sending SIGTERM to the job process. If
+		the process does not terminate after a timeout then SIGKILL
+		will be sent. When the job terminates its |on_exit| handler
+		(if any) will be invoked.
+		See |job-control|.
+
+		Returns 1 for valid job id, 0 for invalid id, including jobs have
+		exited or stopped.
+
+jobwait({jobs} [, {timeout}])				*jobwait()*
+		Waits for jobs and their |on_exit| handlers to complete.
+
+		{jobs} is a List of |job-id|s to wait for.
+		{timeout} is the maximum waiting time in milliseconds. If
+		omitted or -1, wait forever.
+
+		Timeout of 0 can be used to check the status of a job: >
+			let running = jobwait([{job-id}], 0)[0] == -1
+<
+		During jobwait() callbacks for jobs not in the {jobs} list may
+		be invoked. The screen will not redraw unless |:redraw| is
+		invoked by a callback.
+
+		Returns a list of len({jobs}) integers, where each integer is
+		the status of the corresponding job:
+			Exit-code, if the job exited
+			-1 if the timeout was exceeded
+			-2 if the job was interrupted (by |CTRL-C|)
+			-3 if the job-id is invalid
+
+join({list} [, {sep}])					*join()*
+		Join the items in {list} together into one String.
+		When {sep} is specified it is put in between the items.  If
+		{sep} is omitted a single space is used.
+		Note that {sep} is not added at the end.  You might want to
+		add it there too: >
+			let lines = join(mylist, "\n") .. "\n"
+<		String items are used as-is.  |Lists| and |Dictionaries| are
+		converted into a string like with |string()|.
+		The opposite function is |split()|.
+
+		Can also be used as a |method|: >
+			mylist->join()
+
+json_decode({expr})					*json_decode()*
+		Convert {expr} from JSON object.  Accepts |readfile()|-style
+		list as the input, as well as regular string.  May output any
+		Vim value. In the following cases it will output
+		|msgpack-special-dict|:
+		1. Dictionary contains duplicate key.
+		2. Dictionary contains empty key.
+		3. String contains NUL byte.  Two special dictionaries: for
+		   dictionary and for string will be emitted in case string
+		   with NUL byte was a dictionary key.
+
+		Note: function treats its input as UTF-8 always.  The JSON
+		standard allows only a few encodings, of which UTF-8 is
+		recommended and the only one required to be supported.
+		Non-UTF-8 characters are an error.
+
+		Can also be used as a |method|: >
+			ReadObject()->json_decode()
+
+json_encode({expr})					*json_encode()*
+		Convert {expr} into a JSON string.  Accepts
+		|msgpack-special-dict| as the input.  Will not convert
+		|Funcref|s, mappings with non-string keys (can be created as
+		|msgpack-special-dict|), values with self-referencing
+		containers, strings which contain non-UTF-8 characters,
+		pseudo-UTF-8 strings which contain codepoints reserved for
+		surrogate pairs (such strings are not valid UTF-8 strings).
+		Non-printable characters are converted into "\u1234" escapes
+		or special escapes like "\t", other are dumped as-is.
+		|Blob|s are converted to arrays of the individual bytes.
+
+		Can also be used as a |method|: >
+			GetObject()->json_encode()
+
+keys({dict})						*keys()*
+		Return a |List| with all the keys of {dict}.  The |List| is in
+		arbitrary order.  Also see |items()| and |values()|.
+
+		Can also be used as a |method|: >
+			mydict->keys()
+
+<							*len()* *E701*
+len({expr})	The result is a Number, which is the length of the argument.
+		When {expr} is a String or a Number the length in bytes is
+		used, as with |strlen()|.
+		When {expr} is a |List| the number of items in the |List| is
+		returned.
+		When {expr} is a |Blob| the number of bytes is returned.
+		When {expr} is a |Dictionary| the number of entries in the
+		|Dictionary| is returned.
+		Otherwise an error is given and returns zero.
+
+		Can also be used as a |method|: >
+			mylist->len()
+
+<						*libcall()* *E364* *E368*
+libcall({libname}, {funcname}, {argument})
+		Call function {funcname} in the run-time library {libname}
+		with single argument {argument}.
+		This is useful to call functions in a library that you
+		especially made to be used with Vim.  Since only one argument
+		is possible, calling standard library functions is rather
+		limited.
+		The result is the String returned by the function.  If the
+		function returns NULL, this will appear as an empty string ""
+		to Vim.
+		If the function returns a number, use libcallnr()!
+		If {argument} is a number, it is passed to the function as an
+		int; if {argument} is a string, it is passed as a
+		null-terminated string.
+
+		libcall() allows you to write your own 'plug-in' extensions to
+		Vim without having to recompile the program.  It is NOT a
+		means to call system functions!  If you try to do so Vim will
+		very probably crash.
+
+		For Win32, the functions you write must be placed in a DLL
+		and use the normal C calling convention (NOT Pascal which is
+		used in Windows System DLLs).  The function must take exactly
+		one parameter, either a character pointer or a long integer,
+		and must return a character pointer or NULL.  The character
+		pointer returned must point to memory that will remain valid
+		after the function has returned (e.g. in static data in the
+		DLL).  If it points to allocated memory, that memory will
+		leak away.  Using a static buffer in the function should work,
+		it's then freed when the DLL is unloaded.
+
+		WARNING: If the function returns a non-valid pointer, Vim may
+		crash!	This also happens if the function returns a number,
+		because Vim thinks it's a pointer.
+		For Win32 systems, {libname} should be the filename of the DLL
+		without the ".DLL" suffix.  A full path is only required if
+		the DLL is not in the usual places.
+		For Unix: When compiling your own plugins, remember that the
+		object code must be compiled as position-independent ('PIC').
+		Examples: >
+			:echo libcall("libc.so", "getenv", "HOME")
+
+<		Can also be used as a |method|, the base is passed as the
+		third argument: >
+			GetValue()->libcall("libc.so", "getenv")
+<
+							*libcallnr()*
+libcallnr({libname}, {funcname}, {argument})
+		Just like |libcall()|, but used for a function that returns an
+		int instead of a string.
+		Examples: >
+			:echo libcallnr("/usr/lib/libc.so", "getpid", "")
+			:call libcallnr("libc.so", "printf", "Hello World!\n")
+			:call libcallnr("libc.so", "sleep", 10)
+<
+		Can also be used as a |method|, the base is passed as the
+		third argument: >
+			GetValue()->libcallnr("libc.so", "printf")
+<
+line({expr} [, {winid}])				*line()*
+		The result is a Number, which is the line number of the file
+		position given with {expr}.  The {expr} argument is a string.
+		The accepted positions are:
+		    .	    the cursor position
+		    $	    the last line in the current buffer
+		    'x	    position of mark x (if the mark is not set, 0 is
+			    returned)
+		    w0	    first line visible in current window (one if the
+			    display isn't updated, e.g. in silent Ex mode)
+		    w$	    last line visible in current window (this is one
+			    less than "w0" if no lines are visible)
+		    v	    In Visual mode: the start of the Visual area (the
+			    cursor is the end).  When not in Visual mode
+			    returns the cursor position.  Differs from |'<| in
+			    that it's updated right away.
+		Note that a mark in another file can be used.  The line number
+		then applies to another buffer.
+		To get the column number use |col()|.  To get both use
+		|getpos()|.
+		With the optional {winid} argument the values are obtained for
+		that window instead of the current window.
+		Returns 0 for invalid values of {expr} and {winid}.
+		Examples: >
+			line(".")		line number of the cursor
+			line(".", winid)	idem, in window "winid"
+			line("'t")		line number of mark t
+			line("'" .. marker)	line number of mark marker
+<
+		To jump to the last known position when opening a file see
+		|last-position-jump|.
+
+		Can also be used as a |method|: >
+			GetValue()->line()
+
+line2byte({lnum})					*line2byte()*
+		Return the byte count from the start of the buffer for line
+		{lnum}.  This includes the end-of-line character, depending on
+		the 'fileformat' option for the current buffer.  The first
+		line returns 1. UTF-8 encoding is used, 'fileencoding' is
+		ignored.  This can also be used to get the byte count for the
+		line just below the last line: >
+			line2byte(line("$") + 1)
+<		This is the buffer size plus one.  If 'fileencoding' is empty
+		it is the file size plus one.  {lnum} is used like with
+		|getline()|.  When {lnum} is invalid -1 is returned.
+		Also see |byte2line()|, |go| and |:goto|.
+
+		Can also be used as a |method|: >
+			GetLnum()->line2byte()
+
+lispindent({lnum})					*lispindent()*
+		Get the amount of indent for line {lnum} according the lisp
+		indenting rules, as with 'lisp'.
+		The indent is counted in spaces, the value of 'tabstop' is
+		relevant.  {lnum} is used just like in |getline()|.
+		When {lnum} is invalid, -1 is returned.
+
+		Can also be used as a |method|: >
+			GetLnum()->lispindent()
+
+list2str({list} [, {utf8}])				*list2str()*
+		Convert each number in {list} to a character string can
+		concatenate them all.  Examples: >
+			list2str([32])		returns " "
+			list2str([65, 66, 67])	returns "ABC"
+<		The same can be done (slowly) with: >
+			join(map(list, {nr, val -> nr2char(val)}), '')
+<		|str2list()| does the opposite.
+
+		UTF-8 encoding is always used, {utf8} option has no effect,
+		and exists only for backwards-compatibility.
+		With UTF-8 composing characters work as expected: >
+			list2str([97, 769])	returns "á"
+<
+		Returns an empty string on error.
+
+		Can also be used as a |method|: >
+			GetList()->list2str()
+
+localtime()						*localtime()*
+		Return the current time, measured as seconds since 1st Jan
+		1970.  See also |strftime()|, |strptime()| and |getftime()|.
+
+
+log({expr})						*log()*
+		Return the natural logarithm (base e) of {expr} as a |Float|.
+		{expr} must evaluate to a |Float| or a |Number| in the range
+		(0, inf].
+		Returns 0.0 if {expr} is not a |Float| or a |Number|.
+		Examples: >
+			:echo log(10)
+<			2.302585 >
+			:echo log(exp(5))
+<			5.0
+
+		Can also be used as a |method|: >
+			Compute()->log()
+
+log10({expr})						*log10()*
+		Return the logarithm of Float {expr} to base 10 as a |Float|.
+		{expr} must evaluate to a |Float| or a |Number|.
+		Returns 0.0 if {expr} is not a |Float| or a |Number|.
+		Examples: >
+			:echo log10(1000)
+<			3.0 >
+			:echo log10(0.01)
+<			-2.0
+
+		Can also be used as a |method|: >
+			Compute()->log10()
+
+luaeval({expr} [, {expr}])
+		Evaluate Lua expression {expr} and return its result converted
+		to Vim data structures. See |lua-eval| for more details.
+
+		Can also be used as a |method|: >
+			GetExpr()->luaeval()
+
+map({expr1}, {expr2})					*map()*
+		{expr1} must be a |List|, |Blob| or |Dictionary|.
+		Replace each item in {expr1} with the result of evaluating
+		{expr2}.  For a |Blob| each byte is replaced.
+
+		{expr2} must be a |string| or |Funcref|.
+
+		If {expr2} is a |string|, inside {expr2} |v:val| has the value
+		of the current item.  For a |Dictionary| |v:key| has the key
+		of the current item and for a |List| |v:key| has the index of
+		the current item.  For a |Blob| |v:key| has the index of the
+		current byte.
+		Example: >
+			:call map(mylist, '"> " .. v:val .. " <"')
+<		This puts "> " before and " <" after each item in "mylist".
+
+		Note that {expr2} is the result of an expression and is then
+		used as an expression again.  Often it is good to use a
+		|literal-string| to avoid having to double backslashes.  You
+		still have to double ' quotes
+
+		If {expr2} is a |Funcref| it is called with two arguments:
+			1. The key or the index of the current item.
+			2. the value of the current item.
+		The function must return the new value of the item. Example
+		that changes each value by "key-value": >
+			func KeyValue(key, val)
+			  return a:key .. '-' .. a:val
+			endfunc
+			call map(myDict, function('KeyValue'))
+<		It is shorter when using a |lambda|: >
+			call map(myDict, {key, val -> key .. '-' .. val})
+<		If you do not use "val" you can leave it out: >
+			call map(myDict, {key -> 'item: ' .. key})
+<		If you do not use "key" you can use a short name: >
+			call map(myDict, {_, val -> 'item: ' .. val})
+<
+		The operation is done in-place.  If you want a |List| or
+		|Dictionary| to remain unmodified make a copy first: >
+			:let tlist = map(copy(mylist), ' v:val .. "\t"')
+
+<		Returns {expr1}, the |List|, |Blob| or |Dictionary| that was
+		filtered.  When an error is encountered while evaluating
+		{expr2} no further items in {expr1} are processed.  When
+		{expr2} is a Funcref errors inside a function are ignored,
+		unless it was defined with the "abort" flag.
+
+		Can also be used as a |method|: >
+			mylist->map(expr2)
+
+maparg({name} [, {mode} [, {abbr} [, {dict}]]])			*maparg()*
+		When {dict} is omitted or zero: Return the rhs of mapping
+		{name} in mode {mode}.  The returned String has special
+		characters translated like in the output of the ":map" command
+		listing.
+
+		When there is no mapping for {name}, an empty String is
+ 		returned if {dict} is FALSE, otherwise returns an empty Dict.
+ 		When the mapping for {name} is empty, then "<Nop>" is
+ 		returned.
+
+		The {name} can have special key names, like in the ":map"
+		command.
+
+		{mode} can be one of these strings:
+			"n"	Normal
+			"v"	Visual (including Select)
+			"o"	Operator-pending
+			"i"	Insert
+			"c"	Cmd-line
+			"s"	Select
+			"x"	Visual
+			"l"	langmap |language-mapping|
+			"t"	Terminal
+			""	Normal, Visual and Operator-pending
+		When {mode} is omitted, the modes for "" are used.
+
+		When {abbr} is there and it is |TRUE| use abbreviations
+		instead of mappings.
+
+		When {dict} is there and it is |TRUE| return a dictionary
+		containing all the information of the mapping with the
+		following items:
+		  "lhs"	     The {lhs} of the mapping.
+		  "rhs"	     The {rhs} of the mapping as typed.
+		  "silent"   1 for a |:map-silent| mapping, else 0.
+		  "noremap"  1 if the {rhs} of the mapping is not remappable.
+		  "script"   1 if mapping was defined with <script>.
+		  "expr"     1 for an expression mapping (|:map-<expr>|).
+		  "buffer"   1 for a buffer local mapping (|:map-local|).
+		  "mode"     Modes for which the mapping is defined. In
+			     addition to the modes mentioned above, these
+			     characters will be used:
+			     " "     Normal, Visual and Operator-pending
+			     "!"     Insert and Commandline mode
+				     (|mapmode-ic|)
+		  "sid"	     The script local ID, used for <sid> mappings
+			     (|<SID>|).
+		  "lnum"     The line number in "sid", zero if unknown.
+		  "nowait"   Do not wait for other, longer mappings.
+			     (|:map-<nowait>|).
+
+		The mappings local to the current buffer are checked first,
+		then the global mappings.
+		This function can be used to map a key even when it's already
+		mapped, and have it do the original mapping too.  Sketch: >
+			exe 'nnoremap <Tab> ==' .. maparg('<Tab>', 'n')
+
+<		Can also be used as a |method|: >
+			GetKey()->maparg('n')
+
+mapcheck({name} [, {mode} [, {abbr}]])			*mapcheck()*
+		Check if there is a mapping that matches with {name} in mode
+		{mode}.  See |maparg()| for {mode} and special names in
+		{name}.
+		When {abbr} is there and it is non-zero use abbreviations
+		instead of mappings.
+		A match happens with a mapping that starts with {name} and
+		with a mapping which is equal to the start of {name}.
+
+			matches mapping "a"	"ab"	"abc" ~
+		   mapcheck("a")	yes	yes	 yes
+		   mapcheck("abc")	yes	yes	 yes
+		   mapcheck("ax")	yes	no	 no
+		   mapcheck("b")	no	no	 no
+
+		The difference with maparg() is that mapcheck() finds a
+		mapping that matches with {name}, while maparg() only finds a
+		mapping for {name} exactly.
+		When there is no mapping that starts with {name}, an empty
+		String is returned.  If there is one, the RHS of that mapping
+		is returned.  If there are several mappings that start with
+		{name}, the RHS of one of them is returned.  This will be
+		"<Nop>" if the RHS is empty.
+		The mappings local to the current buffer are checked first,
+		then the global mappings.
+		This function can be used to check if a mapping can be added
+		without being ambiguous.  Example: >
+	:if mapcheck("_vv") == ""
+	:   map _vv :set guifont=7x13<CR>
+	:endif
+<		This avoids adding the "_vv" mapping when there already is a
+		mapping for "_v" or for "_vvv".
+
+		Can also be used as a |method|: >
+			GetKey()->mapcheck('n')
+
+match({expr}, {pat} [, {start} [, {count}]])			*match()*
+		When {expr} is a |List| then this returns the index of the
+		first item where {pat} matches.  Each item is used as a
+		String, |Lists| and |Dictionaries| are used as echoed.
+
+		Otherwise, {expr} is used as a String.  The result is a
+		Number, which gives the index (byte offset) in {expr} where
+		{pat} matches.
+
+		A match at the first character or |List| item returns zero.
+		If there is no match -1 is returned.
+
+		For getting submatches see |matchlist()|.
+		Example: >
+			:echo match("testing", "ing")	" results in 4
+			:echo match([1, 'x'], '\a')	" results in 1
+<		See |string-match| for how {pat} is used.
+								*strpbrk()*
+		Vim doesn't have a strpbrk() function.  But you can do: >
+			:let sepidx = match(line, '[.,;: \t]')
+<								*strcasestr()*
+		Vim doesn't have a strcasestr() function.  But you can add
+		"\c" to the pattern to ignore case: >
+			:let idx = match(haystack, '\cneedle')
+<
+		If {start} is given, the search starts from byte index
+		{start} in a String or item {start} in a |List|.
+		The result, however, is still the index counted from the
+		first character/item.  Example: >
+			:echo match("testing", "ing", 2)
+<		result is again "4". >
+			:echo match("testing", "ing", 4)
+<		result is again "4". >
+			:echo match("testing", "t", 2)
+<		result is "3".
+		For a String, if {start} > 0 then it is like the string starts
+		{start} bytes later, thus "^" will match at {start}.  Except
+		when {count} is given, then it's like matches before the
+		{start} byte are ignored (this is a bit complicated to keep it
+		backwards compatible).
+		For a String, if {start} < 0, it will be set to 0.  For a list
+		the index is counted from the end.
+		If {start} is out of range ({start} > strlen({expr}) for a
+		String or {start} > len({expr}) for a |List|) -1 is returned.
+
+		When {count} is given use the {count}'th match.  When a match
+		is found in a String the search for the next one starts one
+		character further.  Thus this example results in 1: >
+			echo match("testing", "..", 0, 2)
+<		In a |List| the search continues in the next item.
+		Note that when {count} is added the way {start} works changes,
+		see above.
+
+		See |pattern| for the patterns that are accepted.
+		The 'ignorecase' option is used to set the ignore-caseness of
+		the pattern.  'smartcase' is NOT used.  The matching is always
+		done like 'magic' is set and 'cpoptions' is empty.
+		Note that a match at the start is preferred, thus when the
+		pattern is using "*" (any number of matches) it tends to find
+		zero matches at the start instead of a number of matches
+		further down in the text.
+
+		Can also be used as a |method|: >
+			GetText()->match('word')
+			GetList()->match('word')
+<
+			*matchadd()* *E798* *E799* *E801* *E957*
+matchadd({group}, {pattern} [, {priority} [, {id} [, {dict}]]])
+		Defines a pattern to be highlighted in the current window (a
+		"match").  It will be highlighted with {group}.  Returns an
+		identification number (ID), which can be used to delete the
+		match using |matchdelete()|.  The ID is bound to the window.
+		Matching is case sensitive and magic, unless case sensitivity
+		or magicness are explicitly overridden in {pattern}.  The
+		'magic', 'smartcase' and 'ignorecase' options are not used.
+		The "Conceal" value is special, it causes the match to be
+		concealed.
+
+		The optional {priority} argument assigns a priority to the
+		match.  A match with a high priority will have its
+		highlighting overrule that of a match with a lower priority.
+		A priority is specified as an integer (negative numbers are no
+		exception).  If the {priority} argument is not specified, the
+		default priority is 10.  The priority of 'hlsearch' is zero,
+		hence all matches with a priority greater than zero will
+		overrule it.  Syntax highlighting (see 'syntax') is a separate
+		mechanism, and regardless of the chosen priority a match will
+		always overrule syntax highlighting.
+
+		The optional {id} argument allows the request for a specific
+		match ID.  If a specified ID is already taken, an error
+		message will appear and the match will not be added.  An ID
+		is specified as a positive integer (zero excluded).  IDs 1, 2
+		and 3 are reserved for |:match|, |:2match| and |:3match|,
+		respectively.  If the {id} argument is not specified or -1,
+		|matchadd()| automatically chooses a free ID.
+
+		The optional {dict} argument allows for further custom
+		values. Currently this is used to specify a match specific
+		conceal character that will be shown for |hl-Conceal|
+		highlighted matches. The dict can have the following members:
+
+			conceal	    Special character to show instead of the
+				    match (only for |hl-Conceal| highlighed
+				    matches, see |:syn-cchar|)
+			window	    Instead of the current window use the
+				    window with this number or window ID.
+
+		The number of matches is not limited, as it is the case with
+		the |:match| commands.
+
+		Returns -1 on error.
+
+		Example: >
+			:highlight MyGroup ctermbg=green guibg=green
+			:let m = matchadd("MyGroup", "TODO")
+<		Deletion of the pattern: >
+			:call matchdelete(m)
+
+<		A list of matches defined by |matchadd()| and |:match| are
+		available from |getmatches()|.  All matches can be deleted in
+		one operation by |clearmatches()|.
+
+		Can also be used as a |method|: >
+			GetGroup()->matchadd('TODO')
+<
+							*matchaddpos()*
+matchaddpos({group}, {pos} [, {priority} [, {id} [, {dict}]]])
+		Same as |matchadd()|, but requires a list of positions {pos}
+		instead of a pattern. This command is faster than |matchadd()|
+		because it does not require to handle regular expressions and
+		sets buffer line boundaries to redraw screen. It is supposed
+		to be used when fast match additions and deletions are
+		required, for example to highlight matching parentheses.
+							*E5030* *E5031*
+		{pos} is a list of positions.  Each position can be one of
+		these:
+		- A number.  This whole line will be highlighted.  The first
+		  line has number 1.
+		- A list with one number, e.g., [23]. The whole line with this
+		  number will be highlighted.
+		- A list with two numbers, e.g., [23, 11]. The first number is
+		  the line number, the second one is the column number (first
+		  column is 1, the value must correspond to the byte index as
+		  |col()| would return).  The character at this position will
+		  be highlighted.
+		- A list with three numbers, e.g., [23, 11, 3]. As above, but
+		  the third number gives the length of the highlight in bytes.
+
+		Entries with zero and negative line numbers are silently
+		ignored, as well as entries with negative column numbers and
+		lengths.
+
+		The maximum number of positions in {pos} is 8.
+
+		Returns -1 on error.
+
+		Example: >
+			:highlight MyGroup ctermbg=green guibg=green
+			:let m = matchaddpos("MyGroup", [[23, 24], 34])
+<		Deletion of the pattern: >
+			:call matchdelete(m)
+
+<		Matches added by |matchaddpos()| are returned by
+		|getmatches()|.
+
+		Can also be used as a |method|: >
+			GetGroup()->matchaddpos([23, 11])
+
+matcharg({nr})							*matcharg()*
+		Selects the {nr} match item, as set with a |:match|,
+		|:2match| or |:3match| command.
+		Return a |List| with two elements:
+			The name of the highlight group used
+			The pattern used.
+		When {nr} is not 1, 2 or 3 returns an empty |List|.
+		When there is no match item set returns ['', ''].
+		This is useful to save and restore a |:match|.
+		Highlighting matches using the |:match| commands are limited
+		to three matches. |matchadd()| does not have this limitation.
+
+		Can also be used as a |method|: >
+			GetMatch()->matcharg()
+
+matchdelete({id} [, {win}])		       *matchdelete()* *E802* *E803*
+		Deletes a match with ID {id} previously defined by |matchadd()|
+		or one of the |:match| commands.  Returns 0 if successful,
+		otherwise -1.  See example for |matchadd()|.  All matches can
+		be deleted in one operation by |clearmatches()|.
+		If {win} is specified, use the window with this number or
+		window ID instead of the current window.
+
+		Can also be used as a |method|: >
+			GetMatch()->matchdelete()
+
+matchend({expr}, {pat} [, {start} [, {count}]])			*matchend()*
+		Same as |match()|, but return the index of first character
+		after the match.  Example: >
+			:echo matchend("testing", "ing")
+<		results in "7".
+							*strspn()* *strcspn()*
+		Vim doesn't have a strspn() or strcspn() function, but you can
+		do it with matchend(): >
+			:let span = matchend(line, '[a-zA-Z]')
+			:let span = matchend(line, '[^a-zA-Z]')
+<		Except that -1 is returned when there are no matches.
+
+		The {start}, if given, has the same meaning as for |match()|. >
+			:echo matchend("testing", "ing", 2)
+<		results in "7". >
+			:echo matchend("testing", "ing", 5)
+<		result is "-1".
+		When {expr} is a |List| the result is equal to |match()|.
+
+		Can also be used as a |method|: >
+			GetText()->matchend('word')
+
+matchfuzzy({list}, {str} [, {dict}])			*matchfuzzy()*
+		If {list} is a list of strings, then returns a |List| with all
+		the strings in {list} that fuzzy match {str}. The strings in
+		the returned list are sorted based on the matching score.
+
+		The optional {dict} argument always supports the following
+		items:
+		    matchseq	When this item is present return only matches
+				that contain the characters in {str} in the
+				given sequence.
+		    limit	Maximum number of matches in {list} to be
+				returned.  Zero means no limit.
+
+		If {list} is a list of dictionaries, then the optional {dict}
+		argument supports the following additional items:
+		    key		Key of the item which is fuzzy matched against
+				{str}. The value of this item should be a
+				string.
+		    text_cb	|Funcref| that will be called for every item
+				in {list} to get the text for fuzzy matching.
+				This should accept a dictionary item as the
+				argument and return the text for that item to
+				use for fuzzy matching.
+
+		{str} is treated as a literal string and regular expression
+		matching is NOT supported.  The maximum supported {str} length
+		is 256.
+
+		When {str} has multiple words each separated by white space,
+		then the list of strings that have all the words is returned.
+
+		If there are no matching strings or there is an error, then an
+		empty list is returned. If length of {str} is greater than
+		256, then returns an empty list.
+
+		When {limit} is given, matchfuzzy() will find up to this
+		number of matches in {list} and return them in sorted order.
+
+		Refer to |fuzzy-matching| for more information about fuzzy
+		matching strings.
+
+		Example: >
+		   :echo matchfuzzy(["clay", "crow"], "cay")
+<		results in ["clay"]. >
+		   :echo getbufinfo()->map({_, v -> v.name})->matchfuzzy("ndl")
+<		results in a list of buffer names fuzzy matching "ndl". >
+		   :echo getbufinfo()->matchfuzzy("ndl", {'key' : 'name'})
+<		results in a list of buffer information dicts with buffer
+		names fuzzy matching "ndl". >
+		   :echo getbufinfo()->matchfuzzy("spl",
+						\ {'text_cb' : {v -> v.name}})
+<		results in a list of buffer information dicts with buffer
+		names fuzzy matching "spl". >
+		   :echo v:oldfiles->matchfuzzy("test")
+<		results in a list of file names fuzzy matching "test". >
+		   :let l = readfile("buffer.c")->matchfuzzy("str")
+<		results in a list of lines in "buffer.c" fuzzy matching "str". >
+		   :echo ['one two', 'two one']->matchfuzzy('two one')
+<		results in ['two one', 'one two']. >
+		   :echo ['one two', 'two one']->matchfuzzy('two one',
+						\ {'matchseq': 1})
+<		results in ['two one'].
+
+matchfuzzypos({list}, {str} [, {dict}])			*matchfuzzypos()*
+		Same as |matchfuzzy()|, but returns the list of matched
+		strings, the list of character positions where characters
+		in {str} matches and a list of matching scores.  You can
+		use |byteidx()| to convert a character position to a byte
+		position.
+
+		If {str} matches multiple times in a string, then only the
+		positions for the best match is returned.
+
+		If there are no matching strings or there is an error, then a
+		list with three empty list items is returned.
+
+		Example: >
+			:echo matchfuzzypos(['testing'], 'tsg')
+<		results in [['testing'], [[0, 2, 6]], [99]] >
+			:echo matchfuzzypos(['clay', 'lacy'], 'la')
+<		results in [['lacy', 'clay'], [[0, 1], [1, 2]], [153, 133]] >
+			:echo [{'text': 'hello', 'id' : 10}]
+				\ ->matchfuzzypos('ll', {'key' : 'text'})
+<		results in [[{'id': 10, 'text': 'hello'}], [[2, 3]], [127]]
+
+matchlist({expr}, {pat} [, {start} [, {count}]])		*matchlist()*
+		Same as |match()|, but return a |List|.  The first item in the
+		list is the matched string, same as what matchstr() would
+		return.  Following items are submatches, like "\1", "\2", etc.
+		in |:substitute|.  When an optional submatch didn't match an
+		empty string is used.  Example: >
+			echo matchlist('acd', '\(a\)\?\(b\)\?\(c\)\?\(.*\)')
+<		Results in: ['acd', 'a', '', 'c', 'd', '', '', '', '', '']
+		When there is no match an empty list is returned.
+
+		You can pass in a List, but that is not very useful.
+
+		Can also be used as a |method|: >
+			GetText()->matchlist('word')
+
+matchstr({expr}, {pat} [, {start} [, {count}]])			*matchstr()*
+		Same as |match()|, but return the matched string.  Example: >
+			:echo matchstr("testing", "ing")
+<		results in "ing".
+		When there is no match "" is returned.
+		The {start}, if given, has the same meaning as for |match()|. >
+			:echo matchstr("testing", "ing", 2)
+<		results in "ing". >
+			:echo matchstr("testing", "ing", 5)
+<		result is "".
+		When {expr} is a |List| then the matching item is returned.
+		The type isn't changed, it's not necessarily a String.
+
+		Can also be used as a |method|: >
+			GetText()->matchstr('word')
+
+matchstrpos({expr}, {pat} [, {start} [, {count}]])		*matchstrpos()*
+		Same as |matchstr()|, but return the matched string, the start
+		position and the end position of the match.  Example: >
+			:echo matchstrpos("testing", "ing")
+<		results in ["ing", 4, 7].
+		When there is no match ["", -1, -1] is returned.
+		The {start}, if given, has the same meaning as for |match()|. >
+			:echo matchstrpos("testing", "ing", 2)
+<		results in ["ing", 4, 7]. >
+			:echo matchstrpos("testing", "ing", 5)
+<		result is ["", -1, -1].
+		When {expr} is a |List| then the matching item, the index
+		of first item where {pat} matches, the start position and the
+		end position of the match are returned. >
+			:echo matchstrpos([1, '__x'], '\a')
+<		result is ["x", 1, 2, 3].
+		The type isn't changed, it's not necessarily a String.
+
+		Can also be used as a |method|: >
+			GetText()->matchstrpos('word')
+<
+							*max()*
+max({expr})	Return the maximum value of all items in {expr}. Example: >
+			echo max([apples, pears, oranges])
+
+<		{expr} can be a |List| or a |Dictionary|.  For a Dictionary,
+		it returns the maximum of all values in the Dictionary.
+		If {expr} is neither a List nor a Dictionary, or one of the
+		items in {expr} cannot be used as a Number this results in
+                an error.  An empty |List| or |Dictionary| results in zero.
+
+		Can also be used as a |method|: >
+			mylist->max()
+
+menu_get({path} [, {modes}])				*menu_get()*
+		Returns a |List| of |Dictionaries| describing |menus| (defined
+		by |:menu|, |:amenu|, …), including |hidden-menus|.
+
+		{path} matches a menu by name, or all menus if {path} is an
+		empty string.  Example: >
+			:echo menu_get('File','')
+			:echo menu_get('')
+<
+		{modes} is a string of zero or more modes (see |maparg()| or
+		|creating-menus| for the list of modes). "a" means "all".
+
+		Example: >
+			nnoremenu &Test.Test inormal
+			inoremenu Test.Test insert
+			vnoremenu Test.Test x
+			echo menu_get("")
+
+<		returns something like this: >
+
+			[ {
+			  "hidden": 0,
+			  "name": "Test",
+			  "priority": 500,
+			  "shortcut": 84,
+			  "submenus": [ {
+			    "hidden": 0,
+			    "mappings": {
+			      i": {
+				"enabled": 1,
+				"noremap": 1,
+				"rhs": "insert",
+				"sid": 1,
+				"silent": 0
+			      },
+			      n": { ... },
+			      s": { ... },
+			      v": { ... }
+			    },
+			    "name": "Test",
+			    "priority": 500,
+			    "shortcut": 0
+			  } ]
+			} ]
+<
+
+							*min()*
+min({expr})	Return the minimum value of all items in {expr}. Example:  >
+			echo min([apples, pears, oranges])
+
+<		{expr} can be a |List| or a |Dictionary|.  For a Dictionary,
+		it returns the minimum of all values in the Dictionary.
+		If {expr} is neither a List nor a Dictionary, or one of the
+		items in {expr} cannot be used as a Number this results in
+		an error.  An empty |List| or |Dictionary| results in zero.
+
+		Can also be used as a |method|: >
+			mylist->min()
+
+<							*mkdir()* *E739*
+mkdir({name} [, {path} [, {prot}]])
+		Create directory {name}.
+
+		If {path} is "p" then intermediate directories are created as
+		necessary.  Otherwise it must be "".
+
+		If {prot} is given it is used to set the protection bits of
+		the new directory.  The default is 0o755 (rwxr-xr-x: r/w for
+		the user, readable for others).  Use 0o700 to make it
+		unreadable for others.
+
+		{prot} is applied for all parts of {name}.  Thus if you create
+		/tmp/foo/bar then /tmp/foo will be created with 0o700. Example: >
+			:call mkdir($HOME .. "/tmp/foo/bar", "p", 0o700)
+
+<		This function is not available in the |sandbox|.
+
+		If you try to create an existing directory with {path} set to
+		"p" mkdir() will silently exit.
+
+		The function result is a Number, which is TRUE if the call was
+		successful or FALSE if the directory creation failed or partly
+		failed.
+
+		Can also be used as a |method|: >
+			GetName()->mkdir()
+<
+							*mode()*
+mode([expr])	Return a string that indicates the current mode.
+		If [expr] is supplied and it evaluates to a non-zero Number or
+		a non-empty String (|non-zero-arg|), then the full mode is
+		returned, otherwise only the first letter is returned.
+
+		   n	    Normal
+		   no	    Operator-pending
+		   nov	    Operator-pending (forced charwise |o_v|)
+		   noV	    Operator-pending (forced linewise |o_V|)
+		   noCTRL-V Operator-pending (forced blockwise |o_CTRL-V|)
+				CTRL-V is one character
+		   niI	    Normal using |i_CTRL-O| in |Insert-mode|
+		   niR	    Normal using |i_CTRL-O| in |Replace-mode|
+		   niV	    Normal using |i_CTRL-O| in |Virtual-Replace-mode|
+		   nt	    Normal in |terminal-emulator| (insert goes to
+				Terminal mode)
+		   v	    Visual by character
+		   vs	    Visual by character using |v_CTRL-O| in Select mode
+		   V	    Visual by line
+		   Vs	    Visual by line using |v_CTRL-O| in Select mode
+		   CTRL-V   Visual blockwise
+		   CTRL-Vs  Visual blockwise using |v_CTRL-O| in Select mode
+		   s	    Select by character
+		   S	    Select by line
+		   CTRL-S   Select blockwise
+		   i	    Insert
+		   ic	    Insert mode completion |compl-generic|
+		   ix	    Insert mode |i_CTRL-X| completion
+		   R	    Replace |R|
+		   Rc	    Replace mode completion |compl-generic|
+		   Rx	    Replace mode |i_CTRL-X| completion
+		   Rv	    Virtual Replace |gR|
+		   Rvc	    Virtual Replace mode completion |compl-generic|
+		   Rvx	    Virtual Replace mode |i_CTRL-X| completion
+		   c	    Command-line editing
+		   cv	    Vim Ex mode |gQ|
+		   r	    Hit-enter prompt
+		   rm	    The -- more -- prompt
+		   r?	    A |:confirm| query of some sort
+		   !	    Shell or external command is executing
+		   t	    Terminal mode: keys go to the job
+
+		This is useful in the 'statusline' option or RPC calls. In
+		most other places it always returns "c" or "n".
+		Note that in the future more modes and more specific modes may
+		be added. It's better not to compare the whole string but only
+		the leading character(s).
+		Also see |visualmode()|.
+
+		Can also be used as a |method|: >
+			DoFull()->mode()
+
+msgpackdump({list} [, {type}])				*msgpackdump()*
+		Convert a list of VimL objects to msgpack. Returned value is a
+		|readfile()|-style list. When {type} contains "B", a |Blob| is
+		returned instead. Example: >
+			call writefile(msgpackdump([{}]), 'fname.mpack', 'b')
+<		or, using a |Blob|: >
+			call writefile(msgpackdump([{}], 'B'), 'fname.mpack')
+<
+		This will write the single 0x80 byte to a `fname.mpack` file
+		(dictionary with zero items is represented by 0x80 byte in
+		messagepack).
+
+		Limitations:				*E5004* *E5005*
+		1. |Funcref|s cannot be dumped.
+		2. Containers that reference themselves cannot be dumped.
+		3. Dictionary keys are always dumped as STR strings.
+		4. Other strings and |Blob|s are always dumped as BIN strings.
+		5. Points 3. and 4. do not apply to |msgpack-special-dict|s.
+
+msgpackparse({data})					*msgpackparse()*
+		Convert a |readfile()|-style list or a |Blob| to a list of
+		VimL objects.
+		Example: >
+			let fname = expand('~/.config/nvim/shada/main.shada')
+			let mpack = readfile(fname, 'b')
+			let shada_objects = msgpackparse(mpack)
+<		This will read ~/.config/nvim/shada/main.shada file to
+		`shada_objects` list.
+
+		Limitations:
+		1. Mapping ordering is not preserved unless messagepack
+		   mapping is dumped using generic mapping
+		   (|msgpack-special-map|).
+		2. Since the parser aims to preserve all data untouched
+		   (except for 1.) some strings are parsed to
+		   |msgpack-special-dict| format which is not convenient to
+		   use.
+							*msgpack-special-dict*
+		Some messagepack strings may be parsed to special
+		dictionaries. Special dictionaries are dictionaries which
+
+		1. Contain exactly two keys: `_TYPE` and `_VAL`.
+		2. `_TYPE` key is one of the types found in |v:msgpack_types|
+		   variable.
+		3. Value for `_VAL` has the following format (Key column
+		   contains name of the key from |v:msgpack_types|):
+
+		Key	Value ~
+		nil	Zero, ignored when dumping.  Not returned by
+			|msgpackparse()| since |v:null| was introduced.
+		boolean	One or zero.  When dumping it is only checked that
+			value is a |Number|.  Not returned by |msgpackparse()|
+			since |v:true| and |v:false| were introduced.
+		integer	|List| with four numbers: sign (-1 or 1), highest two
+			bits, number with bits from 62nd to 31st, lowest 31
+			bits. I.e. to get actual number one will need to use
+			code like >
+				_VAL[0] * ((_VAL[1] << 62)
+				           & (_VAL[2] << 31)
+				           & _VAL[3])
+<			Special dictionary with this type will appear in
+			|msgpackparse()| output under one of the following
+			circumstances:
+			1. |Number| is 32-bit and value is either above
+			   INT32_MAX or below INT32_MIN.
+			2. |Number| is 64-bit and value is above INT64_MAX. It
+			   cannot possibly be below INT64_MIN because msgpack
+			   C parser does not support such values.
+		float	|Float|. This value cannot possibly appear in
+			|msgpackparse()| output.
+		string	|readfile()|-style list of strings. This value will
+			appear in |msgpackparse()| output if string contains
+			zero byte or if string is a mapping key and mapping is
+			being represented as special dictionary for other
+			reasons.
+		binary	|String|, or |Blob| if binary string contains zero
+			byte. This value cannot appear in |msgpackparse()|
+			output since blobs were introduced.
+		array	|List|. This value cannot appear in |msgpackparse()|
+			output.
+							*msgpack-special-map*
+		map	|List| of |List|s with two items (key and value) each.
+			This value will appear in |msgpackparse()| output if
+			parsed mapping contains one of the following keys:
+			1. Any key that is not a string (including keys which
+			   are binary strings).
+			2. String with NUL byte inside.
+			3. Duplicate key.
+			4. Empty key.
+		ext	|List| with two values: first is a signed integer
+			representing extension type. Second is
+			|readfile()|-style list of strings.
+
+nextnonblank({lnum})					*nextnonblank()*
+		Return the line number of the first line at or below {lnum}
+		that is not blank.  Example: >
+			if getline(nextnonblank(1)) =~ "Java"
+<		When {lnum} is invalid or there is no non-blank line at or
+		below it, zero is returned.
+		{lnum} is used like with |getline()|.
+		See also |prevnonblank()|.
+
+		Can also be used as a |method|: >
+			GetLnum()->nextnonblank()
+
+nr2char({expr} [, {utf8}])				*nr2char()*
+		Return a string with a single character, which has the number
+		value {expr}.  Examples: >
+			nr2char(64)		returns "@"
+			nr2char(32)		returns " "
+<		Example for "utf-8": >
+			nr2char(300)		returns I with bow character
+<		UTF-8 encoding is always used, {utf8} option has no effect,
+		and exists only for backwards-compatibility.
+		Note that a NUL character in the file is specified with
+		nr2char(10), because NULs are represented with newline
+		characters.  nr2char(0) is a real NUL and terminates the
+		string, thus results in an empty string.
+
+		Can also be used as a |method|: >
+			GetNumber()->nr2char()
+
+nvim_...({...})					*E5555* *nvim_...()* *eval-api*
+		Call nvim |api| functions. The type checking of arguments will
+		be stricter than for most other builtins. For instance,
+		if Integer is expected, a |Number| must be passed in, a
+		|String| will not be autoconverted.
+		Buffer numbers, as returned by |bufnr()| could be used as
+		first argument to nvim_buf_... functions.  All functions
+		expecting an object (buffer, window or tabpage) can
+		also take the numerical value 0 to indicate the current
+		(focused) object.
+
+or({expr}, {expr})					*or()*
+		Bitwise OR on the two arguments.  The arguments are converted
+		to a number.  A List, Dict or Float argument causes an error.
+		Example: >
+			:let bits = or(bits, 0x80)
+<		Can also be used as a |method|: >
+			:let bits = bits->or(0x80)
+
+pathshorten({expr} [, {len}])				*pathshorten()*
+		Shorten directory names in the path {path} and return the
+		result.  The tail, the file name, is kept as-is.  The other
+		components in the path are reduced to {len} letters in length.
+		If {len} is omitted or smaller than 1 then 1 is used (single
+		letters).  Leading '~' and '.' characters are kept.  Examples: >
+			:echo pathshorten('~/.config/nvim/autoload/file1.vim')
+<			~/.c/n/a/file1.vim ~
+>
+			:echo pathshorten('~/.config/nvim/autoload/file2.vim', 2)
+<			~/.co/nv/au/file2.vim ~
+		It doesn't matter if the path exists or not.
+		Returns an empty string on error.
+
+		Can also be used as a |method|: >
+			GetDirectories()->pathshorten()
+
+perleval({expr})					*perleval()*
+		Evaluate |perl| expression {expr} and return its result
+		converted to Vim data structures.
+		Numbers and strings are returned as they are (strings are
+		copied though).
+		Lists are represented as Vim |List| type.
+		Dictionaries are represented as Vim |Dictionary| type,
+		non-string keys result in error.
+
+		Note: If you want an array or hash, {expr} must return a
+		reference to it.
+		Example: >
+			:echo perleval('[1 .. 4]')
+<			[1, 2, 3, 4]
+
+		Can also be used as a |method|: >
+			GetExpr()->perleval()
+
+pow({x}, {y})						*pow()*
+		Return the power of {x} to the exponent {y} as a |Float|.
+		{x} and {y} must evaluate to a |Float| or a |Number|.
+		Returns 0.0 if {x} or {y} is not a |Float| or a |Number|.
+		Examples: >
+			:echo pow(3, 3)
+<			27.0 >
+			:echo pow(2, 16)
+<			65536.0 >
+			:echo pow(32, 0.20)
+<			2.0
+
+		Can also be used as a |method|: >
+			Compute()->pow(3)
+
+prevnonblank({lnum})					*prevnonblank()*
+		Return the line number of the first line at or above {lnum}
+		that is not blank.  Example: >
+			let ind = indent(prevnonblank(v:lnum - 1))
+<		When {lnum} is invalid or there is no non-blank line at or
+		above it, zero is returned.
+		{lnum} is used like with |getline()|.
+		Also see |nextnonblank()|.
+
+		Can also be used as a |method|: >
+			GetLnum()->prevnonblank()
+
+printf({fmt}, {expr1} ...)				*printf()*
+		Return a String with {fmt}, where "%" items are replaced by
+		the formatted form of their respective arguments.  Example: >
+			printf("%4d: E%d %.30s", lnum, errno, msg)
+<		May result in:
+			"  99: E42 asdfasdfasdfasdfasdfasdfasdfas" ~
+
+		When used as a |method| the base is passed as the second
+		argument: >
+			Compute()->printf("result: %d")
+<
+		You can use `call()` to pass the items as a list.
+
+		Often used items are:
+		  %s	string
+		  %6S	string right-aligned in 6 display cells
+		  %6s	string right-aligned in 6 bytes
+		  %.9s	string truncated to 9 bytes
+		  %c	single byte
+		  %d	decimal number
+		  %5d	decimal number padded with spaces to 5 characters
+		  %b	binary number
+		  %08b	binary number padded with zeros to at least 8 characters
+		  %B	binary number using upper case letters
+		  %x	hex number
+		  %04x	hex number padded with zeros to at least 4 characters
+		  %X	hex number using upper case letters
+		  %o	octal number
+		  %f	floating point number as 12.23, inf, -inf or nan
+		  %F	floating point number as 12.23, INF, -INF or NAN
+		  %e	floating point number as 1.23e3, inf, -inf or nan
+		  %E	floating point number as 1.23E3, INF, -INF or NAN
+		  %g	floating point number, as %f or %e depending on value
+		  %G	floating point number, as %F or %E depending on value
+		  %%	the % character itself
+		  %p	representation of the pointer to the container
+
+		Conversion specifications start with '%' and end with the
+		conversion type.  All other characters are copied unchanged to
+		the result.
+
+		The "%" starts a conversion specification.  The following
+		arguments appear in sequence:
+
+			%  [flags]  [field-width]  [.precision]  type
+
+		flags
+			Zero or more of the following flags:
+
+		    #	      The value should be converted to an "alternate
+			      form".  For c, d, and s conversions, this option
+			      has no effect.  For o conversions, the precision
+			      of the number is increased to force the first
+			      character of the output string to a zero (except
+			      if a zero value is printed with an explicit
+			      precision of zero).
+			      For x and X conversions, a non-zero result has
+			      the string "0x" (or "0X" for X conversions)
+			      prepended to it.
+
+		    0 (zero)  Zero padding.  For all conversions the converted
+			      value is padded on the left with zeros rather
+			      than blanks.  If a precision is given with a
+			      numeric conversion (d, o, x, and X), the 0 flag
+			      is ignored.
+
+		    -	      A negative field width flag; the converted value
+			      is to be left adjusted on the field boundary.
+			      The converted value is padded on the right with
+			      blanks, rather than on the left with blanks or
+			      zeros.  A - overrides a 0 if both are given.
+
+		    ' ' (space)  A blank should be left before a positive
+			      number produced by a signed conversion (d).
+
+		    +	      A sign must always be placed before a number
+			      produced by a signed conversion.  A + overrides
+			      a space if both are used.
+
+		field-width
+			An optional decimal digit string specifying a minimum
+			field width.  If the converted value has fewer bytes
+			than the field width, it will be padded with spaces on
+			the left (or right, if the left-adjustment flag has
+			been given) to fill out the field width.  For the S
+			conversion the count is in cells.
+
+		.precision
+			An optional precision, in the form of a period '.'
+			followed by an optional digit string.  If the digit
+			string is omitted, the precision is taken as zero.
+			This gives the minimum number of digits to appear for
+			d, o, x, and X conversions, the maximum number of
+			bytes to be printed from a string for s conversions,
+			or the maximum number of cells to be printed from a
+			string for S conversions.
+			For floating point it is the number of digits after
+			the decimal point.
+
+		type
+			A character that specifies the type of conversion to
+			be applied, see below.
+
+		A field width or precision, or both, may be indicated by an
+		asterisk '*' instead of a digit string.  In this case, a
+		Number argument supplies the field width or precision.  A
+		negative field width is treated as a left adjustment flag
+		followed by a positive field width; a negative precision is
+		treated as though it were missing.  Example: >
+			:echo printf("%d: %.*s", nr, width, line)
+<		This limits the length of the text used from "line" to
+		"width" bytes.
+
+		The conversion specifiers and their meanings are:
+
+				*printf-d* *printf-b* *printf-B* *printf-o* *printf-x* *printf-X*
+		dbBoxX	The Number argument is converted to signed decimal (d),
+			unsigned binary (b and B), unsigned octal (o), or
+			unsigned hexadecimal (x and X) notation.  The letters
+			"abcdef" are used for x conversions; the letters
+			"ABCDEF" are used for X conversions.  The precision, if
+			any, gives the minimum number of digits that must
+			appear; if the converted value requires fewer digits, it
+			is padded on the left with zeros.  In no case does a
+			non-existent or small field width cause truncation of a
+			numeric field; if the result of a conversion is wider
+			than the field width, the field is expanded to contain
+			the conversion result.
+			The 'h' modifier indicates the argument is 16 bits.
+			The 'l' modifier indicates the argument is 32 bits.
+			The 'L' modifier indicates the argument is 64 bits.
+			Generally, these modifiers are not useful. They are
+			ignored when type is known from the argument.
+
+		i	alias for d
+		D	alias for ld
+		U	alias for lu
+		O	alias for lo
+
+							*printf-c*
+		c	The Number argument is converted to a byte, and the
+			resulting character is written.
+
+							*printf-s*
+		s	The text of the String argument is used.  If a
+			precision is specified, no more bytes than the number
+			specified are used.
+			If the argument is not a String type, it is
+			automatically converted to text with the same format
+			as ":echo".
+							*printf-S*
+		S	The text of the String argument is used.  If a
+			precision is specified, no more display cells than the
+			number specified are used.
+
+							*printf-f* *E807*
+		f F	The Float argument is converted into a string of the
+			form 123.456.  The precision specifies the number of
+			digits after the decimal point.  When the precision is
+			zero the decimal point is omitted.  When the precision
+			is not specified 6 is used.  A really big number
+			(out of range or dividing by zero) results in "inf"
+			 or "-inf" with %f (INF or -INF with %F).
+			 "0.0 / 0.0" results in "nan" with %f (NAN with %F).
+			Example: >
+				echo printf("%.2f", 12.115)
+<				12.12
+			Note that roundoff depends on the system libraries.
+			Use |round()| when in doubt.
+
+							*printf-e* *printf-E*
+		e E	The Float argument is converted into a string of the
+			form 1.234e+03 or 1.234E+03 when using 'E'.  The
+			precision specifies the number of digits after the
+			decimal point, like with 'f'.
+
+							*printf-g* *printf-G*
+		g G	The Float argument is converted like with 'f' if the
+			value is between 0.001 (inclusive) and 10000000.0
+			(exclusive).  Otherwise 'e' is used for 'g' and 'E'
+			for 'G'.  When no precision is specified superfluous
+			zeroes and '+' signs are removed, except for the zero
+			immediately after the decimal point.  Thus 10000000.0
+			results in 1.0e7.
+
+							*printf-%*
+		%	A '%' is written.  No argument is converted.  The
+			complete conversion specification is "%%".
+
+		When a Number argument is expected a String argument is also
+		accepted and automatically converted.
+		When a Float or String argument is expected a Number argument
+		is also accepted and automatically converted.
+		Any other argument type results in an error message.
+
+							*E766* *E767*
+		The number of {exprN} arguments must exactly match the number
+		of "%" items.  If there are not sufficient or too many
+		arguments an error is given.  Up to 18 arguments can be used.
+
+prompt_getprompt({buf})					*prompt_getprompt()*
+		Returns the effective prompt text for buffer {buf}.  {buf} can
+		be a buffer name or number.  See |prompt-buffer|.
+
+		If the buffer doesn't exist or isn't a prompt buffer, an empty
+		string is returned.
+
+		Can also be used as a |method|: >
+			GetBuffer()->prompt_getprompt()
+
+prompt_setcallback({buf}, {expr})			*prompt_setcallback()*
+		Set prompt callback for buffer {buf} to {expr}.  When {expr}
+		is an empty string the callback is removed.  This has only
+		effect if {buf} has 'buftype' set to "prompt".
+
+		The callback is invoked when pressing Enter.  The current
+		buffer will always be the prompt buffer.  A new line for a
+		prompt is added before invoking the callback, thus the prompt
+		for which the callback was invoked will be in the last but one
+		line.
+		If the callback wants to add text to the buffer, it must
+		insert it above the last line, since that is where the current
+		prompt is.  This can also be done asynchronously.
+		The callback is invoked with one argument, which is the text
+		that was entered at the prompt.  This can be an empty string
+		if the user only typed Enter.
+		Example: >
+		   call prompt_setcallback(bufnr(''), function('s:TextEntered'))
+		   func s:TextEntered(text)
+		     if a:text == 'exit' || a:text == 'quit'
+		       stopinsert
+		       close
+		     else
+		       call append(line('$') - 1, 'Entered: "' .. a:text .. '"')
+		       " Reset 'modified' to allow the buffer to be closed.
+		       set nomodified
+		     endif
+		   endfunc
+
+<		Can also be used as a |method|: >
+			GetBuffer()->prompt_setcallback(callback)
+
+prompt_setinterrupt({buf}, {expr})			*prompt_setinterrupt()*
+		Set a callback for buffer {buf} to {expr}.  When {expr} is an
+		empty string the callback is removed.  This has only effect if
+		{buf} has 'buftype' set to "prompt".
+
+		This callback will be invoked when pressing CTRL-C in Insert
+		mode.  Without setting a callback Vim will exit Insert mode,
+		as in any buffer.
+
+		Can also be used as a |method|: >
+			GetBuffer()->prompt_setinterrupt(callback)
+
+prompt_setprompt({buf}, {text})				*prompt_setprompt()*
+		Set prompt for buffer {buf} to {text}.  You most likely want
+		{text} to end in a space.
+		The result is only visible if {buf} has 'buftype' set to
+		"prompt".  Example: >
+			call prompt_setprompt(bufnr(''), 'command: ')
+<
+		Can also be used as a |method|: >
+			GetBuffer()->prompt_setprompt('command: ')
+
+pum_getpos()						*pum_getpos()*
+		If the popup menu (see |ins-completion-menu|) is not visible,
+		returns an empty |Dictionary|, otherwise, returns a
+		|Dictionary| with the following keys:
+			height		nr of items visible
+			width		screen cells
+			row		top screen row (0 first row)
+			col		leftmost screen column (0 first col)
+			size		total nr of items
+			scrollbar	|TRUE| if scrollbar is visible
+
+  		The values are the same as in |v:event| during |CompleteChanged|.
+
+pumvisible()						*pumvisible()*
+		Returns non-zero when the popup menu is visible, zero
+		otherwise.  See |ins-completion-menu|.
+		This can be used to avoid some things that would remove the
+		popup menu.
+
+py3eval({expr})						*py3eval()*
+		Evaluate Python expression {expr} and return its result
+		converted to Vim data structures.
+		Numbers and strings are returned as they are (strings are
+		copied though, Unicode strings are additionally converted to
+		UTF-8).
+		Lists are represented as Vim |List| type.
+		Dictionaries are represented as Vim |Dictionary| type with
+		keys converted to strings.
+
+		Can also be used as a |method|: >
+			GetExpr()->py3eval()
+<
+							*E858* *E859*
+pyeval({expr})						*pyeval()*
+		Evaluate Python expression {expr} and return its result
+		converted to Vim data structures.
+		Numbers and strings are returned as they are (strings are
+		copied though).
+		Lists are represented as Vim |List| type.
+		Dictionaries are represented as Vim |Dictionary| type,
+		non-string keys result in error.
+
+		Can also be used as a |method|: >
+			GetExpr()->pyeval()
+
+pyxeval({expr})						*pyxeval()*
+		Evaluate Python expression {expr} and return its result
+		converted to Vim data structures.
+		Uses Python 2 or 3, see |python_x| and 'pyxversion'.
+		See also: |pyeval()|, |py3eval()|
+
+		Can also be used as a |method|: >
+			GetExpr()->pyxeval()
+<
+							*E726* *E727*
+range({expr} [, {max} [, {stride}]])				*range()*
+		Returns a |List| with Numbers:
+		- If only {expr} is specified: [0, 1, ..., {expr} - 1]
+		- If {max} is specified: [{expr}, {expr} + 1, ..., {max}]
+		- If {stride} is specified: [{expr}, {expr} + {stride}, ...,
+		  {max}] (increasing {expr} with {stride} each time, not
+		  producing a value past {max}).
+		When the maximum is one before the start the result is an
+		empty list.  When the maximum is more than one before the
+		start this is an error.
+		Examples: >
+			range(4)		" [0, 1, 2, 3]
+			range(2, 4)		" [2, 3, 4]
+			range(2, 9, 3)		" [2, 5, 8]
+			range(2, -2, -1)	" [2, 1, 0, -1, -2]
+			range(0)		" []
+			range(2, 0)		" error!
+<
+		Can also be used as a |method|: >
+			GetExpr()->range()
+<
+rand([{expr}])						*rand()*
+		Return a pseudo-random Number generated with an xoshiro128**
+		algorithm using seed {expr}.  The returned number is 32 bits,
+		also on 64 bits systems, for consistency.
+		{expr} can be initialized by |srand()| and will be updated by
+		rand().  If {expr} is omitted, an internal seed value is used
+		and updated.
+		Returns -1 if {expr} is invalid.
+
+		Examples: >
+			:echo rand()
+			:let seed = srand()
+			:echo rand(seed)
+			:echo rand(seed) % 16  " random number 0 - 15
+<
+		Can also be used as a |method|: >
+			seed->rand()
+<
+							*readdir()*
+readdir({directory} [, {expr}])
+		Return a list with file and directory names in {directory}.
+
+		When {expr} is omitted all entries are included.
+		When {expr} is given, it is evaluated to check what to do:
+			If {expr} results in -1 then no further entries will
+			be handled.
+			If {expr} results in 0 then this entry will not be
+			added to the list.
+			If {expr} results in 1 then this entry will be added
+			to the list.
+		Each time {expr} is evaluated |v:val| is set to the entry name.
+		When {expr} is a function the name is passed as the argument.
+		For example, to get a list of files ending in ".txt": >
+		  readdir(dirname, {n -> n =~ '.txt$'})
+<		To skip hidden and backup files: >
+		  readdir(dirname, {n -> n !~ '^\.\|\~$'})
+
+<		If you want to get a directory tree: >
+                  function! s:tree(dir)
+                      return {a:dir : map(readdir(a:dir),
+		      \ {_, x -> isdirectory(x) ?
+		      \          {x : s:tree(a:dir .. '/' .. x)} : x})}
+                  endfunction
+                  echo s:tree(".")
+<
+		Returns an empty List on error.
+
+		Can also be used as a |method|: >
+			GetDirName()->readdir()
+<
+							*readfile()*
+readfile({fname} [, {type} [, {max}]])
+		Read file {fname} and return a |List|, each line of the file
+		as an item.  Lines are broken at NL characters.  Macintosh
+		files separated with CR will result in a single long line
+		(unless a NL appears somewhere).
+		All NUL characters are replaced with a NL character.
+		When {type} contains "b" binary mode is used:
+		- When the last line ends in a NL an extra empty list item is
+		  added.
+		- No CR characters are removed.
+		When {type} contains "B" a |Blob| is returned with the binary
+		data of the file unmodified.
+		Otherwise:
+		- CR characters that appear before a NL are removed.
+		- Whether the last line ends in a NL or not does not matter.
+		- Any UTF-8 byte order mark is removed from the text.
+		When {max} is given this specifies the maximum number of lines
+		to be read.  Useful if you only want to check the first ten
+		lines of a file: >
+			:for line in readfile(fname, '', 10)
+			:  if line =~ 'Date' | echo line | endif
+			:endfor
+<		When {max} is negative -{max} lines from the end of the file
+		are returned, or as many as there are.
+		When {max} is zero the result is an empty list.
+		Note that without {max} the whole file is read into memory.
+		Also note that there is no recognition of encoding.  Read a
+		file into a buffer if you need to.
+		When the file can't be opened an error message is given and
+		the result is an empty list.
+		Also see |writefile()|.
+
+		Can also be used as a |method|: >
+			GetFileName()->readfile()
+
+reduce({object}, {func} [, {initial}])			*reduce()* *E998*
+		{func} is called for every item in {object}, which can be a
+		|List| or a |Blob|.  {func} is called with two arguments: the
+		result so far and current item.  After processing all items
+		the result is returned.
+
+		{initial} is the initial result.  When omitted, the first item
+		in {object} is used and {func} is first called for the second
+		item.  If {initial} is not given and {object} is empty no
+		result can be computed, an E998 error is given.
+
+		Examples: >
+			echo reduce([1, 3, 5], { acc, val -> acc + val })
+			echo reduce(['x', 'y'], { acc, val -> acc .. val }, 'a')
+			echo reduce(0z1122, { acc, val -> 2 * acc + val })
+<
+		Can also be used as a |method|: >
+			echo mylist->reduce({ acc, val -> acc + val }, 0)
+
+reg_executing()						*reg_executing()*
+		Returns the single letter name of the register being executed.
+		Returns an empty string when no register is being executed.
+		See |@|.
+
+reg_recorded()						*reg_recorded()*
+		Returns the single letter name of the last recorded register.
+		Returns an empty string when nothing was recorded yet.
+		See |q| and |Q|.
+
+reg_recording()						*reg_recording()*
+		Returns the single letter name of the register being recorded.
+		Returns an empty string when not recording.  See |q|.
+
+reltime([{start} [, {end}]])				*reltime()*
+		Return an item that represents a time value.  The item is a
+		list with items that depend on the system.
+		The item can be passed to |reltimestr()| to convert it to a
+		string or |reltimefloat()| to convert to a Float.
+
+		Without an argument it returns the current "relative time", an
+		implementation-defined value meaningful only when used as an
+		argument to |reltime()|, |reltimestr()| and |reltimefloat()|.
+
+		With one argument it returns the time passed since the time
+		specified in the argument.
+		With two arguments it returns the time passed between {start}
+		and {end}.
+
+		The {start} and {end} arguments must be values returned by
+		reltime().  Returns zero on error.
+
+		Can also be used as a |method|: >
+			GetStart()->reltime()
+<
+		Note: |localtime()| returns the current (non-relative) time.
+
+reltimefloat({time})				*reltimefloat()*
+		Return a Float that represents the time value of {time}.
+		Unit of time is seconds.
+		Example:
+			let start = reltime()
+			call MyFunction()
+			let seconds = reltimefloat(reltime(start))
+		See the note of reltimestr() about overhead.
+		Also see |profiling|.
+		If there is an error an empty string is returned
+
+		Can also be used as a |method|: >
+			reltime(start)->reltimefloat()
+
+reltimestr({time})				*reltimestr()*
+		Return a String that represents the time value of {time}.
+		This is the number of seconds, a dot and the number of
+		microseconds.  Example: >
+			let start = reltime()
+			call MyFunction()
+			echo reltimestr(reltime(start))
+<		Note that overhead for the commands will be added to the time.
+		Leading spaces are used to make the string align nicely.  You
+		can use split() to remove it. >
+			echo split(reltimestr(reltime(start)))[0]
+<		Also see |profiling|.
+		If there is an error an empty string is returned
+
+		Can also be used as a |method|: >
+			reltime(start)->reltimestr()
+<
+remove({list}, {idx} [, {end}])				*remove()*
+		Without {end}: Remove the item at {idx} from |List| {list} and
+		return the item.
+		With {end}: Remove items from {idx} to {end} (inclusive) and
+		return a |List| with these items.  When {idx} points to the same
+		item as {end} a list with one item is returned.  When {end}
+		points to an item before {idx} this is an error.
+		See |list-index| for possible values of {idx} and {end}.
+		Returns zero on error.
+		Example: >
+			:echo "last item: " .. remove(mylist, -1)
+			:call remove(mylist, 0, 9)
+<
+		Use |delete()| to remove a file.
+
+		Can also be used as a |method|: >
+			mylist->remove(idx)
+
+remove({blob}, {idx} [, {end}])
+		Without {end}: Remove the byte at {idx} from |Blob| {blob} and
+		return the byte.
+		With {end}: Remove bytes from {idx} to {end} (inclusive) and
+		return a |Blob| with these bytes.  When {idx} points to the same
+		byte as {end} a |Blob| with one byte is returned.  When {end}
+		points to a byte before {idx} this is an error.
+		Returns zero on error.
+		Example: >
+			:echo "last byte: " .. remove(myblob, -1)
+			:call remove(mylist, 0, 9)
+
+remove({dict}, {key})
+		Remove the entry from {dict} with key {key} and return it.
+		Example: >
+			:echo "removed " .. remove(dict, "one")
+<		If there is no {key} in {dict} this is an error.
+		Returns zero on error.
+
+rename({from}, {to})					*rename()*
+		Rename the file by the name {from} to the name {to}.  This
+		should also work to move files across file systems.  The
+		result is a Number, which is 0 if the file was renamed
+		successfully, and non-zero when the renaming failed.
+		NOTE: If {to} exists it is overwritten without warning.
+		This function is not available in the |sandbox|.
+
+		Can also be used as a |method|: >
+			GetOldName()->rename(newname)
+
+repeat({expr}, {count})					*repeat()*
+		Repeat {expr} {count} times and return the concatenated
+		result.  Example: >
+			:let separator = repeat('-', 80)
+<		When {count} is zero or negative the result is empty.
+		When {expr} is a |List| the result is {expr} concatenated
+		{count} times.  Example: >
+			:let longlist = repeat(['a', 'b'], 3)
+<		Results in ['a', 'b', 'a', 'b', 'a', 'b'].
+
+		Can also be used as a |method|: >
+			mylist->repeat(count)
+
+resolve({filename})					*resolve()* *E655*
+		On MS-Windows, when {filename} is a shortcut (a .lnk file),
+		returns the path the shortcut points to in a simplified form.
+		On Unix, repeat resolving symbolic links in all path
+		components of {filename} and return the simplified result.
+		To cope with link cycles, resolving of symbolic links is
+		stopped after 100 iterations.
+		On other systems, return the simplified {filename}.
+		The simplification step is done as by |simplify()|.
+		resolve() keeps a leading path component specifying the
+		current directory (provided the result is still a relative
+		path name) and also keeps a trailing path separator.
+
+		Can also be used as a |method|: >
+			GetName()->resolve()
+<
+							*reverse()*
+reverse({object})
+		Reverse the order of items in {object} in-place.
+		{object} can be a |List| or a |Blob|.
+		Returns {object}.
+		Returns zero if {object} is not a List or a Blob.
+		If you want an object to remain unmodified make a copy first: >
+			:let revlist = reverse(copy(mylist))
+<		Can also be used as a |method|: >
+			mylist->reverse()
+
+round({expr})							*round()*
+		Round off {expr} to the nearest integral value and return it
+		as a |Float|.  If {expr} lies halfway between two integral
+		values, then use the larger one (away from zero).
+		{expr} must evaluate to a |Float| or a |Number|.
+		Returns 0.0 if {expr} is not a |Float| or a |Number|.
+		Examples: >
+			echo round(0.456)
+<			0.0  >
+			echo round(4.5)
+<			5.0 >
+			echo round(-4.5)
+<			-5.0
+
+		Can also be used as a |method|: >
+			Compute()->round()
+
+rpcnotify({channel}, {event} [, {args}...])			*rpcnotify()*
+		Sends {event} to {channel} via |RPC| and returns immediately.
+		If {channel} is 0, the event is broadcast to all channels.
+		Example: >
+			:au VimLeave call rpcnotify(0, "leaving")
+
+rpcrequest({channel}, {method} [, {args}...])			*rpcrequest()*
+		Sends a request to {channel} to invoke {method} via
+		|RPC| and blocks until a response is received.
+		Example: >
+			:let result = rpcrequest(rpc_chan, "func", 1, 2, 3)
+
+rpcstart({prog} [, {argv}])					*rpcstart()*
+		Deprecated. Replace  >
+			:let id = rpcstart('prog', ['arg1', 'arg2'])
+<		with >
+			:let id = jobstart(['prog', 'arg1', 'arg2'], {'rpc': v:true})
+
+rubyeval({expr})					*rubyeval()*
+		Evaluate Ruby expression {expr} and return its result
+		converted to Vim data structures.
+		Numbers, floats and strings are returned as they are (strings
+		are copied though).
+		Arrays are represented as Vim |List| type.
+		Hashes are represented as Vim |Dictionary| type.
+		Other objects are represented as strings resulted from their
+		"Object#to_s" method.
+
+		Can also be used as a |method|: >
+			GetRubyExpr()->rubyeval()
+
+screenattr({row}, {col})					*screenattr()*
+		Like |screenchar()|, but return the attribute.  This is a rather
+		arbitrary number that can only be used to compare to the
+		attribute at other positions.
+		Returns -1 when row or col is out of range.
+
+		Can also be used as a |method|: >
+			GetRow()->screenattr(col)
+
+screenchar({row}, {col})					*screenchar()*
+		The result is a Number, which is the character at position
+		[row, col] on the screen.  This works for every possible
+		screen position, also status lines, window separators and the
+		command line.  The top left position is row one, column one
+		The character excludes composing characters.  For double-byte
+		encodings it may only be the first byte.
+		This is mainly to be used for testing.
+		Returns -1 when row or col is out of range.
+
+		Can also be used as a |method|: >
+			GetRow()->screenchar(col)
+
+screenchars({row}, {col})					*screenchars()*
+		The result is a List of Numbers.  The first number is the same
+		as what |screenchar()| returns.  Further numbers are
+		composing characters on top of the base character.
+		This is mainly to be used for testing.
+		Returns an empty List when row or col is out of range.
+
+		Can also be used as a |method|: >
+			GetRow()->screenchars(col)
+
+screencol()							*screencol()*
+		The result is a Number, which is the current screen column of
+		the cursor. The leftmost column has number 1.
+		This function is mainly used for testing.
+
+		Note: Always returns the current screen column, thus if used
+		in a command (e.g. ":echo screencol()") it will return the
+		column inside the command line, which is 1 when the command is
+		executed. To get the cursor position in the file use one of
+		the following mappings: >
+			nnoremap <expr> GG ":echom " .. screencol() .. "\n"
+			nnoremap <silent> GG :echom screencol()<CR>
+			noremap GG <Cmd>echom screencol()<Cr>
+<
+screenpos({winid}, {lnum}, {col})				*screenpos()*
+		The result is a Dict with the screen position of the text
+		character in window {winid} at buffer line {lnum} and column
+		{col}.  {col} is a one-based byte index.
+		The Dict has these members:
+			row	screen row
+			col	first screen column
+			endcol	last screen column
+			curscol	cursor screen column
+		If the specified position is not visible, all values are zero.
+		The "endcol" value differs from "col" when the character
+		occupies more than one screen cell.  E.g. for a Tab "col" can
+		be 1 and "endcol" can be 8.
+		The "curscol" value is where the cursor would be placed.  For
+		a Tab it would be the same as "endcol", while for a double
+		width character it would be the same as "col".
+		The |conceal| feature is ignored here, the column numbers are
+		as if 'conceallevel' is zero.  You can set the cursor to the
+		right position and use |screencol()| to get the value with
+		|conceal| taken into account.
+		Returns an empty Dict if {winid} is invalid.
+
+		Can also be used as a |method|: >
+			GetWinid()->screenpos(lnum, col)
+
+screenrow()							*screenrow()*
+		The result is a Number, which is the current screen row of the
+		cursor.  The top line has number one.
+		This function is mainly used for testing.
+		Alternatively you can use |winline()|.
+
+		Note: Same restrictions as with |screencol()|.
+
+screenstring({row}, {col})					*screenstring()*
+		The result is a String that contains the base character and
+		any composing characters at position [row, col] on the screen.
+		This is like |screenchars()| but returning a String with the
+		characters.
+		This is mainly to be used for testing.
+		Returns an empty String when row or col is out of range.
+
+		Can also be used as a |method|: >
+			GetRow()->screenstring(col)
+<
+								*search()*
+search({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]])
+		Search for regexp pattern {pattern}.  The search starts at the
+		cursor position (you can use |cursor()| to set it).
+
+		When a match has been found its line number is returned.
+		If there is no match a 0 is returned and the cursor doesn't
+		move.  No error message is given.
+
+		{flags} is a String, which can contain these character flags:
+		'b'	search Backward instead of forward
+		'c'	accept a match at the Cursor position
+		'e'	move to the End of the match
+		'n'	do Not move the cursor
+		'p'	return number of matching sub-Pattern (see below)
+		's'	Set the ' mark at the previous location of the cursor
+		'w'	Wrap around the end of the file
+		'W'	don't Wrap around the end of the file
+		'z'	start searching at the cursor column instead of Zero
+		If neither 'w' or 'W' is given, the 'wrapscan' option applies.
+
+		If the 's' flag is supplied, the ' mark is set, only if the
+		cursor is moved. The 's' flag cannot be combined with the 'n'
+		flag.
+
+		'ignorecase', 'smartcase' and 'magic' are used.
+
+		When the 'z' flag is not given, forward searching always
+		starts in column zero and then matches before the cursor are
+		skipped.  When the 'c' flag is present in 'cpo' the next
+		search starts after the match.  Without the 'c' flag the next
+		search starts one column further.  This matters for
+		overlapping matches.
+		When searching backwards and the 'z' flag is given then the
+		search starts in column zero, thus no match in the current
+		line will be found (unless wrapping around the end of the
+		file).
+
+		When the {stopline} argument is given then the search stops
+		after searching this line.  This is useful to restrict the
+		search to a range of lines.  Examples: >
+			let match = search('(', 'b', line("w0"))
+			let end = search('END', '', line("w$"))
+<		When {stopline} is used and it is not zero this also implies
+		that the search does not wrap around the end of the file.
+		A zero value is equal to not giving the argument.
+
+		When the {timeout} argument is given the search stops when
+		more than this many milliseconds have passed.  Thus when
+		{timeout} is 500 the search stops after half a second.
+		The value must not be negative.  A zero value is like not
+		giving the argument.
+
+		If the {skip} expression is given it is evaluated with the
+		cursor positioned on the start of a match.  If it evaluates to
+		non-zero this match is skipped.  This can be used, for
+		example, to skip a match in a comment or a string.
+		{skip} can be a string, which is evaluated as an expression, a
+		function reference or a lambda.
+		When {skip} is omitted or empty, every match is accepted.
+		When evaluating {skip} causes an error the search is aborted
+		and -1 returned.
+							*search()-sub-match*
+		With the 'p' flag the returned value is one more than the
+		first sub-match in \(\).  One if none of them matched but the
+		whole pattern did match.
+		To get the column number too use |searchpos()|.
+
+		The cursor will be positioned at the match, unless the 'n'
+		flag is used.
+
+		Example (goes over all files in the argument list): >
+		    :let n = 1
+		    :while n <= argc()	    " loop over all files in arglist
+		    :  exe "argument " .. n
+		    :  " start at the last char in the file and wrap for the
+		    :  " first search to find match at start of file
+		    :  normal G$
+		    :  let flags = "w"
+		    :  while search("foo", flags) > 0
+		    :	 s/foo/bar/g
+		    :	 let flags = "W"
+		    :  endwhile
+		    :  update		    " write the file if modified
+		    :  let n = n + 1
+		    :endwhile
+<
+		Example for using some flags: >
+		    :echo search('\<if\|\(else\)\|\(endif\)', 'ncpe')
+<		This will search for the keywords "if", "else", and "endif"
+		under or after the cursor.  Because of the 'p' flag, it
+		returns 1, 2, or 3 depending on which keyword is found, or 0
+		if the search fails.  With the cursor on the first word of the
+		line:
+		    if (foo == 0) | let foo = foo + 1 | endif ~
+		the function returns 1.  Without the 'c' flag, the function
+		finds the "endif" and returns 3.  The same thing happens
+		without the 'e' flag if the cursor is on the "f" of "if".
+		The 'n' flag tells the function not to move the cursor.
+
+		Can also be used as a |method|: >
+			GetPattern()->search()
+
+searchcount([{options}])					*searchcount()*
+		Get or update the last search count, like what is displayed
+		without the "S" flag in 'shortmess'.  This works even if
+		'shortmess' does contain the "S" flag.
+
+		This returns a Dictionary. The dictionary is empty if the
+		previous pattern was not set and "pattern" was not specified.
+
+		  key		type		meaning ~
+		  current	|Number|	current position of match;
+						0 if the cursor position is
+						before the first match
+		  exact_match	|Boolean|	1 if "current" is matched on
+						"pos", otherwise 0
+		  total		|Number|	total count of matches found
+		  incomplete	|Number|	0: search was fully completed
+						1: recomputing was timed out
+						2: max count exceeded
+
+		For {options} see further down.
+
+		To get the last search count when |n| or |N| was pressed, call
+		this function with `recompute: 0` . This sometimes returns
+		wrong information because |n| and |N|'s maximum count is 99.
+		If it exceeded 99 the result must be max count + 1 (100). If
+		you want to get correct information, specify `recompute: 1`: >
+
+			" result == maxcount + 1 (100) when many matches
+			let result = searchcount(#{recompute: 0})
+
+			" Below returns correct result (recompute defaults
+			" to 1)
+			let result = searchcount()
+<
+		The function is useful to add the count to |statusline|: >
+			function! LastSearchCount() abort
+			  let result = searchcount(#{recompute: 0})
+			  if empty(result)
+			    return ''
+			  endif
+			  if result.incomplete ==# 1     " timed out
+			    return printf(' /%s [?/??]', @/)
+			  elseif result.incomplete ==# 2 " max count exceeded
+			    if result.total > result.maxcount &&
+			    \  result.current > result.maxcount
+			      return printf(' /%s [>%d/>%d]', @/,
+			      \             result.current, result.total)
+			    elseif result.total > result.maxcount
+			      return printf(' /%s [%d/>%d]', @/,
+			      \             result.current, result.total)
+			    endif
+			  endif
+			  return printf(' /%s [%d/%d]', @/,
+			  \             result.current, result.total)
+			endfunction
+			let &statusline ..= '%{LastSearchCount()}'
+
+			" Or if you want to show the count only when
+			" 'hlsearch' was on
+			" let &statusline ..=
+			" \   '%{v:hlsearch ? LastSearchCount() : ""}'
+<
+		You can also update the search count, which can be useful in a
+		|CursorMoved| or |CursorMovedI| autocommand: >
+
+			autocmd CursorMoved,CursorMovedI *
+			  \ let s:searchcount_timer = timer_start(
+			  \   200, function('s:update_searchcount'))
+			function! s:update_searchcount(timer) abort
+			  if a:timer ==# s:searchcount_timer
+			    call searchcount(#{
+			    \ recompute: 1, maxcount: 0, timeout: 100})
+			    redrawstatus
+			  endif
+			endfunction
+<
+		This can also be used to count matched texts with specified
+		pattern in the current buffer using "pattern":  >
+
+			" Count '\<foo\>' in this buffer
+			" (Note that it also updates search count)
+			let result = searchcount(#{pattern: '\<foo\>'})
+
+			" To restore old search count by old pattern,
+			" search again
+			call searchcount()
+<
+		{options} must be a Dictionary. It can contain:
+		  key		type		meaning ~
+		  recompute	|Boolean|	if |TRUE|, recompute the count
+						like |n| or |N| was executed.
+						otherwise returns the last
+						result by |n|, |N|, or this
+						function is returned.
+						(default: |TRUE|)
+		  pattern	|String|	recompute if this was given
+						and different with |@/|.
+						this works as same as the
+						below command is executed
+						before calling this function >
+						  let @/ = pattern
+<						(default: |@/|)
+		  timeout	|Number|	0 or negative number is no
+						timeout. timeout milliseconds
+						for recomputing the result
+						(default: 0)
+		  maxcount	|Number|	0 or negative number is no
+						limit. max count of matched
+						text while recomputing the
+						result.  if search exceeded
+						total count, "total" value
+						becomes `maxcount + 1`
+						(default: 0)
+		  pos		|List|		`[lnum, col, off]` value
+						when recomputing the result.
+						this changes "current" result
+						value. see |cursor()|, |getpos()
+						(default: cursor's position)
+
+		Can also be used as a |method|: >
+			GetSearchOpts()->searchcount()
+<
+searchdecl({name} [, {global} [, {thisblock}]])			*searchdecl()*
+		Search for the declaration of {name}.
+
+		With a non-zero {global} argument it works like |gD|, find
+		first match in the file.  Otherwise it works like |gd|, find
+		first match in the function.
+
+		With a non-zero {thisblock} argument matches in a {} block
+		that ends before the cursor position are ignored.  Avoids
+		finding variable declarations only valid in another scope.
+
+		Moves the cursor to the found match.
+		Returns zero for success, non-zero for failure.
+		Example: >
+			if searchdecl('myvar') == 0
+			   echo getline('.')
+			endif
+<
+		Can also be used as a |method|: >
+			GetName()->searchdecl()
+<
+							*searchpair()*
+searchpair({start}, {middle}, {end} [, {flags} [, {skip}
+				[, {stopline} [, {timeout}]]]])
+		Search for the match of a nested start-end pair.  This can be
+		used to find the "endif" that matches an "if", while other
+		if/endif pairs in between are ignored.
+		The search starts at the cursor.  The default is to search
+		forward, include 'b' in {flags} to search backward.
+		If a match is found, the cursor is positioned at it and the
+		line number is returned.  If no match is found 0 or -1 is
+		returned and the cursor doesn't move.  No error message is
+		given.
+
+		{start}, {middle} and {end} are patterns, see |pattern|.  They
+		must not contain \( \) pairs.  Use of \%( \) is allowed.  When
+		{middle} is not empty, it is found when searching from either
+		direction, but only when not in a nested start-end pair.  A
+		typical use is: >
+			searchpair('\<if\>', '\<else\>', '\<endif\>')
+<		By leaving {middle} empty the "else" is skipped.
+
+		{flags} 'b', 'c', 'n', 's', 'w' and 'W' are used like with
+		|search()|.  Additionally:
+		'r'	Repeat until no more matches found; will find the
+			outer pair.  Implies the 'W' flag.
+		'm'	Return number of matches instead of line number with
+			the match; will be > 1 when 'r' is used.
+		Note: it's nearly always a good idea to use the 'W' flag, to
+		avoid wrapping around the end of the file.
+
+		When a match for {start}, {middle} or {end} is found, the
+		{skip} expression is evaluated with the cursor positioned on
+		the start of the match.  It should return non-zero if this
+		match is to be skipped.  E.g., because it is inside a comment
+		or a string.
+		When {skip} is omitted or empty, every match is accepted.
+		When evaluating {skip} causes an error the search is aborted
+		and -1 returned.
+ 		{skip} can be a string, a lambda, a funcref or a partial.
+		Anything else makes the function fail.
+
+		For {stopline} and {timeout} see |search()|.
+
+		The value of 'ignorecase' is used.  'magic' is ignored, the
+		patterns are used like it's on.
+
+		The search starts exactly at the cursor.  A match with
+		{start}, {middle} or {end} at the next character, in the
+		direction of searching, is the first one found.  Example: >
+			if 1
+			  if 2
+			  endif 2
+			endif 1
+<		When starting at the "if 2", with the cursor on the "i", and
+		searching forwards, the "endif 2" is found.  When starting on
+		the character just before the "if 2", the "endif 1" will be
+		found.  That's because the "if 2" will be found first, and
+		then this is considered to be a nested if/endif from "if 2" to
+		"endif 2".
+		When searching backwards and {end} is more than one character,
+		it may be useful to put "\zs" at the end of the pattern, so
+		that when the cursor is inside a match with the end it finds
+		the matching start.
+
+		Example, to find the "endif" command in a Vim script: >
+
+	:echo searchpair('\<if\>', '\<el\%[seif]\>', '\<en\%[dif]\>', 'W',
+			\ 'getline(".") =~ "^\\s*\""')
+
+<		The cursor must be at or after the "if" for which a match is
+		to be found.  Note that single-quote strings are used to avoid
+		having to double the backslashes.  The skip expression only
+		catches comments at the start of a line, not after a command.
+		Also, a word "en" or "if" halfway through a line is considered
+		a match.
+		Another example, to search for the matching "{" of a "}": >
+
+	:echo searchpair('{', '', '}', 'bW')
+
+<		This works when the cursor is at or before the "}" for which a
+		match is to be found.  To reject matches that syntax
+		highlighting recognized as strings: >
+
+	:echo searchpair('{', '', '}', 'bW',
+	     \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string"')
+<
+							*searchpairpos()*
+searchpairpos({start}, {middle}, {end} [, {flags} [, {skip}
+				[, {stopline} [, {timeout}]]]])
+		Same as |searchpair()|, but returns a |List| with the line and
+		column position of the match. The first element of the |List|
+		is the line number and the second element is the byte index of
+		the column position of the match.  If no match is found,
+		returns [0, 0]. >
+
+			:let [lnum,col] = searchpairpos('{', '', '}', 'n')
+<
+		See |match-parens| for a bigger and more useful example.
+
+							*searchpos()*
+searchpos({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]])
+		Same as |search()|, but returns a |List| with the line and
+		column position of the match. The first element of the |List|
+		is the line number and the second element is the byte index of
+		the column position of the match. If no match is found,
+		returns [0, 0].
+		Example: >
+	:let [lnum, col] = searchpos('mypattern', 'n')
+
+<		When the 'p' flag is given then there is an extra item with
+		the sub-pattern match number |search()-sub-match|.  Example: >
+	:let [lnum, col, submatch] = searchpos('\(\l\)\|\(\u\)', 'np')
+<		In this example "submatch" is 2 when a lowercase letter is
+		found |/\l|, 3 when an uppercase letter is found |/\u|.
+
+		Can also be used as a |method|: >
+			GetPattern()->searchpos()
+
+serverlist()						*serverlist()*
+		Returns a list of server addresses, or empty if all servers
+		were stopped. |serverstart()| |serverstop()|
+		Example: >
+			:echo serverlist()
+
+serverstart([{address}])				*serverstart()*
+		Opens a socket or named pipe at {address} and listens for
+		|RPC| messages. Clients can send |API| commands to the
+		returned address to control Nvim.
+
+		Returns the address string (may differ from the requested
+		{address}).
+		 
+		- If {address} contains a colon ":" it is interpreted as
+		  a TCP/IPv4/IPv6 address where the last ":" separates host
+		  and port (empty or zero assigns a random port).
+		- Else it is interpreted as a named pipe or Unix domain socket
+		  path. If there are no slashes it is treated as a name and
+		  appended to a generated path.
+		- If {address} is empty it generates a path.
+
+		Example named pipe: >
+			if has('win32')
+			  echo serverstart('\\.\pipe\nvim-pipe-1234')
+			else
+			  echo serverstart('nvim.sock')
+			endif
+<
+		Example TCP/IP address: >
+			echo serverstart('::1:12345')
+
+serverstop({address})					*serverstop()*
+		Closes the pipe or socket at {address}.
+		Returns TRUE if {address} is valid, else FALSE.
+		If |v:servername| is stopped it is set to the next available
+		address in |serverlist()|.
+
+setbufline({buf}, {lnum}, {text})			*setbufline()*
+		Set line {lnum} to {text} in buffer {buf}.  This works like
+		|setline()| for the specified buffer.
+
+		This function works only for loaded buffers. First call
+		|bufload()| if needed.
+
+		To insert lines use |appendbufline()|.
+		Any text properties in {lnum} are cleared.
+
+		{text} can be a string to set one line, or a list of strings
+		to set multiple lines.  If the list extends below the last
+		line then those lines are added.
+
+		For the use of {buf}, see |bufname()| above.
+
+		{lnum} is used like with |setline()|.
+		Use "$" to refer to the last line in buffer {buf}.
+		When {lnum} is just below the last line the {text} will be
+		added below the last line.
+		On success 0 is returned, on failure 1 is returned.
+
+		If {buf} is not a valid buffer or {lnum} is not valid, an
+		error message is given.
+
+		Can also be used as a |method|, the base is passed as the
+		third argument: >
+			GetText()->setbufline(buf, lnum)
+
+setbufvar({buf}, {varname}, {val})			*setbufvar()*
+		Set option or local variable {varname} in buffer {buf} to
+		{val}.
+		This also works for a global or local window option, but it
+		doesn't work for a global or local window variable.
+		For a local window option the global value is unchanged.
+		For the use of {buf}, see |bufname()| above.
+		The {varname} argument is a string.
+		Note that the variable name without "b:" must be used.
+		Examples: >
+			:call setbufvar(1, "&mod", 1)
+			:call setbufvar("todo", "myvar", "foobar")
+<		This function is not available in the |sandbox|.
+
+		Can also be used as a |method|, the base is passed as the
+		third argument: >
+			GetValue()->setbufvar(buf, varname)
+
+setcharpos({expr}, {list})				*setcharpos()*
+		Same as |setpos()| but uses the specified column number as the
+		character index instead of the byte index in the line.
+
+		Example:
+		With the text "여보세요" in line 8: >
+			call setcharpos('.', [0, 8, 4, 0])
+<		positions the cursor on the fourth character '요'. >
+			call setpos('.', [0, 8, 4, 0])
+<		positions the cursor on the second character '보'.
+
+		Can also be used as a |method|: >
+			GetPosition()->setcharpos('.')
+
+setcharsearch({dict})					*setcharsearch()*
+		Set the current character search information to {dict},
+		which contains one or more of the following entries:
+
+		    char	character which will be used for a subsequent
+				|,| or |;| command; an empty string clears the
+				character search
+		    forward	direction of character search; 1 for forward,
+				0 for backward
+		    until	type of character search; 1 for a |t| or |T|
+				character search, 0 for an |f| or |F|
+				character search
+
+		This can be useful to save/restore a user's character search
+		from a script: >
+			:let prevsearch = getcharsearch()
+			:" Perform a command which clobbers user's search
+			:call setcharsearch(prevsearch)
+<		Also see |getcharsearch()|.
+
+		Can also be used as a |method|: >
+			SavedSearch()->setcharsearch()
+
+setcmdpos({pos})					*setcmdpos()*
+		Set the cursor position in the command line to byte position
+		{pos}.  The first position is 1.
+		Use |getcmdpos()| to obtain the current position.
+		Only works while editing the command line, thus you must use
+		|c_CTRL-\_e|, |c_CTRL-R_=| or |c_CTRL-R_CTRL-R| with '='.  For
+		|c_CTRL-\_e| and |c_CTRL-R_CTRL-R| with '=' the position is
+		set after the command line is set to the expression.  For
+		|c_CTRL-R_=| it is set after evaluating the expression but
+		before inserting the resulting text.
+		When the number is too big the cursor is put at the end of the
+		line.  A number smaller than one has undefined results.
+		Returns FALSE when successful, TRUE when not editing the
+		command line.
+
+		Can also be used as a |method|: >
+			GetPos()->setcmdpos()
+
+setcursorcharpos({lnum}, {col} [, {off}])		*setcursorcharpos()*
+setcursorcharpos({list})
+		Same as |cursor()| but uses the specified column number as the
+		character index instead of the byte index in the line.
+
+		Example:
+		With the text "여보세요" in line 4: >
+			call setcursorcharpos(4, 3)
+<		positions the cursor on the third character '세'. >
+			call cursor(4, 3)
+<		positions the cursor on the first character '여'.
+
+		Can also be used as a |method|: >
+			GetCursorPos()->setcursorcharpos()
+
+setenv({name}, {val})						*setenv()*
+		Set environment variable {name} to {val}.  Example: >
+			call setenv('HOME', '/home/myhome')
+
+<		When {val} is |v:null| the environment variable is deleted.
+		See also |expr-env|.
+
+		Can also be used as a |method|, the base is passed as the
+		second argument: >
+			GetPath()->setenv('PATH')
+
+setfperm({fname}, {mode})				*setfperm()* *chmod*
+		Set the file permissions for {fname} to {mode}.
+		{mode} must be a string with 9 characters.  It is of the form
+		"rwxrwxrwx", where each group of "rwx" flags represent, in
+		turn, the permissions of the owner of the file, the group the
+		file belongs to, and other users.  A '-' character means the
+		permission is off, any other character means on.  Multi-byte
+		characters are not supported.
+
+		For example "rw-r-----" means read-write for the user,
+		readable by the group, not accessible by others.  "xx-x-----"
+		would do the same thing.
+
+		Returns non-zero for success, zero for failure.
+
+		Can also be used as a |method|: >
+			GetFilename()->setfperm(mode)
+<
+		To read permissions see |getfperm()|.
+
+setline({lnum}, {text})					*setline()*
+		Set line {lnum} of the current buffer to {text}.  To insert
+		lines use |append()|. To set lines in another buffer use
+		|setbufline()|.
+
+		{lnum} is used like with |getline()|.
+		When {lnum} is just below the last line the {text} will be
+		added below the last line.
+
+		If this succeeds, FALSE is returned.  If this fails (most likely
+		because {lnum} is invalid) TRUE is returned.
+
+		Example: >
+			:call setline(5, strftime("%c"))
+
+<		When {text} is a |List| then line {lnum} and following lines
+		will be set to the items in the list.  Example: >
+			:call setline(5, ['aaa', 'bbb', 'ccc'])
+<		This is equivalent to: >
+			:for [n, l] in [[5, 'aaa'], [6, 'bbb'], [7, 'ccc']]
+			:  call setline(n, l)
+			:endfor
+
+<		Note: The '[ and '] marks are not set.
+
+		Can also be used as a |method|, the base is passed as the
+		second argument: >
+			GetText()->setline(lnum)
+
+setloclist({nr}, {list} [, {action} [, {what}]])		*setloclist()*
+		Create or replace or add to the location list for window {nr}.
+		{nr} can be the window number or the |window-ID|.
+		When {nr} is zero the current window is used.
+
+		For a location list window, the displayed location list is
+		modified.  For an invalid window number {nr}, -1 is returned.
+		Otherwise, same as |setqflist()|.
+		Also see |location-list|.
+
+		For {action} see |setqflist-action|.
+
+		If the optional {what} dictionary argument is supplied, then
+		only the items listed in {what} are set. Refer to |setqflist()|
+		for the list of supported keys in {what}.
+
+		Can also be used as a |method|, the base is passed as the
+		second argument: >
+			GetLoclist()->setloclist(winnr)
+
+setmatches({list} [, {win}])				*setmatches()*
+		Restores a list of matches saved by |getmatches() for the
+		current window|.  Returns 0 if successful, otherwise -1.  All
+		current matches are cleared before the list is restored.  See
+		example for |getmatches()|.
+		If {win} is specified, use the window with this number or
+		window ID instead of the current window.
+
+		Can also be used as a |method|: >
+			GetMatches()->setmatches()
+<
+							*setpos()*
+setpos({expr}, {list})
+		Set the position for String {expr}.  Possible values:
+			.	the cursor
+			'x	mark x
+
+		{list} must be a |List| with four or five numbers:
+		    [bufnum, lnum, col, off]
+		    [bufnum, lnum, col, off, curswant]
+
+		"bufnum" is the buffer number.	Zero can be used for the
+		current buffer.  When setting an uppercase mark "bufnum" is
+		used for the mark position.  For other marks it specifies the
+		buffer to set the mark in.  You can use the |bufnr()| function
+		to turn a file name into a buffer number.
+		For setting the cursor and the ' mark "bufnum" is ignored,
+		since these are associated with a window, not a buffer.
+		Does not change the jumplist.
+
+		"lnum" and "col" are the position in the buffer.  The first
+		column is 1.  Use a zero "lnum" to delete a mark.  If "col" is
+		smaller than 1 then 1 is used. To use the character count
+		instead of the byte count, use |setcharpos()|.
+
+		The "off" number is only used when 'virtualedit' is set. Then
+		it is the offset in screen columns from the start of the
+		character.  E.g., a position within a <Tab> or after the last
+		character.
+
+		The "curswant" number is only used when setting the cursor
+		position.  It sets the preferred column for when moving the
+		cursor vertically.  When the "curswant" number is missing the
+		preferred column is not set.  When it is present and setting a
+		mark position it is not used.
+
+		Note that for '< and '> changing the line number may result in
+		the marks to be effectively be swapped, so that '< is always
+		before '>.
+
+		Returns 0 when the position could be set, -1 otherwise.
+		An error message is given if {expr} is invalid.
+
+		Also see |setcharpos()|, |getpos()| and |getcurpos()|.
+
+		This does not restore the preferred column for moving
+		vertically; if you set the cursor position with this, |j| and
+		|k| motions will jump to previous columns!  Use |cursor()| to
+		also set the preferred column.  Also see the "curswant" key in
+		|winrestview()|.
+
+		Can also be used as a |method|: >
+			GetPosition()->setpos('.')
+
+setqflist({list} [, {action} [, {what}]])		*setqflist()*
+		Create or replace or add to the quickfix list.
+
+		If the optional {what} dictionary argument is supplied, then
+		only the items listed in {what} are set. The first {list}
+		argument is ignored.  See below for the supported items in
+		{what}.
+							*setqflist-what*
+		When {what} is not present, the items in {list} are used.  Each
+		item must be a dictionary.  Non-dictionary items in {list} are
+		ignored.  Each dictionary item can contain the following
+		entries:
+
+		    bufnr	buffer number; must be the number of a valid
+				buffer
+		    filename	name of a file; only used when "bufnr" is not
+				present or it is invalid.
+		    module	name of a module; if given it will be used in
+				quickfix error window instead of the filename.
+		    lnum	line number in the file
+		    end_lnum	end of lines, if the item spans multiple lines
+		    pattern	search pattern used to locate the error
+		    col		column number
+		    vcol	when non-zero: "col" is visual column
+				when zero: "col" is byte index
+		    end_col	end column, if the item spans multiple columns
+		    nr		error number
+		    text	description of the error
+		    type	single-character error type, 'E', 'W', etc.
+		    valid	recognized error message
+
+		The "col", "vcol", "nr", "type" and "text" entries are
+		optional.  Either "lnum" or "pattern" entry can be used to
+		locate a matching error line.
+		If the "filename" and "bufnr" entries are not present or
+		neither the "lnum" or "pattern" entries are present, then the
+		item will not be handled as an error line.
+		If both "pattern" and "lnum" are present then "pattern" will
+		be used.
+		If the "valid" entry is not supplied, then the valid flag is
+		set when "bufnr" is a valid buffer or "filename" exists.
+		If you supply an empty {list}, the quickfix list will be
+		cleared.
+		Note that the list is not exactly the same as what
+		|getqflist()| returns.
+
+		{action} values:		*setqflist-action* *E927*
+		'a'	The items from {list} are added to the existing
+			quickfix list. If there is no existing list, then a
+			new list is created.
+
+		'r'	The items from the current quickfix list are replaced
+			with the items from {list}.  This can also be used to
+			clear the list: >
+				:call setqflist([], 'r')
+<
+		'f'	All the quickfix lists in the quickfix stack are
+			freed.
+
+		If {action} is not present or is set to ' ', then a new list
+		is created. The new quickfix list is added after the current
+		quickfix list in the stack and all the following lists are
+		freed. To add a new quickfix list at the end of the stack,
+		set "nr" in {what} to "$".
+
+		The following items can be specified in dictionary {what}:
+		    context	quickfix list context. See |quickfix-context|
+		    efm		errorformat to use when parsing text from
+				"lines". If this is not present, then the
+				'errorformat' option value is used.
+				See |quickfix-parse|
+		    id		quickfix list identifier |quickfix-ID|
+		    idx		index of the current entry in the quickfix
+				list specified by 'id' or 'nr'. If set to '$',
+				then the last entry in the list is set as the
+				current entry.  See |quickfix-index|
+		    items	list of quickfix entries. Same as the {list}
+				argument.
+		    lines	use 'errorformat' to parse a list of lines and
+				add the resulting entries to the quickfix list
+				{nr} or {id}.  Only a |List| value is supported.
+				See |quickfix-parse|
+		    nr		list number in the quickfix stack; zero
+				means the current quickfix list and "$" means
+				the last quickfix list.
+		    quickfixtextfunc
+				function to get the text to display in the
+				quickfix window.  The value can be the name of
+				a function or a funcref or a lambda.  Refer to
+				|quickfix-window-function| for an explanation
+				of how to write the function and an example.
+		    title	quickfix list title text. See |quickfix-title|
+		Unsupported keys in {what} are ignored.
+		If the "nr" item is not present, then the current quickfix list
+		is modified. When creating a new quickfix list, "nr" can be
+		set to a value one greater than the quickfix stack size.
+		When modifying a quickfix list, to guarantee that the correct
+		list is modified, "id" should be used instead of "nr" to
+		specify the list.
+
+		Examples (See also |setqflist-examples|): >
+		   :call setqflist([], 'r', {'title': 'My search'})
+		   :call setqflist([], 'r', {'nr': 2, 'title': 'Errors'})
+		   :call setqflist([], 'a', {'id':qfid, 'lines':["F1:10:L10"]})
+<
+		Returns zero for success, -1 for failure.
+
+		This function can be used to create a quickfix list
+		independent of the 'errorformat' setting.  Use a command like
+		`:cc 1` to jump to the first position.
+
+		Can also be used as a |method|, the base is passed as the
+		second argument: >
+			GetErrorlist()->setqflist()
+<
+							*setreg()*
+setreg({regname}, {value} [, {options}])
+		Set the register {regname} to {value}.
+		The {regname} argument is a string.
+
+		{value} may be any value returned by |getreg()| or
+		|getreginfo()|, including a |List| or |Dict|.
+		If {options} contains "a" or {regname} is upper case,
+		then the value is appended.
+
+		{options} can also contain a register type specification:
+		    "c" or "v"	      |charwise| mode
+		    "l" or "V"	      |linewise| mode
+		    "b" or "<CTRL-V>" |blockwise-visual| mode
+		If a number immediately follows "b" or "<CTRL-V>" then this is
+		used as the width of the selection - if it is not specified
+		then the width of the block is set to the number of characters
+		in the longest line (counting a <Tab> as 1 character).
+		If {options} contains "u" or '"', then the unnamed register is
+		set to point to register {regname}.
+
+		If {options} contains no register settings, then the default
+		is to use character mode unless {value} ends in a <NL> for
+		string {value} and linewise mode for list {value}. Blockwise
+		mode is never selected automatically.
+		Returns zero for success, non-zero for failure.
+
+							*E883*
+		Note: you may not use |List| containing more than one item to
+		      set search and expression registers. Lists containing no
+		      items act like empty strings.
+
+		Examples: >
+			:call setreg(v:register, @*)
+			:call setreg('*', @%, 'ac')
+			:call setreg('a', "1\n2\n3", 'b5')
+			:call setreg('"', { 'points_to': 'a'})
+
+<		This example shows using the functions to save and restore a
+		register: >
+			:let var_a = getreginfo()
+			:call setreg('a', var_a)
+<		or: >
+			:let var_a = getreg('a', 1, 1)
+			:let var_amode = getregtype('a')
+			    ....
+			:call setreg('a', var_a, var_amode)
+<		Note: you may not reliably restore register value
+		without using the third argument to |getreg()| as without it
+		newlines are represented as newlines AND Nul bytes are
+		represented as newlines as well, see |NL-used-for-Nul|.
+
+		You can also change the type of a register by appending
+		nothing: >
+			:call setreg('a', '', 'al')
+
+<		Can also be used as a |method|, the base is passed as the
+		second argument: >
+			GetText()->setreg('a')
+
+settabvar({tabnr}, {varname}, {val})			*settabvar()*
+		Set tab-local variable {varname} to {val} in tab page {tabnr}.
+		|t:var|
+		The {varname} argument is a string.
+		Note that the variable name without "t:" must be used.
+		Tabs are numbered starting with one.
+		This function is not available in the |sandbox|.
+
+		Can also be used as a |method|, the base is passed as the
+		third argument: >
+			GetValue()->settabvar(tab, name)
+
+settabwinvar({tabnr}, {winnr}, {varname}, {val})	*settabwinvar()*
+		Set option or local variable {varname} in window {winnr} to
+		{val}.
+		Tabs are numbered starting with one.  For the current tabpage
+		use |setwinvar()|.
+		{winnr} can be the window number or the |window-ID|.
+		When {winnr} is zero the current window is used.
+		This also works for a global or local buffer option, but it
+		doesn't work for a global or local buffer variable.
+		For a local buffer option the global value is unchanged.
+		Note that the variable name without "w:" must be used.
+		Examples: >
+			:call settabwinvar(1, 1, "&list", 0)
+			:call settabwinvar(3, 2, "myvar", "foobar")
+<		This function is not available in the |sandbox|.
+
+		Can also be used as a |method|, the base is passed as the
+		fourth argument: >
+			GetValue()->settabwinvar(tab, winnr, name)
+
+settagstack({nr}, {dict} [, {action}])			*settagstack()*
+		Modify the tag stack of the window {nr} using {dict}.
+		{nr} can be the window number or the |window-ID|.
+
+		For a list of supported items in {dict}, refer to
+		|gettagstack()|. "curidx" takes effect before changing the tag
+		stack.
+							*E962*
+		How the tag stack is modified depends on the {action}
+		argument:
+		- If {action} is not present or is set to 'r', then the tag
+		  stack is replaced.
+		- If {action} is set to 'a', then new entries from {dict} are
+		  pushed (added) onto the tag stack.
+		- If {action} is set to 't', then all the entries from the
+		  current entry in the tag stack or "curidx" in {dict} are
+		  removed and then new entries are pushed to the stack.
+
+		The current index is set to one after the length of the tag
+		stack after the modification.
+
+		Returns zero for success, -1 for failure.
+
+		Examples (for more examples see |tagstack-examples|):
+		    Empty the tag stack of window 3: >
+			call settagstack(3, {'items' : []})
+
+<		    Save and restore the tag stack: >
+			let stack = gettagstack(1003)
+			" do something else
+			call settagstack(1003, stack)
+			unlet stack
+<
+		Can also be used as a |method|, the base is passed as the
+		second argument: >
+			GetStack()->settagstack(winnr)
+
+setwinvar({nr}, {varname}, {val})			*setwinvar()*
+		Like |settabwinvar()| for the current tab page.
+		Examples: >
+			:call setwinvar(1, "&list", 0)
+			:call setwinvar(2, "myvar", "foobar")
+
+<		Can also be used as a |method|, the base is passed as the
+		third argument: >
+			GetValue()->setwinvar(winnr, name)
+
+sha256({string})						*sha256()*
+		Returns a String with 64 hex characters, which is the SHA256
+		checksum of {string}.
+
+		Can also be used as a |method|: >
+			GetText()->sha256()
+
+shellescape({string} [, {special}])			*shellescape()*
+		Escape {string} for use as a shell command argument.
+
+		On Windows when 'shellslash' is not set, encloses {string} in
+		double-quotes and doubles all double-quotes within {string}.
+		Otherwise encloses {string} in single-quotes and replaces all
+		"'" with "'\''".
+
+		If {special} is a |non-zero-arg|:
+		- Special items such as "!", "%", "#" and "<cword>" will be
+		  preceded by a backslash. The backslash will be removed again
+		  by the |:!| command.
+		- The <NL> character is escaped.
+
+		If 'shell' contains "csh" in the tail:
+		- The "!" character will be escaped. This is because csh and
+		  tcsh use "!" for history replacement even in single-quotes.
+		- The <NL> character is escaped (twice if {special} is
+		  a |non-zero-arg|).
+
+		If 'shell' contains "fish" in the tail, the "\" character will
+		be escaped because in fish it is used as an escape character
+		inside single quotes.
+
+		Example of use with a |:!| command: >
+		    :exe '!dir ' .. shellescape(expand('<cfile>'), 1)
+<		This results in a directory listing for the file under the
+		cursor.  Example of use with |system()|: >
+		    :call system("chmod +w -- " .. shellescape(expand("%")))
+<		See also |::S|.
+
+		Can also be used as a |method|: >
+			GetCommand()->shellescape()
+
+shiftwidth([{col}])						*shiftwidth()*
+		Returns the effective value of 'shiftwidth'. This is the
+		'shiftwidth' value unless it is zero, in which case it is the
+		'tabstop' value.  To be backwards compatible in indent
+		plugins, use this: >
+			if exists('*shiftwidth')
+			  func s:sw()
+			    return shiftwidth()
+			  endfunc
+			else
+			  func s:sw()
+			    return &sw
+			  endfunc
+			endif
+<		And then use s:sw() instead of &sw.
+
+		When there is one argument {col} this is used as column number
+		for which to return the 'shiftwidth' value. This matters for the
+		'vartabstop' feature. If no {col} argument is given, column 1
+		will be assumed.
+
+		Can also be used as a |method|: >
+			GetColumn()->shiftwidth()
+
+sign_ functions are documented here: |sign-functions-details|
+
+simplify({filename})					*simplify()*
+		Simplify the file name as much as possible without changing
+		the meaning.  Shortcuts (on MS-Windows) or symbolic links (on
+		Unix) are not resolved.  If the first path component in
+		{filename} designates the current directory, this will be
+		valid for the result as well.  A trailing path separator is
+		not removed either. On Unix "//path" is unchanged, but
+		"///path" is simplified to "/path" (this follows the Posix
+		standard).
+		Example: >
+			simplify("./dir/.././/file/") == "./file/"
+<		Note: The combination "dir/.." is only removed if "dir" is
+		a searchable directory or does not exist.  On Unix, it is also
+		removed when "dir" is a symbolic link within the same
+		directory.  In order to resolve all the involved symbolic
+		links before simplifying the path name, use |resolve()|.
+
+		Can also be used as a |method|: >
+			GetName()->simplify()
+
+sin({expr})						*sin()*
+		Return the sine of {expr}, measured in radians, as a |Float|.
+		{expr} must evaluate to a |Float| or a |Number|.
+		Returns 0.0 if {expr} is not a |Float| or a |Number|.
+		Examples: >
+			:echo sin(100)
+<			-0.506366 >
+			:echo sin(-4.01)
+<			0.763301
+
+		Can also be used as a |method|: >
+			Compute()->sin()
+
+sinh({expr})						*sinh()*
+		Return the hyperbolic sine of {expr} as a |Float| in the range
+		[-inf, inf].
+		{expr} must evaluate to a |Float| or a |Number|.
+		Returns 0.0 if {expr} is not a |Float| or a |Number|.
+		Examples: >
+			:echo sinh(0.5)
+<			0.521095 >
+			:echo sinh(-0.9)
+<			-1.026517
+
+		Can also be used as a |method|: >
+			Compute()->sinh()
+
+sockconnect({mode}, {address} [, {opts}])		 *sockconnect()*
+		Connect a socket to an address. If {mode} is "pipe" then
+		{address} should be the path of a named pipe. If {mode} is
+		"tcp" then {address} should be of the form "host:port" where
+		the host should be an ip adderess or host name, and port the
+		port number.
+
+		Returns a |channel| ID. Close the socket with |chanclose()|.
+		Use |chansend()| to send data over a bytes socket, and
+		|rpcrequest()| and |rpcnotify()| to communicate with a RPC
+		socket.
+
+		{opts} is an optional dictionary with these keys:
+		  |on_data| : callback invoked when data was read from socket
+		  data_buffered : read socket data in |channel-buffered| mode.
+		  rpc     : If set, |msgpack-rpc| will be used to communicate
+			    over the socket.
+		Returns:
+		  - The channel ID on success (greater than zero)
+		  - 0 on invalid arguments or connection failure.
+
+sort({list} [, {func} [, {dict}]])			*sort()* *E702*
+		Sort the items in {list} in-place.  Returns {list}.
+
+		If you want a list to remain unmodified make a copy first: >
+			:let sortedlist = sort(copy(mylist))
+
+<		When {func} is omitted, is empty or zero, then sort() uses the
+		string representation of each item to sort on.  Numbers sort
+		after Strings, |Lists| after Numbers.  For sorting text in the
+		current buffer use |:sort|.
+
+		When {func} is given and it is '1' or 'i' then case is
+		ignored.
+
+		When {func} is given and it is 'l' then the current collation
+		locale is used for ordering. Implementation details: strcoll()
+		is used to compare strings. See |:language| check or set the
+		collation locale. |v:collate| can also be used to check the
+		current locale. Sorting using the locale typically ignores
+		case. Example: >
+			" ö is sorted similarly to o with English locale.
+			:language collate en_US.UTF8
+			:echo sort(['n', 'o', 'O', 'ö', 'p', 'z'], 'l')
+<			['n', 'o', 'O', 'ö', 'p', 'z'] ~
+>
+			" ö is sorted after z with Swedish locale.
+			:language collate sv_SE.UTF8
+			:echo sort(['n', 'o', 'O', 'ö', 'p', 'z'], 'l')
+<			['n', 'o', 'O', 'p', 'z', 'ö'] ~
+		This does not work properly on Mac.
+
+		When {func} is given and it is 'n' then all items will be
+		sorted numerical (Implementation detail: this uses the
+		strtod() function to parse numbers, Strings, Lists, Dicts and
+		Funcrefs will be considered as being 0).
+
+		When {func} is given and it is 'N' then all items will be
+		sorted numerical. This is like 'n' but a string containing
+		digits will be used as the number they represent.
+
+		When {func} is given and it is 'f' then all items will be
+		sorted numerical. All values must be a Number or a Float.
+
+		When {func} is a |Funcref| or a function name, this function
+		is called to compare items.  The function is invoked with two
+		items as argument and must return zero if they are equal, 1 or
+		bigger if the first one sorts after the second one, -1 or
+		smaller if the first one sorts before the second one.
+
+		{dict} is for functions with the "dict" attribute.  It will be
+		used to set the local variable "self". |Dictionary-function|
+
+		The sort is stable, items which compare equal (as number or as
+		string) will keep their relative position. E.g., when sorting
+		on numbers, text strings will sort next to each other, in the
+		same order as they were originally.
+
+		Can also be used as a |method|: >
+			mylist->sort()
+
+<		Also see |uniq()|.
+
+		Example: >
+			func MyCompare(i1, i2)
+			   return a:i1 == a:i2 ? 0 : a:i1 > a:i2 ? 1 : -1
+			endfunc
+			eval mylist->sort("MyCompare")
+<		A shorter compare version for this specific simple case, which
+		ignores overflow: >
+			func MyCompare(i1, i2)
+			   return a:i1 - a:i2
+			endfunc
+<		For a simple expression you can use a lambda: >
+			eval mylist->sort({i1, i2 -> i1 - i2})
+<
+							*soundfold()*
+soundfold({word})
+		Return the sound-folded equivalent of {word}.  Uses the first
+		language in 'spelllang' for the current window that supports
+		soundfolding.  'spell' must be set.  When no sound folding is
+		possible the {word} is returned unmodified.
+		This can be used for making spelling suggestions.  Note that
+		the method can be quite slow.
+
+		Can also be used as a |method|: >
+			GetWord()->soundfold()
+<
+							*spellbadword()*
+spellbadword([{sentence}])
+		Without argument: The result is the badly spelled word under
+		or after the cursor.  The cursor is moved to the start of the
+		bad word.  When no bad word is found in the cursor line the
+		result is an empty string and the cursor doesn't move.
+
+		With argument: The result is the first word in {sentence} that
+		is badly spelled.  If there are no spelling mistakes the
+		result is an empty string.
+
+		The return value is a list with two items:
+		- The badly spelled word or an empty string.
+		- 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
+		Example: >
+			echo spellbadword("the quik brown fox")
+<			['quik', 'bad'] ~
+
+		The spelling information for the current window and the value
+		of 'spelllang' are used.
+
+		Can also be used as a |method|: >
+			GetText()->spellbadword()
+<
+							*spellsuggest()*
+spellsuggest({word} [, {max} [, {capital}]])
+		Return a |List| with spelling suggestions to replace {word}.
+		When {max} is given up to this number of suggestions are
+		returned.  Otherwise up to 25 suggestions are returned.
+
+		When the {capital} argument is given and it's non-zero only
+		suggestions with a leading capital will be given.  Use this
+		after a match with 'spellcapcheck'.
+
+		{word} can be a badly spelled word followed by other text.
+		This allows for joining two words that were split.  The
+		suggestions also include the following text, thus you can
+		replace a line.
+
+		{word} may also be a good word.  Similar words will then be
+		returned.  {word} itself is not included in the suggestions,
+		although it may appear capitalized.
+
+		The spelling information for the current window is used.  The
+		values of 'spelllang' and 'spellsuggest' are used.
+
+		Can also be used as a |method|: >
+			GetWord()->spellsuggest()
+
+split({string} [, {pattern} [, {keepempty}]])			*split()*
+		Make a |List| out of {string}.  When {pattern} is omitted or
+		empty each white-separated sequence of characters becomes an
+		item.
+		Otherwise the string is split where {pattern} matches,
+		removing the matched characters. 'ignorecase' is not used
+		here, add \c to ignore case. |/\c|
+		When the first or last item is empty it is omitted, unless the
+		{keepempty} argument is given and it's non-zero.
+		Other empty items are kept when {pattern} matches at least one
+		character or when {keepempty} is non-zero.
+		Example: >
+			:let words = split(getline('.'), '\W\+')
+<		To split a string in individual characters: >
+			:for c in split(mystring, '\zs')
+<		If you want to keep the separator you can also use '\zs' at
+		the end of the pattern: >
+			:echo split('abc:def:ghi', ':\zs')
+<			['abc:', 'def:', 'ghi'] ~
+		Splitting a table where the first element can be empty: >
+			:let items = split(line, ':', 1)
+<		The opposite function is |join()|.
+
+		Can also be used as a |method|: >
+			GetString()->split()
+
+sqrt({expr})						*sqrt()*
+		Return the non-negative square root of Float {expr} as a
+		|Float|.
+		{expr} must evaluate to a |Float| or a |Number|.  When {expr}
+		is negative the result is NaN (Not a Number).  Returns 0.0 if
+		{expr} is not a |Float| or a |Number|.
+		Examples: >
+			:echo sqrt(100)
+<			10.0 >
+			:echo sqrt(-4.01)
+<			str2float('nan')
+		NaN may be different, it depends on system libraries.
+
+		Can also be used as a |method|: >
+			Compute()->sqrt()
+
+srand([{expr}])						*srand()*
+		Initialize seed used by |rand()|:
+		- If {expr} is not given, seed values are initialized by
+		  reading from /dev/urandom, if possible, or using time(NULL)
+		  a.k.a. epoch time otherwise; this only has second accuracy.
+		- If {expr} is given it must be a Number.  It is used to
+		  initialize the seed values.  This is useful for testing or
+		  when a predictable sequence is intended.
+
+		Examples: >
+			:let seed = srand()
+			:let seed = srand(userinput)
+			:echo rand(seed)
+<
+		Can also be used as a |method|: >
+			userinput->srand()
+
+stdioopen({opts})			 *stdioopen()*
+		With |--headless| this opens stdin and stdout as a |channel|.
+		May be called only once. See |channel-stdio|. stderr is not
+		handled by this function, see |v:stderr|.
+
+		Close the stdio handles with |chanclose()|. Use |chansend()|
+		to send data to stdout, and |rpcrequest()| and |rpcnotify()|
+		to communicate over RPC.
+
+		{opts} is a dictionary with these keys:
+		  |on_stdin| : callback invoked when stdin is written to.
+		  on_print : callback invoked when Nvim needs to print a
+			     message, with the message (whose type is string)
+			     as sole argument.
+		  stdin_buffered : read stdin in |channel-buffered| mode.
+		  rpc      : If set, |msgpack-rpc| will be used to communicate
+			     over stdio
+		Returns:
+		  - |channel-id| on success (value is always 1)
+		  - 0 on invalid arguments
+
+
+stdpath({what})					*stdpath()* *E6100*
+		Returns |standard-path| locations of various default files and
+		directories.
+
+		{what}       Type    Description ~
+		cache        String  Cache directory: arbitrary temporary
+		                     storage for plugins, etc.
+		config       String  User configuration directory. |init.vim|
+		                     is stored here.
+		config_dirs  List    Other configuration directories.
+		data         String  User data directory. The |shada-file|
+		                     is stored here.
+		data_dirs    List    Other data directories.
+		log          String  Logs directory (for use by plugins too).
+		run          String  Run directory: temporary, local storage
+				     for sockets, named pipes, etc.
+		state        String  Session state directory: storage for file
+				     drafts, undo, shada, etc.
+
+		Example: >
+			:echo stdpath("config")
+
+
+str2float({string} [, {quoted}])				*str2float()*
+ 		Convert String {string} to a Float.  This mostly works the
+ 		same as when using a floating point number in an expression,
+ 		see |floating-point-format|.  But it's a bit more permissive.
+ 		E.g., "1e40" is accepted, while in an expression you need to
+ 		write "1.0e40".  The hexadecimal form "0x123" is also
+ 		accepted, but not others, like binary or octal.
+ 		When {quoted} is present and non-zero then embedded single
+ 		quotes before the dot are ignored, thus "1'000.0" is a
+ 		thousand.
+		Text after the number is silently ignored.
+		The decimal point is always '.', no matter what the locale is
+		set to.  A comma ends the number: "12,345.67" is converted to
+		12.0.  You can strip out thousands separators with
+		|substitute()|: >
+			let f = str2float(substitute(text, ',', '', 'g'))
+<
+		Returns 0.0 if the conversion fails.
+
+		Can also be used as a |method|: >
+			let f = text->substitute(',', '', 'g')->str2float()
+
+str2list({string} [, {utf8}])				*str2list()*
+		Return a list containing the number values which represent
+		each character in String {string}.  Examples: >
+			str2list(" ")		returns [32]
+			str2list("ABC")		returns [65, 66, 67]
+<		|list2str()| does the opposite.
+
+		UTF-8 encoding is always used, {utf8} option has no effect,
+		and exists only for backwards-compatibility.
+		With UTF-8 composing characters are handled properly: >
+			str2list("á")		returns [97, 769]
+
+<		Can also be used as a |method|: >
+			GetString()->str2list()
+
+str2nr({string} [, {base}])			*str2nr()*
+		Convert string {string} to a number.
+		{base} is the conversion base, it can be 2, 8, 10 or 16.
+		When {quoted} is present and non-zero then embedded single
+		quotes are ignored, thus "1'000'000" is a million.
+
+		When {base} is omitted base 10 is used.  This also means that
+		a leading zero doesn't cause octal conversion to be used, as
+		with the default String to Number conversion.  Example: >
+			let nr = str2nr('0123')
+<
+		When {base} is 16 a leading "0x" or "0X" is ignored.  With a
+		different base the result will be zero. Similarly, when
+		{base} is 8 a leading "0", "0o" or "0O" is ignored, and when
+		{base} is 2 a leading "0b" or "0B" is ignored.
+		Text after the number is silently ignored.
+
+		Returns 0 if {string} is empty or on error.
+
+		Can also be used as a |method|: >
+			GetText()->str2nr()
+
+strcharpart({src}, {start} [, {len}])			*strcharpart()*
+		Like |strpart()| but using character index and length instead
+		of byte index and length.  Composing characters are counted
+		separately.
+		When a character index is used where a character does not
+		exist it is assumed to be one character.  For example: >
+			strcharpart('abc', -1, 2)
+<		results in 'a'.
+
+		Returns an empty string on error.
+
+		Can also be used as a |method|: >
+			GetText()->strcharpart(5)
+
+strchars({string} [, {skipcc}])					*strchars()*
+		The result is a Number, which is the number of characters
+		in String {string}.
+		When {skipcc} is omitted or zero, composing characters are
+		counted separately.
+		When {skipcc} set to 1, Composing characters are ignored.
+
+		Returns zero on error.
+
+		Also see |strlen()|, |strdisplaywidth()| and |strwidth()|.
+
+		{skipcc} is only available after 7.4.755.  For backward
+		compatibility, you can define a wrapper function: >
+		    if has("patch-7.4.755")
+		      function s:strchars(str, skipcc)
+			return strchars(a:str, a:skipcc)
+		      endfunction
+		    else
+		      function s:strchars(str, skipcc)
+			if a:skipcc
+			  return strlen(substitute(a:str, ".", "x", "g"))
+			else
+			  return strchars(a:str)
+			endif
+		      endfunction
+		    endif
+<
+		Can also be used as a |method|: >
+			GetText()->strchars()
+
+strdisplaywidth({string} [, {col}])			*strdisplaywidth()*
+		The result is a Number, which is the number of display cells
+		String {string} occupies on the screen when it starts at {col}
+		(first column is zero).  When {col} is omitted zero is used.
+		Otherwise it is the screen column where to start.  This
+		matters for Tab characters.
+		The option settings of the current window are used.  This
+		matters for anything that's displayed differently, such as
+		'tabstop' and 'display'.
+		When {string} contains characters with East Asian Width Class
+		Ambiguous, this function's return value depends on 'ambiwidth'.
+		Returns zero on error.
+		Also see |strlen()|, |strwidth()| and |strchars()|.
+
+		Can also be used as a |method|: >
+			GetText()->strdisplaywidth()
+
+strftime({format} [, {time}])				*strftime()*
+		The result is a String, which is a formatted date and time, as
+		specified by the {format} string.  The given {time} is used,
+		or the current time if no time is given.  The accepted
+		{format} depends on your system, thus this is not portable!
+		See the manual page of the C function strftime() for the
+		format.  The maximum length of the result is 80 characters.
+		See also |localtime()|, |getftime()| and |strptime()|.
+		The language can be changed with the |:language| command.
+		Examples: >
+		  :echo strftime("%c")		   Sun Apr 27 11:49:23 1997
+		  :echo strftime("%Y %b %d %X")	   1997 Apr 27 11:53:25
+		  :echo strftime("%y%m%d %T")	   970427 11:53:55
+		  :echo strftime("%H:%M")	   11:55
+		  :echo strftime("%c", getftime("file.c"))
+						   Show mod time of file.c.
+
+<		Can also be used as a |method|: >
+			GetFormat()->strftime()
+
+strgetchar({str}, {index})				*strgetchar()*
+		Get a Number corresponding to the character at {index} in
+		{str}.  This uses a zero-based character index, not a byte
+		index.  Composing characters are considered separate
+		characters here.  Use |nr2char()| to convert the Number to a
+		String.
+		Returns -1 if {index} is invalid.
+		Also see |strcharpart()| and |strchars()|.
+
+		Can also be used as a |method|: >
+			GetText()->strgetchar(5)
+
+stridx({haystack}, {needle} [, {start}])		*stridx()*
+		The result is a Number, which gives the byte index in
+		{haystack} of the first occurrence of the String {needle}.
+		If {start} is specified, the search starts at index {start}.
+		This can be used to find a second match: >
+			:let colon1 = stridx(line, ":")
+			:let colon2 = stridx(line, ":", colon1 + 1)
+<		The search is done case-sensitive.
+		For pattern searches use |match()|.
+		-1 is returned if the {needle} does not occur in {haystack}.
+		See also |strridx()|.
+		Examples: >
+		  :echo stridx("An Example", "Example")	     3
+		  :echo stridx("Starting point", "Start")    0
+		  :echo stridx("Starting point", "start")   -1
+<						*strstr()* *strchr()*
+		stridx() works similar to the C function strstr().  When used
+		with a single character it works similar to strchr().
+
+		Can also be used as a |method|: >
+			GetHaystack()->stridx(needle)
+
+							*string()*
+string({expr})	Return {expr} converted to a String.  If {expr} is a Number,
+		Float, String, Blob or a composition of them, then the result
+		can be parsed back with |eval()|.
+			{expr} type	result ~
+			String		'string'
+			Number		123
+			Float		123.123456 or 1.123456e8 or
+					`str2float('inf')`
+			Funcref		`function('name')`
+			Blob		0z00112233.44556677.8899
+			List		[item, item]
+			Dictionary	{key: value, key: value}
+		Note that in String values the ' character is doubled.
+		Also see |strtrans()|.
+		Note 2: Output format is mostly compatible with YAML, except
+		for infinite and NaN floating-point values representations
+		which use |str2float()|.  Strings are also dumped literally,
+		only single quote is escaped, which does not allow using YAML
+		for parsing back binary strings.  |eval()| should always work for
+		strings and floats though and this is the only official
+		method, use |msgpackdump()| or |json_encode()| if you need to
+		share data with other application.
+
+		Can also be used as a |method|: >
+			mylist->string()
+
+strlen({string})						*strlen()*
+		The result is a Number, which is the length of the String
+		{string} in bytes.
+		If the argument is a Number it is first converted to a String.
+		For other types an error is given and zero is returned.
+		If you want to count the number of multibyte characters use
+		|strchars()|.
+		Also see |len()|, |strdisplaywidth()| and |strwidth()|.
+
+		Can also be used as a |method|: >
+			GetString()->strlen()
+
+strpart({src}, {start} [, {len} [, {chars}]])			*strpart()*
+		The result is a String, which is part of {src}, starting from
+		byte {start}, with the byte length {len}.
+		When {chars} is present and TRUE then {len} is the number of
+		characters positions (composing characters are not counted
+		separately, thus "1" means one base character and any
+		following composing characters).
+		To count {start} as characters instead of bytes use
+		|strcharpart()|.
+
+		When bytes are selected which do not exist, this doesn't
+		result in an error, the bytes are simply omitted.
+		If {len} is missing, the copy continues from {start} till the
+		end of the {src}. >
+			strpart("abcdefg", 3, 2)    == "de"
+			strpart("abcdefg", -2, 4)   == "ab"
+			strpart("abcdefg", 5, 4)    == "fg"
+			strpart("abcdefg", 3)	    == "defg"
+
+<		Note: To get the first character, {start} must be 0.  For
+		example, to get the character under the cursor: >
+			strpart(getline("."), col(".") - 1, 1, v:true)
+<
+		Returns an empty string on error.
+
+		Can also be used as a |method|: >
+			GetText()->strpart(5)
+
+strptime({format}, {timestring})				*strptime()*
+		The result is a Number, which is a unix timestamp representing
+		the date and time in {timestring}, which is expected to match
+		the format specified in {format}.
+
+		The accepted {format} depends on your system, thus this is not
+		portable!  See the manual page of the C function strptime()
+		for the format.  Especially avoid "%c".  The value of $TZ also
+		matters.
+
+		If the {timestring} cannot be parsed with {format} zero is
+		returned.  If you do not know the format of {timestring} you
+		can try different {format} values until you get a non-zero
+		result.
+
+		See also |strftime()|.
+		Examples: >
+		  :echo strptime("%Y %b %d %X", "1997 Apr 27 11:49:23")
+<		  862156163 >
+		  :echo strftime("%c", strptime("%y%m%d %T", "970427 11:53:55"))
+<		  Sun Apr 27 11:53:55 1997 >
+		  :echo strftime("%c", strptime("%Y%m%d%H%M%S", "19970427115355") + 3600)
+<		  Sun Apr 27 12:53:55 1997
+
+		Can also be used as a |method|: >
+			GetFormat()->strptime(timestring)
+<
+strridx({haystack}, {needle} [, {start}])			*strridx()*
+		The result is a Number, which gives the byte index in
+		{haystack} of the last occurrence of the String {needle}.
+		When {start} is specified, matches beyond this index are
+		ignored.  This can be used to find a match before a previous
+		match: >
+			:let lastcomma = strridx(line, ",")
+			:let comma2 = strridx(line, ",", lastcomma - 1)
+<		The search is done case-sensitive.
+		For pattern searches use |match()|.
+		-1 is returned if the {needle} does not occur in {haystack}.
+		If the {needle} is empty the length of {haystack} is returned.
+		See also |stridx()|.  Examples: >
+		  :echo strridx("an angry armadillo", "an")	     3
+<							*strrchr()*
+		When used with a single character it works similar to the C
+		function strrchr().
+
+		Can also be used as a |method|: >
+			GetHaystack()->strridx(needle)
+
+strtrans({string})					*strtrans()*
+		The result is a String, which is {string} with all unprintable
+		characters translated into printable characters |'isprint'|.
+		Like they are shown in a window.  Example: >
+			echo strtrans(@a)
+<		This displays a newline in register a as "^@" instead of
+		starting a new line.
+
+		Returns an empty string on error.
+
+		Can also be used as a |method|: >
+			GetString()->strtrans()
+
+strwidth({string})					*strwidth()*
+		The result is a Number, which is the number of display cells
+		String {string} occupies.  A Tab character is counted as one
+		cell, alternatively use |strdisplaywidth()|.
+		When {string} contains characters with East Asian Width Class
+		Ambiguous, this function's return value depends on 'ambiwidth'.
+		Returns zero on error.
+		Also see |strlen()|, |strdisplaywidth()| and |strchars()|.
+
+		Can also be used as a |method|: >
+			GetString()->strwidth()
+
+submatch({nr} [, {list}])			*submatch()* *E935*
+		Only for an expression in a |:substitute| command or
+		substitute() function.
+		Returns the {nr}'th submatch of the matched text.  When {nr}
+		is 0 the whole matched text is returned.
+		Note that a NL in the string can stand for a line break of a
+		multi-line match or a NUL character in the text.
+		Also see |sub-replace-expression|.
+
+		If {list} is present and non-zero then submatch() returns
+		a list of strings, similar to |getline()| with two arguments.
+		NL characters in the text represent NUL characters in the
+		text.
+		Only returns more than one item for |:substitute|, inside
+		|substitute()| this list will always contain one or zero
+		items, since there are no real line breaks.
+
+		When substitute() is used recursively only the submatches in
+		the current (deepest) call can be obtained.
+
+		Returns an empty string or list on error.
+
+		Examples: >
+			:s/\d\+/\=submatch(0) + 1/
+			:echo substitute(text, '\d\+', '\=submatch(0) + 1', '')
+<		This finds the first number in the line and adds one to it.
+		A line break is included as a newline character.
+
+		Can also be used as a |method|: >
+			GetNr()->submatch()
+
+substitute({string}, {pat}, {sub}, {flags})		*substitute()*
+		The result is a String, which is a copy of {string}, in which
+		the first match of {pat} is replaced with {sub}.
+		When {flags} is "g", all matches of {pat} in {string} are
+		replaced.  Otherwise {flags} should be "".
+
+		This works like the ":substitute" command (without any flags).
+		But the matching with {pat} is always done like the 'magic'
+		option is set and 'cpoptions' is empty (to make scripts
+		portable).  'ignorecase' is still relevant, use |/\c| or |/\C|
+		if you want to ignore or match case and ignore 'ignorecase'.
+		'smartcase' is not used.  See |string-match| for how {pat} is
+		used.
+
+		A "~" in {sub} is not replaced with the previous {sub}.
+		Note that some codes in {sub} have a special meaning
+		|sub-replace-special|.  For example, to replace something with
+		"\n" (two characters), use "\\\\n" or '\\n'.
+
+		When {pat} does not match in {string}, {string} is returned
+		unmodified.
+
+		Example: >
+			:let &path = substitute(&path, ",\\=[^,]*$", "", "")
+<		This removes the last component of the 'path' option. >
+			:echo substitute("testing", ".*", "\\U\\0", "")
+<		results in "TESTING".
+
+		When {sub} starts with "\=", the remainder is interpreted as
+		an expression. See |sub-replace-expression|.  Example: >
+			:echo substitute(s, '%\(\x\x\)',
+			   \ '\=nr2char("0x" .. submatch(1))', 'g')
+
+<		When {sub} is a Funcref that function is called, with one
+		optional argument.  Example: >
+		   :echo substitute(s, '%\(\x\x\)', SubNr, 'g')
+<		The optional argument is a list which contains the whole
+		matched string and up to nine submatches, like what
+		|submatch()| returns.  Example: >
+		   :echo substitute(s, '%\(\x\x\)', {m -> '0x' .. m[1]}, 'g')
+
+<		Returns an empty string on error.
+
+		Can also be used as a |method|: >
+			GetString()->substitute(pat, sub, flags)
+
+swapinfo({fname})					*swapinfo()*
+		The result is a dictionary, which holds information about the
+		swapfile {fname}. The available fields are:
+			version Vim version
+			user	user name
+			host	host name
+			fname	original file name
+			pid	PID of the Vim process that created the swap
+				file
+			mtime	last modification time in seconds
+			inode	Optional: INODE number of the file
+			dirty	1 if file was modified, 0 if not
+		In case of failure an "error" item is added with the reason:
+			Cannot open file: file not found or in accessible
+			Cannot read file: cannot read first block
+			Not a swap file: does not contain correct block ID
+			Magic number mismatch: Info in first block is invalid
+
+		Can also be used as a |method|: >
+			GetFilename()->swapinfo()
+
+swapname({buf})						*swapname()*
+		The result is the swap file path of the buffer {buf}.
+		For the use of {buf}, see |bufname()| above.
+		If buffer {buf} is the current buffer, the result is equal to
+		|:swapname| (unless there is no swap file).
+		If buffer {buf} has no swap file, returns an empty string.
+
+		Can also be used as a |method|: >
+			GetBufname()->swapname()
+
+synID({lnum}, {col}, {trans})				*synID()*
+		The result is a Number, which is the syntax ID at the position
+		{lnum} and {col} in the current window.
+		The syntax ID can be used with |synIDattr()| and
+		|synIDtrans()| to obtain syntax information about text.
+
+		{col} is 1 for the leftmost column, {lnum} is 1 for the first
+		line.  'synmaxcol' applies, in a longer line zero is returned.
+		Note that when the position is after the last character,
+		that's where the cursor can be in Insert mode, synID() returns
+		zero.  {lnum} is used like with |getline()|.
+
+		When {trans} is |TRUE|, transparent items are reduced to the
+		item that they reveal.  This is useful when wanting to know
+		the effective color.  When {trans} is |FALSE|, the transparent
+		item is returned.  This is useful when wanting to know which
+		syntax item is effective (e.g. inside parens).
+		Warning: This function can be very slow.  Best speed is
+		obtained by going through the file in forward direction.
+
+		Returns zero on error.
+
+		Example (echoes the name of the syntax item under the cursor): >
+			:echo synIDattr(synID(line("."), col("."), 1), "name")
+<
+
+synIDattr({synID}, {what} [, {mode}])			*synIDattr()*
+		The result is a String, which is the {what} attribute of
+		syntax ID {synID}.  This can be used to obtain information
+		about a syntax item.
+		{mode} can be "gui", "cterm" or "term", to get the attributes
+		for that mode.  When {mode} is omitted, or an invalid value is
+		used, the attributes for the currently active highlighting are
+		used (GUI, cterm or term).
+		Use synIDtrans() to follow linked highlight groups.
+		{what}		result
+		"name"		the name of the syntax item
+		"fg"		foreground color (GUI: color name used to set
+				the color, cterm: color number as a string,
+				term: empty string)
+		"bg"		background color (as with "fg")
+		"font"		font name (only available in the GUI)
+				|highlight-font|
+		"sp"		special color (as with "fg") |highlight-guisp|
+		"fg#"		like "fg", but for the GUI and the GUI is
+				running the name in "#RRGGBB" form
+		"bg#"		like "fg#" for "bg"
+		"sp#"		like "fg#" for "sp"
+		"bold"		"1" if bold
+		"italic"	"1" if italic
+		"reverse"	"1" if reverse
+		"inverse"	"1" if inverse (= reverse)
+		"standout"	"1" if standout
+		"underline"	"1" if underlined
+		"undercurl"	"1" if undercurled
+		"underdouble"	"1" if double underlined
+		"underdotted"	"1" if dotted underlined
+		"underdashed"	"1" if dashed underlined
+		"strikethrough" "1" if struckthrough
+
+		Example (echoes the color of the syntax item under the
+		cursor): >
+	:echo synIDattr(synIDtrans(synID(line("."), col("."), 1)), "fg")
+<
+		Returns an empty string on error.
+
+		Can also be used as a |method|: >
+	:echo synID(line("."), col("."), 1)->synIDtrans()->synIDattr("fg")
+
+synIDtrans({synID})					*synIDtrans()*
+		The result is a Number, which is the translated syntax ID of
+		{synID}.  This is the syntax group ID of what is being used to
+		highlight the character.  Highlight links given with
+		":highlight link" are followed.
+
+		Returns zero on error.
+
+		Can also be used as a |method|: >
+	:echo synID(line("."), col("."), 1)->synIDtrans()->synIDattr("fg")
+
+synconcealed({lnum}, {col})				*synconcealed()*
+		The result is a |List| with currently three items:
+		1. The first item in the list is 0 if the character at the
+		   position {lnum} and {col} is not part of a concealable
+		   region, 1 if it is.  {lnum} is used like with |getline()|.
+		2. The second item in the list is a string. If the first item
+		   is 1, the second item contains the text which will be
+		   displayed in place of the concealed text, depending on the
+		   current setting of 'conceallevel' and 'listchars'.
+		3. The third and final item in the list is a number
+		   representing the specific syntax region matched in the
+		   line. When the character is not concealed the value is
+		   zero. This allows detection of the beginning of a new
+		   concealable region if there are two consecutive regions
+		   with the same replacement character.  For an example, if
+		   the text is "123456" and both "23" and "45" are concealed
+		   and replaced by the character "X", then:
+			call			returns ~
+		   	synconcealed(lnum, 1)   [0, '', 0]
+		   	synconcealed(lnum, 2)   [1, 'X', 1]
+		   	synconcealed(lnum, 3)   [1, 'X', 1]
+		   	synconcealed(lnum, 4)   [1, 'X', 2]
+		   	synconcealed(lnum, 5)   [1, 'X', 2]
+		   	synconcealed(lnum, 6)   [0, '', 0]
+
+
+synstack({lnum}, {col})					*synstack()*
+		Return a |List|, which is the stack of syntax items at the
+		position {lnum} and {col} in the current window.  {lnum} is
+		used like with |getline()|.  Each item in the List is an ID
+		like what |synID()| returns.
+		The first item in the List is the outer region, following are
+		items contained in that one.  The last one is what |synID()|
+		returns, unless not the whole item is highlighted or it is a
+		transparent item.
+		This function is useful for debugging a syntax file.
+		Example that shows the syntax stack under the cursor: >
+			for id in synstack(line("."), col("."))
+			   echo synIDattr(id, "name")
+			endfor
+<		When the position specified with {lnum} and {col} is invalid
+		an empty list is returned.  The position just after the last
+		character in a line and the first column in an empty line are
+		valid positions.
+
+system({cmd} [, {input}])				*system()* *E677*
+		Gets the output of {cmd} as a |string| (|systemlist()| returns
+		a |List|) and sets |v:shell_error| to the error code.
+		{cmd} is treated as in |jobstart()|:
+		If {cmd} is a List it runs directly (no 'shell').
+		If {cmd} is a String it runs in the 'shell', like this: >
+		  :call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}'])
+
+<		Not to be used for interactive commands.
+
+		Result is a String, filtered to avoid platform-specific quirks:
+		- <CR><NL> is replaced with <NL>
+		- NUL characters are replaced with SOH (0x01)
+
+		Example: >
+		    :echo system(['ls', expand('%:h')])
+
+<		If {input} is a string it is written to a pipe and passed as
+		stdin to the command.  The string is written as-is, line
+		separators are not changed.
+		If {input} is a |List| it is written to the pipe as
+		|writefile()| does with {binary} set to "b" (i.e. with
+		a newline between each list item, and newlines inside list
+		items converted to NULs).
+		When {input} is given and is a valid buffer id, the content of
+		the buffer is written to the file line by line, each line
+		terminated by NL (and NUL where the text has NL).
+								*E5677*
+		Note: system() cannot write to or read from backgrounded ("&")
+		shell commands, e.g.: >
+		    :echo system("cat - &", "foo")
+<		which is equivalent to: >
+		    $ echo foo | bash -c 'cat - &'
+<		The pipes are disconnected (unless overridden by shell
+		redirection syntax) before input can reach it. Use
+		|jobstart()| instead.
+
+		Note: Use |shellescape()| or |::S| with |expand()| or
+		|fnamemodify()| to escape special characters in a command
+		argument. 'shellquote' and 'shellxquote' must be properly
+		configured. Example: >
+		    :echo system('ls '..shellescape(expand('%:h')))
+		    :echo system('ls '..expand('%:h:S'))
+
+<		Unlike ":!cmd" there is no automatic check for changed files.
+		Use |:checktime| to force a check.
+
+		Can also be used as a |method|: >
+			:echo GetCmd()->system()
+
+systemlist({cmd} [, {input} [, {keepempty}]])		*systemlist()*
+		Same as |system()|, but returns a |List| with lines (parts of
+		output separated by NL) with NULs transformed into NLs. Output
+		is the same as |readfile()| will output with {binary} argument
+		set to "b", except that a final newline is not preserved,
+		unless {keepempty} is non-zero.
+		Note that on MS-Windows you may get trailing CR characters.
+
+		To see the difference between "echo hello" and "echo -n hello"
+		use |system()| and |split()|: >
+			echo split(system('echo hello'), '\n', 1)
+<
+		Returns an empty string on error.
+
+		Can also be used as a |method|: >
+			:echo GetCmd()->systemlist()
+
+tabpagebuflist([{arg}])					*tabpagebuflist()*
+		The result is a |List|, where each item is the number of the
+		buffer associated with each window in the current tab page.
+		{arg} specifies the number of the tab page to be used. When
+		omitted the current tab page is used.
+		When {arg} is invalid the number zero is returned.
+		To get a list of all buffers in all tabs use this: >
+			let buflist = []
+			for i in range(tabpagenr('$'))
+			   call extend(buflist, tabpagebuflist(i + 1))
+			endfor
+<		Note that a buffer may appear in more than one window.
+
+		Can also be used as a |method|: >
+			GetTabpage()->tabpagebuflist()
+
+tabpagenr([{arg}])					*tabpagenr()*
+		The result is a Number, which is the number of the current
+		tab page.  The first tab page has number 1.
+
+		The optional argument {arg} supports the following values:
+			$	the number of the last tab page (the tab page
+				count).
+			#	the number of the last accessed tab page
+				(where |g<Tab>| goes to).  If there is no
+				previous tab page, 0 is returned.
+		The number can be used with the |:tab| command.
+
+		Returns zero on error.
+
+tabpagewinnr({tabarg} [, {arg}])			*tabpagewinnr()*
+		Like |winnr()| but for tab page {tabarg}.
+		{tabarg} specifies the number of tab page to be used.
+		{arg} is used like with |winnr()|:
+		- When omitted the current window number is returned.  This is
+		  the window which will be used when going to this tab page.
+		- When "$" the number of windows is returned.
+		- When "#" the previous window nr is returned.
+		Useful examples: >
+		    tabpagewinnr(1)	    " current window of tab page 1
+		    tabpagewinnr(4, '$')    " number of windows in tab page 4
+<		When {tabarg} is invalid zero is returned.
+
+		Can also be used as a |method|: >
+			GetTabpage()->tabpagewinnr()
+<
+							*tagfiles()*
+tagfiles()	Returns a |List| with the file names used to search for tags
+		for the current buffer.  This is the 'tags' option expanded.
+
+
+taglist({expr} [, {filename}])				*taglist()*
+		Returns a |List| of tags matching the regular expression {expr}.
+
+		If {filename} is passed it is used to prioritize the results
+		in the same way that |:tselect| does. See |tag-priority|.
+		{filename} should be the full path of the file.
+
+		Each list item is a dictionary with at least the following
+		entries:
+			name		Name of the tag.
+			filename	Name of the file where the tag is
+					defined.  It is either relative to the
+					current directory or a full path.
+			cmd		Ex command used to locate the tag in
+					the file.
+			kind		Type of the tag.  The value for this
+					entry depends on the language specific
+					kind values.  Only available when
+					using a tags file generated by
+					Universal/Exuberant ctags or hdrtag.
+			static		A file specific tag.  Refer to
+					|static-tag| for more information.
+		More entries may be present, depending on the content of the
+		tags file: access, implementation, inherits and signature.
+		Refer to the ctags documentation for information about these
+		fields.  For C code the fields "struct", "class" and "enum"
+		may appear, they give the name of the entity the tag is
+		contained in.
+
+		The ex-command "cmd" can be either an ex search pattern, a
+		line number or a line number followed by a byte number.
+
+		If there are no matching tags, then an empty list is returned.
+
+		To get an exact tag match, the anchors '^' and '$' should be
+		used in {expr}.  This also make the function work faster.
+		Refer to |tag-regexp| for more information about the tag
+		search regular expression pattern.
+
+		Refer to |'tags'| for information about how the tags file is
+		located by Vim. Refer to |tags-file-format| for the format of
+		the tags file generated by the different ctags tools.
+
+		Can also be used as a |method|: >
+			GetTagpattern()->taglist()
+
+tempname()					*tempname()* *temp-file-name*
+		The result is a String, which is the name of a file that
+		doesn't exist.  It can be used for a temporary file.  Example: >
+			:let tmpfile = tempname()
+			:exe "redir > " .. tmpfile
+<		For Unix, the file will be in a private directory |tempfile|.
+		For MS-Windows forward slashes are used when the 'shellslash'
+		option is set or when 'shellcmdflag' starts with '-'.
+
+termopen({cmd} [, {opts}])			*termopen()*
+		Spawns {cmd} in a new pseudo-terminal session connected
+		to the current (unmodified) buffer. Parameters and behavior
+		are the same as |jobstart()| except "pty", "width", "height",
+		and "TERM" are ignored: "height" and "width" are taken from
+		the current window.
+		Returns the same values as |jobstart()|.
+
+		Terminal environment is initialized as in ||jobstart-env|,
+		except $TERM is set to "xterm-256color". Full behavior is
+		described in |terminal|.
+
+tan({expr})						*tan()*
+		Return the tangent of {expr}, measured in radians, as a |Float|
+		in the range [-inf, inf].
+		{expr} must evaluate to a |Float| or a |Number|.
+		Returns 0.0 if {expr} is not a |Float| or a |Number|.
+		Examples: >
+			:echo tan(10)
+<			0.648361 >
+			:echo tan(-4.01)
+<			-1.181502
+
+		Can also be used as a |method|: >
+			Compute()->tan()
+
+tanh({expr})						*tanh()*
+		Return the hyperbolic tangent of {expr} as a |Float| in the
+		range [-1, 1].
+		{expr} must evaluate to a |Float| or a |Number|.
+		Returns 0.0 if {expr} is not a |Float| or a |Number|.
+		Examples: >
+			:echo tanh(0.5)
+<			0.462117 >
+			:echo tanh(-1)
+<			-0.761594
+
+		Can also be used as a |method|: >
+			Compute()->tanh()
+<
+							*timer_info()*
+timer_info([{id}])
+		Return a list with information about timers.
+		When {id} is given only information about this timer is
+		returned.  When timer {id} does not exist an empty list is
+		returned.
+		When {id} is omitted information about all timers is returned.
+
+		For each timer the information is stored in a |Dictionary| with
+		these items:
+		    "id"	    the timer ID
+		    "time"	    time the timer was started with
+		    "repeat"	    number of times the timer will still fire;
+				    -1 means forever
+		    "callback"	    the callback
+
+		Can also be used as a |method|: >
+			GetTimer()->timer_info()
+<
+timer_pause({timer}, {paused})				*timer_pause()*
+		Pause or unpause a timer.  A paused timer does not invoke its
+		callback when its time expires.  Unpausing a timer may cause
+		the callback to be invoked almost immediately if enough time
+		has passed.
+
+		Pausing a timer is useful to avoid the callback to be called
+		for a short time.
+
+		If {paused} evaluates to a non-zero Number or a non-empty
+		String, then the timer is paused, otherwise it is unpaused.
+		See |non-zero-arg|.
+
+		Can also be used as a |method|: >
+			GetTimer()->timer_pause(1)
+<
+						*timer_start()* *timer* *timers*
+timer_start({time}, {callback} [, {options}])
+		Create a timer and return the timer ID.
+
+		{time} is the waiting time in milliseconds. This is the
+		minimum time before invoking the callback.  When the system is
+		busy or Vim is not waiting for input the time will be longer.
+
+		{callback} is the function to call.  It can be the name of a
+		function or a |Funcref|.  It is called with one argument, which
+		is the timer ID.  The callback is only invoked when Vim is
+		waiting for input.
+
+		{options} is a dictionary.  Supported entries:
+		   "repeat"	Number of times to repeat the callback.
+				-1 means forever.  Default is 1.
+				If the timer causes an error three times in a
+				row the repeat is cancelled.
+
+		Returns -1 on error.
+
+		Example: >
+			func MyHandler(timer)
+			  echo 'Handler called'
+			endfunc
+			let timer = timer_start(500, 'MyHandler',
+				\ {'repeat': 3})
+<		This invokes MyHandler() three times at 500 msec intervals.
+
+		Can also be used as a |method|: >
+			GetMsec()->timer_start(callback)
+
+<		Not available in the |sandbox|.
+
+timer_stop({timer})					*timer_stop()*
+		Stop a timer.  The timer callback will no longer be invoked.
+		{timer} is an ID returned by timer_start(), thus it must be a
+		Number.  If {timer} does not exist there is no error.
+
+		Can also be used as a |method|: >
+			GetTimer()->timer_stop()
+<
+timer_stopall()						*timer_stopall()*
+		Stop all timers.  The timer callbacks will no longer be
+		invoked.  Useful if some timers is misbehaving.  If there are
+		no timers there is no error.
+
+tolower({expr})						*tolower()*
+		The result is a copy of the String given, with all uppercase
+		characters turned into lowercase (just like applying |gu| to
+		the string).  Returns an empty string on error.
+
+		Can also be used as a |method|: >
+			GetText()->tolower()
+
+toupper({expr})						*toupper()*
+		The result is a copy of the String given, with all lowercase
+		characters turned into uppercase (just like applying |gU| to
+		the string).  Returns an empty string on error.
+
+		Can also be used as a |method|: >
+			GetText()->toupper()
+
+tr({src}, {fromstr}, {tostr})				*tr()*
+		The result is a copy of the {src} string with all characters
+		which appear in {fromstr} replaced by the character in that
+		position in the {tostr} string.  Thus the first character in
+		{fromstr} is translated into the first character in {tostr}
+		and so on.  Exactly like the unix "tr" command.
+		This code also deals with multibyte characters properly.
+
+		Returns an empty string on error.
+
+		Examples: >
+			echo tr("hello there", "ht", "HT")
+<		returns "Hello THere" >
+			echo tr("<blob>", "<>", "{}")
+<		returns "{blob}"
+
+		Can also be used as a |method|: >
+			GetText()->tr(from, to)
+
+trim({text} [, {mask} [, {dir}]])				*trim()*
+		Return {text} as a String where any character in {mask} is
+		removed from the beginning and/or end of {text}.
+		If {mask} is not given, {mask} is all characters up to 0x20,
+		which includes Tab, space, NL and CR, plus the non-breaking
+		space character 0xa0.
+		The optional {dir} argument specifies where to remove the
+		characters:
+			0	remove from the beginning and end of {text}
+			1	remove only at the beginning of {text}
+			2	remove only at the end of {text}
+		When omitted both ends are trimmed.
+		This function deals with multibyte characters properly.
+		Returns an empty string on error.
+
+		Examples: >
+			echo trim("   some text ")
+<		returns "some text" >
+			echo trim("  \r\t\t\r RESERVE \t\n\x0B\xA0") .. "_TAIL"
+<		returns "RESERVE_TAIL" >
+			echo trim("rm<Xrm<>X>rrm", "rm<>")
+<		returns "Xrm<>X" (characters in the middle are not removed) >
+			echo trim("  vim  ", " ", 2)
+<		returns "  vim"
+
+		Can also be used as a |method|: >
+			GetText()->trim()
+
+trunc({expr})							*trunc()*
+		Return the largest integral value with magnitude less than or
+		equal to {expr} as a |Float| (truncate towards zero).
+		{expr} must evaluate to a |Float| or a |Number|.
+		Returns 0.0 if {expr} is not a |Float| or a |Number|.
+		Examples: >
+			echo trunc(1.456)
+<			1.0  >
+			echo trunc(-5.456)
+<			-5.0  >
+			echo trunc(4.0)
+<			4.0
+
+		Can also be used as a |method|: >
+			Compute()->trunc()
+
+type({expr})							*type()*
+		The result is a Number representing the type of {expr}.
+		Instead of using the number directly, it is better to use the
+		v:t_ variable that has the value:
+		        Number:     0 (|v:t_number|)
+			String:     1 (|v:t_string|)
+			Funcref:    2 (|v:t_func|)
+			List:       3 (|v:t_list|)
+			Dictionary: 4 (|v:t_dict|)
+			Float:      5 (|v:t_float|)
+			Boolean:    6 (|v:true| and |v:false|)
+			Null:       7 (|v:null|)
+			Blob:      10 (|v:t_blob|)
+		For backward compatibility, this method can be used: >
+			:if type(myvar) == type(0)
+			:if type(myvar) == type("")
+			:if type(myvar) == type(function("tr"))
+			:if type(myvar) == type([])
+			:if type(myvar) == type({})
+			:if type(myvar) == type(0.0)
+			:if type(myvar) == type(v:true)
+<		In place of checking for |v:null| type it is better to check
+		for |v:null| directly as it is the only value of this type: >
+			:if myvar is v:null
+<               To check if the v:t_ variables exist use this: >
+                        :if exists('v:t_number')
+
+<		Can also be used as a |method|: >
+			mylist->type()
+
+undofile({name})					*undofile()*
+		Return the name of the undo file that would be used for a file
+		with name {name} when writing.  This uses the 'undodir'
+		option, finding directories that exist.  It does not check if
+		the undo file exists.
+		{name} is always expanded to the full path, since that is what
+		is used internally.
+		If {name} is empty undofile() returns an empty string, since a
+		buffer without a file name will not write an undo file.
+		Useful in combination with |:wundo| and |:rundo|.
+
+		Can also be used as a |method|: >
+			GetFilename()->undofile()
+
+undotree()						*undotree()*
+		Return the current state of the undo tree in a dictionary with
+		the following items:
+		  "seq_last"	The highest undo sequence number used.
+		  "seq_cur"	The sequence number of the current position in
+				the undo tree.  This differs from "seq_last"
+				when some changes were undone.
+		  "time_cur"	Time last used for |:earlier| and related
+				commands.  Use |strftime()| to convert to
+				something readable.
+		  "save_last"	Number of the last file write.  Zero when no
+				write yet.
+		  "save_cur"	Number of the current position in the undo
+				tree.
+		  "synced"	Non-zero when the last undo block was synced.
+				This happens when waiting from input from the
+				user.  See |undo-blocks|.
+		  "entries"	A list of dictionaries with information about
+				undo blocks.
+
+		The first item in the "entries" list is the oldest undo item.
+		Each List item is a |Dictionary| with these items:
+		  "seq"		Undo sequence number.  Same as what appears in
+				|:undolist|.
+		  "time"	Timestamp when the change happened.  Use
+				|strftime()| to convert to something readable.
+		  "newhead"	Only appears in the item that is the last one
+				that was added.  This marks the last change
+				and where further changes will be added.
+		  "curhead"	Only appears in the item that is the last one
+				that was undone.  This marks the current
+				position in the undo tree, the block that will
+				be used by a redo command.  When nothing was
+				undone after the last change this item will
+				not appear anywhere.
+		  "save"	Only appears on the last block before a file
+				write.  The number is the write count.  The
+				first write has number 1, the last one the
+				"save_last" mentioned above.
+		  "alt"		Alternate entry.  This is again a List of undo
+				blocks.  Each item may again have an "alt"
+				item.
+
+uniq({list} [, {func} [, {dict}]])			*uniq()* *E882*
+		Remove second and succeeding copies of repeated adjacent
+		{list} items in-place.  Returns {list}.  If you want a list
+		to remain unmodified make a copy first: >
+			:let newlist = uniq(copy(mylist))
+<		The default compare function uses the string representation of
+		each item.  For the use of {func} and {dict} see |sort()|.
+
+		Returns zero if {list} is not a |List|.
+
+		Can also be used as a |method|: >
+			mylist->uniq()
+
+values({dict})						*values()*
+		Return a |List| with all the values of {dict}.  The |List| is
+		in arbitrary order.  Also see |items()| and |keys()|.
+		Returns zero if {dict} is not a |Dict|.
+
+		Can also be used as a |method|: >
+			mydict->values()
+
+virtcol({expr})						*virtcol()*
+		The result is a Number, which is the screen column of the file
+		position given with {expr}.  That is, the last screen position
+		occupied by the character at that position, when the screen
+		would be of unlimited width.  When there is a <Tab> at the
+		position, the returned Number will be the column at the end of
+		the <Tab>.  For example, for a <Tab> in column 1, with 'ts'
+		set to 8, it returns 8. |conceal| is ignored.
+		For the byte position use |col()|.
+		For the use of {expr} see |col()|.
+		When 'virtualedit' is used {expr} can be [lnum, col, off], where
+		"off" is the offset in screen columns from the start of the
+		character.  E.g., a position within a <Tab> or after the last
+		character.  When "off" is omitted zero is used.
+		When Virtual editing is active in the current mode, a position
+		beyond the end of the line can be returned. |'virtualedit'|
+		The accepted positions are:
+		    .	    the cursor position
+		    $	    the end of the cursor line (the result is the
+			    number of displayed characters in the cursor line
+			    plus one)
+		    'x	    position of mark x (if the mark is not set, 0 is
+			    returned)
+		    v       In Visual mode: the start of the Visual area (the
+			    cursor is the end).  When not in Visual mode
+			    returns the cursor position.  Differs from |'<| in
+			    that it's updated right away.
+		Note that only marks in the current file can be used.
+		Examples: >
+  virtcol(".")	   with text "foo^Lbar", with cursor on the "^L", returns 5
+  virtcol("$")	   with text "foo^Lbar", returns 9
+  virtcol("'t")    with text "	  there", with 't at 'h', returns 6
+<		The first column is 1.  0 is returned for an error.
+		A more advanced example that echoes the maximum length of
+		all lines: >
+		    echo max(map(range(1, line('$')), "virtcol([v:val, '$'])"))
+
+<		Can also be used as a |method|: >
+			GetPos()->virtcol()
+
+visualmode([{expr}])						*visualmode()*
+		The result is a String, which describes the last Visual mode
+		used in the current buffer.  Initially it returns an empty
+		string, but once Visual mode has been used, it returns "v",
+		"V", or "<CTRL-V>" (a single CTRL-V character) for
+		character-wise, line-wise, or block-wise Visual mode
+		respectively.
+		Example: >
+			:exe "normal " .. visualmode()
+<		This enters the same Visual mode as before.  It is also useful
+		in scripts if you wish to act differently depending on the
+		Visual mode that was used.
+		If Visual mode is active, use |mode()| to get the Visual mode
+		(e.g., in a |:vmap|).
+		If {expr} is supplied and it evaluates to a non-zero Number or
+		a non-empty String, then the Visual mode will be cleared and
+		the old value is returned.  See |non-zero-arg|.
+
+wait({timeout}, {condition} [, {interval}])			*wait()*
+		Waits until {condition} evaluates to |TRUE|, where {condition}
+		is a |Funcref| or |string| containing an expression.
+
+		{timeout} is the maximum waiting time in milliseconds, -1
+		means forever.
+
+		Condition is evaluated on user events, internal events, and
+		every {interval} milliseconds (default: 200).
+
+		Returns a status integer:
+			0 if the condition was satisfied before timeout
+			-1 if the timeout was exceeded
+			-2 if the function was interrupted (by |CTRL-C|)
+			-3 if an error occurred
+
+wildmenumode()					*wildmenumode()*
+		Returns |TRUE| when the wildmenu is active and |FALSE|
+		otherwise.  See 'wildmenu' and 'wildmode'.
+		This can be used in mappings to handle the 'wildcharm' option
+		gracefully. (Makes only sense with |mapmode-c| mappings).
+
+		For example to make <c-j> work like <down> in wildmode, use: >
+    :cnoremap <expr> <C-j> wildmenumode() ? "\<Down>\<Tab>" : "\<c-j>"
+<
+		(Note, this needs the 'wildcharm' option set appropriately).
+
+win_execute({id}, {command} [, {silent}])		*win_execute()*
+		Like `execute()` but in the context of window {id}.
+		The window will temporarily be made the current window,
+		without triggering autocommands or changing directory.  When
+		executing {command} autocommands will be triggered, this may
+		have unexpected side effects.  Use |:noautocmd| if needed.
+		Example: >
+			call win_execute(winid, 'syntax enable')
+<
+		Can also be used as a |method|, the base is passed as the
+		second argument: >
+			GetCommand()->win_execute(winid)
+
+win_findbuf({bufnr})					*win_findbuf()*
+		Returns a |List| with |window-ID|s for windows that contain
+		buffer {bufnr}.  When there is none the list is empty.
+
+		Can also be used as a |method|: >
+			GetBufnr()->win_findbuf()
+
+win_getid([{win} [, {tab}]])				*win_getid()*
+		Get the |window-ID| for the specified window.
+		When {win} is missing use the current window.
+		With {win} this is the window number.  The top window has
+		number 1.
+		Without {tab} use the current tab, otherwise the tab with
+		number {tab}.  The first tab has number one.
+		Return zero if the window cannot be found.
+
+		Can also be used as a |method|: >
+			GetWinnr()->win_getid()
+
+win_gettype([{nr}])					*win_gettype()*
+		Return the type of the window:
+			"autocmd"	autocommand window. Temporary window
+					used to execute autocommands.
+			"command"	command-line window |cmdwin|
+			(empty)		normal window
+			"loclist"	|location-list-window|
+			"popup"		floating window |api-floatwin|
+			"preview"	preview window |preview-window|
+			"quickfix"	|quickfix-window|
+			"unknown"	window {nr} not found
+
+		When {nr} is omitted return the type of the current window.
+		When {nr} is given return the type of this window by number or
+		|window-ID|.
+
+		Also see the 'buftype' option.
+
+		Can also be used as a |method|: >
+			GetWinid()->win_gettype()
+<
+win_gotoid({expr})					*win_gotoid()*
+		Go to window with ID {expr}.  This may also change the current
+		tabpage.
+		Return TRUE if successful, FALSE if the window cannot be found.
+
+		Can also be used as a |method|: >
+			GetWinid()->win_gotoid()
+
+win_id2tabwin({expr})					*win_id2tabwin()*
+		Return a list with the tab number and window number of window
+		with ID {expr}: [tabnr, winnr].
+		Return [0, 0] if the window cannot be found.
+
+		Can also be used as a |method|: >
+			GetWinid()->win_id2tabwin()
+
+win_id2win({expr})					*win_id2win()*
+		Return the window number of window with ID {expr}.
+		Return 0 if the window cannot be found in the current tabpage.
+
+		Can also be used as a |method|: >
+			GetWinid()->win_id2win()
+
+win_move_separator({nr}, {offset})			*win_move_separator()*
+		Move window {nr}'s vertical separator (i.e., the right border)
+		by {offset} columns, as if being dragged by the mouse. {nr}
+		can be a window number or |window-ID|. A positive {offset}
+		moves right and a negative {offset} moves left. Moving a
+		window's vertical separator will change the width of the
+		window and the width of other windows adjacent to the vertical
+		separator. The magnitude of movement may be smaller than
+		specified (e.g., as a consequence of maintaining
+		'winminwidth'). Returns TRUE if the window can be found and
+		FALSE otherwise.
+		This will fail for the rightmost window and a full-width
+		window, since it has no separator on the right.
+
+		Can also be used as a |method|: >
+			GetWinnr()->win_move_separator(offset)
+
+win_move_statusline({nr}, {offset})			*win_move_statusline()*
+		Move window {nr}'s status line (i.e., the bottom border) by
+		{offset} rows, as if being dragged by the mouse. {nr} can be a
+		window number or |window-ID|. A positive {offset} moves down
+		and a negative {offset} moves up. Moving a window's status
+		line will change the height of the window and the height of
+		other windows adjacent to the status line. The magnitude of
+		movement may be smaller than specified (e.g., as a consequence
+		of maintaining 'winminheight'). Returns TRUE if the window can
+		be found and FALSE otherwise.
+
+		Can also be used as a |method|: >
+			GetWinnr()->win_move_statusline(offset)
+
+win_screenpos({nr})					*win_screenpos()*
+		Return the screen position of window {nr} as a list with two
+		numbers: [row, col].  The first window always has position
+		[1, 1], unless there is a tabline, then it is [2, 1].
+		{nr} can be the window number or the |window-ID|.  Use zero
+		for the current window.
+		Returns [0, 0] if the window cannot be found in the current
+		tabpage.
+
+		Can also be used as a |method|: >
+			GetWinid()->win_screenpos()
+<
+win_splitmove({nr}, {target} [, {options}])		*win_splitmove()*
+		Move the window {nr} to a new split of the window {target}.
+		This is similar to moving to {target}, creating a new window
+		using |:split| but having the same contents as window {nr}, and
+		then closing {nr}.
+
+		Both {nr} and {target} can be window numbers or |window-ID|s.
+		Both must be in the current tab page.
+
+		Returns zero for success, non-zero for failure.
+
+		{options} is a |Dictionary| with the following optional entries:
+		  "vertical"	When TRUE, the split is created vertically,
+				like with |:vsplit|.
+		  "rightbelow"	When TRUE, the split is made below or to the
+				right (if vertical).  When FALSE, it is done
+				above or to the left (if vertical).  When not
+				present, the values of 'splitbelow' and
+				'splitright' are used.
+
+		Can also be used as a |method|: >
+			GetWinid()->win_splitmove(target)
+<
+							*winbufnr()*
+winbufnr({nr})	The result is a Number, which is the number of the buffer
+		associated with window {nr}.  {nr} can be the window number or
+		the |window-ID|.
+		When {nr} is zero, the number of the buffer in the current
+		window is returned.
+		When window {nr} doesn't exist, -1 is returned.
+		Example: >
+  :echo "The file in the current window is " .. bufname(winbufnr(0))
+<
+		Can also be used as a |method|: >
+			FindWindow()->winbufnr()->bufname()
+<
+							*wincol()*
+wincol()	The result is a Number, which is the virtual column of the
+		cursor in the window.  This is counting screen cells from the
+		left side of the window.  The leftmost column is one.
+
+							*windowsversion()*
+windowsversion()
+		The result is a String.  For MS-Windows it indicates the OS
+		version.  E.g, Windows 10 is "10.0", Windows 8 is "6.2",
+		Windows XP is "5.1".  For non-MS-Windows systems the result is
+		an empty string.
+
+winheight({nr})						*winheight()*
+		The result is a Number, which is the height of window {nr}.
+		{nr} can be the window number or the |window-ID|.
+		When {nr} is zero, the height of the current window is
+		returned.  When window {nr} doesn't exist, -1 is returned.
+		An existing window always has a height of zero or more.
+		This excludes any window toolbar line.
+		Examples: >
+  :echo "The current window has " .. winheight(0) .. " lines."
+
+<		Can also be used as a |method|: >
+			GetWinid()->winheight()
+<
+winlayout([{tabnr}])					*winlayout()*
+		The result is a nested List containing the layout of windows
+		in a tabpage.
+
+		Without {tabnr} use the current tabpage, otherwise the tabpage
+		with number {tabnr}. If the tabpage {tabnr} is not found,
+		returns an empty list.
+
+		For a leaf window, it returns:
+			['leaf', {winid}]
+		For horizontally split windows, which form a column, it
+		returns:
+			['col', [{nested list of windows}]]
+		For vertically split windows, which form a row, it returns:
+			['row', [{nested list of windows}]]
+
+		Example: >
+			" Only one window in the tab page
+			:echo winlayout()
+			['leaf', 1000]
+			" Two horizontally split windows
+			:echo winlayout()
+			['col', [['leaf', 1000], ['leaf', 1001]]]
+			" The second tab page, with three horizontally split
+			" windows, with two vertically split windows in the
+			" middle window
+			:echo winlayout(2)
+			['col', [['leaf', 1002], ['row', [['leaf', 1003],
+					    ['leaf', 1001]]], ['leaf', 1000]]]
+<
+		Can also be used as a |method|: >
+			GetTabnr()->winlayout()
+<
+							*winline()*
+winline()	The result is a Number, which is the screen line of the cursor
+		in the window.  This is counting screen lines from the top of
+		the window.  The first line is one.
+		If the cursor was moved the view on the file will be updated
+		first, this may cause a scroll.
+
+							*winnr()*
+winnr([{arg}])	The result is a Number, which is the number of the current
+		window.  The top window has number 1.
+		Returns zero for a popup window.
+
+		The optional argument {arg} supports the following values:
+			$	the number of the last window (the window
+				count).
+			#	the number of the last accessed window (where
+				|CTRL-W_p| goes to).  If there is no previous
+				window or it is in another tab page 0 is
+				returned.
+			{N}j	the number of the Nth window below the
+				current window (where |CTRL-W_j| goes to).
+			{N}k	the number of the Nth window above the current
+				window (where |CTRL-W_k| goes to).
+			{N}h	the number of the Nth window left of the
+				current window (where |CTRL-W_h| goes to).
+			{N}l	the number of the Nth window right of the
+				current window (where |CTRL-W_l| goes to).
+		The number can be used with |CTRL-W_w| and ":wincmd w"
+		|:wincmd|.
+		When {arg} is invalid an error is given and zero is returned.
+		Also see |tabpagewinnr()| and |win_getid()|.
+		Examples: >
+			let window_count = winnr('$')
+			let prev_window = winnr('#')
+			let wnum = winnr('3k')
+
+<		Can also be used as a |method|: >
+			GetWinval()->winnr()
+<
+							*winrestcmd()*
+winrestcmd()	Returns a sequence of |:resize| commands that should restore
+		the current window sizes.  Only works properly when no windows
+		are opened or closed and the current window and tab page is
+		unchanged.
+		Example: >
+			:let cmd = winrestcmd()
+			:call MessWithWindowSizes()
+			:exe cmd
+<
+							*winrestview()*
+winrestview({dict})
+		Uses the |Dictionary| returned by |winsaveview()| to restore
+		the view of the current window.
+		Note: The {dict} does not have to contain all values, that are
+		returned by |winsaveview()|. If values are missing, those
+		settings won't be restored. So you can use: >
+		    :call winrestview({'curswant': 4})
+<
+		This will only set the curswant value (the column the cursor
+		wants to move on vertical movements) of the cursor to column 5
+		(yes, that is 5), while all other settings will remain the
+		same. This is useful, if you set the cursor position manually.
+
+		If you have changed the values the result is unpredictable.
+		If the window size changed the result won't be the same.
+
+		Can also be used as a |method|: >
+			GetView()->winrestview()
+<
+							*winsaveview()*
+winsaveview()	Returns a |Dictionary| that contains information to restore
+		the view of the current window.  Use |winrestview()| to
+		restore the view.
+		This is useful if you have a mapping that jumps around in the
+		buffer and you want to go back to the original view.
+		This does not save fold information.  Use the 'foldenable'
+		option to temporarily switch off folding, so that folds are
+		not opened when moving around. This may have side effects.
+		The return value includes:
+			lnum		cursor line number
+			col		cursor column (Note: the first column
+					zero, as opposed to what getpos()
+					returns)
+			coladd		cursor column offset for 'virtualedit'
+			curswant	column for vertical movement
+			topline		first line in the window
+			topfill		filler lines, only in diff mode
+			leftcol		first column displayed; only used when
+					'wrap' is off
+			skipcol		columns skipped
+		Note that no option values are saved.
+
+
+winwidth({nr})						*winwidth()*
+		The result is a Number, which is the width of window {nr}.
+		{nr} can be the window number or the |window-ID|.
+		When {nr} is zero, the width of the current window is
+		returned.  When window {nr} doesn't exist, -1 is returned.
+		An existing window always has a width of zero or more.
+		Examples: >
+  :echo "The current window has " .. winwidth(0) .. " columns."
+  :if winwidth(0) <= 50
+  :  50 wincmd |
+  :endif
+<		For getting the terminal or screen size, see the 'columns'
+		option.
+
+		Can also be used as a |method|: >
+			GetWinid()->winwidth()
+
+wordcount()						*wordcount()*
+		The result is a dictionary of byte/chars/word statistics for
+		the current buffer.  This is the same info as provided by
+		|g_CTRL-G|
+		The return value includes:
+			bytes		Number of bytes in the buffer
+			chars		Number of chars in the buffer
+			words		Number of words in the buffer
+			cursor_bytes    Number of bytes before cursor position
+					(not in Visual mode)
+			cursor_chars    Number of chars before cursor position
+					(not in Visual mode)
+			cursor_words    Number of words before cursor position
+					(not in Visual mode)
+			visual_bytes    Number of bytes visually selected
+					(only in Visual mode)
+			visual_chars    Number of chars visually selected
+					(only in Visual mode)
+			visual_words    Number of words visually selected
+					(only in Visual mode)
+
+
+							*writefile()*
+writefile({object}, {fname} [, {flags}])
+		When {object} is a |List| write it to file {fname}.  Each list
+		item is separated with a NL.  Each list item must be a String
+		or Number.
+		When {flags} contains "b" then binary mode is used: There will
+		not be a NL after the last list item.  An empty item at the
+		end does cause the last line in the file to end in a NL.
+
+		When {object} is a |Blob| write the bytes to file {fname}
+		unmodified.
+
+		When {flags} contains "a" then append mode is used, lines are
+		appended to the file: >
+			:call writefile(["foo"], "event.log", "a")
+			:call writefile(["bar"], "event.log", "a")
+<
+		When {flags} contains "S" fsync() call is not used, with "s"
+		it is used, 'fsync' option applies by default. No fsync()
+		means that writefile() will finish faster, but writes may be
+		left in OS buffers and not yet written to disk. Such changes
+		will disappear if system crashes before OS does writing.
+
+		All NL characters are replaced with a NUL character.
+		Inserting CR characters needs to be done before passing {list}
+		to writefile().
+		An existing file is overwritten, if possible.
+		When the write fails -1 is returned, otherwise 0.  There is an
+		error message if the file can't be created or when writing
+		fails.
+		Also see |readfile()|.
+		To copy a file byte for byte: >
+			:let fl = readfile("foo", "b")
+			:call writefile(fl, "foocopy", "b")
+
+<		Can also be used as a |method|: >
+			GetText()->writefile("thefile")
+
+xor({expr}, {expr})					*xor()*
+		Bitwise XOR on the two arguments.  The arguments are converted
+		to a number.  A List, Dict or Float argument causes an error.
+		Example: >
+			:let bits = xor(bits, 0x80)
+<
+		Can also be used as a |method|: >
+			:let bits = bits->xor(0x80)
+<
+==============================================================================
+3. Matching a pattern in a String			*string-match*
+
+This is common between several functions. A regexp pattern as explained at
+|pattern| is normally used to find a match in the buffer lines.  When a
+pattern is used to find a match in a String, almost everything works in the
+same way.  The difference is that a String is handled like it is one line.
+When it contains a "\n" character, this is not seen as a line break for the
+pattern.  It can be matched with a "\n" in the pattern, or with ".".  Example:
+>
+	:let a = "aaaa\nxxxx"
+	:echo matchstr(a, "..\n..")
+	aa
+	xx
+	:echo matchstr(a, "a.x")
+	a
+	x
+
+Don't forget that "^" will only match at the first character of the String and
+"$" at the last character of the string.  They don't match after or before a
+"\n".
+
+ vim:tw=78:ts=8:noet:ft=help:norl:
diff --git a/runtime/doc/change.txt b/runtime/doc/change.txt
index 953f097a92..b905f53db7 100644
--- a/runtime/doc/change.txt
+++ b/runtime/doc/change.txt
@@ -42,8 +42,6 @@ For inserting text see |insert.txt|.
 			of the line and [count]-1 more lines [into register
 			x]; synonym for "d$".
 			(not |linewise|)
-			When the '#' flag is in 'cpoptions' the count is
-			ignored.
 
 {Visual}["x]x	or					*v_x* *v_d* *v_<Del>*
 {Visual}["x]d   or
@@ -355,14 +353,14 @@ CTRL-A			Add [count] to the number or alphabetic character at
 
                                                        *v_CTRL-A*
 {Visual}CTRL-A		Add [count] to the number or alphabetic character in
-			the highlighted text.  {not in Vi}
+			the highlighted text.
 
 							*v_g_CTRL-A*
 {Visual}g CTRL-A	Add [count] to the number or alphabetic character in
 			the highlighted text. If several lines are
 		        highlighted, each one will be incremented by an
 			additional [count] (so effectively creating a
-			[count] incrementing sequence).  {not in Vi}
+			[count] incrementing sequence).
 			For Example, if you have this list of numbers:
 				1. ~
 				1. ~
@@ -381,14 +379,14 @@ CTRL-X			Subtract [count] from the number or alphabetic
 
 							*v_CTRL-X*
 {Visual}CTRL-X		Subtract [count] from the number or alphabetic
-			character in the highlighted text.  {not in Vi}
+			character in the highlighted text.
 
 							*v_g_CTRL-X*
 {Visual}g CTRL-X	Subtract [count] from the number or alphabetic
 			character in the highlighted text. If several lines
 			are highlighted, each value will be decremented by an
 			additional [count] (so effectively creating a [count]
-			decrementing sequence).  {not in Vi}
+			decrementing sequence).
 
 The CTRL-A and CTRL-X commands work for (signed) decimal numbers, unsigned
 binary/octal/hexadecimal numbers and alphabetic characters.
@@ -585,7 +583,7 @@ attack or other people reading your file).  When Vim exits the directory and
 all files in it are deleted.  When Vim has the setuid bit set this may cause
 problems, the temp file is owned by the setuid user but the filter command
 probably runs as the original user.
-Directory for temporary files is created in the first suitable directory of:
+Directory for temporary files is created in the first possible directory of:
 	Unix:    $TMPDIR, /tmp, current-dir, $HOME.
 	Windows: $TMPDIR, $TMP, $TEMP, $USERPROFILE, current-dir.
 
@@ -635,6 +633,9 @@ Directory for temporary files is created in the first suitable directory of:
 			actually work differently.  You can use `:&&` to keep
 			the flags.
 
+								*&-default*
+			Mapped to ":&&<CR>" by default. |default-mappings|
+
 								*g&*
 g&			Synonym for `:%s//~/&` (repeat last substitute with
 			last search pattern on all lines with the same flags).
@@ -906,7 +907,7 @@ Consider using a character like "@" or ":".  There is no problem if the result
 of the expression contains the separation character.
 
 Examples: >
-	:s@\n@\="\r" . expand("$HOME") . "\r"@
+	:s@\n@\="\r" .. expand("$HOME") .. "\r"@
 This replaces an end-of-line with a new line containing the value of $HOME. >
 
 	s/E/\="\<Char-0x20ac>"/g
@@ -1018,7 +1019,7 @@ inside of strings can change!  Also see 'softtabstop' option. >
 			in [range] (default: current line |cmdline-ranges|),
 			[into register x].
 
-							*p* *put* *E353*
+						*p* *put* *E353* *E1240*
 ["x]p			Put the text [from register x] after the cursor
 			[count] times.
 
@@ -1065,7 +1066,7 @@ inside of strings can change!  Also see 'softtabstop' option. >
 			the command.  You need to escape the '|' and '"'
 			characters to prevent them from terminating the
 			command.  Example: >
-				:put ='path' . \",/test\"
+				:put ='path' .. \",/test\"
 <			If there is no expression after '=', Vim uses the
 			previous expression.  You can see it with ":dis =".
 
@@ -1118,11 +1119,15 @@ register.  With blockwise selection it also depends on the size of the block
 and whether the corners are on an existing character.  (Implementation detail:
 it actually works by first putting the register after the selection and then
 deleting the selection.)
-The previously selected text is put in the unnamed register.  If you want to
-put the same text into a Visual selection several times you need to use
-another register.  E.g., yank the text to copy, Visually select the text to
-replace and use "0p .  You can repeat this as many times as you like, the
-unnamed register will be changed each time.
+With |p| the previously selected text is put in the unnamed register (and
+possibly the selection and/or clipboard).  This is useful if you want to put
+that text somewhere else.  But you cannot repeat the same change.
+With |P| the unnamed register is not changed (and neither the selection or
+clipboard), you can repeat the same change. But the deleted text cannot be
+used.  If you do need it you can use |p| with another register.  E.g., yank
+the text to copy, Visually select the text to replace and use "0p .  You can
+repeat this as many times as you like, and the unnamed register will be
+changed each time.
 
 When you use a blockwise Visual mode command and yank only a single line into
 a register, a paste on a visual selected area will paste that single line on
@@ -1205,7 +1210,7 @@ to their previous contents.  When the '>' flag is present in 'cpoptions' then
 a line break is inserted before the appended text.
 
 5. Read-only registers ":, ". and "%
-These are '%', '#', ':' and '.'.  You can use them only with the "p", "P",
+These are '%', ':' and '.'.  You can use them only with the "p", "P",
 and ":put" commands and with CTRL-R.
 						*quote_.* *quote.* *E29*
 	".	Contains the last inserted text (the same as what is inserted
@@ -1584,11 +1589,10 @@ You can use the 'formatoptions' option  to influence how Vim formats text.
 can separate the option letters with commas for readability.
 
 letter	 meaning when present in 'formatoptions'    ~
-
 							*fo-t*
-t	Auto-wrap text using textwidth
+t	Auto-wrap text using 'textwidth'
 							*fo-c*
-c	Auto-wrap comments using textwidth, inserting the current comment
+c	Auto-wrap comments using 'textwidth', inserting the current comment
 	leader automatically.
 							*fo-r*
 r	Automatically insert the current comment leader after hitting
@@ -1597,6 +1601,9 @@ r	Automatically insert the current comment leader after hitting
 o	Automatically insert the current comment leader after hitting 'o' or
 	'O' in Normal mode.  In case comment is unwanted in a specific place
 	use CTRL-U to quickly delete it. |i_CTRL-U|
+							*fo-/*
+/	When 'o' is included: do not insert the comment leader for a //
+	comment after a statement, only when // is at the start of the line.
 							*fo-q*
 q	Allow formatting of comments with "gq".
 	Note that formatting will not change blank lines or lines containing
@@ -1659,8 +1666,8 @@ B	When joining lines, don't insert a space between two multibyte
 1	Don't break a line after a one-letter word.  It's broken before it
 	instead (if possible).
 							*fo-]*
-]	Respect textwidth rigorously. With this flag set, no line can be
-	longer than textwidth, unless line-break-prohibition rules make this
+]	Respect 'textwidth' rigorously. With this flag set, no line can be
+	longer than 'textwidth', unless line-break-prohibition rules make this
 	impossible.  Mainly for CJK scripts and works only if 'encoding' is
 	"utf-8".
 							*fo-j*
diff --git a/runtime/doc/channel.txt b/runtime/doc/channel.txt
index e14427494d..d4bed7a5f2 100644
--- a/runtime/doc/channel.txt
+++ b/runtime/doc/channel.txt
@@ -229,12 +229,12 @@ prompt. >
 	  call chansend(g:shell_job, [a:text, ''])
 	endfunc
 
-	" Function handling output from the shell: Added above the prompt.
+	" Function handling output from the shell: Add it above the prompt.
 	func GotOutput(channel, msg, name)
 	  call append(line("$") - 1, a:msg)
 	endfunc
 
-	" Function handling the shell exit: close the window.
+	" Function handling the shell exits: close the window.
 	func JobExit(job, status, event)
 	  quit!
 	endfunc
diff --git a/runtime/doc/cmdline.txt b/runtime/doc/cmdline.txt
index 641cd93386..3f3f1e6ba3 100644
--- a/runtime/doc/cmdline.txt
+++ b/runtime/doc/cmdline.txt
@@ -67,12 +67,19 @@ CTRL-V		Insert next non-digit literally.  Up to three digits form the
 		decimal value of a single byte.  The non-digit and the three
 		digits are not considered for mapping.  This works the same
 		way as in Insert mode (see above, |i_CTRL-V|).
+		For special keys, the CTRL modifier may be included into the
+		key to produce a control character.  If there is no control
+		character for the key then its |key-notation| is inserted.
 		Note: Under Windows CTRL-V is often mapped to paste text.
 		Use CTRL-Q instead then.
 							*c_CTRL-Q*
 CTRL-Q		Same as CTRL-V.  But with some terminals it is used for
 		control flow, it doesn't work then.
 
+CTRL-SHIFT-V				*c_CTRL-SHIFT-V* *c_CTRL-SHIFT-Q*
+CTRL-SHIFT-Q	Works just like CTRL-V, but do not try to include the CTRL
+		modifier into the key.
+
 							*c_<Left>* *c_Left*
 <Left>		cursor left
 							*c_<Right>* *c_Right*
@@ -207,7 +214,7 @@ CTRL-\ e {expr}						*c_CTRL-\_e*
 		Example: >
 			:cmap <F7> <C-\>eAppendSome()<CR>
 			:func AppendSome()
-			   :let cmd = getcmdline() . " Some()"
+			   :let cmd = getcmdline() .. " Some()"
 			   :" place the cursor on the )
 			   :call setcmdpos(strlen(cmd))
 			   :return cmd
@@ -679,7 +686,7 @@ If more line specifiers are given than required for the command, the first
 one(s) will be ignored.
 
 Line numbers may be specified with:		*:range* *{address}*
-	{number}	an absolute line number
+	{number}	an absolute line number  *E1247*
 	.		the current line			  *:.*
 	$		the last line in the file		  *:$*
 	%		equal to 1,$ (the entire file)		  *:%*
@@ -870,7 +877,7 @@ Note: these are typed literally, they are not special keys!
 		   When the match is with a file name, it is expanded to the
  		   full path.
 							*:<sfile>* *<sfile>*
-	<sfile>    When executing a ":source" command, is replaced with the
+	<sfile>    When executing a `:source` command, is replaced with the
 		   file name of the sourced file.  *E498*
 		   When executing a function, is replaced with:
 		   "function {function-name}[{lnum}]"
@@ -879,7 +886,7 @@ Note: these are typed literally, they are not special keys!
 		   Note that filename-modifiers are useless when <sfile> is
 		   used inside a function.
 							*:<slnum>* *<slnum>*
-	<slnum>	   When executing a ":source" command, is replaced with the
+	<slnum>	   When executing a `:source` command, is replaced with the
 		   line number.  *E842*
 		   When executing a function it's the line number relative to
 		   the start of the function.
@@ -908,8 +915,7 @@ These modifiers can be given, in this order:
 		directory.
 	:.	Reduce file name to be relative to current directory, if
 		possible.  File name is unmodified if it is not below the
-		current directory, but on MS-Windows the drive is removed if
-		it is the current drive.
+		current directory.
 		For maximum shortness, use ":~:.".
 	:h	Head of the file name (the last component and any separators
 		removed).  Cannot be used with :e, :r or :t.
@@ -1059,8 +1065,7 @@ line contains the command as typed so far.  The left column will show a
 character that indicates the type of command-line being edited, see
 |cmdwin-char|.
 
-Vim will be in Normal mode when the editor is opened, except when 'insertmode'
-is set.
+Vim will be in Normal mode when the editor is opened.
 
 The height of the window is specified with 'cmdwinheight' (or smaller if there
 is no room).  The window is always full width and is positioned just above the
@@ -1131,8 +1136,8 @@ save the command-line history and read it back later.
 If the 'wildchar' option is set to <Tab>, and the command-line window is used
 for an Ex command, then two mappings will be added to use <Tab> for completion
 in the command-line window, like this: >
-	:imap <buffer> <Tab> <C-X><C-V>
-	:nmap <buffer> <Tab> a<C-X><C-V>
+	:inoremap <buffer> <Tab> <C-X><C-V>
+	:nnoremap <buffer> <Tab> a<C-X><C-V>
 Note that hitting <Tab> in Normal mode will do completion on the next
 character.  That way it works at the end of the line.
 If you don't want these mappings, disable them with: >
diff --git a/runtime/doc/deprecated.txt b/runtime/doc/deprecated.txt
index 21a34178b3..eb6d9b6dc9 100644
--- a/runtime/doc/deprecated.txt
+++ b/runtime/doc/deprecated.txt
@@ -6,9 +6,8 @@
 
 Nvim                                                             *deprecated*
 
-The items listed below are "deprecated". This means they will be removed in
-the future. They should not be used in new scripts, and old scripts should be
-updated.
+The items listed below are deprecated: they will be removed in the future.
+They should not be used in new scripts, and old scripts should be updated.
 
 ==============================================================================
 
@@ -25,8 +24,12 @@ Commands ~
 *:wviminfo*		Deprecated alias to |:wshada| command.
 
 Environment Variables ~
-*$NVIM_LISTEN_ADDRESS*	Deprecated in favor of |--listen|.  If both are given,
-			$NVIM_LISTEN_ADDRESS is ignored.
+*$NVIM_LISTEN_ADDRESS*	Deprecated way to
+			* set the server name (use |--listen| instead)
+			* get the server name (use |v:servername| instead)
+			* detect a parent Nvim (use |$NVIM| instead)
+			Unset by |terminal| and |jobstart()| (unless explicitly
+			given by the "env" option). Ignored if --listen is given.
 
 Events ~
 *BufCreate*		Use |BufAdd| instead.
@@ -55,6 +58,10 @@ Functions ~
 			without stopping the job. Use chanclose(id) to close
 			any socket.
 
+Highlights ~
+
+*hl-VertSplit*		Use |hl-WinSeparator| instead.
+
 LSP Diagnostics ~
 
 For each of the functions below, use the corresponding function in
@@ -99,11 +106,13 @@ internally and are no longer exposed as part of the API. Instead, use
 *vim.lsp.diagnostic.set_underline()*
 *vim.lsp.diagnostic.set_virtual_text()*
 
-LSP Utility Functions ~
+LSP Functions ~
 
 *vim.lsp.util.diagnostics_to_items()*	Use |vim.diagnostic.toqflist()| instead.
 *vim.lsp.util.set_qflist()*		Use |setqflist()| instead.
 *vim.lsp.util.set_loclist()*		Use |setloclist()| instead.
+*vim.lsp.buf_get_clients()*		Use |vim.lsp.get_active_clients()| with
+                                        {buffer = bufnr} instead.
 
 Lua ~
 *vim.register_keystroke_callback()* Use |vim.on_key()| instead.
diff --git a/runtime/doc/dev_style.txt b/runtime/doc/dev_style.txt
index 82f279e781..77253e7831 100644
--- a/runtime/doc/dev_style.txt
+++ b/runtime/doc/dev_style.txt
@@ -48,22 +48,6 @@ The format of the symbol name should be `NVIM_<DIRECTORY>_<FILE>_H`.
 <
 
 
-Names and Order of Includes ~
-
-Use standard order for readability and to avoid hidden dependencies: C
-library, other libraries' `.h`, your project's `.h`.
-
-    In foo.c order your includes as follows:
-
-        1. C system files.
-        2. Other libraries' `.h` files.
-        3. Your project's `.h` files.
-
-    Exception: sometimes, system-specific code needs conditional includes.
-    Such code can put conditional includes after other includes. Of course,
-    keep your system-specific code small and localized.
-
-
 Constants ~
 
 Do not use macros to define constants in headers.
@@ -545,12 +529,12 @@ it is for and how it should be used. >
     };
 
 If the field comments are short, you can also put them next to the field. But
-be consistent within one struct. >
+be consistent within one struct, and follow the necessary doxygen style. >
 
     struct wininfo_S {
-      WinInfo *wi_next;  /// Next entry or NULL for last entry.
-      WinInfo *wi_prev;  /// Previous entry or NULL for first entry.
-      Win *wi_win;       /// Pointer to window that did the wi_fpos.
+      WinInfo *wi_next;  ///< Next entry or NULL for last entry.
+      WinInfo *wi_prev;  ///< Previous entry or NULL for first entry.
+      Win *wi_win;       ///< Pointer to window that did the wi_fpos.
       ...
     };
 
@@ -787,15 +771,6 @@ getting used to, but it is important that all project contributors follow the
 style rules so that they can all read and understand everyone's code easily.
 
 
-Line Length ~
-
-Each line of text in your code should be at most 100 characters long.
-
-Exception: if a comment line contains an example command or a literal URL
-longer than 100 characters, that line may be longer than 100 characters for ease
-of cut and paste.
-
-
 Non-ASCII Characters ~
 
 Non-ASCII characters should be rare, and must use UTF-8 formatting.
@@ -814,11 +789,6 @@ example, `"\uFEFF"`, is the Unicode zero-width no-break space character, which
 would be invisible if included in the source as straight UTF-8.
 
 
-Spaces vs. Tabs ~
-
-Use only spaces, and indent 2 spaces at a time. Do not use tabs in your code.
-
-
 Function Declarations and Definitions ~
 
 Return type on the same line as function name, parameters on the same line if
@@ -928,7 +898,7 @@ no name, assume a zero-length name. >
 
 Conditionals ~
 
-Don't use spaces inside parentheses. Always use curly braces. >
+Don't use spaces inside parentheses. >
 
     if (condition) {  // no spaces inside parentheses
       ...  // 2 space indent.
@@ -938,19 +908,9 @@ Don't use spaces inside parentheses. Always use curly braces. >
       ...
     }
 
-You must have a space between the `if` and the open parenthesis. You must also
-have a space between the close parenthesis and the curly brace, if you're
-using one. >
-
-    if(condition) {   // BAD: space missing after IF.
-    if (condition){   // BAD: space missing before {.
-    if (condition) {  // GOOD: proper space after IF and before {.
-
-
 Loops and Switch Statements ~
 
-Annotate non-trivial fall-through between cases. Empty loop bodies should use
-`{}` or `continue`.
+Annotate non-trivial fall-through between cases.
 
 If not conditional on an enumerated value, switch statements should always
 have a `default` case (in the case of an enumerated value, the compiler will
@@ -958,8 +918,8 @@ warn you if any values are not handled). If the default case should never
 execute, simply `assert`: >
 
     switch (var) {
-      case 0:    // 2 space indent
-        ...      // 4 space indent
+      case 0:
+        ...
         break;
       case 1:
         ...
@@ -968,16 +928,6 @@ execute, simply `assert`: >
         assert(false);
     }
 
-Empty loop bodies should use `{}` or `continue`, but not a single semicolon. >
-
-    while (condition) {
-      // Repeat test until it returns false.
-    }
-    for (int i = 0; i < kSomeNumber; i++) {}  // GOOD: empty body.
-    while (condition) continue;  // GOOD: continue indicates no logic.
-
-    while (condition);  // BAD: looks like part of do/while loop.
-
 Pointer Expressions ~
 
 No spaces around period or arrow. Pointer operators do not have trailing
@@ -996,15 +946,6 @@ Note that:
     - There are no spaces around the period or arrow when accessing a member.
     - Pointer operators have no space after the * or &.
 
-When declaring a pointer variable or argument, place the asterisk adjacent to
-the variable name: >
-
-    char *c;
-
-    char * c;  // BAD: spaces on both sides of *
-    char* c;   // BAD
-
-
 Boolean Expressions ~
 
 When you have a boolean expression that is longer than the standard line
@@ -1034,48 +975,12 @@ expr;`. >
     return(result);  // return is not a function!
 
 
-Preprocessor Directives ~
-
-The hash mark that starts a preprocessor directive should always be at the
-beginning of the line.
-
-Even when preprocessor directives are within the body of indented code, the
-directives should start at the beginning of the line.
-
-Nested directives should add one spaces after the hash mark for each level of
-indentation. 
-
-    // GOOD: directives at beginning of line >
-      if (lopsided_score) {
-    #if DISASTER_PENDING      // Correct -- Starts at beginning of line
-        drop_everything();
-    # if NOTIFY               // One space after #
-        notify_client();
-    # endif
-    #endif
-        BackToNormal();
-      }
-
-<    // BAD: indented directives >
-      if (lopsided_score) {
-        #if DISASTER_PENDING  // Wrong!  The "#if" should be at beginning of line
-        drop_everything();
-        #endif                // Wrong!  Do not indent "#endif"
-        back_to_normal();
-      }
-
-
 Horizontal Whitespace ~
 
-Use of horizontal whitespace depends on location. Never put trailing
-whitespace at the end of a line.
+Use of horizontal whitespace depends on location.
 
     General ~
 >
-        if (x) {          // Open braces should always have a space before them.
-          ...
-        }
-        int i = 0;        // Semicolons usually have no space before them.
         int x[] = { 0 };  // Spaces inside braces for braced-init-list.
 <
 
@@ -1095,29 +1000,6 @@ whitespace at the end of a line.
         };
 <
 
-    Macros ~
->
-        #define FI(x) \  // Don't align \'s in macro definitions.
-          foo();      \
-          bar();      \
-          ...
-<
-
-    Loops and Conditionals ~
->
-        if (b) {              // Space after the keyword in condition.
-        } else {              // Spaces around else.
-        }
-        while (test) {}       // There is usually no space inside parentheses.
-        for (; i < 5; i++) {  // For loops always have a space after the
-          ...                 // semicolon and no a space before the
-          ...                 // semicolon.
-        }
-        switch (i) {
-          case 1:             // No space before colon in a switch case.
-            ...
-          case 2: break;      // Space after a colon if there's code after it.
-<
 
     Operators ~
 >
@@ -1127,8 +1009,6 @@ whitespace at the end of a line.
         x++;              // arguments.
         if (x && !y)
           ...
-        v = w*x + y/z;    // Use spaces to indicate operator precedence.
-        v = w * (x + z);  // Parentheses should have no spaces inside them.
         i = (int)d;       // No spaces after a cast operator.
 <
 
@@ -1136,12 +1016,6 @@ Vertical Whitespace ~
 
 Minimize use of vertical whitespace.
 
-This is more a principle than a rule: don't use blank lines when you don't
-have to. In particular, don't put more than one or two blank lines between
-functions, resist starting functions with a blank line, don't end functions
-with a blank line, and be discriminating with your use of blank lines inside
-functions.
-
 The basic principle is: The more code that fits on one screen, the easier it
 is to follow and understand the control flow of the program. Of course,
 readability can suffer from code being too dense as well as too spread out, so
diff --git a/runtime/doc/develop.txt b/runtime/doc/develop.txt
index 178b0dc62b..b31ac47bda 100644
--- a/runtime/doc/develop.txt
+++ b/runtime/doc/develop.txt
@@ -204,7 +204,7 @@ Docstring format:
 - Use `<pre>`  for code samples.
 
 Example: the help for |vim.paste()| is generated from a docstring decorating
-vim.paste in src/nvim/lua/vim.lua like this: >
+vim.paste in runtime/lua/vim/_editor.lua like this: >
 
     --- Paste handler, invoked by |nvim_paste()| when a conforming UI
     --- (such as the |TUI|) pastes text into the editor.
@@ -243,12 +243,13 @@ If the function acts on an object then {thing} is the name of that object
 with a {thing} that groups functions under a common concept).
 
 Use existing common {action} names if possible:
-    add   Append to, or insert into, a collection
-    del   Delete a thing (or group of things)
-    exec  Execute code
-    get   Get a thing (or group of things by query)
-    list  Get all things
-    set   Set a thing (or group of things)
+    add     Append to, or insert into, a collection
+    create  Create a new thing
+    del     Delete a thing (or group of things)
+    exec    Execute code
+    get     Get a thing (or group of things by query)
+    list    Get all things
+    set     Set a thing (or group of things)
 
 Use consistent names for {thing} in all API functions. E.g. a buffer is called
 "buf" everywhere, not "buffer" in some places and "buf" in others.
diff --git a/runtime/doc/diagnostic.txt b/runtime/doc/diagnostic.txt
index bb36fa46f6..2446506dec 100644
--- a/runtime/doc/diagnostic.txt
+++ b/runtime/doc/diagnostic.txt
@@ -39,16 +39,18 @@ modify the diagnostics for a buffer (e.g. |vim.diagnostic.set()|) then it
 requires a namespace.
 
 							*diagnostic-structure*
-A diagnostic is a Lua table with the following keys:
+A diagnostic is a Lua table with the following keys. Required keys are
+indicated with (*):
 
 	bufnr: Buffer number
-	lnum: The starting line of the diagnostic
+	lnum(*): The starting line of the diagnostic
 	end_lnum: The final line of the diagnostic
-	col: The starting column of the diagnostic
+	col(*): The starting column of the diagnostic
 	end_col: The final column of the diagnostic
 	severity: The severity of the diagnostic |vim.diagnostic.severity|
-	message: The diagnostic text
+	message(*): The diagnostic text
 	source: The source of the diagnostic
+	code: The diagnostic code
 	user_data: Arbitrary data plugins or users can add
 
 Diagnostics use the same indexing as the rest of the Nvim API (i.e. 0-based
@@ -72,7 +74,7 @@ Functions that take a severity as an optional parameter (e.g.
 
 2. A table with a "min" or "max" key (or both): >
 
-	vim.diagnostic.get(0, { severity = {min=vim.diagnostic.severity.WARN})
+	vim.diagnostic.get(0, { severity = {min=vim.diagnostic.severity.WARN} })
 
 The latter form allows users to specify a range of severities.
 
@@ -326,16 +328,17 @@ config({opts}, {namespace})                          *vim.diagnostic.config()*
                 Note:
                     Each of the configuration options below accepts one of the
                     following:
-                    • `false` : Disable this feature
-                    • `true` : Enable this feature, use default settings.
-                    • `table` : Enable this feature with overrides. Use an
+                    • `false`: Disable this feature
+                    • `true`: Enable this feature, use default settings.
+                    • `table`: Enable this feature with overrides. Use an
                       empty table to use default values.
-                    • `function` : Function with signature (namespace, bufnr)
+                    • `function`: Function with signature (namespace, bufnr)
                       that returns any of the above.
 
                 Parameters: ~
-                    {opts}       table Configuration table with the following
-                                 keys:
+                    {opts}       (table|nil) When omitted or "nil", retrieve
+                                 the current configuration. Otherwise, a
+                                 configuration table with the following keys:
                                  • underline: (default true) Use underline for
                                    diagnostics. Options:
                                    • severity: Only underline diagnostics
@@ -398,7 +401,7 @@ config({opts}, {namespace})                          *vim.diagnostic.config()*
                                    displayed before lower severities (e.g.
                                    ERROR is displayed before WARN). Options:
                                    • reverse: (boolean) Reverse sort order
-                    {namespace}  number|nil Update the options for the given
+                    {namespace}  (number|nil) Update the options for the given
                                  namespace. When omitted, update the global
                                  diagnostic options.
 
@@ -406,28 +409,28 @@ disable({bufnr}, {namespace})                       *vim.diagnostic.disable()*
                 Disable diagnostics in the given buffer.
 
                 Parameters: ~
-                    {bufnr}      number|nil Buffer number, or 0 for current
+                    {bufnr}      (number|nil) Buffer number, or 0 for current
                                  buffer. When omitted, disable diagnostics in
                                  all buffers.
-                    {namespace}  number|nil Only disable diagnostics for the
+                    {namespace}  (number|nil) Only disable diagnostics for the
                                  given namespace.
 
 enable({bufnr}, {namespace})                         *vim.diagnostic.enable()*
                 Enable diagnostics in the given buffer.
 
                 Parameters: ~
-                    {bufnr}      number|nil Buffer number, or 0 for current
+                    {bufnr}      (number|nil) Buffer number, or 0 for current
                                  buffer. When omitted, enable diagnostics in
                                  all buffers.
-                    {namespace}  number|nil Only enable diagnostics for the
+                    {namespace}  (number|nil) Only enable diagnostics for the
                                  given namespace.
 
 fromqflist({list})                               *vim.diagnostic.fromqflist()*
                 Convert a list of quickfix items to a list of diagnostics.
 
                 Parameters: ~
-                    {list}  table A list of quickfix items from |getqflist()|
-                            or |getloclist()|.
+                    {list}  (table) A list of quickfix items from
+                            |getqflist()| or |getloclist()|.
 
                 Return: ~
                     array of diagnostics |diagnostic-structure|
@@ -436,9 +439,10 @@ get({bufnr}, {opts})                                    *vim.diagnostic.get()*
                 Get current diagnostics.
 
                 Parameters: ~
-                    {bufnr}  number|nil Buffer number to get diagnostics from.
-                             Use 0 for current buffer or nil for all buffers.
-                    {opts}   table|nil A table with the following keys:
+                    {bufnr}  (number|nil) Buffer number to get diagnostics
+                             from. Use 0 for current buffer or nil for all
+                             buffers.
+                    {opts}   (table|nil) A table with the following keys:
                              • namespace: (number) Limit diagnostics to the
                                given namespace.
                              • lnum: (number) Limit diagnostics to the given
@@ -446,67 +450,68 @@ get({bufnr}, {opts})                                    *vim.diagnostic.get()*
                              • severity: See |diagnostic-severity|.
 
                 Return: ~
-                    table A list of diagnostic items |diagnostic-structure|.
+                    (table) A list of diagnostic items |diagnostic-structure|.
 
 get_namespace({namespace})                    *vim.diagnostic.get_namespace()*
                 Get namespace metadata.
 
                 Parameters: ~
-                    {namespace}  number Diagnostic namespace
+                    {namespace}  (number) Diagnostic namespace
 
                 Return: ~
-                    table Namespace metadata
+                    (table) Namespace metadata
 
 get_namespaces()                             *vim.diagnostic.get_namespaces()*
                 Get current diagnostic namespaces.
 
                 Return: ~
-                    table A list of active diagnostic namespaces
+                    (table) A list of active diagnostic namespaces
                     |vim.diagnostic|.
 
 get_next({opts})                                   *vim.diagnostic.get_next()*
                 Get the next diagnostic closest to the cursor position.
 
                 Parameters: ~
-                    {opts}  table See |vim.diagnostic.goto_next()|
+                    {opts}  (table) See |vim.diagnostic.goto_next()|
 
                 Return: ~
-                    table Next diagnostic
+                    (table) Next diagnostic
 
 get_next_pos({opts})                           *vim.diagnostic.get_next_pos()*
                 Return the position of the next diagnostic in the current
                 buffer.
 
                 Parameters: ~
-                    {opts}  table See |vim.diagnostic.goto_next()|
+                    {opts}  (table) See |vim.diagnostic.goto_next()|
 
                 Return: ~
-                    table Next diagnostic position as a (row, col) tuple.
+                    (table) Next diagnostic position as a (row, col) tuple.
 
 get_prev({opts})                                   *vim.diagnostic.get_prev()*
                 Get the previous diagnostic closest to the cursor position.
 
                 Parameters: ~
-                    {opts}  table See |vim.diagnostic.goto_next()|
+                    {opts}  (table) See |vim.diagnostic.goto_next()|
 
                 Return: ~
-                    table Previous diagnostic
+                    (table) Previous diagnostic
 
 get_prev_pos({opts})                           *vim.diagnostic.get_prev_pos()*
                 Return the position of the previous diagnostic in the current
                 buffer.
 
                 Parameters: ~
-                    {opts}  table See |vim.diagnostic.goto_next()|
+                    {opts}  (table) See |vim.diagnostic.goto_next()|
 
                 Return: ~
-                    table Previous diagnostic position as a (row, col) tuple.
+                    (table) Previous diagnostic position as a (row, col)
+                    tuple.
 
 goto_next({opts})                                 *vim.diagnostic.goto_next()*
                 Move to the next diagnostic.
 
                 Parameters: ~
-                    {opts}  table|nil Configuration table with the following
+                    {opts}  (table|nil) Configuration table with the following
                             keys:
                             • namespace: (number) Only consider diagnostics
                               from the given namespace.
@@ -530,7 +535,7 @@ goto_prev({opts})                                 *vim.diagnostic.goto_prev()*
                 Move to the previous diagnostic in the current buffer.
 
                 Parameters: ~
-                    {opts}  table See |vim.diagnostic.goto_next()|
+                    {opts}  (table) See |vim.diagnostic.goto_next()|
 
 hide({namespace}, {bufnr})                             *vim.diagnostic.hide()*
                 Hide currently displayed diagnostics.
@@ -544,10 +549,10 @@ hide({namespace}, {bufnr})                             *vim.diagnostic.hide()*
                 |vim.diagnostic.disable()|.
 
                 Parameters: ~
-                    {namespace}  number|nil Diagnostic namespace. When
+                    {namespace}  (number|nil) Diagnostic namespace. When
                                  omitted, hide diagnostics from all
                                  namespaces.
-                    {bufnr}      number|nil Buffer number, or 0 for current
+                    {bufnr}      (number|nil) Buffer number, or 0 for current
                                  buffer. When omitted, hide diagnostics in all
                                  buffers.
 
@@ -570,16 +575,16 @@ match({str}, {pat}, {groups}, {severity_map}, {defaults})
 <
 
                 Parameters: ~
-                    {str}           string String to parse diagnostics from.
-                    {pat}           string Lua pattern with capture groups.
-                    {groups}        table List of fields in a
+                    {str}           (string) String to parse diagnostics from.
+                    {pat}           (string) Lua pattern with capture groups.
+                    {groups}        (table) List of fields in a
                                     |diagnostic-structure| to associate with
                                     captures from {pat}.
-                    {severity_map}  table A table mapping the severity field
+                    {severity_map}  (table) A table mapping the severity field
                                     from {groups} with an item from
                                     |vim.diagnostic.severity|.
-                    {defaults}      table|nil Table of default values for any
-                                    fields not listed in {groups}. When
+                    {defaults}      (table|nil) Table of default values for
+                                    any fields not listed in {groups}. When
                                     omitted, numeric values default to 0 and
                                     "severity" defaults to ERROR.
 
@@ -591,7 +596,7 @@ open_float({opts}, {...})                        *vim.diagnostic.open_float()*
                 Show diagnostics in a floating window.
 
                 Parameters: ~
-                    {opts}  table|nil Configuration table with the same keys
+                    {opts}  (table|nil) Configuration table with the same keys
                             as |vim.lsp.util.open_floating_preview()| in
                             addition to the following:
                             • bufnr: (number) Buffer number to show
@@ -662,10 +667,10 @@ reset({namespace}, {bufnr})                           *vim.diagnostic.reset()*
                 |vim.diagnostic.hide()|.
 
                 Parameters: ~
-                    {namespace}  number|nil Diagnostic namespace. When
+                    {namespace}  (number|nil) Diagnostic namespace. When
                                  omitted, remove diagnostics from all
                                  namespaces.
-                    {bufnr}      number|nil Remove diagnostics for the given
+                    {bufnr}      (number|nil) Remove diagnostics for the given
                                  buffer. When omitted, diagnostics are removed
                                  for all buffers.
 
@@ -673,18 +678,18 @@ set({namespace}, {bufnr}, {diagnostics}, {opts})        *vim.diagnostic.set()*
                 Set diagnostics for the given namespace and buffer.
 
                 Parameters: ~
-                    {namespace}    number The diagnostic namespace
-                    {bufnr}        number Buffer number
-                    {diagnostics}  table A list of diagnostic items
+                    {namespace}    (number) The diagnostic namespace
+                    {bufnr}        (number) Buffer number
+                    {diagnostics}  (table) A list of diagnostic items
                                    |diagnostic-structure|
-                    {opts}         table|nil Display options to pass to
+                    {opts}         (table|nil) Display options to pass to
                                    |vim.diagnostic.show()|
 
 setloclist({opts})                               *vim.diagnostic.setloclist()*
                 Add buffer diagnostics to the location list.
 
                 Parameters: ~
-                    {opts}  table|nil Configuration table with the following
+                    {opts}  (table|nil) Configuration table with the following
                             keys:
                             • namespace: (number) Only add diagnostics from
                               the given namespace.
@@ -700,7 +705,7 @@ setqflist({opts})                                 *vim.diagnostic.setqflist()*
                 Add all diagnostics to the quickfix list.
 
                 Parameters: ~
-                    {opts}  table|nil Configuration table with the following
+                    {opts}  (table|nil) Configuration table with the following
                             keys:
                             • namespace: (number) Only add diagnostics from
                               the given namespace.
@@ -715,20 +720,20 @@ show({namespace}, {bufnr}, {diagnostics}, {opts})
                 Display diagnostics for the given namespace and buffer.
 
                 Parameters: ~
-                    {namespace}    number|nil Diagnostic namespace. When
+                    {namespace}    (number|nil) Diagnostic namespace. When
                                    omitted, show diagnostics from all
                                    namespaces.
-                    {bufnr}        number|nil Buffer number, or 0 for current
-                                   buffer. When omitted, show diagnostics in
-                                   all buffers.
-                    {diagnostics}  table|nil The diagnostics to display. When
-                                   omitted, use the saved diagnostics for the
-                                   given namespace and buffer. This can be
+                    {bufnr}        (number|nil) Buffer number, or 0 for
+                                   current buffer. When omitted, show
+                                   diagnostics in all buffers.
+                    {diagnostics}  (table|nil) The diagnostics to display.
+                                   When omitted, use the saved diagnostics for
+                                   the given namespace and buffer. This can be
                                    used to display a list of diagnostics
                                    without saving them or to display only a
                                    subset of diagnostics. May not be used when
                                    {namespace} or {bufnr} is nil.
-                    {opts}         table|nil Display options. See
+                    {opts}         (table|nil) Display options. See
                                    |vim.diagnostic.config()|.
 
 toqflist({diagnostics})                            *vim.diagnostic.toqflist()*
@@ -736,7 +741,7 @@ toqflist({diagnostics})                            *vim.diagnostic.toqflist()*
                 can be passed to |setqflist()| or |setloclist()|.
 
                 Parameters: ~
-                    {diagnostics}  table List of diagnostics
+                    {diagnostics}  (table) List of diagnostics
                                    |diagnostic-structure|.
 
                 Return: ~
diff --git a/runtime/doc/diff.txt b/runtime/doc/diff.txt
index 6115a5d235..9c5792dd43 100644
--- a/runtime/doc/diff.txt
+++ b/runtime/doc/diff.txt
@@ -324,8 +324,9 @@ After setting this variable, reload the syntax script: >
 
 FINDING THE DIFFERENCES					*diff-diffexpr*
 
-The 'diffexpr' option can be set to use something else than the standard
-"diff" program to compare two files and find the differences. *E959*
+The 'diffexpr' option can be set to use something else than the internal diff
+support or the standard "diff" program to compare two files and find the
+differences.
 
 When 'diffexpr' is empty, Vim uses this command to find the differences
 between file1 and file2: >
@@ -358,7 +359,7 @@ format mentioned.  These variables are set to the file names used:
 
 	v:fname_in		original file
 	v:fname_new		new version of the same file
-	v:fname_out		resulting diff file
+	v:fname_out		where to write the resulting diff file
 
 Additionally, 'diffexpr' should take care of "icase" and "iwhite" in the
 'diffopt' option.  'diffexpr' cannot change the value of 'lines' and
@@ -370,13 +371,13 @@ Example (this does almost the same as 'diffexpr' being empty): >
 	function MyDiff()
 	   let opt = ""
 	   if &diffopt =~ "icase"
-	     let opt = opt . "-i "
+	     let opt = opt .. "-i "
 	   endif
 	   if &diffopt =~ "iwhite"
-	     let opt = opt . "-b "
+	     let opt = opt .. "-b "
 	   endif
-	   silent execute "!diff -a --binary " . opt . v:fname_in . " " . v:fname_new .
-		\  " > " . v:fname_out
+	   silent execute "!diff -a --binary " .. opt .. v:fname_in .. " " .. v:fname_new ..
+		\  " > " .. v:fname_out
 	   redraw!
 	endfunction
 
@@ -426,8 +427,8 @@ Example (this does the same as 'patchexpr' being empty): >
 
 	set patchexpr=MyPatch()
 	function MyPatch()
-	   :call system("patch -o " . v:fname_out . " " . v:fname_in .
-	   \  " < " . v:fname_diff)
+	   :call system("patch -o " .. v:fname_out .. " " .. v:fname_in ..
+	   \  " < " .. v:fname_diff)
 	endfunction
 
 Make sure that using the "patch" program doesn't have unwanted side effects.
diff --git a/runtime/doc/digraph.txt b/runtime/doc/digraph.txt
index dd7e9a331a..eb3de0111f 100644
--- a/runtime/doc/digraph.txt
+++ b/runtime/doc/digraph.txt
@@ -35,6 +35,9 @@ An alternative is using the 'keymap' option.
 <			Avoid defining a digraph with '_' (underscore) as the
 			first character, it has a special meaning in the
 			future.
+			NOTE: This command cannot add a digraph that starts
+			with a white space.  If you want to add such digraph,
+			you can use |digraph_set()| instead.
 
 Example of the output of ":digraphs": >
  TH Þ  222  ss ß  223  a! à  224  a' á  225  a> â  226  a? ã  227  a: ä  228
diff --git a/runtime/doc/editing.txt b/runtime/doc/editing.txt
index 14df41e6c8..c19d9f482b 100644
--- a/runtime/doc/editing.txt
+++ b/runtime/doc/editing.txt
@@ -196,7 +196,7 @@ If you want to keep the changed buffer without saving it, switch on the
 			Edit {file} always.  Discard any changes to the
 			current buffer.
 			Also see |++opt| and |+cmd|.
-
+							*:edit_#* *:e#*
 :e[dit] [++opt] [+cmd] #[count]
 			Edit the [count]th buffer (as shown by |:files|).
 			This command does the same as [count] CTRL-^.  But ":e
@@ -356,7 +356,7 @@ as a wildcard when "[" is in the 'isfname' option.  A simple way to avoid this
 is to use "path\[[]abc]", this matches the file "path\[abc]".
 
 					*starstar-wildcard*
-Expanding "**" is possible on Unix, Win32, Mac OS/X and a few other systems.
+Expanding "**" is possible on Unix, Win32, macOS and a few other systems.
 This allows searching a directory tree.  This goes up to 100 directories deep.
 Note there are some commands where this works slightly differently, see
 |file-searching|.
@@ -411,9 +411,10 @@ does apply like to other wildcards.
 
 Environment variables in the expression are expanded when evaluating the
 expression, thus this works: >
-	:e `=$HOME . '/.vimrc'`
-This does not work, $HOME is inside a string and used literally: >
-	:e `='$HOME' . '/.vimrc'`
+	:e `=$HOME .. '/.vimrc'`
+This uses $HOME inside a string and it will be used literally, most likely not
+what you intended: >
+	:e `='$HOME' .. '/.vimrc'`
 
 If the expression returns a string then names are to be separated with line
 breaks.  When the result is a |List| then each item is used as a name.  Line
@@ -845,7 +846,7 @@ Note: When the 'write' option is off, you are not able to write any file.
 
 							*:w* *:write*
 					*E502* *E503* *E504* *E505*
-					*E512* *E514* *E667* *E796* *E949*
+					*E512* *E514* *E667* *E949*
 :w[rite] [++opt]	Write the whole buffer to the current file.  This is
 			the normal way to save changes to a file.  It fails
 			when the 'readonly' option is set or when there is
@@ -1172,7 +1173,7 @@ Examples: >
 
 If you want to always use ":confirm", set the 'confirm' option.
 
-			*:browse* *:bro* *E338* *E614* *E615* *E616*
+					*:browse* *:bro* *E338* *E614* *E615* *E616*
 :bro[wse] {command}	Open a file selection dialog for an argument to
 			{command}.  At present this works for |:e|, |:w|,
 			|:wall|, |:wq|, |:wqall|, |:x|, |:xall|, |:exit|,
@@ -1331,6 +1332,7 @@ current directory for that window.  Windows where the |:lcd| command has not
 been used stick to the global or tab-local directory.  When jumping to another
 window the current directory is changed to the last specified local current
 directory.  If none was specified, the global or tab-local directory is used.
+When creating a new window it inherits the local directory of the current window.
 
 When changing tabs the same behaviour applies.  If the current tab has no
 local working directory the global working directory is used.
@@ -1449,6 +1451,11 @@ If you don't get warned often enough you can use the following command.
 			if it exists now.
 			Once a file has been checked the timestamp is reset,
 			you will not be warned again.
+			Syntax highlighting, marks, diff status,
+			'fileencoding', 'fileformat' and 'binary' options
+			are not changed.  See |v:fcs_choice| to reload these
+			too (for example, if a code formatting tools has
+			changed the file).
 
 :[N]checkt[ime] {filename}
 :[N]checkt[ime] [N]
@@ -1488,8 +1495,8 @@ session or with another command (e.g., a filter command).  Then you will know
 which version of the file you want to keep.
 
 The accuracy of the time check depends on the filesystem.  On Unix it is
-usually sub-second.  With old file sytems and on MS-Windows it is normally one
-second.  Use has('nanotime') check if sub-second time stamp checks are
+usually sub-second.  With old file systems and on MS-Windows it is normally one
+second.  Use `has('nanotime')` to check if sub-second time stamp checks are
 available.
 
 There is one situation where you get the message while there is nothing wrong:
@@ -1568,6 +1575,10 @@ There are three different types of searching:
 	/u/user_x/work/include
 	/u/user_x/include
 
+<   Note: If your 'path' setting includes a non-existing directory, Vim will
+   skip the non-existing directory, and also does not search in the parent of
+   the non-existing directory if upwards searching is used.
+
 3) Combined up/downward search:
    If Vim's current path is /u/user_x/work/release and you do >
 	set path=**;/u/user_x
diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt
index fa75ead9a3..17af40bdb9 100644
--- a/runtime/doc/eval.txt
+++ b/runtime/doc/eval.txt
@@ -119,7 +119,7 @@ You will not get an error if you try to change the type of a variable.
 
 
 1.2 Function references ~
-						*Funcref* *E695* *E718*
+							*Funcref* *E695* *E718*
 A Funcref variable is obtained with the |function()| function, the |funcref()|
 function or created with the lambda expression |expr-lambda|.  It can be used
 in an expression in the place of a function name, before the parenthesis
@@ -196,7 +196,7 @@ position in the sequence.
 
 List creation ~
 							*E696* *E697*
-A List is created with a comma separated list of items in square brackets.
+A List is created with a comma-separated list of items in square brackets.
 Examples: >
 	:let mylist = [1, two, 3, "four"]
 	:let emptylist = []
@@ -372,8 +372,8 @@ Changing the order of items in a list: >
 
 For loop ~
 
-The |:for| loop executes commands for each item in a |List| or |Blob|.
-A variable is set to each item in the sequence.  Example with a List: >
+The |:for| loop executes commands for each item in a |List|, |String| or |Blob|.
+A variable is set to each item in sequence.  Example with a List: >
 	:for item in mylist
 	:   call Doit(item)
 	:endfor
@@ -390,7 +390,7 @@ If all you want to do is modify each item in the list then the |map()|
 function will be a simpler method than a for loop.
 
 Just like the |:let| command, |:for| also accepts a list of variables.  This
-requires the argument to be a list of lists. >
+requires the argument to be a List of Lists. >
 	:for [lnum, col] in [[1, 3], [2, 8], [3, 0]]
 	:   call Doit(lnum, col)
 	:endfor
@@ -402,12 +402,18 @@ It is also possible to put remaining items in a List variable: >
 	:for [i, j; rest] in listlist
 	:   call Doit(i, j)
 	:   if !empty(rest)
-	:      echo "remainder: " . string(rest)
+	:      echo "remainder: " .. string(rest)
 	:   endif
 	:endfor
 
 For a Blob one byte at a time is used.
 
+For a String one character, including any composing characters, is used as a
+String.  Example: >
+	for c in text
+	  echo 'This character is ' .. c
+	endfor
+
 
 List functions ~
 						*E714*
@@ -424,11 +430,11 @@ Functions that are useful with a List: >
 	:let list = split("a b c")	" create list from items in a string
 	:let string = join(list, ', ')	" create string from list items
 	:let s = string(list)		" String representation of list
-	:call map(list, '">> " . v:val')  " prepend ">> " to each item
+	:call map(list, '">> " .. v:val')  " prepend ">> " to each item
 
 Don't forget that a combination of features can make things simple.  For
 example, to add up all the numbers in a list: >
-	:exe 'let sum = ' . join(nrlist, '+')
+	:exe 'let sum = ' .. join(nrlist, '+')
 
 
 1.4 Dictionaries ~
@@ -440,7 +446,7 @@ ordering.
 
 Dictionary creation ~
 						*E720* *E721* *E722* *E723*
-A Dictionary is created with a comma separated list of entries in curly
+A Dictionary is created with a comma-separated list of entries in curly
 braces.  Each entry has a key and a value, separated by a colon.  Each key can
 only appear once.  Examples: >
 	:let mydict = {1: 'one', 2: 'two', 3: 'three'}
@@ -449,8 +455,8 @@ only appear once.  Examples: >
 A key is always a String.  You can use a Number, it will be converted to a
 String automatically.  Thus the String '4' and the number 4 will find the same
 entry.  Note that the String '04' and the Number 04 are different, since the
-Number will be converted to the String '4'.  The empty string can also be used
-as a key.
+Number will be converted to the String '4', leading zeros are dropped.  The
+empty string can also be used as a key.
 						*literal-Dict*
 To avoid having to put quotes around every key the #{} form can be used.  This
 does require the key to consist only of ASCII letters, digits, '-' and '_'.
@@ -490,7 +496,7 @@ turn the Dictionary into a List and pass it to |:for|.
 
 Most often you want to loop over the keys, using the |keys()| function: >
 	:for key in keys(mydict)
-	:   echo key . ': ' . mydict[key]
+	:   echo key .. ': ' .. mydict[key]
 	:endfor
 
 The List of keys is unsorted.  You may want to sort them first: >
@@ -498,13 +504,13 @@ The List of keys is unsorted.  You may want to sort them first: >
 
 To loop over the values use the |values()| function:  >
 	:for v in values(mydict)
-	:   echo "value: " . v
+	:   echo "value: " .. v
 	:endfor
 
 If you want both the key and the value use the |items()| function.  It returns
 a List in which each item is a List with two items, the key and the value: >
 	:for [key, value] in items(mydict)
-	:   echo key . ': ' . value
+	:   echo key .. ': ' .. value
 	:endfor
 
 
@@ -599,7 +605,7 @@ Functions that can be used with a Dictionary: >
 	:let small = min(dict)		" minimum value in dict
 	:let xs = count(dict, 'x')	" count nr of times 'x' appears in dict
 	:let s = string(dict)		" String representation of dict
-	:call map(dict, '">> " . v:val')  " prepend ">> " to each item
+	:call map(dict, '">> " .. v:val')  " prepend ">> " to each item
 
 
 1.5 Blobs ~
@@ -676,7 +682,7 @@ similar to -1. >
 	:let otherblob = myblob[:]	" make a copy of the Blob
 
 If the first index is beyond the last byte of the Blob or the second byte is
-before the first byte, the result is an empty Blob.  There is no error
+before the first index, the result is an empty Blob.  There is no error
 message.
 
 If the second index is equal to or greater than the length of the Blob the
@@ -834,7 +840,7 @@ Example: >
 All expressions within one level are parsed from left to right.
 
 
-expr1							*expr1* *trinary* *E109*
+expr1							*expr1* *ternary* *E109*
 -----
 
 expr2 ? expr1 : expr1
@@ -1066,7 +1072,7 @@ expr7							*expr7*
 
 For '!' |TRUE| becomes |FALSE|, |FALSE| becomes |TRUE| (one).
 For '-' the sign of the number is changed.
-For '+' the number is unchanged.
+For '+' the number is unchanged.  Note: "++" has no effect.
 
 A String will be converted to a Number first.
 
@@ -1117,7 +1123,7 @@ Generally, if a |List| index is equal to or higher than the length of the
 error.
 
 
-expr8[expr1a : expr1b]	substring or sublist		*expr-[:]*
+expr8[expr1a : expr1b]	substring or |sublist|		*expr-[:]* *substring*
 
 If expr8 is a String this results in the substring with the bytes or
 characters from expr1a to and including expr1b.  expr8 is used as a String,
@@ -1228,8 +1234,8 @@ And NOT: >
 number
 ------
 number			number constant			*expr-number*
-				*hex-number* *octal-number* *binary-number*
 
+			*0x* *hex-number* *0o* *octal-number* *binary-number*
 Decimal, Hexadecimal (starting with 0x or 0X), Binary (starting with 0b or 0B)
 and Octal (starting with 0, 0o or 0O).
 
@@ -1319,6 +1325,9 @@ A string constant accepts these special characters:
 	To use the double quote character it must be escaped: "<M-\">".
 	Don't use <Char-xxxx> to get a UTF-8 character, use \uxxxx as
 	mentioned above.
+\<*xxx>	Like \<xxx> but prepends a modifier instead of including it in the
+	character.  E.g. "\<C-w>" is one character 0x17 while "\<*C-w>" is four
+	bytes: 3 for the CTRL modifier and then character "W".
 
 Note that "\xff" is stored as the byte 255, which may be invalid in some
 encodings.  Use "\u00ff" to store character 255 correctly as UTF-8.
@@ -1356,8 +1365,8 @@ option						*expr-option* *E112* *E113*
 &l:option		local option value
 
 Examples: >
-	echo "tabstop is " . &tabstop
-	if &insertmode
+	echo "tabstop is " .. &tabstop
+	if &expandtab
 
 Any option name can be used here.  See |options|.  When using the local value
 and there is no buffer-local or window-local value, the global value is used
@@ -1451,7 +1460,7 @@ the function returns: >
 	:let Bar = Foo(4)
 	:echo Bar(6)
 <	5
-Note that the variables must exist in the outer scope before the lamba is
+Note that the variables must exist in the outer scope before the lambda is
 defined for this to work.  See also |:func-closure|.
 
 Lambda and closure support can be checked with: >
@@ -1486,7 +1495,7 @@ Notice how execute() is used to execute an Ex command.  That's ugly though.
 
 Lambda expressions have internal names like '<lambda>42'.  If you get an error
 for a lambda expression, you can find what it is with the following command: >
-	:function {'<lambda>42'}
+	:function <lambda>42
 See also: |numbered-function|
 
 ==============================================================================
@@ -1631,7 +1640,7 @@ maintain a counter: >
 	  echo "script executed for the first time"
 	else
 	  let s:counter = s:counter + 1
-	  echo "script executed " . s:counter . " times now"
+	  echo "script executed " .. s:counter .. " times now"
 	endif
 
 Note that this means that filetype plugins don't get a different set of script
@@ -1645,6 +1654,7 @@ Some variables can be set by the user, but the type cannot be changed.
 					*v:argv* *argv-variable*
 v:argv		The command line arguments Vim was invoked with.  This is a
 		list of strings.  The first item is the Vim command.
+		See |v:progpath| for the command with full path.
 
 					*v:beval_col* *beval_col-variable*
 v:beval_col	The number of the column, over which the mouse pointer is.
@@ -1730,7 +1740,7 @@ v:completed_item
 					*v:count* *count-variable*
 v:count		The count given for the last Normal mode command.  Can be used
 		to get the count before a mapping.  Read-only.  Example: >
-	:map _x :<C-U>echo "the count is " . v:count<CR>
+	:map _x :<C-U>echo "the count is " .. v:count<CR>
 <		Note: The <C-U> is required to remove the line range that you
 		get when typing ':' after a count.
 		When there are two counts, as in "3d2w", they are multiplied,
@@ -1876,6 +1886,11 @@ v:fcs_choice	What should happen after a |FileChangedShell| event was
 		do with the affected buffer:
 			reload		Reload the buffer (does not work if
 					the file was deleted).
+			edit		Reload the buffer and detect the
+					values for options such as
+					'fileformat', 'fileencoding', 'binary'
+					(does not work if the file was
+					deleted).
 			ask		Ask the user what to do, as if there
 					was no autocommand.  Except that when
 					only the timestamp changed nothing
@@ -2016,6 +2031,9 @@ v:null		Special value used to put "null" in JSON and NIL in msgpack.
 		used as a String (e.g. in |expr5| with string concatenation
 		operator) and to zero when used as a Number (e.g. in |expr5|
 		or |expr7| when used with numeric operators). Read-only.
+		In some places `v:null` can be used for a List, Dict, etc.
+		that is not set.  That is slightly different than an empty
+		List, Dict, etc.
 
 					*v:numbermax* *numbermax-variable*
 v:numbermax	Maximum value of a number.
@@ -2120,9 +2138,19 @@ v:scrollstart	String describing the script or function that caused the
 					*v:servername* *servername-variable*
 v:servername	Primary listen-address of the current Nvim instance, the first
 		item returned by |serverlist()|.  Can be set by |--listen| or
-		|$NVIM_LISTEN_ADDRESS| at startup. |serverstart()| |serverstop()|
+		|$NVIM_LISTEN_ADDRESS| (deprecated) at startup.
+		See also |serverstart()| |serverstop()|.
 		Read-only.
 
+								       *$NVIM*
+		$NVIM is set by |terminal| and |jobstart()|, and is thus
+		a hint that the current environment is a subprocess of Nvim.
+		Example: >
+		    if $NVIM
+		      echo nvim_get_chan_info(v:parent)
+		    endif
+
+<		Note the contents of $NVIM may change in the future.
 
 v:searchforward			*v:searchforward* *searchforward-variable*
 		Search direction:  1 after a forward search, 0 after a
@@ -2267,8656 +2295,13 @@ v:windowid	Application-specific window "handle" which may be set by any
 ==============================================================================
 4. Builtin Functions				*vim-function* *functions*
 
-The Vimscript subsystem (referred to as "eval" internally) provides the
-following builtin functions.  Scripts can also define |user-function|s.
+The Vimscript subsystem (referred to as "eval" internally) provides builtin
+functions.  Scripts can also define |user-function|s.
 
 See |function-list| to browse functions by topic.
 
-(Use CTRL-] on the function name to jump to the full explanation.)
-
-USAGE				RESULT	DESCRIPTION	~
-
-abs({expr})			Float or Number  absolute value of {expr}
-acos({expr})			Float	arc cosine of {expr}
-add({object}, {item})		List/Blob   append {item} to {object}
-and({expr}, {expr})		Number	bitwise AND
-api_info()			Dict	api metadata
-append({lnum}, {string})	Number	append {string} below line {lnum}
-append({lnum}, {list})		Number	append lines {list} below line {lnum}
-argc([{winid}])			Number	number of files in the argument list
-argidx()			Number	current index in the argument list
-arglistid([{winnr} [, {tabnr}]]) Number	argument list id
-argv({nr} [, {winid}])		String	{nr} entry of the argument list
-argv([-1, {winid}])		List	the argument list
-asin({expr})			Float	arc sine of {expr}
-assert_beeps({cmd})		Number	assert {cmd} causes a beep
-assert_equal({exp}, {act} [, {msg}])
-				Number	assert {exp} is equal to {act}
-assert_equalfile({fname-one}, {fname-two} [, {msg}])
-				Number	assert file contents are equal
-assert_exception({error} [, {msg}])
-				Number	assert {error} is in v:exception
-assert_fails({cmd} [, {error}])	Number	assert {cmd} fails
-assert_false({actual} [, {msg}])
-				Number	assert {actual} is false
-assert_inrange({lower}, {upper}, {actual} [, {msg}])
-				Number	assert {actual} is inside the range
-assert_match({pat}, {text} [, {msg}])
-				Number	assert {pat} matches {text}
-assert_nobeep({cmd})		Number	assert {cmd} does not cause a beep
-assert_notequal({exp}, {act} [, {msg}])
-				Number	assert {exp} is not equal {act}
-assert_notmatch({pat}, {text} [, {msg}])
-				Number	assert {pat} not matches {text}
-assert_report({msg})		Number	report a test failure
-assert_true({actual} [, {msg}])	Number	assert {actual} is true
-atan({expr})			Float	arc tangent of {expr}
-atan2({expr}, {expr})		Float	arc tangent of {expr1} / {expr2}
-browse({save}, {title}, {initdir}, {default})
-				String	put up a file requester
-browsedir({title}, {initdir})	String	put up a directory requester
-bufadd({name})			Number	add a buffer to the buffer list
-bufexists({expr})		Number	|TRUE| if buffer {expr} exists
-buflisted({expr})		Number	|TRUE| if buffer {expr} is listed
-bufload({expr})			Number	load buffer {expr} if not loaded yet
-bufloaded({expr})		Number	|TRUE| if buffer {expr} is loaded
-bufname([{expr}])		String	Name of the buffer {expr}
-bufnr([{expr} [, {create}]])	Number	Number of the buffer {expr}
-bufwinid({expr})		Number	|window-ID| of buffer {expr}
-bufwinnr({expr})		Number	window number of buffer {expr}
-byte2line({byte})		Number	line number at byte count {byte}
-byteidx({expr}, {nr})		Number	byte index of {nr}'th char in {expr}
-byteidxcomp({expr}, {nr})	Number	byte index of {nr}'th char in {expr}
-call({func}, {arglist} [, {dict}])
-				any	call {func} with arguments {arglist}
-ceil({expr})			Float	round {expr} up
-changenr()			Number	current change number
-chanclose({id}[, {stream}])	Number	Closes a channel or one of its streams
-chansend({id}, {data})		Number	Writes {data} to channel
-char2nr({expr}[, {utf8}])	Number	ASCII/UTF-8 value of first char in {expr}
-charidx({string}, {idx} [, {countcc}])
-				Number	char index of byte {idx} in {string}
-chdir({dir})			String	change current working directory
-cindent({lnum})			Number	C indent for line {lnum}
-clearmatches([{win}])		none	clear all matches
-col({expr})			Number	column nr of cursor or mark
-complete({startcol}, {matches}) none	set Insert mode completion
-complete_add({expr})		Number	add completion match
-complete_check()		Number	check for key typed during completion
-complete_info([{what}])		Dict	get current completion information
-confirm({msg} [, {choices} [, {default} [, {type}]]])
-				Number	number of choice picked by user
-copy({expr})			any	make a shallow copy of {expr}
-cos({expr})			Float	cosine of {expr}
-cosh({expr})			Float	hyperbolic cosine of {expr}
-count({list}, {expr} [, {ic} [, {start}]])
-				Number	count how many {expr} are in {list}
-cscope_connection([{num}, {dbpath} [, {prepend}]])
-				Number	checks existence of cscope connection
-ctxget([{index}])		Dict	return the |context| dict at {index}
-ctxpop()			none	pop and restore |context| from the
-					|context-stack|
-ctxpush([{types}])		none	push the current |context| to the
-					|context-stack|
-ctxset({context}[, {index}])	none	set |context| at {index}
-ctxsize()			Number	return |context-stack| size
-cursor({lnum}, {col} [, {off}])
-				Number	move cursor to {lnum}, {col}, {off}
-cursor({list})			Number	move cursor to position in {list}
-debugbreak({pid})		Number	interrupt process being debugged
-deepcopy({expr} [, {noref}])	any	make a full copy of {expr}
-delete({fname} [, {flags}])	Number	delete the file or directory {fname}
-deletebufline({buf}, {first}[, {last}])
-				Number	delete lines from buffer {buf}
-dictwatcheradd({dict}, {pattern}, {callback})
-				Start watching a dictionary
-dictwatcherdel({dict}, {pattern}, {callback})
-				Stop watching a dictionary
-did_filetype()			Number	|TRUE| if FileType autocommand event used
-diff_filler({lnum})		Number	diff filler lines about {lnum}
-diff_hlID({lnum}, {col})	Number	diff highlighting at {lnum}/{col}
-empty({expr})			Number	|TRUE| if {expr} is empty
-environ()			Dict	return environment variables
-escape({string}, {chars})	String	escape {chars} in {string} with '\'
-eval({string})			any	evaluate {string} into its value
-eventhandler()			Number	|TRUE| if inside an event handler
-executable({expr})		Number	1 if executable {expr} exists
-execute({command})		String	execute and capture output of {command}
-exepath({expr})			String	full path of the command {expr}
-exists({expr})			Number	|TRUE| if {expr} exists
-extend({expr1}, {expr2} [, {expr3}])
-				List/Dict insert items of {expr2} into {expr1}
-exp({expr})			Float	exponential of {expr}
-expand({expr} [, {nosuf} [, {list}]])
-				any	expand special keywords in {expr}
-expandcmd({expr})		String	expand {expr} like with `:edit`
-feedkeys({string} [, {mode}])	Number	add key sequence to typeahead buffer
-filereadable({file})		Number	|TRUE| if {file} is a readable file
-filewritable({file})		Number	|TRUE| if {file} is a writable file
-filter({expr1}, {expr2})	List/Dict  remove items from {expr1} where
-					{expr2} is 0
-finddir({name} [, {path} [, {count}]])
-				String	find directory {name} in {path}
-findfile({name} [, {path} [, {count}]])
-				String	find file {name} in {path}
-flatten({list} [, {maxdepth}])	List	flatten {list} up to {maxdepth} levels
-float2nr({expr})		Number	convert Float {expr} to a Number
-floor({expr})			Float	round {expr} down
-fmod({expr1}, {expr2})		Float	remainder of {expr1} / {expr2}
-fnameescape({fname})		String	escape special characters in {fname}
-fnamemodify({fname}, {mods})	String	modify file name
-foldclosed({lnum})		Number	first line of fold at {lnum} if closed
-foldclosedend({lnum})		Number	last line of fold at {lnum} if closed
-foldlevel({lnum})		Number	fold level at {lnum}
-foldtext()			String	line displayed for closed fold
-foldtextresult({lnum})		String	text for closed fold at {lnum}
-foreground()			Number	bring the Vim window to the foreground
-fullcommand({name})		String	get full command from {name}
-funcref({name} [, {arglist}] [, {dict}])
-				Funcref	reference to function {name}
-function({name} [, {arglist}] [, {dict}])
-				Funcref	named reference to function {name}
-garbagecollect([{atexit}])	none	free memory, breaking cyclic references
-get({list}, {idx} [, {def}])	any	get item {idx} from {list} or {def}
-get({dict}, {key} [, {def}])	any	get item {key} from {dict} or {def}
-get({func}, {what})		any	get property of funcref/partial {func}
-getbufinfo([{buf}])		List	information about buffers
-getbufline({buf}, {lnum} [, {end}])
-				List	lines {lnum} to {end} of buffer {buf}
-getbufvar({buf}, {varname} [, {def}])
-				any	variable {varname} in buffer {buf}
-getchangelist([{buf}])		List	list of change list items
-getchar([expr])			Number or String
-					get one character from the user
-getcharmod()			Number	modifiers for the last typed character
-getcharsearch()			Dict	last character search
-getcharstr([expr])		String	get one character from the user
-getcmdline()			String	return the current command-line
-getcmdpos()			Number	return cursor position in command-line
-getcmdtype()			String	return current command-line type
-getcmdwintype()			String	return current command-line window type
-getcompletion({pat}, {type} [, {filtered}])
-				List	list of cmdline completion matches
-getcurpos()			List	position of the cursor
-getcwd([{winnr} [, {tabnr}]])	String	get the current working directory
-getenv({name})			String	return environment variable
-getfontname([{name}])		String	name of font being used
-getfperm({fname})		String	file permissions of file {fname}
-getfsize({fname})		Number	size in bytes of file {fname}
-getftime({fname})		Number	last modification time of file
-getftype({fname})		String	description of type of file {fname}
-getjumplist([{winnr} [, {tabnr}]])
-				List	list of jump list items
-getline({lnum})			String	line {lnum} of current buffer
-getline({lnum}, {end})		List	lines {lnum} to {end} of current buffer
-getloclist({nr})		List	list of location list items
-getloclist({nr}, {what})	Dict	get specific location list properties
-getmarklist([{buf}])		List	list of global/local marks
-getmatches([{win}])		List	list of current matches
-getmousepos()			Dict	last known mouse position
-getpid()			Number	process ID of Vim
-getpos({expr})			List	position of cursor, mark, etc.
-getqflist()			List	list of quickfix items
-getqflist({what})		Dict	get specific quickfix list properties
-getreg([{regname} [, 1 [, {list}]]])
-				String or List   contents of a register
-getreginfo([{regname}])		Dict	information about a register
-getregtype([{regname}])		String	type of a register
-gettabinfo([{expr}])		List	list of tab pages
-gettabvar({nr}, {varname} [, {def}])
-				any	variable {varname} in tab {nr} or {def}
-gettabwinvar({tabnr}, {winnr}, {name} [, {def}])
-				any	{name} in {winnr} in tab page {tabnr}
-gettagstack([{nr}])		Dict	get the tag stack of window {nr}
-getwininfo([{winid}])		List	list of windows
-getwinpos([{timeout}])		List	X and Y coord in pixels of the Vim window
-getwinposx()			Number	X coord in pixels of Vim window
-getwinposy()			Number	Y coord in pixels of Vim window
-getwinvar({nr}, {varname} [, {def}])
-				any	variable {varname} in window {nr}
-glob({expr} [, {nosuf} [, {list} [, {alllinks}]]])
-				any	expand file wildcards in {expr}
-glob2regpat({expr})		String	convert a glob pat into a search pat
-globpath({path}, {expr} [, {nosuf} [, {list} [, {alllinks}]]])
-				String	do glob({expr}) for all dirs in {path}
-has({feature})			Number	|TRUE| if feature {feature} supported
-has_key({dict}, {key})		Number	|TRUE| if {dict} has entry {key}
-haslocaldir([{winnr} [, {tabnr}]])
-				Number	|TRUE| if the window executed |:lcd| or
-					the tab executed |:tcd|
-hasmapto({what} [, {mode} [, {abbr}]])
-				Number	|TRUE| if mapping to {what} exists
-histadd({history}, {item})	String	add an item to a history
-histdel({history} [, {item}])	String	remove an item from a history
-histget({history} [, {index}])	String	get the item {index} from a history
-histnr({history})		Number	highest index of a history
-hlexists({name})		Number	|TRUE| if highlight group {name} exists
-hlID({name})			Number	syntax ID of highlight group {name}
-hostname()			String	name of the machine Vim is running on
-iconv({expr}, {from}, {to})	String	convert encoding of {expr}
-indent({lnum})			Number	indent of line {lnum}
-index({object}, {expr} [, {start} [, {ic}]])
-				Number	index in {object} where {expr} appears
-input({prompt} [, {text} [, {completion}]])
-				String	get input from the user
-inputlist({textlist})		Number	let the user pick from a choice list
-inputrestore()			Number	restore typeahead
-inputsave()			Number	save and clear typeahead
-inputsecret({prompt} [, {text}])
-				String	like input() but hiding the text
-insert({object}, {item} [, {idx}])
-				List	insert {item} in {object} [before {idx}]
-interrupt()			none	interrupt script execution
-invert({expr})			Number	bitwise invert
-isdirectory({directory})	Number	|TRUE| if {directory} is a directory
-isinf({expr})			Number	determine if {expr} is infinity value
-					(positive or negative)
-islocked({expr})		Number	|TRUE| if {expr} is locked
-isnan({expr})			Number	|TRUE| if {expr} is NaN
-id({expr})			String	identifier of the container
-items({dict})			List	key-value pairs in {dict}
-jobpid({id})			Number	Returns pid of a job.
-jobresize({id}, {width}, {height})
-				Number	Resize pseudo terminal window of a job
-jobstart({cmd}[, {opts}])	Number	Spawns {cmd} as a job
-jobstop({id})			Number	Stops a job
-jobwait({ids}[, {timeout}])	Number	Wait for a set of jobs
-join({list} [, {sep}])		String	join {list} items into one String
-json_decode({expr})		any	Convert {expr} from JSON
-json_encode({expr})		String	Convert {expr} to JSON
-keys({dict})			List	keys in {dict}
-len({expr})			Number	the length of {expr}
-libcall({lib}, {func}, {arg})	String	call {func} in library {lib} with {arg}
-libcallnr({lib}, {func}, {arg})	Number	idem, but return a Number
-line({expr} [, {winid}])	Number	line nr of cursor, last line or mark
-line2byte({lnum})		Number	byte count of line {lnum}
-lispindent({lnum})		Number	Lisp indent for line {lnum}
-list2str({list} [, {utf8}])	String	turn numbers in {list} into a String
-localtime()			Number	current time
-log({expr})			Float	natural logarithm (base e) of {expr}
-log10({expr})			Float	logarithm of Float {expr} to base 10
-luaeval({expr}[, {expr}])	any	evaluate Lua expression
-map({expr1}, {expr2})		List/Dict  change each item in {expr1} to {expr}
-maparg({name}[, {mode} [, {abbr} [, {dict}]]])
-				String or Dict
-					rhs of mapping {name} in mode {mode}
-mapcheck({name}[, {mode} [, {abbr}]])
-				String	check for mappings matching {name}
-match({expr}, {pat}[, {start}[, {count}]])
-				Number	position where {pat} matches in {expr}
-matchadd({group}, {pattern}[, {priority}[, {id}]])
-				Number	highlight {pattern} with {group}
-matchaddpos({group}, {list}[, {priority}[, {id}]])
-				Number	highlight positions with {group}
-matcharg({nr})			List	arguments of |:match|
-matchdelete({id} [, {win}])	Number	delete match identified by {id}
-matchend({expr}, {pat}[, {start}[, {count}]])
-				Number	position where {pat} ends in {expr}
-matchlist({expr}, {pat}[, {start}[, {count}]])
-				List	match and submatches of {pat} in {expr}
-matchstr({expr}, {pat}[, {start}[, {count}]])
-				String	{count}'th match of {pat} in {expr}
-matchstrpos({expr}, {pat}[, {start}[, {count}]])
-				List	{count}'th match of {pat} in {expr}
-max({expr})			Number	maximum value of items in {expr}
-menu_get({path} [, {modes}])	List	description of |menus| matched by {path}
-min({expr})			Number	minimum value of items in {expr}
-mkdir({name} [, {path} [, {prot}]])
-				Number	create directory {name}
-mode([expr])			String	current editing mode
-msgpackdump({list} [, {type}])	List/Blob  dump objects to msgpack
-msgpackparse({data})		List	parse msgpack to a list of objects
-nextnonblank({lnum})		Number	line nr of non-blank line >= {lnum}
-nr2char({expr}[, {utf8}])	String	single char with ASCII/UTF-8 value {expr}
-nvim_...({args}...)		any	call nvim |api| functions
-or({expr}, {expr})		Number	bitwise OR
-pathshorten({expr})		String	shorten directory names in a path
-perleval({expr})		any	evaluate |perl| expression
-pow({x}, {y})			Float	{x} to the power of {y}
-prevnonblank({lnum})		Number	line nr of non-blank line <= {lnum}
-printf({fmt}, {expr1}...)	String	format text
-prompt_getprompt({buf})		String	get prompt text
-prompt_setcallback({buf}, {expr}) none	set prompt callback function
-prompt_setinterrupt({buf}, {text}) none	set prompt interrupt function
-prompt_setprompt({buf}, {text}) none	set prompt text
-pum_getpos()			Dict	position and size of pum if visible
-pumvisible()			Number	whether popup menu is visible
-pyeval({expr})			any	evaluate |Python| expression
-py3eval({expr})			any	evaluate |python3| expression
-pyxeval({expr})			any	evaluate |python_x| expression
-range({expr} [, {max} [, {stride}]])
-				List	items from {expr} to {max}
-readdir({dir} [, {expr}])	List	file names in {dir} selected by {expr}
-readfile({fname} [, {type} [, {max}]])
-				List	get list of lines from file {fname}
-reg_executing()			String	get the executing register name
-reg_recorded()			String	get the last recorded register name
-reg_recording()			String	get the recording register name
-reltime([{start} [, {end}]])	List	get time value
-reltimefloat({time})		Float	turn the time value into a Float
-reltimestr({time})		String	turn time value into a String
-remote_expr({server}, {string} [, {idvar} [, {timeout}]])
-				String	send expression
-remote_foreground({server})	Number	bring Vim server to the foreground
-remote_peek({serverid} [, {retvar}])
-				Number	check for reply string
-remote_read({serverid} [, {timeout}])
-				String	read reply string
-remote_send({server}, {string} [, {idvar}])
-				String	send key sequence
-remote_startserver({name})	none	become server {name}
-remove({list}, {idx} [, {end}])	any/List
-					remove items {idx}-{end} from {list}
-remove({blob}, {idx} [, {end}])	Number/Blob
-					remove bytes {idx}-{end} from {blob}
-remove({dict}, {key})		any	remove entry {key} from {dict}
-rename({from}, {to})		Number	rename (move) file from {from} to {to}
-repeat({expr}, {count})		String	repeat {expr} {count} times
-resolve({filename})		String	get filename a shortcut points to
-reverse({list})			List	reverse {list} in-place
-round({expr})			Float	round off {expr}
-rubyeval({expr})		any	evaluate |Ruby| expression
-rpcnotify({channel}, {event}[, {args}...])
-				Sends an |RPC| notification to {channel}
-rpcrequest({channel}, {method}[, {args}...])
-				Sends an |RPC| request to {channel}
-screenattr({row}, {col})	Number	attribute at screen position
-screenchar({row}, {col})	Number	character at screen position
-screenchars({row}, {col})	List	List of characters at screen position
-screencol()			Number	current cursor column
-screenpos({winid}, {lnum}, {col}) Dict	screen row and col of a text character
-screenrow()			Number	current cursor row
-screenstring({row}, {col})	String	characters at screen position
-search({pattern} [, {flags} [, {stopline} [, {timeout}]]])
-				Number	search for {pattern}
-searchcount([{options}])	Dict	Get or update the last search count
-searchdecl({name} [, {global} [, {thisblock}]])
-				Number	search for variable declaration
-searchpair({start}, {middle}, {end} [, {flags} [, {skip} [...]]])
-				Number	search for other end of start/end pair
-searchpairpos({start}, {middle}, {end} [, {flags} [, {skip} [...]]])
-				List	search for other end of start/end pair
-searchpos({pattern} [, {flags} [, {stopline} [, {timeout}]]])
-				List	search for {pattern}
-server2client({clientid}, {string})
-				Number	send reply string
-serverlist()			String	get a list of available servers
-setbufline( {expr}, {lnum}, {line})
-				Number	set line {lnum} to {line} in buffer
-					{expr}
-setbufvar({buf}, {varname}, {val})	set {varname} in buffer {buf} to {val}
-setcharsearch({dict})		Dict	set character search from {dict}
-setcmdpos({pos})		Number	set cursor position in command-line
-setenv({name}, {val})		none	set environment variable
-setfperm({fname}, {mode}	Number	set {fname} file permissions to {mode}
-setline({lnum}, {line})		Number	set line {lnum} to {line}
-setloclist({nr}, {list} [, {action}])
-				Number	modify location list using {list}
-setloclist({nr}, {list}, {action}, {what})
-				Number	modify specific location list props
-setmatches({list} [, {win}])	Number	restore a list of matches
-setpos({expr}, {list})		Number	set the {expr} position to {list}
-setqflist({list} [, {action}])	Number	modify quickfix list using {list}
-setqflist({list}, {action}, {what})
-				Number	modify specific quickfix list props
-setreg({n}, {v}[, {opt}])	Number	set register to value and type
-settabvar({nr}, {varname}, {val})	set {varname} in tab page {nr} to {val}
-settabwinvar({tabnr}, {winnr}, {varname}, {val})    set {varname} in window
-					{winnr} in tab page {tabnr} to {val}
-settagstack({nr}, {dict} [, {action}])
-				Number	modify tag stack using {dict}
-setwinvar({nr}, {varname}, {val})	set {varname} in window {nr} to {val}
-sha256({string})		String	SHA256 checksum of {string}
-shellescape({string} [, {special}])
-				String	escape {string} for use as shell
-					command argument
-shiftwidth([{col}])		Number	effective value of 'shiftwidth'
-sign_define({name} [, {dict}])	Number	define or update a sign
-sign_define({list})		List	define or update a list of signs
-sign_getdefined([{name}])	List	get a list of defined signs
-sign_getplaced([{buf} [, {dict}]])
-				List	get a list of placed signs
-sign_jump({id}, {group}, {buf})
-				Number	jump to a sign
-sign_place({id}, {group}, {name}, {buf} [, {dict}])
-				Number	place a sign
-sign_placelist({list})		List	place a list of signs
-sign_undefine([{name}])		Number	undefine a sign
-sign_undefine({list})		List	undefine a list of signs
-sign_unplace({group} [, {dict}])
-				Number	unplace a sign
-sign_unplacelist({list})	List	unplace a list of signs
-simplify({filename})		String	simplify filename as much as possible
-sin({expr})			Float	sine of {expr}
-sinh({expr})			Float	hyperbolic sine of {expr}
-sockconnect({mode}, {address} [, {opts}])
-				Number	Connects to socket
-sort({list} [, {func} [, {dict}]])
-				List	sort {list}, using {func} to compare
-soundfold({word})		String	sound-fold {word}
-spellbadword()			String	badly spelled word at cursor
-spellsuggest({word} [, {max} [, {capital}]])
-				List	spelling suggestions
-split({expr} [, {pat} [, {keepempty}]])
-				List	make |List| from {pat} separated {expr}
-sqrt({expr})			Float	square root of {expr}
-stdioopen({dict})		Number	open stdio in a headless instance.
-stdpath({what})			String/List  returns the standard path(s) for {what}
-str2float({expr} [, {quoted}])	Float	convert String to Float
-str2list({expr} [, {utf8}])	List	convert each character of {expr} to
-					ASCII/UTF-8 value
-str2nr({expr} [, {base} [, {quoted}]])
-				Number	convert String to Number
-strchars({expr} [, {skipcc}])	Number	character length of the String {expr}
-strcharpart({str}, {start} [, {len}])
-				String	{len} characters of {str} at
-					character {start}
-strdisplaywidth({expr} [, {col}]) Number display length of the String {expr}
-strftime({format} [, {time}])	String	format time with a specified format
-strgetchar({str}, {index})	Number	get char {index} from {str}
-stridx({haystack}, {needle} [, {start}])
-				Number	index of {needle} in {haystack}
-string({expr})			String	String representation of {expr} value
-strlen({expr})			Number	length of the String {expr}
-strpart({str}, {start} [, {len} [, {chars}]])
-				String	{len} bytes/chars of {str} at
-					byte {start}
-strptime({format}, {timestring})
-				Number	Convert {timestring} to unix timestamp
-strridx({haystack}, {needle} [, {start}])
-				Number	last index of {needle} in {haystack}
-strtrans({expr})		String	translate string to make it printable
-strwidth({expr})		Number	display cell length of the String {expr}
-submatch({nr} [, {list}])	String or List
-					specific match in ":s" or substitute()
-substitute({expr}, {pat}, {sub}, {flags})
-				String	all {pat} in {expr} replaced with {sub}
-swapinfo({fname})		Dict	information about swap file {fname}
-swapname({buf})			String	swap file of buffer {buf}
-synID({lnum}, {col}, {trans})	Number	syntax ID at {lnum} and {col}
-synIDattr({synID}, {what} [, {mode}])
-				String	attribute {what} of syntax ID {synID}
-synIDtrans({synID})		Number	translated syntax ID of {synID}
-synconcealed({lnum}, {col})	List	info about concealing
-synstack({lnum}, {col})	List	stack of syntax IDs at {lnum} and {col}
-system({cmd} [, {input}])	String	output of shell command/filter {cmd}
-systemlist({cmd} [, {input}])	List	output of shell command/filter {cmd}
-tabpagebuflist([{arg}])		List	list of buffer numbers in tab page
-tabpagenr([{arg}])		Number	number of current or last tab page
-tabpagewinnr({tabarg}[, {arg}])
-				Number	number of current window in tab page
-taglist({expr}[, {filename}])	List	list of tags matching {expr}
-tagfiles()			List	tags files used
-tan({expr})			Float	tangent of {expr}
-tanh({expr})			Float	hyperbolic tangent of {expr}
-tempname()			String	name for a temporary file
-test_garbagecollect_now()	none	free memory right now for testing
-timer_info([{id}])		List	information about timers
-timer_pause({id}, {pause})	none	pause or unpause a timer
-timer_start({time}, {callback} [, {options}])
-				Number	create a timer
-timer_stop({timer})		none	stop a timer
-timer_stopall()			none	stop all timers
-tolower({expr})			String	the String {expr} switched to lowercase
-toupper({expr})			String	the String {expr} switched to uppercase
-tr({src}, {fromstr}, {tostr})	String	translate chars of {src} in {fromstr}
-					to chars in {tostr}
-trim({text} [, {mask} [, {dir}]])
-				String	trim characters in {mask} from {text}
-trunc({expr})			Float	truncate Float {expr}
-type({name})			Number	type of variable {name}
-undofile({name})		String	undo file name for {name}
-undotree()			List	undo file tree
-uniq({list} [, {func} [, {dict}]])
-				List	remove adjacent duplicates from a list
-values({dict})			List	values in {dict}
-virtcol({expr})			Number	screen column of cursor or mark
-visualmode([expr])		String	last visual mode used
-wait({timeout}, {condition}[, {interval}])
-				Number	Wait until {condition} is satisfied
-wildmenumode()			Number	whether 'wildmenu' mode is active
-win_execute({id}, {command} [, {silent}])
-				String	execute {command} in window {id}
-win_findbuf({bufnr})		List	find windows containing {bufnr}
-win_getid([{win} [, {tab}]])	Number	get |window-ID| for {win} in {tab}
-win_gettype([{nr}])		String	type of window {nr}
-win_gotoid({expr})		Number	go to |window-ID| {expr}
-win_id2tabwin({expr})		List	get tab and window nr from |window-ID|
-win_id2win({expr})		Number	get window nr from |window-ID|
-win_screenpos({nr})		List	get screen position of window {nr}
-win_splitmove({nr}, {target} [, {options}])
-				Number	move window {nr} to split of {target}
-winbufnr({nr})			Number	buffer number of window {nr}
-wincol()			Number	window column of the cursor
-windowsversion()		String	MS-Windows OS version
-winheight({nr})			Number	height of window {nr}
-winlayout([{tabnr}])		List	layout of windows in tab {tabnr}
-winline()			Number	window line of the cursor
-winnr([{expr}])			Number	number of current window
-winrestcmd()			String	returns command to restore window sizes
-winrestview({dict})		none	restore view of current window
-winsaveview()			Dict	save view of current window
-winwidth({nr})			Number	width of window {nr}
-wordcount()			Dict	get byte/char/word statistics
-writefile({object}, {fname} [, {flags}])
-				Number	write |Blob| or |List| of lines to file
-xor({expr}, {expr})		Number	bitwise XOR
-
-
-abs({expr})							*abs()*
-		Return the absolute value of {expr}.  When {expr} evaluates to
-		a |Float| abs() returns a |Float|.  When {expr} can be
-		converted to a |Number| abs() returns a |Number|.  Otherwise
-		abs() gives an error message and returns -1.
-		Examples: >
-			echo abs(1.456)
-<			1.456  >
-			echo abs(-5.456)
-<			5.456  >
-			echo abs(-4)
-<			4
-
-		Can also be used as a |method|: >
-			Compute()->abs()
-
-acos({expr})							*acos()*
-		Return the arc cosine of {expr} measured in radians, as a
-		|Float| in the range of [0, pi].
-		{expr} must evaluate to a |Float| or a |Number| in the range
-		[-1, 1].
-		Examples: >
-			:echo acos(0)
-<			1.570796 >
-			:echo acos(-0.5)
-<			2.094395
-
-		Can also be used as a |method|: >
-			Compute()->acos()
-
-add({object}, {expr})					*add()*
-		Append the item {expr} to |List| or |Blob| {object}.  Returns
-		the resulting |List| or |Blob|.  Examples: >
-			:let alist = add([1, 2, 3], item)
-			:call add(mylist, "woodstock")
-<		Note that when {expr} is a |List| it is appended as a single
-		item.  Use |extend()| to concatenate |Lists|.
-		When {object} is a |Blob| then {expr} must be a number.
-		Use |insert()| to add an item at another position.
-
-		Can also be used as a |method|: >
-			mylist->add(val1)->add(val2)
-
-and({expr}, {expr})					*and()*
-		Bitwise AND on the two arguments.  The arguments are converted
-		to a number.  A List, Dict or Float argument causes an error.
-		Example: >
-			:let flag = and(bits, 0x80)
-<		Can also be used as a |method|: >
-			:let flag = bits->and(0x80)
-
-api_info()						*api_info()*
-		Returns Dictionary of |api-metadata|.
-
-		View it in a nice human-readable format: >
-		       :lua print(vim.inspect(vim.fn.api_info()))
-
-append({lnum}, {text})					*append()*
-		When {text} is a |List|: Append each item of the |List| as a
-		text line below line {lnum} in the current buffer.
-		Otherwise append {text} as one text line below line {lnum} in
-		the current buffer.
-		{lnum} can be zero to insert a line before the first one.
-		{lnum} is used like with |getline()|.
-		Returns 1 for failure ({lnum} out of range or out of memory),
-		0 for success.  Example: >
-			:let failed = append(line('$'), "# THE END")
-			:let failed = append(0, ["Chapter 1", "the beginning"])
-
-<		Can also be used as a |method| after a List: >
-			mylist->append(lnum)
-
-appendbufline({buf}, {lnum}, {text})			*appendbufline()*
-		Like |append()| but append the text in buffer {expr}.
-
-		This function works only for loaded buffers. First call
-		|bufload()| if needed.
-
-		For the use of {buf}, see |bufname()|.
-
-		{lnum} is used like with |append()|.  Note that using |line()|
-		would use the current buffer, not the one appending to.
-		Use "$" to append at the end of the buffer.
-
-		On success 0 is returned, on failure 1 is returned.
-
-		If {buf} is not a valid buffer or {lnum} is not valid, an
-		error message is given. Example: >
-			:let failed = appendbufline(13, 0, "# THE START")
-<
-		Can also be used as a |method| after a List: >
-			mylist->appendbufline(buf, lnum)
-
-argc([{winid}])					*argc()*
-		The result is the number of files in the argument list.  See
-		|arglist|.
-		If {winid} is not supplied, the argument list of the current
-		window is used.
-		If {winid} is -1, the global argument list is used.
-		Otherwise {winid} specifies the window of which the argument
-		list is used: either the window number or the window ID.
-		Returns -1 if the {winid} argument is invalid.
-
-							*argidx()*
-argidx()	The result is the current index in the argument list.  0 is
-		the first file.  argc() - 1 is the last one.  See |arglist|.
-
-							*arglistid()*
-arglistid([{winnr} [, {tabnr}]])
-		Return the argument list ID.  This is a number which
-		identifies the argument list being used.  Zero is used for the
-		global argument list.  See |arglist|.
-		Returns -1 if the arguments are invalid.
-
-		Without arguments use the current window.
-		With {winnr} only use this window in the current tab page.
-		With {winnr} and {tabnr} use the window in the specified tab
-		page.
-		{winnr} can be the window number or the |window-ID|.
-
-							*argv()*
-argv([{nr} [, {winid}]])
-		The result is the {nr}th file in the argument list.  See
-		|arglist|.  "argv(0)" is the first one.  Example: >
-	:let i = 0
-	:while i < argc()
-	:  let f = escape(fnameescape(argv(i)), '.')
-	:  exe 'amenu Arg.' . f . ' :e ' . f . '<CR>'
-	:  let i = i + 1
-	:endwhile
-<		Without the {nr} argument, or when {nr} is -1, a |List| with
-		the whole |arglist| is returned.
-
-		The {winid} argument specifies the window ID, see |argc()|.
-		For the Vim command line arguments see |v:argv|.
-
-asin({expr})						*asin()*
-		Return the arc sine of {expr} measured in radians, as a |Float|
-		in the range of [-pi/2, pi/2].
-		{expr} must evaluate to a |Float| or a |Number| in the range
-		[-1, 1].
-		Examples: >
-			:echo asin(0.8)
-<			0.927295 >
-			:echo asin(-0.5)
-<			-0.523599
-
-		Can also be used as a |method|: >
-			Compute()->asin()
-
-
-assert_ functions are documented here: |assert-functions-details|
-
-
-atan({expr})						*atan()*
-		Return the principal value of the arc tangent of {expr}, in
-		the range [-pi/2, +pi/2] radians, as a |Float|.
-		{expr} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			:echo atan(100)
-<			1.560797 >
-			:echo atan(-4.01)
-<			-1.326405
-
-		Can also be used as a |method|: >
-			Compute()->atan()
-
-atan2({expr1}, {expr2})					*atan2()*
-		Return the arc tangent of {expr1} / {expr2}, measured in
-		radians, as a |Float| in the range [-pi, pi].
-		{expr1} and {expr2} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			:echo atan2(-1, 1)
-<			-0.785398 >
-			:echo atan2(1, -1)
-<			2.356194
-
-		Can also be used as a |method|: >
-			Compute()->atan2(1)
-
-							*browse()*
-browse({save}, {title}, {initdir}, {default})
-		Put up a file requester.  This only works when "has("browse")"
-		returns |TRUE| (only in some GUI versions).
-		The input fields are:
-		    {save}	when |TRUE|, select file to write
-		    {title}	title for the requester
-		    {initdir}	directory to start browsing in
-		    {default}	default file name
-		An empty string is returned when the "Cancel" button is hit,
-		something went wrong, or browsing is not possible.
-
-							*browsedir()*
-browsedir({title}, {initdir})
-		Put up a directory requester.  This only works when
-		"has("browse")" returns |TRUE| (only in some GUI versions).
-		On systems where a directory browser is not supported a file
-		browser is used.  In that case: select a file in the directory
-		to be used.
-		The input fields are:
-		    {title}	title for the requester
-		    {initdir}	directory to start browsing in
-		When the "Cancel" button is hit, something went wrong, or
-		browsing is not possible, an empty string is returned.
-
-bufadd({name})						*bufadd()*
-		Add a buffer to the buffer list with String {name}.
-		If a buffer for file {name} already exists, return that buffer
-		number.  Otherwise return the buffer number of the newly
-		created buffer.  When {name} is an empty string then a new
-		buffer is always created.
-		The buffer will not have 'buflisted' set and not be loaded
-		yet.  To add some text to the buffer use this: >
-			let bufnr = bufadd('someName')
-			call bufload(bufnr)
-			call setbufline(bufnr, 1, ['some', 'text'])
-<		Can also be used as a |method|: >
-			let bufnr = 'somename'->bufadd()
-
-bufexists({buf})					*bufexists()*
-		The result is a Number, which is |TRUE| if a buffer called
-		{buf} exists.
-		If the {buf} argument is a number, buffer numbers are used.
-		Number zero is the alternate buffer for the current window.
-
-		If the {buf} argument is a string it must match a buffer name
-		exactly.  The name can be:
-		- Relative to the current directory.
-		- A full path.
-		- The name of a buffer with 'buftype' set to "nofile".
-		- A URL name.
-		Unlisted buffers will be found.
-		Note that help files are listed by their short name in the
-		output of |:buffers|, but bufexists() requires using their
-		long name to be able to find them.
-		bufexists() may report a buffer exists, but to use the name
-		with a |:buffer| command you may need to use |expand()|.  Esp
-		for MS-Windows 8.3 names in the form "c:\DOCUME~1"
-		Use "bufexists(0)" to test for the existence of an alternate
-		file name.
-
-		Can also be used as a |method|: >
-			let exists = 'somename'->bufexists()
-
-buflisted({buf})					*buflisted()*
-		The result is a Number, which is |TRUE| if a buffer called
-		{buf} exists and is listed (has the 'buflisted' option set).
-		The {buf} argument is used like with |bufexists()|.
-
-		Can also be used as a |method|: >
-			let listed = 'somename'->buflisted()
-
-bufload({buf})						*bufload()*
-		Ensure the buffer {buf} is loaded.  When the buffer name
-		refers to an existing file then the file is read.  Otherwise
-		the buffer will be empty.  If the buffer was already loaded
-		then there is no change.
-		If there is an existing swap file for the file of the buffer,
-		there will be no dialog, the buffer will be loaded anyway.
-		The {buf} argument is used like with |bufexists()|.
-
-		Can also be used as a |method|: >
-			eval 'somename'->bufload()
-
-bufloaded({buf})					*bufloaded()*
-		The result is a Number, which is |TRUE| if a buffer called
-		{buf} exists and is loaded (shown in a window or hidden).
-		The {buf} argument is used like with |bufexists()|.
-
-		Can also be used as a |method|: >
-			let loaded = 'somename'->bufloaded()
-
-bufname([{buf}])						*bufname()*
-		The result is the name of a buffer.  Mostly as it is displayed
-		by the `:ls` command, but not using special names such as
-		"[No Name]".
-		If {buf} is omitted the current buffer is used.
-		If {buf} is a Number, that buffer number's name is given.
-		Number zero is the alternate buffer for the current window.
-		If {buf} is a String, it is used as a |file-pattern| to match
-		with the buffer names.  This is always done like 'magic' is
-		set and 'cpoptions' is empty.  When there is more than one
-		match an empty string is returned.
-		"" or "%" can be used for the current buffer, "#" for the
-		alternate buffer.
-		A full match is preferred, otherwise a match at the start, end
-		or middle of the buffer name is accepted.  If you only want a
-		full match then put "^" at the start and "$" at the end of the
-		pattern.
-		Listed buffers are found first.  If there is a single match
-		with a listed buffer, that one is returned.  Next unlisted
-		buffers are searched for.
-		If the {buf} is a String, but you want to use it as a buffer
-		number, force it to be a Number by adding zero to it: >
-			:echo bufname("3" + 0)
-<		Can also be used as a |method|: >
-			echo bufnr->bufname()
-
-<		If the buffer doesn't exist, or doesn't have a name, an empty
-		string is returned. >
-	bufname("#")		alternate buffer name
-	bufname(3)		name of buffer 3
-	bufname("%")		name of current buffer
-	bufname("file2")	name of buffer where "file2" matches.
-<
-							*bufnr()*
-bufnr([{buf} [, {create}]])
-		The result is the number of a buffer, as it is displayed by
-		the `:ls` command.  For the use of {buf}, see |bufname()|
-		above.
-		If the buffer doesn't exist, -1 is returned.  Or, if the
-		{create} argument is present and TRUE, a new, unlisted,
-		buffer is created and its number is returned.
-		bufnr("$") is the last buffer: >
-			:let last_buffer = bufnr("$")
-<		The result is a Number, which is the highest buffer number
-		of existing buffers.  Note that not all buffers with a smaller
-		number necessarily exist, because ":bwipeout" may have removed
-		them.  Use bufexists() to test for the existence of a buffer.
-
-		Can also be used as a |method|: >
-			echo bufref->bufnr()
-
-bufwinid({buf})						*bufwinid()*
-		The result is a Number, which is the |window-ID| of the first
-		window associated with buffer {buf}.  For the use of {buf},
-		see |bufname()| above.  If buffer {buf} doesn't exist or
-		there is no such window, -1 is returned.  Example: >
-
-	echo "A window containing buffer 1 is " . (bufwinid(1))
-<
-		Only deals with the current tab page.
-
-		Can also be used as a |method|: >
-			FindBuffer()->bufwinid()
-
-bufwinnr({buf})						*bufwinnr()*
-		Like |bufwinid()| but return the window number instead of the
-		|window-ID|.
-		If buffer {buf} doesn't exist or there is no such window, -1
-		is returned.  Example: >
-
-	echo "A window containing buffer 1 is " . (bufwinnr(1))
-
-<		The number can be used with |CTRL-W_w| and ":wincmd w"
-		|:wincmd|.
-
-		Can also be used as a |method|: >
-			FindBuffer()->bufwinnr()
-
-byte2line({byte})					*byte2line()*
-		Return the line number that contains the character at byte
-		count {byte} in the current buffer.  This includes the
-		end-of-line character, depending on the 'fileformat' option
-		for the current buffer.  The first character has byte count
-		one.
-		Also see |line2byte()|, |go| and |:goto|.
-
-		Can also be used as a |method|: >
-			GetOffset()->byte2line()
-
-byteidx({expr}, {nr})					*byteidx()*
-		Return byte index of the {nr}'th character in the String
-		{expr}.  Use zero for the first character, it then returns
-		zero.
-		If there are no multibyte characters the returned value is
-		equal to {nr}.
-		Composing characters are not counted separately, their byte
-		length is added to the preceding base character.  See
-		|byteidxcomp()| below for counting composing characters
-		separately.
-		Example : >
-			echo matchstr(str, ".", byteidx(str, 3))
-<		will display the fourth character.  Another way to do the
-		same: >
-			let s = strpart(str, byteidx(str, 3))
-			echo strpart(s, 0, byteidx(s, 1))
-<		Also see |strgetchar()| and |strcharpart()|.
-
-		If there are less than {nr} characters -1 is returned.
-		If there are exactly {nr} characters the length of the string
-		in bytes is returned.
-
-		Can also be used as a |method|: >
-			GetName()->byteidx(idx)
-
-byteidxcomp({expr}, {nr})					*byteidxcomp()*
-		Like byteidx(), except that a composing character is counted
-		as a separate character.  Example: >
-			let s = 'e' . nr2char(0x301)
-			echo byteidx(s, 1)
-			echo byteidxcomp(s, 1)
-			echo byteidxcomp(s, 2)
-<		The first and third echo result in 3 ('e' plus composing
-		character is 3 bytes), the second echo results in 1 ('e' is
-		one byte).
-		Only works differently from byteidx() when 'encoding' is set to
-		a Unicode encoding.
-
-		Can also be used as a |method|: >
-			GetName()->byteidxcomp(idx)
-
-call({func}, {arglist} [, {dict}])			*call()* *E699*
-		Call function {func} with the items in |List| {arglist} as
-		arguments.
-		{func} can either be a |Funcref| or the name of a function.
-		a:firstline and a:lastline are set to the cursor line.
-		Returns the return value of the called function.
-		{dict} is for functions with the "dict" attribute.  It will be
-		used to set the local variable "self". |Dictionary-function|
-
-		Can also be used as a |method|: >
-			GetFunc()->call([arg, arg], dict)
-
-ceil({expr})							*ceil()*
-		Return the smallest integral value greater than or equal to
-		{expr} as a |Float| (round up).
-		{expr} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			echo ceil(1.456)
-<			2.0  >
-			echo ceil(-5.456)
-<			-5.0  >
-			echo ceil(4.0)
-<			4.0
-
-		Can also be used as a |method|: >
-			Compute()->ceil()
-
-changenr()						*changenr()*
-		Return the number of the most recent change.  This is the same
-		number as what is displayed with |:undolist| and can be used
-		with the |:undo| command.
-		When a change was made it is the number of that change.  After
-		redo it is the number of the redone change.  After undo it is
-		one less than the number of the undone change.
-
-chanclose({id}[, {stream}])				*chanclose()*
-		Close a channel or a specific stream associated with it.
-		For a job, {stream} can be one of "stdin", "stdout",
-		"stderr" or "rpc" (closes stdin/stdout for a job started
-		with `"rpc":v:true`) If {stream} is omitted, all streams
-		are closed. If the channel is a pty, this will then close the
-		pty master, sending SIGHUP to the job process.
-		For a socket, there is only one stream, and {stream} should be
-		ommited.
-
-chansend({id}, {data})					*chansend()*
-		Send data to channel {id}. For a job, it writes it to the
-		stdin of the process. For the stdio channel |channel-stdio|,
-		it writes to Nvim's stdout.  Returns the number of bytes
-		written if the write succeeded, 0 otherwise.
-		See |channel-bytes| for more information.
-
-		{data} may be a string, string convertible, |Blob|, or a list.
-		If {data} is a list, the items will be joined by newlines; any
-		newlines in an item will be sent as NUL. To send a final
-		newline, include a final empty string. Example: >
-			:call chansend(id, ["abc", "123\n456", ""])
-< 		will send "abc<NL>123<NUL>456<NL>".
-
-		chansend() writes raw data, not RPC messages.  If the channel
-		was created with `"rpc":v:true` then the channel expects RPC
-		messages, use |rpcnotify()| and |rpcrequest()| instead.
-
-
-char2nr({string} [, {utf8}])					*char2nr()*
-		Return number value of the first char in {string}.
-		Examples: >
-			char2nr(" ")		returns 32
-			char2nr("ABC")		returns 65
-			char2nr("á")		returns 225
-			char2nr("á"[0])		returns 195
-			char2nr("\<M-x>")	returns 128
-<		Non-ASCII characters are always treated as UTF-8 characters.
-		{utf8} is ignored, it exists only for backwards-compatibility.
-		A combining character is a separate character.
-		|nr2char()| does the opposite.
-
-		Can also be used as a |method|: >
-			GetChar()->char2nr()
-<
-							*charidx()*
-charidx({string}, {idx} [, {countcc}])
-		Return the character index of the byte at {idx} in {string}.
-		The index of the first character is zero.
-		If there are no multibyte characters the returned value is
-		equal to {idx}.
-		When {countcc} is omitted or |FALSE|, then composing characters
-		are not counted separately, their byte length is
-		added to the preceding base character.
-		When {countcc} is |TRUE|, then composing characters are
-		counted as separate characters.
-		Returns -1 if the arguments are invalid or if {idx} is greater
-		than the index of the last byte in {string}.  An error is
-		given if the first argument is not a string, the second
-		argument is not a number or when the third argument is present
-		and is not zero or one.
-		See |byteidx()| and |byteidxcomp()| for getting the byte index
-		from the character index.
-		Examples: >
-			echo charidx('áb́ć', 3)		returns 1
-			echo charidx('áb́ć', 6, 1)	returns 4
-			echo charidx('áb́ć', 16)		returns -1
-<
-		Can also be used as a |method|: >
-			GetName()->charidx(idx)
-
-chdir({dir})						*chdir()*
-		Change the current working directory to {dir}.  The scope of
-		the directory change depends on the directory of the current
-		window:
-			- If the current window has a window-local directory
-			  (|:lcd|), then changes the window local directory.
-			- Otherwise, if the current tabpage has a local
-			  directory (|:tcd|) then changes the tabpage local
-			  directory.
-			- Otherwise, changes the global directory.
-		If successful, returns the previous working directory.  Pass
-		this to another chdir() to restore the directory.
-		On failure, returns an empty string.
-
-		Example: >
-			let save_dir = chdir(newdir)
-			if save_dir
-			   " ... do some work
-			   call chdir(save_dir)
-			endif
-<
-cindent({lnum})						*cindent()*
-		Get the amount of indent for line {lnum} according the C
-		indenting rules, as with 'cindent'.
-		The indent is counted in spaces, the value of 'tabstop' is
-		relevant.  {lnum} is used just like in |getline()|.
-		When {lnum} is invalid -1 is returned.
-		See |C-indenting|.
-
-		Can also be used as a |method|: >
-			GetLnum()->cindent()
-
-clearmatches([{win}])					*clearmatches()*
- 		Clears all matches previously defined for the current window
- 		by |matchadd()| and the |:match| commands.
-		If {win} is specified, use the window with this number or
-		window ID instead of the current window.
-
-		Can also be used as a |method|: >
-			GetWin()->clearmatches()
-<
-							*col()*
-col({expr})	The result is a Number, which is the byte index of the column
-		position given with {expr}.  The accepted positions are:
-		    .	    the cursor position
-		    $	    the end of the cursor line (the result is the
-			    number of bytes in the cursor line plus one)
-		    'x	    position of mark x (if the mark is not set, 0 is
-			    returned)
-		    v       In Visual mode: the start of the Visual area (the
-			    cursor is the end).  When not in Visual mode
-			    returns the cursor position.  Differs from |'<| in
-			    that it's updated right away.
-		Additionally {expr} can be [lnum, col]: a |List| with the line
-		and column number. Most useful when the column is "$", to get
-		the last column of a specific line.  When "lnum" or "col" is
-		out of range then col() returns zero.
-		To get the line number use |line()|.  To get both use
-		|getpos()|.
-		For the screen column position use |virtcol()|.
-		Note that only marks in the current file can be used.
-		Examples: >
-			col(".")		column of cursor
-			col("$")		length of cursor line plus one
-			col("'t")		column of mark t
-			col("'" . markname)	column of mark markname
-<		The first column is 1.  0 is returned for an error.
-		For an uppercase mark the column may actually be in another
-		buffer.
-		For the cursor position, when 'virtualedit' is active, the
-		column is one higher if the cursor is after the end of the
-		line.  This can be used to obtain the column in Insert mode: >
-			:imap <F2> <C-O>:let save_ve = &ve<CR>
-				\<C-O>:set ve=all<CR>
-				\<C-O>:echo col(".") . "\n" <Bar>
-				\let &ve = save_ve<CR>
-
-<		Can also be used as a |method|: >
-			GetPos()->col()
-<
-
-complete({startcol}, {matches})			*complete()* *E785*
-		Set the matches for Insert mode completion.
-		Can only be used in Insert mode.  You need to use a mapping
-		with CTRL-R = (see |i_CTRL-R|).  It does not work after CTRL-O
-		or with an expression mapping.
-		{startcol} is the byte offset in the line where the completed
-		text start.  The text up to the cursor is the original text
-		that will be replaced by the matches.  Use col('.') for an
-		empty string.  "col('.') - 1" will replace one character by a
-		match.
-		{matches} must be a |List|.  Each |List| item is one match.
-		See |complete-items| for the kind of items that are possible.
-		"longest" in 'completeopt' is ignored.
-		Note that the after calling this function you need to avoid
-		inserting anything that would cause completion to stop.
-		The match can be selected with CTRL-N and CTRL-P as usual with
-		Insert mode completion.  The popup menu will appear if
-		specified, see |ins-completion-menu|.
-		Example: >
-	inoremap <F5> <C-R>=ListMonths()<CR>
-
-	func! ListMonths()
-	  call complete(col('.'), ['January', 'February', 'March',
-		\ 'April', 'May', 'June', 'July', 'August', 'September',
-		\ 'October', 'November', 'December'])
-	  return ''
-	endfunc
-<		This isn't very useful, but it shows how it works.  Note that
-		an empty string is returned to avoid a zero being inserted.
-
-		Can also be used as a |method|, the base is passed as the
-		second argument: >
-			GetMatches()->complete(col('.'))
-
-complete_add({expr})				*complete_add()*
-		Add {expr} to the list of matches.  Only to be used by the
-		function specified with the 'completefunc' option.
-		Returns 0 for failure (empty string or out of memory),
-		1 when the match was added, 2 when the match was already in
-		the list.
-		See |complete-functions| for an explanation of {expr}.  It is
-		the same as one item in the list that 'omnifunc' would return.
-
-		Can also be used as a |method|: >
-			GetMoreMatches()->complete_add()
-
-complete_check()				*complete_check()*
-		Check for a key typed while looking for completion matches.
-		This is to be used when looking for matches takes some time.
-		Returns |TRUE| when searching for matches is to be aborted,
-		zero otherwise.
-		Only to be used by the function specified with the
-		'completefunc' option.
-
-
-complete_info([{what}])				*complete_info()*
-		Returns a |Dictionary| with information about Insert mode
-		completion.  See |ins-completion|.
-		The items are:
-		   mode		Current completion mode name string.
-				See |complete_info_mode| for the values.
-		   pum_visible	|TRUE| if popup menu is visible.
-				See |pumvisible()|.
-		   items	List of completion matches.  Each item is a
-				dictionary containing the entries "word",
-				"abbr", "menu", "kind", "info" and "user_data".
-				See |complete-items|.
-		   selected	Selected item index.  First index is zero.
-				Index is -1 if no item is selected (showing
-				typed text only, or the last completion after
-				no item is selected when using the <Up> or
-				<Down> keys)
-		   inserted	Inserted string. [NOT IMPLEMENT YET]
-
-							*complete_info_mode*
-		mode values are:
-		   ""		     Not in completion mode
-		   "keyword"	     Keyword completion |i_CTRL-X_CTRL-N|
-		   "ctrl_x"	     Just pressed CTRL-X |i_CTRL-X|
-		   "scroll"	     Scrolling with |i_CTRL-X_CTRL-E| or
-				     |i_CTRL-X_CTRL-Y|
-		   "whole_line"	     Whole lines |i_CTRL-X_CTRL-L|
-		   "files"	     File names |i_CTRL-X_CTRL-F|
-		   "tags"	     Tags |i_CTRL-X_CTRL-]|
-		   "path_defines"    Definition completion |i_CTRL-X_CTRL-D|
-		   "path_patterns"   Include completion |i_CTRL-X_CTRL-I|
-		   "dictionary"	     Dictionary |i_CTRL-X_CTRL-K|
-		   "thesaurus"	     Thesaurus |i_CTRL-X_CTRL-T|
-		   "cmdline"	     Vim Command line |i_CTRL-X_CTRL-V|
-		   "function"	     User defined completion |i_CTRL-X_CTRL-U|
-		   "omni"	     Omni completion |i_CTRL-X_CTRL-O|
-		   "spell"	     Spelling suggestions |i_CTRL-X_s|
-		   "eval"	     |complete()| completion
-		   "unknown"	     Other internal modes
-
-		If the optional {what} list argument is supplied, then only
-		the items listed in {what} are returned.  Unsupported items in
-		{what} are silently ignored.
-
-		To get the position and size of the popup menu, see
-		|pum_getpos()|. It's also available in |v:event| during the
-		|CompleteChanged| event.
-
-		Examples: >
-			" Get all items
-			call complete_info()
-			" Get only 'mode'
-			call complete_info(['mode'])
-			" Get only 'mode' and 'pum_visible'
-			call complete_info(['mode', 'pum_visible'])
-
-<		Can also be used as a |method|: >
-			GetItems()->complete_info()
-<
-						*confirm()*
-confirm({msg} [, {choices} [, {default} [, {type}]]])
-		Confirm() offers the user a dialog, from which a choice can be
-		made.  It returns the number of the choice.  For the first
-		choice this is 1.
-
-		{msg} is displayed in a dialog with {choices} as the
-		alternatives.  When {choices} is missing or empty, "&OK" is
-		used (and translated).
-		{msg} is a String, use '\n' to include a newline.  Only on
-		some systems the string is wrapped when it doesn't fit.
-
-		{choices} is a String, with the individual choices separated
-		by '\n', e.g. >
-			confirm("Save changes?", "&Yes\n&No\n&Cancel")
-<		The letter after the '&' is the shortcut key for that choice.
-		Thus you can type 'c' to select "Cancel".  The shortcut does
-		not need to be the first letter: >
-			confirm("file has been modified", "&Save\nSave &All")
-<		For the console, the first letter of each choice is used as
-		the default shortcut key.  Case is ignored.
-
-		The optional {type} String argument gives the type of dialog.
-		It can be one of these values: "Error", "Question", "Info",
-		"Warning" or "Generic".  Only the first character is relevant.
-		When {type} is omitted, "Generic" is used.
-
-		The optional {type} argument gives the type of dialog.  This
-		is only used for the icon of the Win32 GUI.  It can be one of
-		these values: "Error", "Question", "Info", "Warning" or
-		"Generic".  Only the first character is relevant.
-		When {type} is omitted, "Generic" is used.
-
-		If the user aborts the dialog by pressing <Esc>, CTRL-C,
-		or another valid interrupt key, confirm() returns 0.
-
-		An example: >
-   :let choice = confirm("What do you want?", "&Apples\n&Oranges\n&Bananas", 2)
-   :if choice == 0
-   :	echo "make up your mind!"
-   :elseif choice == 3
-   :	echo "tasteful"
-   :else
-   :	echo "I prefer bananas myself."
-   :endif
-<		In a GUI dialog, buttons are used.  The layout of the buttons
-		depends on the 'v' flag in 'guioptions'.  If it is included,
-		the buttons are always put vertically.  Otherwise,  confirm()
-		tries to put the buttons in one horizontal line.  If they
-		don't fit, a vertical layout is used anyway.  For some systems
-		the horizontal layout is always used.
-
-		Can also be used as a |method|in: >
-			BuildMessage()->confirm("&Yes\n&No")
-<
-							*copy()*
-copy({expr})	Make a copy of {expr}.  For Numbers and Strings this isn't
-		different from using {expr} directly.
-		When {expr} is a |List| a shallow copy is created.  This means
-		that the original |List| can be changed without changing the
-		copy, and vice versa.  But the items are identical, thus
-		changing an item changes the contents of both |Lists|.
-		A |Dictionary| is copied in a similar way as a |List|.
-		Also see |deepcopy()|.
-		Can also be used as a |method|: >
-			mylist->copy()
-
-cos({expr})						*cos()*
-		Return the cosine of {expr}, measured in radians, as a |Float|.
-		{expr} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			:echo cos(100)
-<			0.862319 >
-			:echo cos(-4.01)
-<			-0.646043
-
-		Can also be used as a |method|: >
-			Compute()->cos()
-
-cosh({expr})						*cosh()*
-		Return the hyperbolic cosine of {expr} as a |Float| in the range
-		[1, inf].
-		{expr} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			:echo cosh(0.5)
-<			1.127626 >
-			:echo cosh(-0.5)
-<			-1.127626
-
-		Can also be used as a |method|: >
-			Compute()->cosh()
-
-count({comp}, {expr} [, {ic} [, {start}]])			*count()*
-		Return the number of times an item with value {expr} appears
-		in |String|, |List| or |Dictionary| {comp}.
-
-		If {start} is given then start with the item with this index.
-		{start} can only be used with a |List|.
-
-		When {ic} is given and it's |TRUE| then case is ignored.
-
-		When {comp} is a string then the number of not overlapping
-		occurrences of {expr} is returned. Zero is returned when
-		{expr} is an empty string.
-
-		Can also be used as a |method|: >
-			mylist->count(val)
-<
-							*cscope_connection()*
-cscope_connection([{num} , {dbpath} [, {prepend}]])
-		Checks for the existence of a |cscope| connection.  If no
-		parameters are specified, then the function returns:
-			0, if there are no cscope connections;
-			1, if there is at least one cscope connection.
-
-		If parameters are specified, then the value of {num}
-		determines how existence of a cscope connection is checked:
-
-		{num}	Description of existence check
-		-----	------------------------------
-		0	Same as no parameters (e.g., "cscope_connection()").
-		1	Ignore {prepend}, and use partial string matches for
-			{dbpath}.
-		2	Ignore {prepend}, and use exact string matches for
-			{dbpath}.
-		3	Use {prepend}, use partial string matches for both
-			{dbpath} and {prepend}.
-		4	Use {prepend}, use exact string matches for both
-			{dbpath} and {prepend}.
-
-		Note: All string comparisons are case sensitive!
-
-		Examples.  Suppose we had the following (from ":cs show"): >
-
-  # pid    database name			prepend path
-  0 27664  cscope.out				/usr/local
-<
-		Invocation					Return Val ~
-		----------					---------- >
-		cscope_connection()					1
-		cscope_connection(1, "out")				1
-		cscope_connection(2, "out")				0
-		cscope_connection(3, "out")				0
-		cscope_connection(3, "out", "local")			1
-		cscope_connection(4, "out")				0
-		cscope_connection(4, "out", "local")			0
-		cscope_connection(4, "cscope.out", "/usr/local")	1
-<
-
-ctxget([{index}])					*ctxget()*
-		Returns a |Dictionary| representing the |context| at {index}
-		from the top of the |context-stack| (see |context-dict|).
-		If {index} is not given, it is assumed to be 0 (i.e.: top).
-
-ctxpop()						*ctxpop()*
-		Pops and restores the |context| at the top of the
-		|context-stack|.
-
-ctxpush([{types}])					*ctxpush()*
-		Pushes the current editor state (|context|) on the
-		|context-stack|.
-		If {types} is given and is a |List| of |String|s, it specifies
-		which |context-types| to include in the pushed context.
-		Otherwise, all context types are included.
-
-ctxset({context}[, {index}])				*ctxset()*
-		Sets the |context| at {index} from the top of the
-		|context-stack| to that represented by {context}.
-		{context} is a Dictionary with context data (|context-dict|).
-		If {index} is not given, it is assumed to be 0 (i.e.: top).
-
-ctxsize()						*ctxsize()*
-		Returns the size of the |context-stack|.
-
-cursor({lnum}, {col} [, {off}])				*cursor()*
-cursor({list})
-		Positions the cursor at the column (byte count) {col} in the
-		line {lnum}.  The first column is one.
-
-		When there is one argument {list} this is used as a |List|
-		with two, three or four item:
-			[{lnum}, {col}]
-			[{lnum}, {col}, {off}]
-			[{lnum}, {col}, {off}, {curswant}]
-		This is like the return value of |getpos()| or |getcurpos()|,
-		but without the first item.
-
-		Does not change the jumplist.
-		If {lnum} is greater than the number of lines in the buffer,
-		the cursor will be positioned at the last line in the buffer.
-		If {lnum} is zero, the cursor will stay in the current line.
-		If {col} is greater than the number of bytes in the line,
-		the cursor will be positioned at the last character in the
-		line.
-		If {col} is zero, the cursor will stay in the current column.
-		If {curswant} is given it is used to set the preferred column
-		for vertical movement.  Otherwise {col} is used.
-
-		When 'virtualedit' is used {off} specifies the offset in
-		screen columns from the start of the character.  E.g., a
-		position within a <Tab> or after the last character.
-		Returns 0 when the position could be set, -1 otherwise.
-
-		Can also be used as a |method|: >
-			GetCursorPos()->cursor()
-
-deepcopy({expr}[, {noref}])				*deepcopy()* *E698*
-		Make a copy of {expr}.  For Numbers and Strings this isn't
-		different from using {expr} directly.
-		When {expr} is a |List| a full copy is created.  This means
-		that the original |List| can be changed without changing the
-		copy, and vice versa.  When an item is a |List|, a copy for it
-		is made, recursively.  Thus changing an item in the copy does
-		not change the contents of the original |List|.
-
-		When {noref} is omitted or zero a contained |List| or
-		|Dictionary| is only copied once.  All references point to
-		this single copy.  With {noref} set to 1 every occurrence of a
-		|List| or |Dictionary| results in a new copy.  This also means
-		that a cyclic reference causes deepcopy() to fail.
-								*E724*
-		Nesting is possible up to 100 levels.  When there is an item
-		that refers back to a higher level making a deep copy with
-		{noref} set to 1 will fail.
-		Also see |copy()|.
-
-		Can also be used as a |method|: >
-			GetObject()->deepcopy()
-
-delete({fname} [, {flags}])				*delete()*
-		Without {flags} or with {flags} empty: Deletes the file by the
-		name {fname}.  This also works when {fname} is a symbolic link.
-		A symbolic link itself is deleted, not what it points to.
-
-		When {flags} is "d": Deletes the directory by the name
-		{fname}.  This fails when directory {fname} is not empty.
-
-		When {flags} is "rf": Deletes the directory by the name
-		{fname} and everything in it, recursively.  BE CAREFUL!
-		Note: on MS-Windows it is not possible to delete a directory
-		that is being used.
-
-		The result is a Number, which is 0/false if the delete
-		operation was successful and -1/true when the deletion failed
-		or partly failed.
-
-		Can also be used as a |method|: >
-			GetName()->delete()
-
-deletebufline({buf}, {first}[, {last}])		*deletebufline()*
-		Delete lines {first} to {last} (inclusive) from buffer {buf}.
-		If {last} is omitted then delete line {first} only.
-		On success 0 is returned, on failure 1 is returned.
-
-		This function works only for loaded buffers. First call
-		|bufload()| if needed.
-
-		For the use of {buf}, see |bufname()| above.
-
-		{first} and {last} are used like with |setline()|. Note that
-		when using |line()| this refers to the current buffer. Use "$"
-		to refer to the last line in buffer {buf}.
-
-		Can also be used as a |method|: >
-			GetBuffer()->deletebufline(1)
-<
-dictwatcheradd({dict}, {pattern}, {callback})		      *dictwatcheradd()*
-		Adds a watcher to a dictionary. A dictionary watcher is
-		identified by three components:
-
-		- A dictionary({dict});
-		- A key pattern({pattern}).
-		- A function({callback}).
-
-		After this is called, every change on {dict} and on keys
-		matching {pattern} will result in {callback} being invoked.
-
-		For example, to watch all global variables: >
-			silent! call dictwatcherdel(g:, '*', 'OnDictChanged')
-			function! OnDictChanged(d,k,z)
-			  echomsg string(a:k) string(a:z)
-			endfunction
-			call dictwatcheradd(g:, '*', 'OnDictChanged')
-<
-		For now {pattern} only accepts very simple patterns that can
-		contain a '*' at the end of the string, in which case it will
-		match every key that begins with the substring before the '*'.
-		That means if '*' is not the last character of {pattern}, only
-		keys that are exactly equal as {pattern} will be matched.
-
-		The {callback} receives three arguments:
-
-		- The dictionary being watched.
-		- The key which changed.
-		- A dictionary containing the new and old values for the key.
-
-		The type of change can be determined by examining the keys
-		present on the third argument:
-
-		- If contains both `old` and `new`, the key was updated.
-		- If it contains only `new`, the key was added.
-		- If it contains only `old`, the key was deleted.
-
-		This function can be used by plugins to implement options with
-		validation and parsing logic.
-
-dictwatcherdel({dict}, {pattern}, {callback})		      *dictwatcherdel()*
-		Removes a watcher added  with |dictwatcheradd()|. All three
-		arguments must match the ones passed to |dictwatcheradd()| in
-		order for the watcher to be successfully deleted.
-
-							*did_filetype()*
-did_filetype()	Returns |TRUE| when autocommands are being executed and the
-		FileType event has been triggered at least once.  Can be used
-		to avoid triggering the FileType event again in the scripts
-		that detect the file type. |FileType|
-		Returns |FALSE| when `:setf FALLBACK` was used.
-		When editing another file, the counter is reset, thus this
-		really checks if the FileType event has been triggered for the
-		current buffer.  This allows an autocommand that starts
-		editing another buffer to set 'filetype' and load a syntax
-		file.
-
-diff_filler({lnum})					*diff_filler()*
-		Returns the number of filler lines above line {lnum}.
-		These are the lines that were inserted at this point in
-		another diff'ed window.  These filler lines are shown in the
-		display but don't exist in the buffer.
-		{lnum} is used like with |getline()|.  Thus "." is the current
-		line, "'m" mark m, etc.
-		Returns 0 if the current window is not in diff mode.
-
-		Can also be used as a |method|: >
-			GetLnum()->diff_filler()
-
-diff_hlID({lnum}, {col})				*diff_hlID()*
-		Returns the highlight ID for diff mode at line {lnum} column
-		{col} (byte index).  When the current line does not have a
-		diff change zero is returned.
-		{lnum} is used like with |getline()|.  Thus "." is the current
-		line, "'m" mark m, etc.
-		{col} is 1 for the leftmost column, {lnum} is 1 for the first
-		line.
-		The highlight ID can be used with |synIDattr()| to obtain
-		syntax information about the highlighting.
-
-		Can also be used as a |method|: >
-			GetLnum()->diff_hlID(col)
-
-empty({expr})						*empty()*
-		Return the Number 1 if {expr} is empty, zero otherwise.
-		- A |List| or |Dictionary| is empty when it does not have any
-		  items.
-		- A |String| is empty when its length is zero.
-		- A |Number| and |Float| are empty when their value is zero.
-		- |v:false| and |v:null| are empty, |v:true| is not.
-		- A |Blob| is empty when its length is zero.
-
-		Can also be used as a |method|: >
-			mylist->empty()
-
-environ()						*environ()*
-		Return all of environment variables as dictionary. You can
-		check if an environment variable exists like this: >
-			:echo has_key(environ(), 'HOME')
-<		Note that the variable name may be CamelCase; to ignore case
-		use this: >
-			:echo index(keys(environ()), 'HOME', 0, 1) != -1
-
-escape({string}, {chars})				*escape()*
-		Escape the characters in {chars} that occur in {string} with a
-		backslash.  Example: >
-			:echo escape('c:\program files\vim', ' \')
-<		results in: >
-			c:\\program\ files\\vim
-<		Also see |shellescape()| and |fnameescape()|.
-
-		Can also be used as a |method|: >
-			GetText()->escape(' \')
-<
-							*eval()*
-eval({string})	Evaluate {string} and return the result.  Especially useful to
-		turn the result of |string()| back into the original value.
-		This works for Numbers, Floats, Strings, Blobs and composites
-		of them.  Also works for |Funcref|s that refer to existing
-		functions.
-
-		Can also be used as a |method|: >
-			argv->join()->eval()
-
-eventhandler()						*eventhandler()*
-		Returns 1 when inside an event handler.  That is that Vim got
-		interrupted while waiting for the user to type a character,
-		e.g., when dropping a file on Vim.  This means interactive
-		commands cannot be used.  Otherwise zero is returned.
-
-executable({expr})					*executable()*
-		This function checks if an executable with the name {expr}
-		exists.  {expr} must be the name of the program without any
-		arguments.
-		executable() uses the value of $PATH and/or the normal
-		searchpath for programs.		*PATHEXT*
-		On MS-Windows the ".exe", ".bat", etc. can optionally be
-		included.  Then the extensions in $PATHEXT are tried.  Thus if
-		"foo.exe" does not exist, "foo.exe.bat" can be found.  If
-		$PATHEXT is not set then ".exe;.com;.bat;.cmd" is used.  A dot
-		by itself can be used in $PATHEXT to try using the name
-		without an extension.  When 'shell' looks like a Unix shell,
-		then the name is also tried without adding an extension.
-		On MS-Windows it only checks if the file exists and is not a
-		directory, not if it's really executable.
-		On Windows an executable in the same directory as Vim is
-		always found (it is added to $PATH at |startup|).
-		The result is a Number:
-			1	exists
-			0	does not exist
-			-1	not implemented on this system
-		|exepath()| can be used to get the full path of an executable.
-
-		Can also be used as a |method|: >
-			GetCommand()->executable()
-
-execute({command} [, {silent}])				*execute()*
-		Execute {command} and capture its output.
-		If {command} is a |String|, returns {command} output.
-		If {command} is a |List|, returns concatenated outputs.
-		Examples: >
-			echo execute('echon "foo"')
-<			foo >
-			echo execute(['echon "foo"', 'echon "bar"'])
-<			foobar
-
-		The optional {silent} argument can have these values:
-			""		no `:silent` used
-			"silent"	`:silent` used
-			"silent!"	`:silent!` used
-		The default is "silent".  Note that with "silent!", unlike
-		`:redir`, error messages are dropped.
-
-		To get a list of lines use |split()| on the result: >
-			split(execute('args'), "\n")
-
-<		This function is not available in the |sandbox|.
-		Note: If nested, an outer execute() will not observe output of
-		the inner calls.
-		Note: Text attributes (highlights) are not captured.
-		To execute a command in another window than the current one
-		use `win_execute()`.
-
-		Can also be used as a |method|: >
-			GetCommand()->execute()
-
-exepath({expr})						*exepath()*
-		Returns the full path of {expr} if it is an executable and
-		given as a (partial or full) path or is found in $PATH.
-		Returns empty string otherwise.
-		If {expr} starts with "./" the |current-directory| is used.
-
-		Can also be used as a |method|: >
-			GetCommand()->exepath()
-<
-							*exists()*
-exists({expr})	The result is a Number, which is |TRUE| if {expr} is
-		defined, zero otherwise.
-
-		For checking for a supported feature use |has()|.
-		For checking if a file exists use |filereadable()|.
-
-		The {expr} argument is a string, which contains one of these:
-			&option-name	Vim option (only checks if it exists,
-					not if it really works)
-			+option-name	Vim option that works.
-			$ENVNAME	environment variable (could also be
-					done by comparing with an empty
-					string)
-			*funcname	built-in function (see |functions|)
-					or user defined function (see
-					|user-function|). Also works for a
-					variable that is a Funcref.
-			varname		internal variable (see
-					|internal-variables|).  Also works
-					for |curly-braces-names|, |Dictionary|
-					entries, |List| items, etc.  Beware
-					that evaluating an index may cause an
-					error message for an invalid
-					expression.  E.g.: >
-					   :let l = [1, 2, 3]
-					   :echo exists("l[5]")
-<					   0 >
-					   :echo exists("l[xx]")
-<					   E121: Undefined variable: xx
-					   0
-			:cmdname	Ex command: built-in command, user
-					command or command modifier |:command|.
-					Returns:
-					1  for match with start of a command
-					2  full match with a command
-					3  matches several user commands
-					To check for a supported command
-					always check the return value to be 2.
-			:2match		The |:2match| command.
-			:3match		The |:3match| command.
-			#event		autocommand defined for this event
-			#event#pattern	autocommand defined for this event and
-					pattern (the pattern is taken
-					literally and compared to the
-					autocommand patterns character by
-					character)
-			#group		autocommand group exists
-			#group#event	autocommand defined for this group and
-					event.
-			#group#event#pattern
-					autocommand defined for this group,
-					event and pattern.
-			##event		autocommand for this event is
-					supported.
-
-		Examples: >
-			exists("&mouse")
-			exists("$HOSTNAME")
-			exists("*strftime")
-			exists("*s:MyFunc")
-			exists("bufcount")
-			exists(":Make")
-			exists("#CursorHold")
-			exists("#BufReadPre#*.gz")
-			exists("#filetypeindent")
-			exists("#filetypeindent#FileType")
-			exists("#filetypeindent#FileType#*")
-			exists("##ColorScheme")
-<		There must be no space between the symbol (&/$/*/#) and the
-		name.
-		There must be no extra characters after the name, although in
-		a few cases this is ignored.  That may become more strict in
-		the future, thus don't count on it!
-		Working example: >
-			exists(":make")
-<		NOT working example: >
-			exists(":make install")
-
-<		Note that the argument must be a string, not the name of the
-		variable itself.  For example: >
-			exists(bufcount)
-<		This doesn't check for existence of the "bufcount" variable,
-		but gets the value of "bufcount", and checks if that exists.
-
-		Can also be used as a |method|: >
-			Varname()->exists()
-
-exp({expr})						*exp()*
-		Return the exponential of {expr} as a |Float| in the range
-		[0, inf].
-		{expr} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			:echo exp(2)
-<			7.389056 >
-			:echo exp(-1)
-<			0.367879
-
-		Can also be used as a |method|: >
-			Compute()->exp()
-
-debugbreak({pid})					*debugbreak()*
-		Specifically used to interrupt a program being debugged.  It
-		will cause process {pid} to get a SIGTRAP.  Behavior for other
-		processes is undefined. See |terminal-debugger|.
-		{Sends a SIGINT to a process {pid} other than MS-Windows}
-
-		Can also be used as a |method|: >
-			GetPid()->debugbreak()
-
-expand({string} [, {nosuf} [, {list}]])				*expand()*
-		Expand wildcards and the following special keywords in 
-		{string}.  'wildignorecase' applies.
-
-		If {list} is given and it is |TRUE|, a List will be returned.
-		Otherwise the result is a String and when there are several
-		matches, they are separated by <NL> characters.
-
-		If the expansion fails, the result is an empty string.  A name
-		for a non-existing file is not included, unless {string} does
-		not start with '%', '#' or '<', see below.
-
-		When {string} starts with '%', '#' or '<', the expansion is
-		done like for the |cmdline-special| variables with their
-		associated modifiers.  Here is a short overview:
-
-			%		current file name
-			#		alternate file name
-			#n		alternate file name n
-			<cfile>		file name under the cursor
-			<afile>		autocmd file name
-			<abuf>		autocmd buffer number (as a String!)
-			<amatch>	autocmd matched name
-			<sfile>		sourced script file or function name
-			<slnum>		sourced script line number or function
-					line number
-			<sflnum>	script file line number, also when in
-					a function
-			<SID>		"<SNR>123_"  where "123" is the
-					current script ID  |<SID>|
-			<cword>		word under the cursor
-			<cWORD>		WORD under the cursor
-			<client>	the {clientid} of the last received
-					message |server2client()|
-		Modifiers:
-			:p		expand to full path
-			:h		head (last path component removed)
-			:t		tail (last path component only)
-			:r		root (one extension removed)
-			:e		extension only
-
-		Example: >
-			:let &tags = expand("%:p:h") . "/tags"
-<		Note that when expanding a string that starts with '%', '#' or
-		'<', any following text is ignored.  This does NOT work: >
-			:let doesntwork = expand("%:h.bak")
-<		Use this: >
-			:let doeswork = expand("%:h") . ".bak"
-<		Also note that expanding "<cfile>" and others only returns the
-		referenced file name without further expansion.  If "<cfile>"
-		is "~/.cshrc", you need to do another expand() to have the
-		"~/" expanded into the path of the home directory: >
-			:echo expand(expand("<cfile>"))
-<
-		There cannot be white space between the variables and the
-		following modifier.  The |fnamemodify()| function can be used
-		to modify normal file names.
-
-		When using '%' or '#', and the current or alternate file name
-		is not defined, an empty string is used.  Using "%:p" in a
-		buffer with no name, results in the current directory, with a
-		'/' added.
-
-		When {string} does not start with '%', '#' or '<', it is
-		expanded like a file name is expanded on the command line.
-		'suffixes' and 'wildignore' are used, unless the optional
-		{nosuf} argument is given and it is |TRUE|.
-		Names for non-existing files are included.  The "**" item can
-		be used to search in a directory tree.  For example, to find
-		all "README" files in the current directory and below: >
-			:echo expand("**/README")
-<
-		expand() can also be used to expand variables and environment
-		variables that are only known in a shell.  But this can be
-		slow, because a shell may be used to do the expansion.  See
-		|expr-env-expand|.
-		The expanded variable is still handled like a list of file
-		names.  When an environment variable cannot be expanded, it is
-		left unchanged.  Thus ":echo expand('$FOOBAR')" results in
-		"$FOOBAR".
-
-		See |glob()| for finding existing files.  See |system()| for
-		getting the raw output of an external command.
-
-		Can also be used as a |method|: >
-			Getpattern()->expand()
-
-expandcmd({string})					*expandcmd()*
-		Expand special items in String {string} like what is done for
-		an Ex command such as `:edit`.  This expands special keywords,
-		like with |expand()|, and environment variables, anywhere in
-		{string}.  "~user" and "~/path" are only expanded at the
-		start.
-		Returns the expanded string.  Example: >
-			:echo expandcmd('make %<.o')
-
-<		Can also be used as a |method|: >
-			GetCommand()->expandcmd()
-<
-extend({expr1}, {expr2} [, {expr3}])			*extend()*
-		{expr1} and {expr2} must be both |Lists| or both
-		|Dictionaries|.
-
-		If they are |Lists|: Append {expr2} to {expr1}.
-		If {expr3} is given insert the items of {expr2} before the
-		item with index {expr3} in {expr1}.  When {expr3} is zero
-		insert before the first item.  When {expr3} is equal to
-		len({expr1}) then {expr2} is appended.
-		Examples: >
-			:echo sort(extend(mylist, [7, 5]))
-			:call extend(mylist, [2, 3], 1)
-<		When {expr1} is the same List as {expr2} then the number of
-		items copied is equal to the original length of the List.
-		E.g., when {expr3} is 1 you get N new copies of the first item
-		(where N is the original length of the List).
-		Use |add()| to concatenate one item to a list.  To concatenate
-		two lists into a new list use the + operator: >
-			:let newlist = [1, 2, 3] + [4, 5]
-<
-		If they are |Dictionaries|:
-		Add all entries from {expr2} to {expr1}.
-		If a key exists in both {expr1} and {expr2} then {expr3} is
-		used to decide what to do:
-		{expr3} = "keep": keep the value of {expr1}
-		{expr3} = "force": use the value of {expr2}
-		{expr3} = "error": give an error message		*E737*
-		When {expr3} is omitted then "force" is assumed.
-
-		{expr1} is changed when {expr2} is not empty.  If necessary
-		make a copy of {expr1} first.
-		{expr2} remains unchanged.
-		When {expr1} is locked and {expr2} is not empty the operation
-		fails.
-		Returns {expr1}.
-
-		Can also be used as a |method|: >
-			mylist->extend(otherlist)
-
-feedkeys({string} [, {mode}])				*feedkeys()*
-		Characters in {string} are queued for processing as if they
-		come from a mapping or were typed by the user.
-
-		By default the string is added to the end of the typeahead
-		buffer, thus if a mapping is still being executed the
-		characters come after them.  Use the 'i' flag to insert before
-		other characters, they will be executed next, before any
-		characters from a mapping.
-
-		The function does not wait for processing of keys contained in
-		{string}.
-
-		To include special keys into {string}, use double-quotes
-		and "\..." notation |expr-quote|. For example,
-		feedkeys("\<CR>") simulates pressing of the <Enter> key. But
-		feedkeys('\<CR>') pushes 5 characters.
-		The |<Ignore>| keycode may be used to exit the
-		wait-for-character without doing anything.
-
-		{mode} is a String, which can contain these character flags:
-		'm'	Remap keys. This is default.  If {mode} is absent,
-			keys are remapped.
-		'n'	Do not remap keys.
-		't'	Handle keys as if typed; otherwise they are handled as
-			if coming from a mapping.  This matters for undo,
-			opening folds, etc.
-		'i'	Insert the string instead of appending (see above).
-		'x'	Execute commands until typeahead is empty.  This is
-			similar to using ":normal!".  You can call feedkeys()
-			several times without 'x' and then one time with 'x'
-			(possibly with an empty {string}) to execute all the
-			typeahead.  Note that when Vim ends in Insert mode it
-			will behave as if <Esc> is typed, to avoid getting
-			stuck, waiting for a character to be typed before the
-			script continues.
-			Note that if you manage to call feedkeys() while
-			executing commands, thus calling it recursively, then
-			all typehead will be consumed by the last call.
-		'!'	When used with 'x' will not end Insert mode. Can be
-			used in a test when a timer is set to exit Insert mode
-			a little later.  Useful for testing CursorHoldI.
-
-		Return value is always 0.
-
-		Can also be used as a |method|: >
-			GetInput()->feedkeys()
-
-filereadable({file})					*filereadable()*
-		The result is a Number, which is |TRUE| when a file with the
-		name {file} exists, and can be read.  If {file} doesn't exist,
-		or is a directory, the result is |FALSE|.  {file} is any
-		expression, which is used as a String.
-		If you don't care about the file being readable you can use
-		|glob()|.
-		{file} is used as-is, you may want to expand wildcards first: >
-			echo filereadable('~/.vimrc')
-			0
-			echo filereadable(expand('~/.vimrc'))
-			1
-
-<		Can also be used as a |method|: >
-			GetName()->filereadable()
-
-filewritable({file})					*filewritable()*
-		The result is a Number, which is 1 when a file with the
-		name {file} exists, and can be written.  If {file} doesn't
-		exist, or is not writable, the result is 0.  If {file} is a
-		directory, and we can write to it, the result is 2.
-
-		Can also be used as a |method|: >
-			GetName()->filewriteable()
-
-filter({expr1}, {expr2})					*filter()*
-		{expr1} must be a |List|, |Blob|, or a |Dictionary|.
-		For each item in {expr1} evaluate {expr2} and when the result
-		is zero remove the item from the |List| or |Dictionary|. For a
-		|Blob| each byte is removed.
-
-		{expr2} must be a |string| or |Funcref|.
-
-		If {expr2} is a |string|, inside {expr2} |v:val| has the value
-		of the current item.  For a |Dictionary| |v:key| has the key
-		of the current item and for a |List| |v:key| has the index of
-		the current item.  For a |Blob| |v:key| has the index of the
-		current byte.
-
-		Examples: >
-			call filter(mylist, 'v:val !~ "OLD"')
-<		Removes the items where "OLD" appears. >
-			call filter(mydict, 'v:key >= 8')
-<		Removes the items with a key below 8. >
-			call filter(var, 0)
-<		Removes all the items, thus clears the |List| or |Dictionary|.
-
-		Note that {expr2} is the result of expression and is then
-		used as an expression again.  Often it is good to use a
-		|literal-string| to avoid having to double backslashes.
-
-		If {expr2} is a |Funcref| it must take two arguments:
-			1. the key or the index of the current item.
-			2. the value of the current item.
-		The function must return |TRUE| if the item should be kept.
-		Example that keeps the odd items of a list: >
-			func Odd(idx, val)
-			  return a:idx % 2 == 1
-			endfunc
-			call filter(mylist, function('Odd'))
-<		It is shorter when using a |lambda|: >
-			call filter(myList, {idx, val -> idx * val <= 42})
-<		If you do not use "val" you can leave it out: >
-			call filter(myList, {idx -> idx % 2 == 1})
-<
-		The operation is done in-place.  If you want a |List| or
-		|Dictionary| to remain unmodified make a copy first: >
-			:let l = filter(copy(mylist), 'v:val =~ "KEEP"')
-
-<		Returns {expr1}, the |List|, |Blob| or |Dictionary| that was
-		filtered.  When an error is encountered while evaluating
-		{expr2} no further items in {expr1} are processed.  When
-		{expr2} is a Funcref errors inside a function are ignored,
-		unless it was defined with the "abort" flag.
-
-		Can also be used as a |method|: >
-			mylist->filter(expr2)
-
-finddir({name} [, {path} [, {count}]])				*finddir()*
-		Find directory {name} in {path}.  Supports both downwards and
-		upwards recursive directory searches.  See |file-searching|
-		for the syntax of {path}.
-
-		Returns the path of the first found match.  When the found
-		directory is below the current directory a relative path is
-		returned.  Otherwise a full path is returned.
-		If {path} is omitted or empty then 'path' is used.
-
-		If the optional {count} is given, find {count}'s occurrence of
-		{name} in {path} instead of the first one.
-		When {count} is negative return all the matches in a |List|.
-
-		This is quite similar to the ex-command `:find`.
-
-		Can also be used as a |method|: >
-			GetName()->finddir()
-
-findfile({name} [, {path} [, {count}]])				*findfile()*
-		Just like |finddir()|, but find a file instead of a directory.
-		Uses 'suffixesadd'.
-		Example: >
-			:echo findfile("tags.vim", ".;")
-<		Searches from the directory of the current file upwards until
-		it finds the file "tags.vim".
-
-		Can also be used as a |method|: >
-			GetName()->findfile()
-
-flatten({list} [, {maxdepth}])					*flatten()*
-		Flatten {list} up to {maxdepth} levels.  Without {maxdepth}
-		the result is a |List| without nesting, as if {maxdepth} is
-		a very large number.
-		The {list} is changed in place, make a copy first if you do
-		not want that.
-								*E900*
-		{maxdepth} means how deep in nested lists changes are made.
-		{list} is not modified when {maxdepth} is 0.
-		{maxdepth} must be positive number.
-
-		If there is an error the number zero is returned.
-
-		Example: >
-			:echo flatten([1, [2, [3, 4]], 5])
-<			[1, 2, 3, 4, 5] >
-			:echo flatten([1, [2, [3, 4]], 5], 1)
-<			[1, 2, [3, 4], 5]
-
-		Can also be used as a |method|: >
-			mylist->flatten()
-<
-float2nr({expr})					*float2nr()*
-		Convert {expr} to a Number by omitting the part after the
-		decimal point.
-		{expr} must evaluate to a |Float| or a Number.
-		When the value of {expr} is out of range for a |Number| the
-		result is truncated to 0x7fffffff or -0x7fffffff (or when
-		64-bit Number support is enabled, 0x7fffffffffffffff or
-		-0x7fffffffffffffff).  NaN results in -0x80000000 (or when
-		64-bit Number support is enabled, -0x8000000000000000).
-		Examples: >
-			echo float2nr(3.95)
-<			3  >
-			echo float2nr(-23.45)
-<			-23  >
-			echo float2nr(1.0e100)
-<			2147483647  (or 9223372036854775807) >
-			echo float2nr(-1.0e150)
-<			-2147483647 (or -9223372036854775807) >
-			echo float2nr(1.0e-100)
-<			0
-
-		Can also be used as a |method|: >
-			Compute()->float2nr()
-
-floor({expr})							*floor()*
-		Return the largest integral value less than or equal to
-		{expr} as a |Float| (round down).
-		{expr} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			echo floor(1.856)
-<			1.0  >
-			echo floor(-5.456)
-<			-6.0  >
-			echo floor(4.0)
-<			4.0
-
-		Can also be used as a |method|: >
-			Compute()->floor()
-
-fmod({expr1}, {expr2})					*fmod()*
-		Return the remainder of {expr1} / {expr2}, even if the
-		division is not representable.  Returns {expr1} - i * {expr2}
-		for some integer i such that if {expr2} is non-zero, the
-		result has the same sign as {expr1} and magnitude less than
-		the magnitude of {expr2}.  If {expr2} is zero, the value
-		returned is zero.  The value returned is a |Float|.
-		{expr1} and {expr2} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			:echo fmod(12.33, 1.22)
-<			0.13 >
-			:echo fmod(-12.33, 1.22)
-<			-0.13
-
-		Can also be used as a |method|: >
-			Compute()->fmod(1.22)
-
-fnameescape({string})					*fnameescape()*
-		Escape {string} for use as file name command argument.  All
-		characters that have a special meaning, such as '%' and '|'
-		are escaped with a backslash.
-		For most systems the characters escaped are
-		" \t\n*?[{`$\\%#'\"|!<".  For systems where a backslash
-		appears in a filename, it depends on the value of 'isfname'.
-		A leading '+' and '>' is also escaped (special after |:edit|
-		and |:write|).  And a "-" by itself (special after |:cd|).
-		Example: >
-			:let fname = '+some str%nge|name'
-			:exe "edit " . fnameescape(fname)
-<		results in executing: >
-			edit \+some\ str\%nge\|name
-<
-		Can also be used as a |method|: >
-			GetName()->fnameescape()
-
-fnamemodify({fname}, {mods})				*fnamemodify()*
-		Modify file name {fname} according to {mods}.  {mods} is a
-		string of characters like it is used for file names on the
-		command line.  See |filename-modifiers|.
-		Example: >
-			:echo fnamemodify("main.c", ":p:h")
-<		results in: >
-			/home/mool/vim/vim/src
-<		If {mods} is empty then {fname} is returned.
-		Note: Environment variables don't work in {fname}, use
-		|expand()| first then.
-
-		Can also be used as a |method|: >
-			GetName()->fnamemodify(':p:h')
-
-foldclosed({lnum})					*foldclosed()*
-		The result is a Number.  If the line {lnum} is in a closed
-		fold, the result is the number of the first line in that fold.
-		If the line {lnum} is not in a closed fold, -1 is returned.
-		{lnum} is used like with |getline()|.  Thus "." is the current
-		line, "'m" mark m, etc.
-
-		Can also be used as a |method|: >
-			GetLnum()->foldclosed()
-
-foldclosedend({lnum})					*foldclosedend()*
-		The result is a Number.  If the line {lnum} is in a closed
-		fold, the result is the number of the last line in that fold.
-		If the line {lnum} is not in a closed fold, -1 is returned.
-		{lnum} is used like with |getline()|.  Thus "." is the current
-		line, "'m" mark m, etc.
-
-		Can also be used as a |method|: >
-			GetLnum()->foldclosedend()
-
-foldlevel({lnum})					*foldlevel()*
-		The result is a Number, which is the foldlevel of line {lnum}
-		in the current buffer.  For nested folds the deepest level is
-		returned.  If there is no fold at line {lnum}, zero is
-		returned.  It doesn't matter if the folds are open or closed.
-		When used while updating folds (from 'foldexpr') -1 is
-		returned for lines where folds are still to be updated and the
-		foldlevel is unknown.  As a special case the level of the
-		previous line is usually available.
-		{lnum} is used like with |getline()|.  Thus "." is the current
-		line, "'m" mark m, etc.
-
-		Can also be used as a |method|: >
-			GetLnum()->foldlevel()
-<
-							*foldtext()*
-foldtext()	Returns a String, to be displayed for a closed fold.  This is
-		the default function used for the 'foldtext' option and should
-		only be called from evaluating 'foldtext'.  It uses the
-		|v:foldstart|, |v:foldend| and |v:folddashes| variables.
-		The returned string looks like this: >
-			+-- 45 lines: abcdef
-<		The number of leading dashes depends on the foldlevel.  The
-		"45" is the number of lines in the fold.  "abcdef" is the text
-		in the first non-blank line of the fold.  Leading white space,
-		"//" or "/*" and the text from the 'foldmarker' and
-		'commentstring' options is removed.
-		When used to draw the actual foldtext, the rest of the line
-		will be filled with the fold char from the 'fillchars'
-		setting.
-
-foldtextresult({lnum})					*foldtextresult()*
-		Returns the text that is displayed for the closed fold at line
-		{lnum}.  Evaluates 'foldtext' in the appropriate context.
-		When there is no closed fold at {lnum} an empty string is
-		returned.
-		{lnum} is used like with |getline()|.  Thus "." is the current
-		line, "'m" mark m, etc.
-		Useful when exporting folded text, e.g., to HTML.
-
-		Can also be used as a |method|: >
-			GetLnum()->foldtextresult()
-<
-							*foreground()*
-foreground()	Move the Vim window to the foreground.  Useful when sent from
-		a client to a Vim server. |remote_send()|
-		On Win32 systems this might not work, the OS does not always
-		allow a window to bring itself to the foreground.  Use
-		|remote_foreground()| instead.
-		{only in the Win32 GUI and console version}
-
-fullcommand({name})						*fullcommand()*
-		Get the full command name from a short abbreviated command
-		name; see |20.2| for details on command abbreviations.
-
-		The string argument {name} may start with a `:` and can
-		include a [range], these are skipped and not returned.
-		Returns an empty string if a command doesn't exist or if it's
-		ambiguous (for user-defined commands).
-
-		For example `fullcommand('s')`, `fullcommand('sub')`,
-		`fullcommand(':%substitute')` all return "substitute".
-
-		Can also be used as a |method|: >
-			GetName()->fullcommand()
-<
-						*funcref()*
-funcref({name} [, {arglist}] [, {dict}])
-		Just like |function()|, but the returned Funcref will lookup
-		the function by reference, not by name.  This matters when the
-		function {name} is redefined later.
-
-		Unlike |function()|, {name} must be an existing user function.
-		It only works for an autoloaded function if it has already
-		been loaded (to avoid mistakenly loading the autoload script
-		when only intending to use the function name, use |function()|
-		instead). {name} cannot be a builtin function.
-
-		Can also be used as a |method|: >
-			GetFuncname()->funcref([arg])
-<
-				       *function()* *E700* *E922* *E923*
-function({name} [, {arglist}] [, {dict}])
-		Return a |Funcref| variable that refers to function {name}.
-		{name} can be a user defined function or an internal function.
-
-		{name} can also be a Funcref or a partial. When it is a
-		partial the dict stored in it will be used and the {dict}
-		argument is not allowed. E.g.: >
-			let FuncWithArg = function(dict.Func, [arg])
-			let Broken = function(dict.Func, [arg], dict)
-<
-		When using the Funcref the function will be found by {name},
-		also when it was redefined later. Use |funcref()| to keep the
-		same function.
-
-		When {arglist} or {dict} is present this creates a partial.
-		That means the argument list and/or the dictionary is stored in
-		the Funcref and will be used when the Funcref is called.
-
-		The arguments are passed to the function in front of other
-		arguments, but after any argument from |method|.  Example: >
-			func Callback(arg1, arg2, name)
-			...
-			let Partial = function('Callback', ['one', 'two'])
-			...
-			call Partial('name')
-<		Invokes the function as with: >
-			call Callback('one', 'two', 'name')
-
-<		The Dictionary is only useful when calling a "dict" function.
-		In that case the {dict} is passed in as "self". Example: >
-			function Callback() dict
-			   echo "called for " . self.name
-			endfunction
-			...
-			let context = {"name": "example"}
-			let Func = function('Callback', context)
-			...
-			call Func()	" will echo: called for example
-
-<		The argument list and the Dictionary can be combined: >
-			function Callback(arg1, count) dict
-			...
-			let context = {"name": "example"}
-			let Func = function('Callback', ['one'], context)
-			...
-			call Func(500)
-<		Invokes the function as with: >
-			call context.Callback('one', 500)
-<
-		Can also be used as a |method|: >
-			GetFuncname()->function([arg])
-
-garbagecollect([{atexit}])				*garbagecollect()*
-		Cleanup unused |Lists| and |Dictionaries| that have circular
-		references.
-
-		There is hardly ever a need to invoke this function, as it is
-		automatically done when Vim runs out of memory or is waiting
-		for the user to press a key after 'updatetime'.  Items without
-		circular references are always freed when they become unused.
-		This is useful if you have deleted a very big |List| and/or
-		|Dictionary| with circular references in a script that runs
-		for a long time.
-
-		When the optional {atexit} argument is one, garbage
-		collection will also be done when exiting Vim, if it wasn't
-		done before.  This is useful when checking for memory leaks.
-
-		The garbage collection is not done immediately but only when
-		it's safe to perform.  This is when waiting for the user to
-		type a character.
-
-get({list}, {idx} [, {default}])			*get()*
-		Get item {idx} from |List| {list}.  When this item is not
-		available return {default}.  Return zero when {default} is
-		omitted.
-		Can also be used as a |method|: >
-			mylist->get(idx)
-get({blob}, {idx} [, {default}])
-		Get byte {idx} from |Blob| {blob}.  When this byte is not
-		available return {default}.  Return -1 when {default} is
-		omitted.
-get({dict}, {key} [, {default}])
-		Get item with key {key} from |Dictionary| {dict}.  When this
-		item is not available return {default}.  Return zero when
-		{default} is omitted.  Useful example: >
-			let val = get(g:, 'var_name', 'default')
-<		This gets the value of g:var_name if it exists, and uses
-		'default' when it does not exist.
-get({func}, {what})
-		Get item {what} from Funcref {func}.  Possible values for
-		{what} are:
-			"name"	The function name
-			"func"	The function
-			"dict"	The dictionary
-			"args"	The list with arguments
-
-							*getbufinfo()*
-getbufinfo([{buf}])
-getbufinfo([{dict}])
-		Get information about buffers as a List of Dictionaries.
-
-		Without an argument information about all the buffers is
-		returned.
-
-		When the argument is a |Dictionary| only the buffers matching
-		the specified criteria are returned.  The following keys can
-		be specified in {dict}:
-			buflisted	include only listed buffers.
-			bufloaded	include only loaded buffers.
-			bufmodified	include only modified buffers.
-
-		Otherwise, {buf} specifies a particular buffer to return
-		information for.  For the use of {buf}, see |bufname()|
-		above.  If the buffer is found the returned List has one item.
-		Otherwise the result is an empty list.
-
-		Each returned List item is a dictionary with the following
-		entries:
-			bufnr		Buffer number.
-			changed		TRUE if the buffer is modified.
-			changedtick	Number of changes made to the buffer.
-			hidden		TRUE if the buffer is hidden.
-			lastused	Timestamp in seconds, like
-					|localtime()|, when the buffer was
-					last used.
-			listed		TRUE if the buffer is listed.
-			lnum		Line number used for the buffer when
-					opened in the current window.
-					Only valid if the buffer has been
-					displayed in the window in the past.
-					If you want the line number of the
-					last known cursor position in a given
-					window, use |line()|: >
-						:echo line('.', {winid})
-<
-			linecount	Number of lines in the buffer (only
-					valid when loaded)
-			loaded		TRUE if the buffer is loaded.
-			name		Full path to the file in the buffer.
-			signs		List of signs placed in the buffer.
-					Each list item is a dictionary with
-					the following fields:
-					    id	  sign identifier
-					    lnum  line number
-					    name  sign name
-			variables	A reference to the dictionary with
-					buffer-local variables.
-			windows		List of |window-ID|s that display this
-					buffer
-
-		Examples: >
-			for buf in getbufinfo()
-			    echo buf.name
-			endfor
-			for buf in getbufinfo({'buflisted':1})
-			    if buf.changed
-				....
-			    endif
-			endfor
-<
-		To get buffer-local options use: >
-			getbufvar({bufnr}, '&option_name')
-<
-		Can also be used as a |method|: >
-			GetBufnr()->getbufinfo()
-<
-							*getbufline()*
-getbufline({buf}, {lnum} [, {end}])
-		Return a |List| with the lines starting from {lnum} to {end}
-		(inclusive) in the buffer {buf}.  If {end} is omitted, a
-		|List| with only the line {lnum} is returned.
-
-		For the use of {buf}, see |bufname()| above.
-
-		For {lnum} and {end} "$" can be used for the last line of the
-		buffer.  Otherwise a number must be used.
-
-		When {lnum} is smaller than 1 or bigger than the number of
-		lines in the buffer, an empty |List| is returned.
-
-		When {end} is greater than the number of lines in the buffer,
-		it is treated as {end} is set to the number of lines in the
-		buffer.  When {end} is before {lnum} an empty |List| is
-		returned.
-
-		This function works only for loaded buffers.  For unloaded and
-		non-existing buffers, an empty |List| is returned.
-
-		Example: >
-			:let lines = getbufline(bufnr("myfile"), 1, "$")
-
-<		Can also be used as a |method|: >
-			GetBufnr()->getbufline(lnum)
-
-getbufvar({buf}, {varname} [, {def}])				*getbufvar()*
-		The result is the value of option or local buffer variable
-		{varname} in buffer {buf}.  Note that the name without "b:"
-		must be used.
-		The {varname} argument is a string.
-		When {varname} is empty returns a |Dictionary| with all the
-		buffer-local variables.
-		When {varname} is equal to "&" returns a |Dictionary| with all
-		the buffer-local options.
-		Otherwise, when {varname} starts with "&" returns the value of
-		a buffer-local option.
-		This also works for a global or buffer-local option, but it
-		doesn't work for a global variable, window-local variable or
-		window-local option.
-		For the use of {buf}, see |bufname()| above.
-		When the buffer or variable doesn't exist {def} or an empty
-		string is returned, there is no error message.
-		Examples: >
-			:let bufmodified = getbufvar(1, "&mod")
-			:echo "todo myvar = " . getbufvar("todo", "myvar")
-
-<		Can also be used as a |method|: >
-			GetBufnr()->getbufvar(varname)
-<
-getchangelist([{buf}])					*getchangelist()*
-		Returns the |changelist| for the buffer {buf}. For the use
-		of {buf}, see |bufname()| above. If buffer {buf} doesn't
-		exist, an empty list is returned.
-
-		The returned list contains two entries: a list with the change
-		locations and the current position in the list.  Each
-		entry in the change list is a dictionary with the following
-		entries:
-			col		column number
-			coladd		column offset for 'virtualedit'
-			lnum		line number
-		If buffer {buf} is the current buffer, then the current
-		position refers to the position in the list. For other
-		buffers, it is set to the length of the list.
-
-		Can also be used as a |method|: >
-			GetBufnr()->getchangelist()
-
-getchar([expr])						*getchar()*
-		Get a single character from the user or input stream.
-		If [expr] is omitted, wait until a character is available.
-		If [expr] is 0, only get a character when one is available.
-			Return zero otherwise.
-		If [expr] is 1, only check if a character is available, it is
-			not consumed.  Return zero if no character available.
-		If you prefer always getting a string use |getcharstr()|.
-
-		Without [expr] and when [expr] is 0 a whole character or
-		special key is returned.  If it is a single character, the
-		result is a number.  Use nr2char() to convert it to a String.
-		Otherwise a String is returned with the encoded character.
-		For a special key it's a String with a sequence of bytes
-		starting with 0x80 (decimal: 128).  This is the same value as
-		the String "\<Key>", e.g., "\<Left>".  The returned value is
-		also a String when a modifier (shift, control, alt) was used
-		that is not included in the character.
-
-		When [expr] is 0 and Esc is typed, there will be a short delay
-		while Vim waits to see if this is the start of an escape
-		sequence.
-
-		When [expr] is 1 only the first byte is returned.  For a
-		one-byte character it is the character itself as a number.
-		Use nr2char() to convert it to a String.
-
-		Use getcharmod() to obtain any additional modifiers.
-
-		When the user clicks a mouse button, the mouse event will be
-		returned.  The position can then be found in |v:mouse_col|,
-		|v:mouse_lnum|, |v:mouse_winid| and |v:mouse_win|.
-		|getmousepos()| can also be used.  Mouse move events will be
-		ignored.
-		This example positions the mouse as it would normally happen: >
-			let c = getchar()
-			if c == "\<LeftMouse>" && v:mouse_win > 0
-			  exe v:mouse_win . "wincmd w"
-			  exe v:mouse_lnum
-			  exe "normal " . v:mouse_col . "|"
-			endif
-<
-		There is no prompt, you will somehow have to make clear to the
-		user that a character has to be typed.  The screen is not
-		redrawn, e.g. when resizing the window.
-
-		There is no mapping for the character.
-		Key codes are replaced, thus when the user presses the <Del>
-		key you get the code for the <Del> key, not the raw character
-		sequence.  Examples: >
-			getchar() == "\<Del>"
-			getchar() == "\<S-Left>"
-<		This example redefines "f" to ignore case: >
-			:nmap f :call FindChar()<CR>
-			:function FindChar()
-			:  let c = nr2char(getchar())
-			:  while col('.') < col('$') - 1
-			:    normal l
-			:    if getline('.')[col('.') - 1] ==? c
-			:      break
-			:    endif
-			:  endwhile
-			:endfunction
-<
-getcharmod()						*getcharmod()*
-		The result is a Number which is the state of the modifiers for
-		the last obtained character with getchar() or in another way.
-		These values are added together:
-			2	shift
-			4	control
-			8	alt (meta)
-			16	meta (when it's different from ALT)
-			32	mouse double click
-			64	mouse triple click
-			96	mouse quadruple click (== 32 + 64)
-			128	command (Macintosh only)
-		Only the modifiers that have not been included in the
-		character itself are obtained.  Thus Shift-a results in "A"
-		without a modifier.
-
-getcharsearch()						*getcharsearch()*
-		Return the current character search information as a {dict}
-		with the following entries:
-
-		    char	character previously used for a character
-				search (|t|, |f|, |T|, or |F|); empty string
-				if no character search has been performed
-		    forward	direction of character search; 1 for forward,
-				0 for backward
-		    until	type of character search; 1 for a |t| or |T|
-				character search, 0 for an |f| or |F|
-				character search
-
-		This can be useful to always have |;| and |,| search
-		forward/backward regardless of the direction of the previous
-		character search: >
-			:nnoremap <expr> ; getcharsearch().forward ? ';' : ','
-			:nnoremap <expr> , getcharsearch().forward ? ',' : ';'
-<		Also see |setcharsearch()|.
-
-
-getcharstr([expr])					*getcharstr()*
-		Get a single character from the user or input stream as a
-		string.
-		If [expr] is omitted, wait until a character is available.
-		If [expr] is 0 or false, only get a character when one is
-			available.  Return an empty string otherwise.
-		If [expr] is 1 or true, only check if a character is
-			available, it is not consumed.  Return an empty string
-			if no character is available.
-		Otherwise this works like |getchar()|, except that a number
-		result is converted to a string.
-
-
-getcmdline()						*getcmdline()*
-		Return the current command-line.  Only works when the command
-		line is being edited, thus requires use of |c_CTRL-\_e| or
-		|c_CTRL-R_=|.
-		Example: >
-			:cmap <F7> <C-\>eescape(getcmdline(), ' \')<CR>
-<		Also see |getcmdtype()|, |getcmdpos()| and |setcmdpos()|.
-		Returns an empty string when entering a password or using
-		|inputsecret()|.
-
-getcmdpos()						*getcmdpos()*
-		Return the position of the cursor in the command line as a
-		byte count.  The first column is 1.
-		Only works when editing the command line, thus requires use of
-		|c_CTRL-\_e| or |c_CTRL-R_=| or an expression mapping.
-		Returns 0 otherwise.
-		Also see |getcmdtype()|, |setcmdpos()| and |getcmdline()|.
-
-getcmdtype()						*getcmdtype()*
-		Return the current command-line type. Possible return values
-		are:
-		    :	normal Ex command
-		    >	debug mode command |debug-mode|
-		    /	forward search command
-		    ?	backward search command
-		    @	|input()| command
-		    -	|:insert| or |:append| command
-		    =	|i_CTRL-R_=|
-		Only works when editing the command line, thus requires use of
-		|c_CTRL-\_e| or |c_CTRL-R_=| or an expression mapping.
-		Returns an empty string otherwise.
-		Also see |getcmdpos()|, |setcmdpos()| and |getcmdline()|.
-
-getcmdwintype()						*getcmdwintype()*
-		Return the current |command-line-window| type. Possible return
-		values are the same as |getcmdtype()|. Returns an empty string
-		when not in the command-line window.
-
-getcompletion({pat}, {type} [, {filtered}])		*getcompletion()*
-		Return a list of command-line completion matches. The String
-		{type} argument specifies what for.  The following completion
-		types are supported:
-
-		arglist		file names in argument list
-		augroup		autocmd groups
-		buffer		buffer names
-		behave		:behave suboptions
-		cmdline		|cmdline-completion| result
-		color		color schemes
-		command		Ex command
-		compiler	compilers
-		cscope		|:cscope| suboptions
-		diff_buffer     |:diffget| and |:diffput| completion
-		dir		directory names
-		environment	environment variable names
-		event		autocommand events
-		expression	Vim expression
-		file		file and directory names
-		file_in_path	file and directory names in |'path'|
-		filetype	filetype names |'filetype'|
-		function	function name
-		help		help subjects
-		highlight	highlight groups
-		history		:history suboptions
-		locale		locale names (as output of locale -a)
-		mapclear	buffer argument
-		mapping		mapping name
-		menu		menus
-		messages	|:messages| suboptions
-		option		options
-		packadd		optional package |pack-add| names
-		shellcmd	Shell command
-		sign		|:sign| suboptions
-		syntax		syntax file names |'syntax'|
-		syntime		|:syntime| suboptions
-		tag		tags
-		tag_listfiles	tags, file names
-		user		user names
-		var		user variables
-
-		If {pat} is an empty string, then all the matches are
-		returned.  Otherwise only items matching {pat} are returned.
-		See |wildcards| for the use of special characters in {pat}.
-
-		If the optional {filtered} flag is set to 1, then 'wildignore'
-		is applied to filter the results.  Otherwise all the matches
-		are returned. The 'wildignorecase' option always applies.
-
-		If {type} is "cmdline", then the |cmdline-completion| result is
-		returned.  For example, to complete the possible values after
-		a ":call" command: >
-			echo getcompletion('call ', 'cmdline')
-<
-		If there are no matches, an empty list is returned.  An
-		invalid value for {type} produces an error.
-
-		Can also be used as a |method|: >
-			GetPattern()->getcompletion('color')
-<
-							*getcurpos()*
-getcurpos()	Get the position of the cursor.  This is like getpos('.'), but
-		includes an extra "curswant" in the list:
-		    [0, lnum, col, off, curswant] ~
-		The "curswant" number is the preferred column when moving the
-		cursor vertically.  Also see |getpos()|.
-		The first "bufnum" item is always zero.
-
- 		This can be used to save and restore the cursor position: >
- 			let save_cursor = getcurpos()
- 			MoveTheCursorAround
- 			call setpos('.', save_cursor)
-<		Note that this only works within the window.  See
-		|winrestview()| for restoring more state.
-
-getcwd([{winnr}[, {tabnr}]])				*getcwd()*
-		With no arguments, returns the name of the effective
-		|current-directory|. With {winnr} or {tabnr} the working
-		directory of that scope is returned, and 'autochdir' is
-		ignored.
-		Tabs and windows are identified by their respective numbers,
-		0 means current tab or window. Missing tab number implies 0.
-		Thus the following are equivalent: >
-			getcwd(0)
-			getcwd(0, 0)
-<		If {winnr} is -1 it is ignored, only the tab is resolved.
-		{winnr} can be the window number or the |window-ID|.
-		If both {winnr} and {tabnr} are -1 the global working
-		directory is returned.
-		Throw error if the arguments are invalid. |E5000| |E5001| |E5002|
-
-		Can also be used as a |method|: >
-			GetWinnr()->getcwd()
-
-getenv({name})						*getenv()*
-		Return the value of environment variable {name}.  The {name}
-		argument is a string, without a leading '$'.  Example: >
-			myHome = getenv('HOME')
-
-<		When the variable does not exist |v:null| is returned.  That
-		is different from a variable set to an empty string.
-		See also |expr-env|.
-
-		Can also be used as a |method|: >
-			GetVarname()->getenv()
-
-getfontname([{name}])					*getfontname()*
-		Without an argument returns the name of the normal font being
-		used.  Like what is used for the Normal highlight group
-		|hl-Normal|.
-		With an argument a check is done whether String {name} is a
-		valid font name.  If not then an empty string is returned.
-		Otherwise the actual font name is returned, or {name} if the
-		GUI does not support obtaining the real name.
-		Only works when the GUI is running, thus not in your vimrc or
-		gvimrc file.  Use the |GUIEnter| autocommand to use this
-		function just after the GUI has started.
-
-getfperm({fname})					*getfperm()*
-		The result is a String, which is the read, write, and execute
-		permissions of the given file {fname}.
-		If {fname} does not exist or its directory cannot be read, an
-		empty string is returned.
-		The result is of the form "rwxrwxrwx", where each group of
-		"rwx" flags represent, in turn, the permissions of the owner
-		of the file, the group the file belongs to, and other users.
-		If a user does not have a given permission the flag for this
-		is replaced with the string "-".  Examples: >
-			:echo getfperm("/etc/passwd")
-			:echo getfperm(expand("~/.config/nvim/init.vim"))
-<		This will hopefully (from a security point of view) display
-		the string "rw-r--r--" or even "rw-------".
-
-		Can also be used as a |method|: >
-			GetFilename()->getfperm()
-<
-		For setting permissions use |setfperm()|.
-
-getfsize({fname})					*getfsize()*
-		The result is a Number, which is the size in bytes of the
-		given file {fname}.
-		If {fname} is a directory, 0 is returned.
-		If the file {fname} can't be found, -1 is returned.
-		If the size of {fname} is too big to fit in a Number then -2
-		is returned.
-
-		Can also be used as a |method|: >
-			GetFilename()->getfsize()
-
-getftime({fname})					*getftime()*
-		The result is a Number, which is the last modification time of
-		the given file {fname}.  The value is measured as seconds
-		since 1st Jan 1970, and may be passed to strftime().  See also
-		|localtime()| and |strftime()|.
-		If the file {fname} can't be found -1 is returned.
-
-		Can also be used as a |method|: >
-			GetFilename()->getftime()
-
-getftype({fname})					*getftype()*
-		The result is a String, which is a description of the kind of
-		file of the given file {fname}.
-		If {fname} does not exist an empty string is returned.
-		Here is a table over different kinds of files and their
-		results:
-			Normal file		"file"
-			Directory		"dir"
-			Symbolic link		"link"
-			Block device		"bdev"
-			Character device	"cdev"
-			Socket			"socket"
-			FIFO			"fifo"
-			All other		"other"
-		Example: >
-			getftype("/home")
-<		Note that a type such as "link" will only be returned on
-		systems that support it.  On some systems only "dir" and
-		"file" are returned.
-
-		Can also be used as a |method|: >
-			GetFilename()->getftype()
-
-getjumplist([{winnr} [, {tabnr}]])			*getjumplist()*
-		Returns the |jumplist| for the specified window.
-
-		Without arguments use the current window.
-		With {winnr} only use this window in the current tab page.
-		{winnr} can also be a |window-ID|.
-		With {winnr} and {tabnr} use the window in the specified tab
-		page.
-
-		The returned list contains two entries: a list with the jump
-		locations and the last used jump position number in the list.
-		Each entry in the jump location list is a dictionary with
-		the following entries:
-			bufnr		buffer number
-			col		column number
-			coladd		column offset for 'virtualedit'
-			filename	filename if available
-			lnum		line number
-
-		Can also be used as a |method|: >
-			GetWinnr()->getjumplist()
-
-<							*getline()*
-getline({lnum} [, {end}])
-		Without {end} the result is a String, which is line {lnum}
-		from the current buffer.  Example: >
-			getline(1)
-<		When {lnum} is a String that doesn't start with a
-		digit, |line()| is called to translate the String into a Number.
-		To get the line under the cursor: >
-			getline(".")
-<		When {lnum} is a number smaller than 1 or bigger than the
-		number of lines in the buffer, an empty string is returned.
-
-		When {end} is given the result is a |List| where each item is
-		a line from the current buffer in the range {lnum} to {end},
-		including line {end}.
-		{end} is used in the same way as {lnum}.
-		Non-existing lines are silently omitted.
-		When {end} is before {lnum} an empty |List| is returned.
-		Example: >
-			:let start = line('.')
-			:let end = search("^$") - 1
-			:let lines = getline(start, end)
-
-<		Can also be used as a |method|: >
-			ComputeLnum()->getline()
-
-<		To get lines from another buffer see |getbufline()|
-
-getloclist({nr},[, {what}])				*getloclist()*
-		Returns a |List| with all the entries in the location list for
-		window {nr}.  {nr} can be the window number or the |window-ID|.
-		When {nr} is zero the current window is used.
-
-		For a location list window, the displayed location list is
-		returned.  For an invalid window number {nr}, an empty list is
-		returned. Otherwise, same as |getqflist()|.
-
-		If the optional {what} dictionary argument is supplied, then
-		returns the items listed in {what} as a dictionary. Refer to
-		|getqflist()| for the supported items in {what}.
-		If {what} contains 'filewinid', then returns the id of the
-		window used to display files from the location list. This
-		field is applicable only when called from a location list
-		window. See |location-list-file-window| for more details.
-
-		Returns a |Dictionary| with default values if there is no
-		location list for the window {nr}.
-		Returns an empty Dictionary if window {nr} does not exist.
-
-		Examples (See also |getqflist-examples|): >
-			:echo getloclist(3, {'all': 0})
-			:echo getloclist(5, {'filewinid': 0})
-
-
-getmarklist([{buf}])					*getmarklist()*
-		Without the {buf} argument returns a |List| with information
-		about all the global marks. |mark|
-
-		If the optional {buf} argument is specified, returns the
-		local marks defined in buffer {buf}.  For the use of {buf},
-		see |bufname()|.
-
-		Each item in the returned List is a |Dict| with the following:
-		    mark   name of the mark prefixed by "'"
-		    pos	   a |List| with the position of the mark:
-				[bufnum, lnum, col, off]
-			   Refer to |getpos()| for more information.
-		    file   file name
-
-		Refer to |getpos()| for getting information about a specific
-		mark.
-
-		Can also be used as a |method|: >
-			GetBufnr()->getmarklist()
-
-getmatches([{win}])					*getmatches()*
-		Returns a |List| with all matches previously defined for the
-		current window by |matchadd()| and the |:match| commands.
-		|getmatches()| is useful in combination with |setmatches()|,
-		as |setmatches()| can restore a list of matches saved by
-		|getmatches()|.
-		If {win} is specified, use the window with this number or
-		window ID instead of the current window.
-		Example: >
-			:echo getmatches()
-<			[{'group': 'MyGroup1', 'pattern': 'TODO',
-			'priority': 10, 'id': 1}, {'group': 'MyGroup2',
-			'pattern': 'FIXME', 'priority': 10, 'id': 2}] >
-			:let m = getmatches()
-			:call clearmatches()
-			:echo getmatches()
-<			[] >
-			:call setmatches(m)
-			:echo getmatches()
-<			[{'group': 'MyGroup1', 'pattern': 'TODO',
-			'priority': 10, 'id': 1}, {'group': 'MyGroup2',
-			'pattern': 'FIXME', 'priority': 10, 'id': 2}] >
-			:unlet m
-<
-getmousepos()						*getmousepos()*
-		Returns a Dictionary with the last known position of the
-		mouse.  This can be used in a mapping for a mouse click.  The
-		items are:
-			screenrow	screen row
-			screencol	screen column
-			winid		Window ID of the click
-			winrow		row inside "winid"
-			wincol		column inside "winid"
-			line		text line inside "winid"
-			column		text column inside "winid"
-		All numbers are 1-based.
-
-		If not over a window, e.g. when in the command line, then only
-		"screenrow" and "screencol" are valid, the others are zero.
-
-		When on the status line below a window or the vertical
-		separater right of a window, the "line" and "column" values
-		are zero.
-
-		When the position is after the text then "column" is the
-		length of the text in bytes plus one.
-
-		If the mouse is over a focusable floating window then that
-		window is used.
-
-		When using |getchar()| the Vim variables |v:mouse_lnum|,
-		|v:mouse_col| and |v:mouse_winid| also provide these values.
-
-							*getpid()*
-getpid()	Return a Number which is the process ID of the Vim process.
-		This is a unique number, until Vim exits.
-
-							*getpos()*
-getpos({expr})	Get the position for String {expr}.  For possible values of
-		{expr} see |line()|.  For getting the cursor position see
-		|getcurpos()|.
-		The result is a |List| with four numbers:
-		    [bufnum, lnum, col, off]
-		"bufnum" is zero, unless a mark like '0 or 'A is used, then it
-		is the buffer number of the mark.
-		"lnum" and "col" are the position in the buffer.  The first
-		column is 1.
-		The "off" number is zero, unless 'virtualedit' is used.  Then
-		it is the offset in screen columns from the start of the
-		character.  E.g., a position within a <Tab> or after the last
-		character.
-		Note that for '< and '> Visual mode matters: when it is "V"
-		(visual line mode) the column of '< is zero and the column of
-		'> is a large number.
-		The column number in the returned List is the byte position
-		within the line.
-		The column number can be very large, e.g. 2147483647, in which
-		case it means "after the end of the line".
-		This can be used to save and restore the position of a mark: >
-			let save_a_mark = getpos("'a")
-			...
-			call setpos("'a", save_a_mark)
-<		Also see |getcurpos()| and |setpos()|.
-
-		Can also be used as a |method|: >
-			GetMark()->getpos()
-
-getqflist([{what}])					*getqflist()*
-		Returns a |List| with all the current quickfix errors.  Each
-		list item is a dictionary with these entries:
-			bufnr	number of buffer that has the file name, use
-				bufname() to get the name
-			module	module name
-			lnum	line number in the buffer (first line is 1)
-			end_lnum
-				end of line number if the item is multiline
-			col	column number (first column is 1)
-			end_col	end of column number if the item has range
-			vcol	|TRUE|: "col" is visual column
-				|FALSE|: "col" is byte index
-			nr	error number
-			pattern	search pattern used to locate the error
-			text	description of the error
-			type	type of the error, 'E', '1', etc.
-			valid	|TRUE|: recognized error message
-
-		When there is no error list or it's empty, an empty list is
-		returned. Quickfix list entries with a non-existing buffer
-		number are returned with "bufnr" set to zero (Note: some
-		functions accept buffer number zero for the alternate buffer,
-		you may need to explicitly check for zero).
-
-		Useful application: Find pattern matches in multiple files and
-		do something with them: >
-			:vimgrep /theword/jg *.c
-			:for d in getqflist()
-			:   echo bufname(d.bufnr) ':' d.lnum '=' d.text
-			:endfor
-<
-		If the optional {what} dictionary argument is supplied, then
-		returns only the items listed in {what} as a dictionary. The
-		following string items are supported in {what}:
-			changedtick	get the total number of changes made
-					to the list |quickfix-changedtick|
-			context	get the |quickfix-context|
-			efm	errorformat to use when parsing "lines". If
-				not present, then the 'errorformat' option
-				value is used.
-			id	get information for the quickfix list with
-				|quickfix-ID|; zero means the id for the
-				current list or the list specified by "nr"
-			idx	get information for the quickfix entry at this
-				index in the list specified by 'id' or 'nr'.
-				If set to zero, then uses the current entry.
-				See |quickfix-index|
-			items	quickfix list entries
-			lines	parse a list of lines using 'efm' and return
-				the resulting entries.  Only a |List| type is
-				accepted.  The current quickfix list is not
-				modified. See |quickfix-parse|.
-			nr	get information for this quickfix list; zero
-				means the current quickfix list and "$" means
-				the last quickfix list
-			size	number of entries in the quickfix list
-			title	get the list title |quickfix-title|
-			winid	get the quickfix |window-ID|
-			all	all of the above quickfix properties
-		Non-string items in {what} are ignored. To get the value of a
-		particular item, set it to zero.
-		If "nr" is not present then the current quickfix list is used.
-		If both "nr" and a non-zero "id" are specified, then the list
-		specified by "id" is used.
-		To get the number of lists in the quickfix stack, set "nr" to
-		"$" in {what}. The "nr" value in the returned dictionary
-		contains the quickfix stack size.
-		When "lines" is specified, all the other items except "efm"
-		are ignored.  The returned dictionary contains the entry
-		"items" with the list of entries.
-
-		The returned dictionary contains the following entries:
-			changedtick	total number of changes made to the
-					list |quickfix-changedtick|
-			context	quickfix list context. See |quickfix-context|
-				If not present, set to "".
-			id	quickfix list ID |quickfix-ID|. If not
-				present, set to 0.
-			idx	index of the quickfix entry in the list. If not
-				present, set to 0.
-			items	quickfix list entries. If not present, set to
-				an empty list.
-			nr	quickfix list number. If not present, set to 0
-			size	number of entries in the quickfix list. If not
-				present, set to 0.
-			title	quickfix list title text. If not present, set
-				to "".
-			winid	quickfix |window-ID|. If not present, set to 0
-
-		Examples (See also |getqflist-examples|): >
-			:echo getqflist({'all': 1})
-			:echo getqflist({'nr': 2, 'title': 1})
-			:echo getqflist({'lines' : ["F1:10:L10"]})
-<
-getreg([{regname} [, 1 [, {list}]]])			*getreg()*
-		The result is a String, which is the contents of register
-		{regname}.  Example: >
-			:let cliptext = getreg('*')
-<		When register {regname} was not set the result is an empty
-		string.
-		The {regname} argument must be a string.
-
-		getreg('=') returns the last evaluated value of the expression
-		register.  (For use in maps.)
-		getreg('=', 1) returns the expression itself, so that it can
-		be restored with |setreg()|.  For other registers the extra
-		argument is ignored, thus you can always give it.
-
-		If {list} is present and |TRUE|, the result type is changed
-		to |List|. Each list item is one text line. Use it if you care
-		about zero bytes possibly present inside register: without
-		third argument both NLs and zero bytes are represented as NLs
-		(see |NL-used-for-Nul|).
-		When the register was not set an empty list is returned.
-
-		If {regname} is not specified, |v:register| is used.
-
-		Can also be used as a |method|: >
-			GetRegname()->getreg()
-
-getreginfo([{regname}])					*getreginfo()*
-		Returns detailed information about register {regname} as a
-		Dictionary with the following entries:
-			regcontents	List of lines contained in register
-					{regname}, like
-					|getreg|({regname}, 1, 1).
-			regtype		the type of register {regname}, as in
-					|getregtype()|.
-			isunnamed	Boolean flag, v:true if this register
-					is currently pointed to by the unnamed
-					register.
-			points_to	for the unnamed register, gives the
-					single letter name of the register
-					currently pointed to (see |quotequote|).
-					For example, after deleting a line
-					with `dd`, this field will be "1",
-					which is the register that got the
-					deleted text.
-
-		The {regname} argument is a string.  If {regname} is invalid
-		or not set, an empty Dictionary will be returned.
-		If {regname} is not specified, |v:register| is used.
-		The returned Dictionary can be passed to |setreg()|.
-
-		Can also be used as a |method|: >
-			GetRegname()->getreginfo()
-
-getregtype([{regname}])					*getregtype()*
-		The result is a String, which is type of register {regname}.
-		The value will be one of:
-		    "v"			for |charwise| text
-		    "V"			for |linewise| text
-		    "<CTRL-V>{width}"	for |blockwise-visual| text
-		    ""			for an empty or unknown register
-		<CTRL-V> is one character with value 0x16.
-		The {regname} argument is a string.  If {regname} is not
-		specified, |v:register| is used.
-
-		Can also be used as a |method|: >
-			GetRegname()->getregtype()
-
-gettabinfo([{tabnr}])					*gettabinfo()*
-		If {tabnr} is not specified, then information about all the
-		tab pages is returned as a |List|. Each List item is a
-		|Dictionary|.  Otherwise, {tabnr} specifies the tab page
-		number and information about that one is returned.  If the tab
-		page does not exist an empty List is returned.
-
-		Each List item is a |Dictionary| with the following entries:
-			tabnr		tab page number.
-			variables	a reference to the dictionary with
-					tabpage-local variables
-			windows		List of |window-ID|s in the tab page.
-
-		Can also be used as a |method|: >
-			GetTabnr()->gettabinfo()
-
-gettabvar({tabnr}, {varname} [, {def}])				*gettabvar()*
-		Get the value of a tab-local variable {varname} in tab page
-		{tabnr}. |t:var|
-		Tabs are numbered starting with one.
-		The {varname} argument is a string.  When {varname} is empty a
-		dictionary with all tab-local variables is returned.
-		Note that the name without "t:" must be used.
-		When the tab or variable doesn't exist {def} or an empty
-		string is returned, there is no error message.
-
-		Can also be used as a |method|: >
-			GetTabnr()->gettabvar(varname)
-
-gettabwinvar({tabnr}, {winnr}, {varname} [, {def}])		*gettabwinvar()*
-		Get the value of window-local variable {varname} in window
-		{winnr} in tab page {tabnr}.
-		The {varname} argument is a string.  When {varname} is empty a
- 		dictionary with all window-local variables is returned.
-		When {varname} is equal to "&" get the values of all
-		window-local options in a |Dictionary|.
-		Otherwise, when {varname} starts with "&" get the value of a
-		window-local option.
-		Note that {varname} must be the name without "w:".
-		Tabs are numbered starting with one.  For the current tabpage
-		use |getwinvar()|.
-		{winnr} can be the window number or the |window-ID|.
-		When {winnr} is zero the current window is used.
-		This also works for a global option, buffer-local option and
-		window-local option, but it doesn't work for a global variable
-		or buffer-local variable.
-		When the tab, window or variable doesn't exist {def} or an
-		empty string is returned, there is no error message.
-		Examples: >
-			:let list_is_on = gettabwinvar(1, 2, '&list')
-			:echo "myvar = " . gettabwinvar(3, 1, 'myvar')
-<
-		To obtain all window-local variables use: >
-			gettabwinvar({tabnr}, {winnr}, '&')
-
-<		Can also be used as a |method|: >
-			GetTabnr()->gettabwinvar(winnr, varname)
-
-gettagstack([{winnr}])					*gettagstack()*
-		The result is a Dict, which is the tag stack of window {winnr}.
-		{winnr} can be the window number or the |window-ID|.
-		When {winnr} is not specified, the current window is used.
-		When window {winnr} doesn't exist, an empty Dict is returned.
-
-		The returned dictionary contains the following entries:
-			curidx		Current index in the stack. When at
-					top of the stack, set to (length + 1).
-					Index of bottom of the stack is 1.
-			items		List of items in the stack. Each item
-					is a dictionary containing the
-					entries described below.
-			length		Number of entries in the stack.
-
-		Each item in the stack is a dictionary with the following
-		entries:
-			bufnr		buffer number of the current jump
-			from		cursor position before the tag jump.
-					See |getpos()| for the format of the
-					returned list.
-			matchnr		current matching tag number. Used when
-					multiple matching tags are found for a
-					name.
-			tagname		name of the tag
-
-		See |tagstack| for more information about the tag stack.
-
-		Can also be used as a |method|: >
-			GetWinnr()->gettagstack()
-
-getwininfo([{winid}])					*getwininfo()*
-		Returns information about windows as a |List| with Dictionaries.
-
-		If {winid} is given Information about the window with that ID
-		is returned, as a |List| with one item.  If the window does not
-		exist the result is an empty list.
-
-		Without {winid} information about all the windows in all the
-		tab pages is returned.
-
-		Each List item is a |Dictionary| with the following entries:
-			botline		last complete displayed buffer line
-			bufnr		number of buffer in the window
-			height		window height (excluding winbar)
-			loclist		1 if showing a location list
-			quickfix	1 if quickfix or location list window
-			terminal	1 if a terminal window
-			tabnr		tab page number
-			topline		first displayed buffer line
-			variables	a reference to the dictionary with
-					window-local variables
-			width		window width
-			winbar		1 if the window has a toolbar, 0
-					otherwise
-			wincol		leftmost screen column of the window;
-					"col" from |win_screenpos()|
-			textoff		number of columns occupied by any
-					'foldcolumn', 'signcolumn' and line
-					number in front of the text
-			winid		|window-ID|
-			winnr		window number
-			winrow		topmost screen line of the window;
-					"row" from |win_screenpos()|
-
-		Can also be used as a |method|: >
-			GetWinnr()->getwininfo()
-
-getwinpos([{timeout}])					*getwinpos()*
-		The result is a |List| with two numbers, the result of
-		|getwinposx()| and |getwinposy()| combined:
-			[x-pos, y-pos]
-		{timeout} can be used to specify how long to wait in msec for
-		a response from the terminal.  When omitted 100 msec is used.
-
-		Use a longer time for a remote terminal.
-		When using a value less than 10 and no response is received
-		within that time, a previously reported position is returned,
-		if available.  This can be used to poll for the position and
-		do some work in the meantime: >
-			while 1
-			  let res = getwinpos(1)
-			  if res[0] >= 0
-			    break
-			  endif
-			  " Do some work here
-			endwhile
-<
-		Can also be used as a |method|: >
-			GetTimeout()->getwinpos()
-<
-							*getwinposx()*
-getwinposx()	The result is a Number, which is the X coordinate in pixels of
-		the left hand side of the GUI Vim window.  The result will be
-		-1 if the information is not available.
-		The value can be used with `:winpos`.
-
-							*getwinposy()*
-getwinposy()	The result is a Number, which is the Y coordinate in pixels of
-		the top of the GUI Vim window.  The result will be -1 if the
-		information is not available.
-		The value can be used with `:winpos`.
-
-getwinvar({winnr}, {varname} [, {def}])				*getwinvar()*
-		Like |gettabwinvar()| for the current tabpage.
-		Examples: >
-			:let list_is_on = getwinvar(2, '&list')
-			:echo "myvar = " . getwinvar(1, 'myvar')
-
-<		Can also be used as a |method|: >
-			GetWinnr()->getwinvar(varname)
-<
-glob({expr} [, {nosuf} [, {list} [, {alllinks}]]])		*glob()*
-		Expand the file wildcards in {expr}.  See |wildcards| for the
-		use of special characters.
-
-		Unless the optional {nosuf} argument is given and is |TRUE|,
-		the 'suffixes' and 'wildignore' options apply: Names matching
-		one of the patterns in 'wildignore' will be skipped and
-		'suffixes' affect the ordering of matches.
-		'wildignorecase' always applies.
-
-		When {list} is present and it is |TRUE| the result is a |List|
-		with all matching files. The advantage of using a List is,
-		you also get filenames containing newlines correctly.
-		Otherwise the result is a String and when there are several
-		matches, they are separated by <NL> characters.
-
-		If the expansion fails, the result is an empty String or List.
-
-		You can also use |readdir()| if you need to do complicated
-		things, such as limiting the number of matches.
-
-		A name for a non-existing file is not included.  A symbolic
-		link is only included if it points to an existing file.
-		However, when the {alllinks} argument is present and it is
-		|TRUE| then all symbolic links are included.
-
-		For most systems backticks can be used to get files names from
-		any external command.  Example: >
-			:let tagfiles = glob("`find . -name tags -print`")
-			:let &tags = substitute(tagfiles, "\n", ",", "g")
-<		The result of the program inside the backticks should be one
-		item per line.  Spaces inside an item are allowed.
-
-		See |expand()| for expanding special Vim variables.  See
-		|system()| for getting the raw output of an external command.
-
-		Can also be used as a |method|: >
-			GetExpr()->glob()
-
-glob2regpat({string})					 *glob2regpat()*
-		Convert a file pattern, as used by glob(), into a search
-		pattern.  The result can be used to match with a string that
-		is a file name.  E.g. >
-			if filename =~ glob2regpat('Make*.mak')
-<		This is equivalent to: >
-			if filename =~ '^Make.*\.mak$'
-<		When {string} is an empty string the result is "^$", match an
-		empty string.
-		Note that the result depends on the system.  On MS-Windows
-		a backslash usually means a path separator.
-
-		Can also be used as a |method|: >
-			GetExpr()->glob2regpat()
-<								*globpath()*
-globpath({path}, {expr} [, {nosuf} [, {list} [, {allinks}]]])
-		Perform glob() for String {expr} on all directories in {path}
-		and concatenate the results.  Example: >
-			:echo globpath(&rtp, "syntax/c.vim")
-<
-		{path} is a comma-separated list of directory names.  Each
-		directory name is prepended to {expr} and expanded like with
-		|glob()|.  A path separator is inserted when needed.
-		To add a comma inside a directory name escape it with a
-		backslash.  Note that on MS-Windows a directory may have a
-		trailing backslash, remove it if you put a comma after it.
-		If the expansion fails for one of the directories, there is no
-		error message.
-
-		Unless the optional {nosuf} argument is given and is |TRUE|,
-		the 'suffixes' and 'wildignore' options apply: Names matching
-		one of the patterns in 'wildignore' will be skipped and
-		'suffixes' affect the ordering of matches.
-
-		When {list} is present and it is |TRUE| the result is a |List|
-		with all matching files. The advantage of using a List is, you
-		also get filenames containing newlines correctly. Otherwise
-		the result is a String and when there are several matches,
-		they are separated by <NL> characters.  Example: >
-			:echo globpath(&rtp, "syntax/c.vim", 0, 1)
-<
-		{allinks} is used as with |glob()|.
-
-		The "**" item can be used to search in a directory tree.
-		For example, to find all "README.txt" files in the directories
-		in 'runtimepath' and below: >
-			:echo globpath(&rtp, "**/README.txt")
-<		Upwards search and limiting the depth of "**" is not
-		supported, thus using 'path' will not always work properly.
-
-		Can also be used as a |method|, the base is passed as the
-		second argument: >
-			GetExpr()->globpath(&rtp)
-<
-							*has()*
-has({feature})	Returns 1 if {feature} is supported, 0 otherwise.  The
-		{feature} argument is a feature name like "nvim-0.2.1" or
-		"win32", see below.  See also |exists()|.
-
-		If the code has a syntax error, then Nvim may skip the rest
-		of the line and miss |:endif|. >
-	if has('feature') | let x = this->breaks->without->the->feature | endif
-<
-		Put |:if| and |:endif| on separate lines to avoid the
-		syntax error. >
-	if has('feature')
-	  let x = this->breaks->without->the->feature
-	endif
-<
-		Vim's compile-time feature-names (prefixed with "+") are not
-		recognized because Nvim is always compiled with all possible
-		features. |feature-compile|
-
-		Feature names can be:
-		1.  Nvim version. For example the "nvim-0.2.1" feature means
-		    that Nvim is version 0.2.1 or later: >
-			:if has("nvim-0.2.1")
-
-<		2.  Runtime condition or other pseudo-feature. For example the
-		    "win32" feature checks if the current system is Windows: >
-			:if has("win32")
-<							*feature-list*
-		    List of supported pseudo-feature names:
-		        acl		|ACL| support
-			bsd		BSD system (not macOS, use "mac" for that).
-		        iconv		Can use |iconv()| for conversion.
-		        +shellslash	Can use backslashes in filenames (Windows)
-			clipboard	|clipboard| provider is available.
-			fname_case	Case in file names matters (for Darwin and MS-Windows
-					this is not present).
-			mac		MacOS system.
-			nvim		This is Nvim.
-			python2		Legacy Vim |python2| interface. |has-python|
-			python3		Legacy Vim |python3| interface. |has-python|
-			pythonx		Legacy Vim |python_x| interface. |has-pythonx|
-			ttyin		input is a terminal (tty)
-			ttyout		output is a terminal (tty)
-			unix		Unix system.
-			*vim_starting*	True during |startup|.
-			win32		Windows system (32 or 64 bit).
-			win64		Windows system (64 bit).
-			wsl		WSL (Windows Subsystem for Linux) system
-
-							*has-patch*
-		3.  Vim patch. For example the "patch123" feature means that
-		    Vim patch 123 at the current |v:version| was included: >
-			:if v:version > 602 || v:version == 602 && has("patch148")
-
-<		4.  Vim version. For example the "patch-7.4.237" feature means
-		    that Nvim is Vim-compatible to version 7.4.237 or later. >
-			:if has("patch-7.4.237")
-
-
-has_key({dict}, {key})					*has_key()*
-		The result is a Number, which is TRUE if |Dictionary| {dict}
-		has an entry with key {key}.  FALSE otherwise. The {key}
-		argument is a string.
-
-		Can also be used as a |method|: >
-			mydict->has_key(key)
-
-haslocaldir([{winnr}[, {tabnr}]])			*haslocaldir()*
-		The result is a Number, which is 1 when the window has set a
-		local path via |:lcd| or when {winnr} is -1 and the tabpage
-		has set a local path via |:tcd|, otherwise 0.
-
-		Tabs and windows are identified by their respective numbers,
-		0 means current tab or window. Missing argument implies 0.
-		Thus the following are equivalent: >
-			haslocaldir()
-			haslocaldir(0)
-			haslocaldir(0, 0)
-<		With {winnr} use that window in the current tabpage.
-		With {winnr} and {tabnr} use the window in that tabpage.
-		{winnr} can be the window number or the |window-ID|.
-		If {winnr} is -1 it is ignored, only the tab is resolved.
-		Throw error if the arguments are invalid. |E5000| |E5001| |E5002|
-
-		Can also be used as a |method|: >
-			GetWinnr()->haslocaldir()
-
-hasmapto({what} [, {mode} [, {abbr}]])			*hasmapto()*
-		The result is a Number, which is TRUE if there is a mapping
-		that contains {what} in somewhere in the rhs (what it is
-		mapped to) and this mapping exists in one of the modes
-		indicated by {mode}.
-		The arguments {what} and {mode} are strings.
-		When {abbr} is there and it is |TRUE| use abbreviations
-		instead of mappings.  Don't forget to specify Insert and/or
-		Command-line mode.
-		Both the global mappings and the mappings local to the current
-		buffer are checked for a match.
-		If no matching mapping is found FALSE is returned.
-		The following characters are recognized in {mode}:
-			n	Normal mode
-			v	Visual and Select mode
-			x	Visual mode
-			s	Select mode
-			o	Operator-pending mode
-			i	Insert mode
-			l	Language-Argument ("r", "f", "t", etc.)
-			c	Command-line mode
-		When {mode} is omitted, "nvo" is used.
-
-		This function is useful to check if a mapping already exists
-		to a function in a Vim script.  Example: >
-			:if !hasmapto('\ABCdoit')
-			:   map <Leader>d \ABCdoit
-			:endif
-<		This installs the mapping to "\ABCdoit" only if there isn't
-		already a mapping to "\ABCdoit".
-
-		Can also be used as a |method|: >
-			GetRHS()->hasmapto()
-
-histadd({history}, {item})				*histadd()*
-		Add the String {item} to the history {history} which can be
-		one of:					*hist-names*
-			"cmd"	 or ":"	  command line history
-			"search" or "/"   search pattern history
-			"expr"	 or "="   typed expression history
-			"input"  or "@"	  input line history
-			"debug"  or ">"   debug command history
-			empty		  the current or last used history
-		The {history} string does not need to be the whole name, one
-		character is sufficient.
-		If {item} does already exist in the history, it will be
-		shifted to become the newest entry.
-		The result is a Number: TRUE if the operation was successful,
-		otherwise FALSE is returned.
-
-		Example: >
-			:call histadd("input", strftime("%Y %b %d"))
-			:let date=input("Enter date: ")
-<		This function is not available in the |sandbox|.
-
-		Can also be used as a |method|, the base is passed as the
-		second argument: >
-			GetHistory()->histadd('search')
-
-histdel({history} [, {item}])				*histdel()*
-		Clear {history}, i.e. delete all its entries.  See |hist-names|
-		for the possible values of {history}.
-
-		If the parameter {item} evaluates to a String, it is used as a
-		regular expression.  All entries matching that expression will
-		be removed from the history (if there are any).
-		Upper/lowercase must match, unless "\c" is used |/\c|.
-		If {item} evaluates to a Number, it will be interpreted as
-		an index, see |:history-indexing|.  The respective entry will
-		be removed if it exists.
-
-		The result is TRUE for a successful operation, otherwise FALSE
-		is returned.
-
-		Examples:
-		Clear expression register history: >
-			:call histdel("expr")
-<
-		Remove all entries starting with "*" from the search history: >
-			:call histdel("/", '^\*')
-<
-		The following three are equivalent: >
-			:call histdel("search", histnr("search"))
-			:call histdel("search", -1)
-			:call histdel("search", '^'.histget("search", -1).'$')
-<
-		To delete the last search pattern and use the last-but-one for
-		the "n" command and 'hlsearch': >
-			:call histdel("search", -1)
-			:let @/ = histget("search", -1)
-<
-		Can also be used as a |method|: >
-			GetHistory()->histdel()
-
-histget({history} [, {index}])				*histget()*
-		The result is a String, the entry with Number {index} from
-		{history}.  See |hist-names| for the possible values of
-		{history}, and |:history-indexing| for {index}.  If there is
-		no such entry, an empty String is returned.  When {index} is
-		omitted, the most recent item from the history is used.
-
-		Examples:
-		Redo the second last search from history. >
-			:execute '/' . histget("search", -2)
-
-<		Define an Ex command ":H {num}" that supports re-execution of
-		the {num}th entry from the output of |:history|. >
-			:command -nargs=1 H execute histget("cmd", 0+<args>)
-<
-		Can also be used as a |method|: >
-			GetHistory()->histget()
-
-histnr({history})					*histnr()*
-		The result is the Number of the current entry in {history}.
-		See |hist-names| for the possible values of {history}.
-		If an error occurred, -1 is returned.
-
-		Example: >
-			:let inp_index = histnr("expr")
-
-<		Can also be used as a |method|: >
-			GetHistory()->histnr()
-<
-hlexists({name})					*hlexists()*
-		The result is a Number, which is TRUE if a highlight group
-		called {name} exists.  This is when the group has been
-		defined in some way.  Not necessarily when highlighting has
-		been defined for it, it may also have been used for a syntax
-		item.
-
-		Can also be used as a |method|: >
-			GetName()->hlexists()
-<
-							*hlID()*
-hlID({name})	The result is a Number, which is the ID of the highlight group
-		with name {name}.  When the highlight group doesn't exist,
-		zero is returned.
-		This can be used to retrieve information about the highlight
-		group.  For example, to get the background color of the
-		"Comment" group: >
-	:echo synIDattr(synIDtrans(hlID("Comment")), "bg")
-<
-		Can also be used as a |method|: >
-			GetName()->hlID()
-
-hostname()						*hostname()*
-		The result is a String, which is the name of the machine on
-		which Vim is currently running.  Machine names greater than
-		256 characters long are truncated.
-
-iconv({string}, {from}, {to})				*iconv()*
-		The result is a String, which is the text {string} converted
-		from encoding {from} to encoding {to}.
-		When the conversion completely fails an empty string 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".
-		Note that Vim uses UTF-8 for all Unicode encodings, conversion
-		from/to UCS-2 is automatically changed to use UTF-8.  You
-		cannot use UCS-2 in a string anyway, because of the NUL bytes.
-
-		Can also be used as a |method|: >
-			GetText()->iconv('latin1', 'utf-8')
-<
-							*indent()*
-indent({lnum})	The result is a Number, which is indent of line {lnum} in the
-		current buffer.  The indent is counted in spaces, the value
-		of 'tabstop' is relevant.  {lnum} is used just like in
-		|getline()|.
-		When {lnum} is invalid -1 is returned.
-
-		Can also be used as a |method|: >
-			GetLnum()->indent()
-
-index({object}, {expr} [, {start} [, {ic}]])			*index()*
-		If {object} is a |List| return the lowest index where the item
-		has a value equal to {expr}.  There is no automatic
-		conversion, so the String "4" is different from the Number 4.
-		And the Number 4 is different from the Float 4.0.  The value
-		of 'ignorecase' is not used here, case always matters.
-
-		If {object} is a |Blob| return the lowest index where the byte
-		value is equal to {expr}.
-
-		If {start} is given then start looking at the item with index
-		{start} (may be negative for an item relative to the end).
-		When {ic} is given and it is |TRUE|, ignore case.  Otherwise
-		case must match.
-		-1 is returned when {expr} is not found in {object}.
-		Example: >
-			:let idx = index(words, "the")
-			:if index(numbers, 123) >= 0
-
-<		Can also be used as a |method|: >
-			GetObject()->index(what)
-
-input({prompt} [, {text} [, {completion}]])		*input()*
-input({opts})
-		The result is a String, which is whatever the user typed on
-		the command-line.  The {prompt} argument is either a prompt
-		string, or a blank string (for no prompt).  A '\n' can be used
-		in the prompt to start a new line.
-
-		In the second form it accepts a single dictionary with the
-		following keys, any of which may be omitted:
-
-		Key           Default  Description ~
-		prompt        ""       Same as {prompt} in the first form.
-		default       ""       Same as {text} in the first form.
-		completion    nothing  Same as {completion} in the first form.
-		cancelreturn  ""       The value returned when the dialog is
-		                       cancelled.
-		highlight     nothing  Highlight handler: |Funcref|.
-
-		The highlighting set with |:echohl| is used for the prompt.
-		The input is entered just like a command-line, with the same
-		editing commands and mappings.  There is a separate history
-		for lines typed for input().
-		Example: >
-			:if input("Coffee or beer? ") == "beer"
-			:  echo "Cheers!"
-			:endif
-<
-		If the optional {text} argument is present and not empty, this
-		is used for the default reply, as if the user typed this.
-		Example: >
-			:let color = input("Color? ", "white")
-
-<		The optional {completion} argument specifies the type of
-		completion supported for the input.  Without it completion is
-		not performed.  The supported completion types are the same as
-		that can be supplied to a user-defined command using the
-		"-complete=" argument.  Refer to |:command-completion| for
-		more information.  Example: >
-			let fname = input("File: ", "", "file")
-
-<					*input()-highlight* *E5400* *E5402*
-		The optional `highlight` key allows specifying function which
-		will be used for highlighting user input.  This function
-		receives user input as its only argument and must return
-		a list of 3-tuples [hl_start_col, hl_end_col + 1, hl_group]
-		where
-			hl_start_col is the first highlighted column,
-			hl_end_col is the last highlighted column (+ 1!),
-			hl_group is |:hi| group used for highlighting.
-					      *E5403* *E5404* *E5405* *E5406*
-		Both hl_start_col and hl_end_col + 1 must point to the start
-		of the multibyte character (highlighting must not break
-		multibyte characters), hl_end_col + 1 may be equal to the
-		input length.  Start column must be in range [0, len(input)),
-		end column must be in range (hl_start_col, len(input)],
-		sections must be ordered so that next hl_start_col is greater
-		then or equal to previous hl_end_col.
-
-		Example (try some input with parentheses): >
-			highlight RBP1 guibg=Red ctermbg=red
-			highlight RBP2 guibg=Yellow ctermbg=yellow
-			highlight RBP3 guibg=Green ctermbg=green
-			highlight RBP4 guibg=Blue ctermbg=blue
-			let g:rainbow_levels = 4
-			function! RainbowParens(cmdline)
-			  let ret = []
-			  let i = 0
-			  let lvl = 0
-			  while i < len(a:cmdline)
-			    if a:cmdline[i] is# '('
-			      call add(ret, [i, i + 1, 'RBP' . ((lvl % g:rainbow_levels) + 1)])
-			      let lvl += 1
-			    elseif a:cmdline[i] is# ')'
-			      let lvl -= 1
-			      call add(ret, [i, i + 1, 'RBP' . ((lvl % g:rainbow_levels) + 1)])
-			    endif
-			    let i += 1
-			  endwhile
-			  return ret
-			endfunction
-			call input({'prompt':'>','highlight':'RainbowParens'})
-<
-		Highlight function is called at least once for each new
-		displayed input string, before command-line is redrawn.  It is
-		expected that function is pure for the duration of one input()
-		call, i.e. it produces the same output for the same input, so
-		output may be memoized.  Function is run like under |:silent|
-		modifier. If the function causes any errors, it will be
-		skipped for the duration of the current input() call.
-
-		Highlighting is disabled if command-line contains arabic
-		characters.
-
-		NOTE: This function must not be used in a startup file, for
-		the versions that only run in GUI mode (e.g., the Win32 GUI).
-		Note: When input() is called from within a mapping it will
-		consume remaining characters from that mapping, because a
-		mapping is handled like the characters were typed.
-		Use |inputsave()| before input() and |inputrestore()|
-		after input() to avoid that.  Another solution is to avoid
-		that further characters follow in the mapping, e.g., by using
-		|:execute| or |:normal|.
-
-		Example with a mapping: >
-			:nmap \x :call GetFoo()<CR>:exe "/" . Foo<CR>
-			:function GetFoo()
-			:  call inputsave()
-			:  let g:Foo = input("enter search pattern: ")
-			:  call inputrestore()
-			:endfunction
-
-<		Can also be used as a |method|: >
-			GetPrompt()->input()
-
-inputlist({textlist})					*inputlist()*
-		{textlist} must be a |List| of strings.  This |List| is
-		displayed, one string per line.  The user will be prompted to
-		enter a number, which is returned.
-		The user can also select an item by clicking on it with the
-		mouse, if the mouse is enabled in the command line ('mouse' is
-		"a" or includes "c").  For the first string 0 is returned.
-		When clicking above the first item a negative number is
-		returned.  When clicking on the prompt one more than the
-		length of {textlist} is returned.
-		Make sure {textlist} has less than 'lines' entries, otherwise
-		it won't work.  It's a good idea to put the entry number at
-		the start of the string.  And put a prompt in the first item.
-		Example: >
-			let color = inputlist(['Select color:', '1. red',
-				\ '2. green', '3. blue'])
-
-<		Can also be used as a |method|: >
-			GetChoices()->inputlist()
-
-inputrestore()						*inputrestore()*
-		Restore typeahead that was saved with a previous |inputsave()|.
-		Should be called the same number of times inputsave() is
-		called.  Calling it more often is harmless though.
-		Returns TRUE when there is nothing to restore, FALSE otherwise.
-
-inputsave()						*inputsave()*
-		Preserve typeahead (also from mappings) and clear it, so that
-		a following prompt gets input from the user.  Should be
-		followed by a matching inputrestore() after the prompt.  Can
-		be used several times, in which case there must be just as
-		many inputrestore() calls.
-		Returns TRUE when out of memory, FALSE otherwise.
-
-inputsecret({prompt} [, {text}])			*inputsecret()*
-		This function acts much like the |input()| function with but
-		two exceptions:
-		a) the user's response will be displayed as a sequence of
-		asterisks ("*") thereby keeping the entry secret, and
-		b) the user's response will not be recorded on the input
-		|history| stack.
-		The result is a String, which is whatever the user actually
-		typed on the command-line in response to the issued prompt.
-		NOTE: Command-line completion is not supported.
-
-		Can also be used as a |method|: >
-			GetPrompt()->inputsecret()
-
-insert({object}, {item} [, {idx}])			*insert()*
-		When {object} is a |List| or a |Blob| insert {item} at the start
-		of it.
-
-		If {idx} is specified insert {item} before the item with index
-		{idx}.  If {idx} is zero it goes before the first item, just
-		like omitting {idx}.  A negative {idx} is also possible, see
-		|list-index|.  -1 inserts just before the last item.
-
-		Returns the resulting |List| or |Blob|.  Examples: >
-			:let mylist = insert([2, 3, 5], 1)
-			:call insert(mylist, 4, -1)
-			:call insert(mylist, 6, len(mylist))
-<		The last example can be done simpler with |add()|.
-		Note that when {item} is a |List| it is inserted as a single
-		item.  Use |extend()| to concatenate |Lists|.
-
-		Can also be used as a |method|: >
-			mylist->insert(item)
-
-interrupt()						*interrupt()*
-		Interrupt script execution.  It works more or less like the
-		user typing CTRL-C, most commands won't execute and control
-		returns to the user.  This is useful to abort execution
-		from lower down, e.g. in an autocommand.  Example: >
-		:function s:check_typoname(file)
-		:   if fnamemodify(a:file, ':t') == '['
-		:       echomsg 'Maybe typo'
-		:       call interrupt()
-		:   endif
-		:endfunction
-		:au BufWritePre * call s:check_typoname(expand('<amatch>'))
-
-invert({expr})						*invert()*
-		Bitwise invert.  The argument is converted to a number.  A
-		List, Dict or Float argument causes an error.  Example: >
-			:let bits = invert(bits)
-<		Can also be used as a |method|: >
-			:let bits = bits->invert()
-
-isdirectory({directory})				*isdirectory()*
-		The result is a Number, which is |TRUE| when a directory
-		with the name {directory} exists.  If {directory} doesn't
-		exist, or isn't a directory, the result is |FALSE|.  {directory}
-		is any expression, which is used as a String.
-
-		Can also be used as a |method|: >
-			GetName()->isdirectory()
-
-isinf({expr})						*isinf()*
-		Return 1 if {expr} is a positive infinity, or -1 a negative
-		infinity, otherwise 0. >
-			:echo isinf(1.0 / 0.0)
-<			1 >
-			:echo isinf(-1.0 / 0.0)
-<			-1
-
-		Can also be used as a |method|: >
-			Compute()->isinf()
-
-islocked({expr})					*islocked()* *E786*
-		The result is a Number, which is |TRUE| when {expr} is the
-		name of a locked variable.
-		The string argument {expr} must be the name of a variable,
-		|List| item or |Dictionary| entry, not the variable itself!
-		Example: >
-			:let alist = [0, ['a', 'b'], 2, 3]
-			:lockvar 1 alist
-			:echo islocked('alist')		" 1
-			:echo islocked('alist[1]')	" 0
-
-<		When {expr} is a variable that does not exist you get an error
-		message.  Use |exists()| to check for existence.
-
-		Can also be used as a |method|: >
-			GetName()->islocked()
-
-id({expr})						*id()*
-		Returns a |String| which is a unique identifier of the
-		container type (|List|, |Dict|, |Blob| and |Partial|). It is
-		guaranteed that for the mentioned types `id(v1) ==# id(v2)`
-		returns true iff `type(v1) == type(v2) && v1 is v2`.
-		Note that |v:_null_string|, |v:_null_list|, |v:_null_dict| and
-		|v:_null_blob| have the same `id()` with different types
-		because they are internally represented as NULL pointers.
-		`id()` returns a hexadecimal representanion of the pointers to
-		the containers (i.e. like `0x994a40`), same as `printf("%p",
-		{expr})`, but it is advised against counting on the exact
-		format of the return value.
-
-		It is not guaranteed that `id(no_longer_existing_container)`
-		will not be equal to some other `id()`: new containers may
-		reuse identifiers of the garbage-collected ones.
-
-items({dict})						*items()*
-		Return a |List| with all the key-value pairs of {dict}.  Each
-		|List| item is a list with two items: the key of a {dict}
-		entry and the value of this entry.  The |List| is in arbitrary
-		order.  Also see |keys()| and |values()|.
-		Example: >
-			for [key, value] in items(mydict)
-			   echo key . ': ' . value
-			endfor
-
-<		Can also be used as a |method|: >
-			mydict->items()
-
-isnan({expr})						*isnan()*
-		Return |TRUE| if {expr} is a float with value NaN. >
-			echo isnan(0.0 / 0.0)
-<			1
-
-		Can also be used as a |method|: >
-			Compute()->isnan()
-
-jobpid({job})						*jobpid()*
-		Return the PID (process id) of |job-id| {job}.
-
-jobresize({job}, {width}, {height})			*jobresize()*
-		Resize the pseudo terminal window of |job-id| {job} to {width}
-		columns and {height} rows.
-		Fails if the job was not started with `"pty":v:true`.
-
-jobstart({cmd}[, {opts}])				*jobstart()*
-		Spawns {cmd} as a job.
-		If {cmd} is a List it runs directly (no 'shell').
-		If {cmd} is a String it runs in the 'shell', like this: >
-		  :call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}'])
-<		(See |shell-unquoting| for details.)
-
-		Example: >
-		  :call jobstart('nvim -h', {'on_stdout':{j,d,e->append(line('.'),d)}})
-<
-		Returns |job-id| on success, 0 on invalid arguments (or job
-		table is full), -1 if {cmd}[0] or 'shell' is not executable.
-		The returned job-id is a valid |channel-id| representing the
-		job's stdio streams. Use |chansend()| (or |rpcnotify()| and
-		|rpcrequest()| if "rpc" was enabled) to send data to stdin and
-		|chanclose()| to close the streams without stopping the job.
-
-		See |job-control| and |RPC|.
-
-		NOTE: on Windows if {cmd} is a List:
-		  - cmd[0] must be an executable (not a "built-in"). If it is
-		    in $PATH it can be called by name, without an extension: >
-		      :call jobstart(['ping', 'neovim.io'])
-<		    If it is a full or partial path, extension is required: >
-		      :call jobstart(['System32\ping.exe', 'neovim.io'])
-<		  - {cmd} is collapsed to a string of quoted args as expected
-		    by CommandLineToArgvW https://msdn.microsoft.com/bb776391
-		    unless cmd[0] is some form of "cmd.exe".
-
-							*jobstart-options*
-		{opts} is a dictionary with these keys:
-		  clear_env:  (boolean) `env` defines the job environment
-			      exactly, instead of merging current environment.
-		  cwd:	      (string, default=|current-directory|) Working
-			      directory of the job.
-		  detach:     (boolean) Detach the job process: it will not be
-			      killed when Nvim exits. If the process exits
-			      before Nvim, `on_exit` will be invoked.
-		  env:	      (dict) Map of environment variable name:value
-			      pairs extending (or replacing if |clear_env|)
-			      the current environment.
-		  height:     (number) Height of the `pty` terminal.
-		  |on_exit|:    (function) Callback invoked when the job exits.
-		  |on_stdout|:  (function) Callback invoked when the job emits
-			      stdout data.
-		  |on_stderr|:  (function) Callback invoked when the job emits
-			      stderr data.
-		  overlapped: (boolean) Set FILE_FLAG_OVERLAPPED for the
-			      standard input/output passed to the child process.
-			      Normally you do not need to set this.
-			      (Only available on MS-Windows, On other
-			      platforms, this option is silently ignored.)
-		  pty:	      (boolean) Connect the job to a new pseudo
-			      terminal, and its streams to the master file
-			      descriptor. Then  `on_stderr` is ignored,
-			      `on_stdout` receives all output.
-		  rpc:	      (boolean) Use |msgpack-rpc| to communicate with
-			      the job over stdio. Then `on_stdout` is ignored,
-			      but `on_stderr` can still be used.
-		  stderr_buffered: (boolean) Collect data until EOF (stream closed)
-			      before invoking `on_stderr`. |channel-buffered|
-		  stdout_buffered: (boolean) Collect data until EOF (stream
-			      closed) before invoking `on_stdout`. |channel-buffered|
-		  stdin:      (string) Either "pipe" (default) to connect the
-			      job's stdin to a channel or "null" to disconnect
-			      stdin.
-		  width:      (number) Width of the `pty` terminal.
-
-		{opts} is passed as |self| dictionary to the callback; the
-		caller may set other keys to pass application-specific data.
-
-		Returns:
-		  - |channel-id| on success
-		  - 0 on invalid arguments
-		  - -1 if {cmd}[0] is not executable.
-		See also |job-control|, |channel|, |msgpack-rpc|.
-
-jobstop({id})						*jobstop()*
-		Stop |job-id| {id} by sending SIGTERM to the job process. If
-		the process does not terminate after a timeout then SIGKILL
-		will be sent. When the job terminates its |on_exit| handler
-		(if any) will be invoked.
-		See |job-control|.
-
-		Returns 1 for valid job id, 0 for invalid id, including jobs have
-		exited or stopped.
-
-jobwait({jobs}[, {timeout}])				*jobwait()*
-		Waits for jobs and their |on_exit| handlers to complete.
-
-		{jobs} is a List of |job-id|s to wait for.
-		{timeout} is the maximum waiting time in milliseconds. If
-		omitted or -1, wait forever.
-
-		Timeout of 0 can be used to check the status of a job: >
-			let running = jobwait([{job-id}], 0)[0] == -1
-<
-		During jobwait() callbacks for jobs not in the {jobs} list may
-		be invoked. The screen will not redraw unless |:redraw| is
-		invoked by a callback.
-
-		Returns a list of len({jobs}) integers, where each integer is
-		the status of the corresponding job:
-			Exit-code, if the job exited
-			-1 if the timeout was exceeded
-			-2 if the job was interrupted (by |CTRL-C|)
-			-3 if the job-id is invalid
-
-join({list} [, {sep}])					*join()*
-		Join the items in {list} together into one String.
-		When {sep} is specified it is put in between the items.  If
-		{sep} is omitted a single space is used.
-		Note that {sep} is not added at the end.  You might want to
-		add it there too: >
-			let lines = join(mylist, "\n") . "\n"
-<		String items are used as-is.  |Lists| and |Dictionaries| are
-		converted into a string like with |string()|.
-		The opposite function is |split()|.
-
-		Can also be used as a |method|: >
-			mylist->join()
-
-json_decode({expr})					*json_decode()*
-		Convert {expr} from JSON object.  Accepts |readfile()|-style
-		list as the input, as well as regular string.  May output any
-		Vim value. In the following cases it will output
-		|msgpack-special-dict|:
-		1. Dictionary contains duplicate key.
-		2. Dictionary contains empty key.
-		3. String contains NUL byte.  Two special dictionaries: for
-		   dictionary and for string will be emitted in case string
-		   with NUL byte was a dictionary key.
-
-		Note: function treats its input as UTF-8 always.  The JSON
-		standard allows only a few encodings, of which UTF-8 is
-		recommended and the only one required to be supported.
-		Non-UTF-8 characters are an error.
-
-		Can also be used as a |method|: >
-			ReadObject()->json_decode()
-
-json_encode({expr})					*json_encode()*
-		Convert {expr} into a JSON string.  Accepts
-		|msgpack-special-dict| as the input.  Will not convert
-		|Funcref|s, mappings with non-string keys (can be created as
-		|msgpack-special-dict|), values with self-referencing
-		containers, strings which contain non-UTF-8 characters,
-		pseudo-UTF-8 strings which contain codepoints reserved for
-		surrogate pairs (such strings are not valid UTF-8 strings).
-		Non-printable characters are converted into "\u1234" escapes
-		or special escapes like "\t", other are dumped as-is.
-		|Blob|s are converted to arrays of the individual bytes.
-
-		Can also be used as a |method|: >
-			GetObject()->json_encode()
-
-keys({dict})						*keys()*
-		Return a |List| with all the keys of {dict}.  The |List| is in
-		arbitrary order.  Also see |items()| and |values()|.
-
-		Can also be used as a |method|: >
-			mydict->keys()
-
-<							*len()* *E701*
-len({expr})	The result is a Number, which is the length of the argument.
-		When {expr} is a String or a Number the length in bytes is
-		used, as with |strlen()|.
-		When {expr} is a |List| the number of items in the |List| is
-		returned.
-		When {expr} is a |Blob| the number of bytes is returned.
-		When {expr} is a |Dictionary| the number of entries in the
-		|Dictionary| is returned.
-		Otherwise an error is given.
-
-		Can also be used as a |method|: >
-			mylist->len()
-
-<						*libcall()* *E364* *E368*
-libcall({libname}, {funcname}, {argument})
-		Call function {funcname} in the run-time library {libname}
-		with single argument {argument}.
-		This is useful to call functions in a library that you
-		especially made to be used with Vim.  Since only one argument
-		is possible, calling standard library functions is rather
-		limited.
-		The result is the String returned by the function.  If the
-		function returns NULL, this will appear as an empty string ""
-		to Vim.
-		If the function returns a number, use libcallnr()!
-		If {argument} is a number, it is passed to the function as an
-		int; if {argument} is a string, it is passed as a
-		null-terminated string.
-
-		libcall() allows you to write your own 'plug-in' extensions to
-		Vim without having to recompile the program.  It is NOT a
-		means to call system functions!  If you try to do so Vim will
-		very probably crash.
-
-		For Win32, the functions you write must be placed in a DLL
-		and use the normal C calling convention (NOT Pascal which is
-		used in Windows System DLLs).  The function must take exactly
-		one parameter, either a character pointer or a long integer,
-		and must return a character pointer or NULL.  The character
-		pointer returned must point to memory that will remain valid
-		after the function has returned (e.g. in static data in the
-		DLL).  If it points to allocated memory, that memory will
-		leak away.  Using a static buffer in the function should work,
-		it's then freed when the DLL is unloaded.
-
-		WARNING: If the function returns a non-valid pointer, Vim may
-		crash!	This also happens if the function returns a number,
-		because Vim thinks it's a pointer.
-		For Win32 systems, {libname} should be the filename of the DLL
-		without the ".DLL" suffix.  A full path is only required if
-		the DLL is not in the usual places.
-		For Unix: When compiling your own plugins, remember that the
-		object code must be compiled as position-independent ('PIC').
-		Examples: >
-			:echo libcall("libc.so", "getenv", "HOME")
-
-<		Can also be used as a |method|, the base is passed as the
-		third argument: >
-			GetValue()->libcall("libc.so", "getenv")
-<
-							*libcallnr()*
-libcallnr({libname}, {funcname}, {argument})
-		Just like |libcall()|, but used for a function that returns an
-		int instead of a string.
-		Examples: >
-			:echo libcallnr("/usr/lib/libc.so", "getpid", "")
-			:call libcallnr("libc.so", "printf", "Hello World!\n")
-			:call libcallnr("libc.so", "sleep", 10)
-<
-		Can also be used as a |method|, the base is passed as the
-		third argument: >
-			GetValue()->libcallnr("libc.so", "printf")
-<
-line({expr} [, {winid}])				*line()*
-		The result is a Number, which is the line number of the file
-		position given with {expr}.  The {expr} argument is a string.
-		The accepted positions are:
-		    .	    the cursor position
-		    $	    the last line in the current buffer
-		    'x	    position of mark x (if the mark is not set, 0 is
-			    returned)
-		    w0	    first line visible in current window (one if the
-			    display isn't updated, e.g. in silent Ex mode)
-		    w$	    last line visible in current window (this is one
-			    less than "w0" if no lines are visible)
-		    v	    In Visual mode: the start of the Visual area (the
-			    cursor is the end).  When not in Visual mode
-			    returns the cursor position.  Differs from |'<| in
-			    that it's updated right away.
-		Note that a mark in another file can be used.  The line number
-		then applies to another buffer.
-		To get the column number use |col()|.  To get both use
-		|getpos()|.
-		With the optional {winid} argument the values are obtained for
-		that window instead of the current window.
-		Examples: >
-			line(".")		line number of the cursor
-			line(".", winid)	idem, in window "winid"
-			line("'t")		line number of mark t
-			line("'" . marker)	line number of mark marker
-<
-		Can also be used as a |method|: >
-			GetValue()->line()
-
-line2byte({lnum})					*line2byte()*
-		Return the byte count from the start of the buffer for line
-		{lnum}.  This includes the end-of-line character, depending on
-		the 'fileformat' option for the current buffer.  The first
-		line returns 1. UTF-8 encoding is used, 'fileencoding' is
-		ignored.  This can also be used to get the byte count for the
-		line just below the last line: >
-			line2byte(line("$") + 1)
-<		This is the buffer size plus one.  If 'fileencoding' is empty
-		it is the file size plus one.  {lnum} is used like with
-		|getline()|.  When {lnum} is invalid -1 is returned.
-		Also see |byte2line()|, |go| and |:goto|.
-
-		Can also be used as a |method|: >
-			GetLnum()->line2byte()
-
-lispindent({lnum})					*lispindent()*
-		Get the amount of indent for line {lnum} according the lisp
-		indenting rules, as with 'lisp'.
-		The indent is counted in spaces, the value of 'tabstop' is
-		relevant.  {lnum} is used just like in |getline()|.
-		When {lnum} is invalid, -1 is returned.
-
-		Can also be used as a |method|: >
-			GetLnum()->lispindent()
-
-list2str({list} [, {utf8}])				*list2str()*
-		Convert each number in {list} to a character string can
-		concatenate them all.  Examples: >
-			list2str([32])		returns " "
-			list2str([65, 66, 67])	returns "ABC"
-<		The same can be done (slowly) with: >
-			join(map(list, {nr, val -> nr2char(val)}), '')
-<		|str2list()| does the opposite.
-
-		UTF-8 encoding is always used, {utf8} option has no effect,
-		and exists only for backwards-compatibility.
-		With UTF-8 composing characters work as expected: >
-			list2str([97, 769])	returns "á"
-<
-		Can also be used as a |method|: >
-			GetList()->list2str()
-
-localtime()						*localtime()*
-		Return the current time, measured as seconds since 1st Jan
-		1970.  See also |strftime()|, |strptime()| and |getftime()|.
-
-
-log({expr})						*log()*
-		Return the natural logarithm (base e) of {expr} as a |Float|.
-		{expr} must evaluate to a |Float| or a |Number| in the range
-		(0, inf].
-		Examples: >
-			:echo log(10)
-<			2.302585 >
-			:echo log(exp(5))
-<			5.0
-
-		Can also be used as a |method|: >
-			Compute()->log()
-
-log10({expr})						*log10()*
-		Return the logarithm of Float {expr} to base 10 as a |Float|.
-		{expr} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			:echo log10(1000)
-<			3.0 >
-			:echo log10(0.01)
-<			-2.0
-
-		Can also be used as a |method|: >
-			Compute()->log10()
-
-luaeval({expr}[, {expr}])
-		Evaluate Lua expression {expr} and return its result converted
-		to Vim data structures. See |lua-eval| for more details.
-
-		Can also be used as a |method|: >
-			GetExpr()->luaeval()
-
-map({expr1}, {expr2})					*map()*
-		{expr1} must be a |List|, |Blob| or |Dictionary|.
-		Replace each item in {expr1} with the result of evaluating
-		{expr2}.  For a |Blob| each byte is replaced.
-
-		{expr2} must be a |string| or |Funcref|.
-
-		If {expr2} is a |string|, inside {expr2} |v:val| has the value
-		of the current item.  For a |Dictionary| |v:key| has the key
-		of the current item and for a |List| |v:key| has the index of
-		the current item.  For a |Blob| |v:key| has the index of the
-		current byte.
-		Example: >
-			:call map(mylist, '"> " . v:val . " <"')
-<		This puts "> " before and " <" after each item in "mylist".
-
-		Note that {expr2} is the result of an expression and is then
-		used as an expression again.  Often it is good to use a
-		|literal-string| to avoid having to double backslashes.  You
-		still have to double ' quotes
-
-		If {expr2} is a |Funcref| it is called with two arguments:
-			1. The key or the index of the current item.
-			2. the value of the current item.
-		The function must return the new value of the item. Example
-		that changes each value by "key-value": >
-			func KeyValue(key, val)
-			  return a:key . '-' . a:val
-			endfunc
-			call map(myDict, function('KeyValue'))
-<		It is shorter when using a |lambda|: >
-			call map(myDict, {key, val -> key . '-' . val})
-<		If you do not use "val" you can leave it out: >
-			call map(myDict, {key -> 'item: ' . key})
-<		If you do not use "key" you can use a short name: >
-			call map(myDict, {_, val -> 'item: ' . val})
-<
-		The operation is done in-place.  If you want a |List| or
-		|Dictionary| to remain unmodified make a copy first: >
-			:let tlist = map(copy(mylist), ' v:val . "\t"')
-
-<		Returns {expr1}, the |List|, |Blob| or |Dictionary| that was
-		filtered.  When an error is encountered while evaluating
-		{expr2} no further items in {expr1} are processed.  When
-		{expr2} is a Funcref errors inside a function are ignored,
-		unless it was defined with the "abort" flag.
-
-		Can also be used as a |method|: >
-			mylist->map(expr2)
-
-maparg({name} [, {mode} [, {abbr} [, {dict}]]])			*maparg()*
-		When {dict} is omitted or zero: Return the rhs of mapping
-		{name} in mode {mode}.  The returned String has special
-		characters translated like in the output of the ":map" command
-		listing.
-
-		When there is no mapping for {name}, an empty String is
-		returned.  When the mapping for {name} is empty, then "<Nop>"
-		is returned.
-
-		The {name} can have special key names, like in the ":map"
-		command.
-
-		{mode} can be one of these strings:
-			"n"	Normal
-			"v"	Visual (including Select)
-			"o"	Operator-pending
-			"i"	Insert
-			"c"	Cmd-line
-			"s"	Select
-			"x"	Visual
-			"l"	langmap |language-mapping|
-			"t"	Terminal
-			""	Normal, Visual and Operator-pending
-		When {mode} is omitted, the modes for "" are used.
-
-		When {abbr} is there and it is |TRUE| use abbreviations
-		instead of mappings.
-
-		When {dict} is there and it is |TRUE| return a dictionary
-		containing all the information of the mapping with the
-		following items:
-		  "lhs"	     The {lhs} of the mapping.
-		  "rhs"	     The {rhs} of the mapping as typed.
-		  "silent"   1 for a |:map-silent| mapping, else 0.
-		  "noremap"  1 if the {rhs} of the mapping is not remappable.
-		  "script"   1 if mapping was defined with <script>.
-		  "expr"     1 for an expression mapping (|:map-<expr>|).
-		  "buffer"   1 for a buffer local mapping (|:map-local|).
-		  "mode"     Modes for which the mapping is defined. In
-			     addition to the modes mentioned above, these
-			     characters will be used:
-			     " "     Normal, Visual and Operator-pending
-			     "!"     Insert and Commandline mode
-				     (|mapmode-ic|)
-		  "sid"	     The script local ID, used for <sid> mappings
-			     (|<SID>|).
-		  "lnum"     The line number in "sid", zero if unknown.
-		  "nowait"   Do not wait for other, longer mappings.
-			     (|:map-<nowait>|).
-
-		The mappings local to the current buffer are checked first,
-		then the global mappings.
-		This function can be used to map a key even when it's already
-		mapped, and have it do the original mapping too.  Sketch: >
-			exe 'nnoremap <Tab> ==' . maparg('<Tab>', 'n')
-
-<		Can also be used as a |method|: >
-			GetKey()->maparg('n')
-
-mapcheck({name} [, {mode} [, {abbr}]])			*mapcheck()*
-		Check if there is a mapping that matches with {name} in mode
-		{mode}.  See |maparg()| for {mode} and special names in
-		{name}.
-		When {abbr} is there and it is non-zero use abbreviations
-		instead of mappings.
-		A match happens with a mapping that starts with {name} and
-		with a mapping which is equal to the start of {name}.
-
-			matches mapping "a"	"ab"	"abc" ~
-		   mapcheck("a")	yes	yes	 yes
-		   mapcheck("abc")	yes	yes	 yes
-		   mapcheck("ax")	yes	no	 no
-		   mapcheck("b")	no	no	 no
-
-		The difference with maparg() is that mapcheck() finds a
-		mapping that matches with {name}, while maparg() only finds a
-		mapping for {name} exactly.
-		When there is no mapping that starts with {name}, an empty
-		String is returned.  If there is one, the RHS of that mapping
-		is returned.  If there are several mappings that start with
-		{name}, the RHS of one of them is returned.  This will be
-		"<Nop>" if the RHS is empty.
-		The mappings local to the current buffer are checked first,
-		then the global mappings.
-		This function can be used to check if a mapping can be added
-		without being ambiguous.  Example: >
-	:if mapcheck("_vv") == ""
-	:   map _vv :set guifont=7x13<CR>
-	:endif
-<		This avoids adding the "_vv" mapping when there already is a
-		mapping for "_v" or for "_vvv".
-
-		Can also be used as a |method|: >
-			GetKey()->mapcheck('n')
-
-match({expr}, {pat} [, {start} [, {count}]])			*match()*
-		When {expr} is a |List| then this returns the index of the
-		first item where {pat} matches.  Each item is used as a
-		String, |Lists| and |Dictionaries| are used as echoed.
-
-		Otherwise, {expr} is used as a String.  The result is a
-		Number, which gives the index (byte offset) in {expr} where
-		{pat} matches.
-
-		A match at the first character or |List| item returns zero.
-		If there is no match -1 is returned.
-
-		For getting submatches see |matchlist()|.
-		Example: >
-			:echo match("testing", "ing")	" results in 4
-			:echo match([1, 'x'], '\a')	" results in 1
-<		See |string-match| for how {pat} is used.
-								*strpbrk()*
-		Vim doesn't have a strpbrk() function.  But you can do: >
-			:let sepidx = match(line, '[.,;: \t]')
-<								*strcasestr()*
-		Vim doesn't have a strcasestr() function.  But you can add
-		"\c" to the pattern to ignore case: >
-			:let idx = match(haystack, '\cneedle')
-<
-		If {start} is given, the search starts from byte index
-		{start} in a String or item {start} in a |List|.
-		The result, however, is still the index counted from the
-		first character/item.  Example: >
-			:echo match("testing", "ing", 2)
-<		result is again "4". >
-			:echo match("testing", "ing", 4)
-<		result is again "4". >
-			:echo match("testing", "t", 2)
-<		result is "3".
-		For a String, if {start} > 0 then it is like the string starts
-		{start} bytes later, thus "^" will match at {start}.  Except
-		when {count} is given, then it's like matches before the
-		{start} byte are ignored (this is a bit complicated to keep it
-		backwards compatible).
-		For a String, if {start} < 0, it will be set to 0.  For a list
-		the index is counted from the end.
-		If {start} is out of range ({start} > strlen({expr}) for a
-		String or {start} > len({expr}) for a |List|) -1 is returned.
-
-		When {count} is given use the {count}'th match.  When a match
-		is found in a String the search for the next one starts one
-		character further.  Thus this example results in 1: >
-			echo match("testing", "..", 0, 2)
-<		In a |List| the search continues in the next item.
-		Note that when {count} is added the way {start} works changes,
-		see above.
-
-		See |pattern| for the patterns that are accepted.
-		The 'ignorecase' option is used to set the ignore-caseness of
-		the pattern.  'smartcase' is NOT used.  The matching is always
-		done like 'magic' is set and 'cpoptions' is empty.
-		Note that a match at the start is preferred, thus when the
-		pattern is using "*" (any number of matches) it tends to find
-		zero matches at the start instead of a number of matches
-		further down in the text.
-
-		Can also be used as a |method|: >
-			GetText()->match('word')
-			GetList()->match('word')
-<
-			*matchadd()* *E798* *E799* *E801* *E957*
-matchadd({group}, {pattern}[, {priority}[, {id} [, {dict}]]])
-		Defines a pattern to be highlighted in the current window (a
-		"match").  It will be highlighted with {group}.  Returns an
-		identification number (ID), which can be used to delete the
-		match using |matchdelete()|.  The ID is bound to the window.
-		Matching is case sensitive and magic, unless case sensitivity
-		or magicness are explicitly overridden in {pattern}.  The
-		'magic', 'smartcase' and 'ignorecase' options are not used.
-		The "Conceal" value is special, it causes the match to be
-		concealed.
-
-		The optional {priority} argument assigns a priority to the
-		match.  A match with a high priority will have its
-		highlighting overrule that of a match with a lower priority.
-		A priority is specified as an integer (negative numbers are no
-		exception).  If the {priority} argument is not specified, the
-		default priority is 10.  The priority of 'hlsearch' is zero,
-		hence all matches with a priority greater than zero will
-		overrule it.  Syntax highlighting (see 'syntax') is a separate
-		mechanism, and regardless of the chosen priority a match will
-		always overrule syntax highlighting.
-
-		The optional {id} argument allows the request for a specific
-		match ID.  If a specified ID is already taken, an error
-		message will appear and the match will not be added.  An ID
-		is specified as a positive integer (zero excluded).  IDs 1, 2
-		and 3 are reserved for |:match|, |:2match| and |:3match|,
-		respectively.  If the {id} argument is not specified or -1,
-		|matchadd()| automatically chooses a free ID.
-
-		The optional {dict} argument allows for further custom
-		values. Currently this is used to specify a match specific
-		conceal character that will be shown for |hl-Conceal|
-		highlighted matches. The dict can have the following members:
-
-			conceal	    Special character to show instead of the
-				    match (only for |hl-Conceal| highlighed
-				    matches, see |:syn-cchar|)
-			window	    Instead of the current window use the
-				    window with this number or window ID.
-
-		The number of matches is not limited, as it is the case with
-		the |:match| commands.
-
-		Example: >
-			:highlight MyGroup ctermbg=green guibg=green
-			:let m = matchadd("MyGroup", "TODO")
-<		Deletion of the pattern: >
-			:call matchdelete(m)
-
-<		A list of matches defined by |matchadd()| and |:match| are
-		available from |getmatches()|.  All matches can be deleted in
-		one operation by |clearmatches()|.
-
-		Can also be used as a |method|: >
-			GetGroup()->matchadd('TODO')
-<
-							*matchaddpos()*
-matchaddpos({group}, {pos} [, {priority} [, {id} [, {dict}]]])
-		Same as |matchadd()|, but requires a list of positions {pos}
-		instead of a pattern. This command is faster than |matchadd()|
-		because it does not require to handle regular expressions and
-		sets buffer line boundaries to redraw screen. It is supposed
-		to be used when fast match additions and deletions are
-		required, for example to highlight matching parentheses.
-							*E5030* *E5031*
-		{pos} is a list of positions.  Each position can be one of
-		these:
-		- A number.  This whole line will be highlighted.  The first
-		  line has number 1.
-		- A list with one number, e.g., [23]. The whole line with this
-		  number will be highlighted.
-		- A list with two numbers, e.g., [23, 11]. The first number is
-		  the line number, the second one is the column number (first
-		  column is 1, the value must correspond to the byte index as
-		  |col()| would return).  The character at this position will
-		  be highlighted.
-		- A list with three numbers, e.g., [23, 11, 3]. As above, but
-		  the third number gives the length of the highlight in bytes.
-
-		Entries with zero and negative line numbers are silently
-		ignored, as well as entries with negative column numbers and
-		lengths.
-
-		The maximum number of positions in {pos} is 8.
-
-		Example: >
-			:highlight MyGroup ctermbg=green guibg=green
-			:let m = matchaddpos("MyGroup", [[23, 24], 34])
-<		Deletion of the pattern: >
-			:call matchdelete(m)
-
-<		Matches added by |matchaddpos()| are returned by
-		|getmatches()|.
-
-		Can also be used as a |method|: >
-			GetGroup()->matchaddpos([23, 11])
-
-matcharg({nr})							*matcharg()*
-		Selects the {nr} match item, as set with a |:match|,
-		|:2match| or |:3match| command.
-		Return a |List| with two elements:
-			The name of the highlight group used
-			The pattern used.
-		When {nr} is not 1, 2 or 3 returns an empty |List|.
-		When there is no match item set returns ['', ''].
-		This is useful to save and restore a |:match|.
-		Highlighting matches using the |:match| commands are limited
-		to three matches. |matchadd()| does not have this limitation.
-
-		Can also be used as a |method|: >
-			GetMatch()->matcharg()
-
-matchdelete({id} [, {win}])		       *matchdelete()* *E802* *E803*
-		Deletes a match with ID {id} previously defined by |matchadd()|
-		or one of the |:match| commands.  Returns 0 if successful,
-		otherwise -1.  See example for |matchadd()|.  All matches can
-		be deleted in one operation by |clearmatches()|.
-		If {win} is specified, use the window with this number or
-		window ID instead of the current window.
-
-		Can also be used as a |method|: >
-			GetMatch()->matchdelete()
-
-matchend({expr}, {pat} [, {start} [, {count}]])			*matchend()*
-		Same as |match()|, but return the index of first character
-		after the match.  Example: >
-			:echo matchend("testing", "ing")
-<		results in "7".
-							*strspn()* *strcspn()*
-		Vim doesn't have a strspn() or strcspn() function, but you can
-		do it with matchend(): >
-			:let span = matchend(line, '[a-zA-Z]')
-			:let span = matchend(line, '[^a-zA-Z]')
-<		Except that -1 is returned when there are no matches.
-
-		The {start}, if given, has the same meaning as for |match()|. >
-			:echo matchend("testing", "ing", 2)
-<		results in "7". >
-			:echo matchend("testing", "ing", 5)
-<		result is "-1".
-		When {expr} is a |List| the result is equal to |match()|.
-
-		Can also be used as a |method|: >
-			GetText()->matchend('word')
-
-matchlist({expr}, {pat} [, {start} [, {count}]])		*matchlist()*
-		Same as |match()|, but return a |List|.  The first item in the
-		list is the matched string, same as what matchstr() would
-		return.  Following items are submatches, like "\1", "\2", etc.
-		in |:substitute|.  When an optional submatch didn't match an
-		empty string is used.  Example: >
-			echo matchlist('acd', '\(a\)\?\(b\)\?\(c\)\?\(.*\)')
-<		Results in: ['acd', 'a', '', 'c', 'd', '', '', '', '', '']
-		When there is no match an empty list is returned.
-
-		You can pass in a List, but that is not very useful.
-
-		Can also be used as a |method|: >
-			GetText()->matchlist('word')
-
-matchstr({expr}, {pat} [, {start} [, {count}]])			*matchstr()*
-		Same as |match()|, but return the matched string.  Example: >
-			:echo matchstr("testing", "ing")
-<		results in "ing".
-		When there is no match "" is returned.
-		The {start}, if given, has the same meaning as for |match()|. >
-			:echo matchstr("testing", "ing", 2)
-<		results in "ing". >
-			:echo matchstr("testing", "ing", 5)
-<		result is "".
-		When {expr} is a |List| then the matching item is returned.
-		The type isn't changed, it's not necessarily a String.
-
-		Can also be used as a |method|: >
-			GetText()->matchstr('word')
-
-matchstrpos({expr}, {pat} [, {start} [, {count}]])		*matchstrpos()*
-		Same as |matchstr()|, but return the matched string, the start
-		position and the end position of the match.  Example: >
-			:echo matchstrpos("testing", "ing")
-<		results in ["ing", 4, 7].
-		When there is no match ["", -1, -1] is returned.
-		The {start}, if given, has the same meaning as for |match()|. >
-			:echo matchstrpos("testing", "ing", 2)
-<		results in ["ing", 4, 7]. >
-			:echo matchstrpos("testing", "ing", 5)
-<		result is ["", -1, -1].
-		When {expr} is a |List| then the matching item, the index
-		of first item where {pat} matches, the start position and the
-		end position of the match are returned. >
-			:echo matchstrpos([1, '__x'], '\a')
-<		result is ["x", 1, 2, 3].
-		The type isn't changed, it's not necessarily a String.
-
-		Can also be used as a |method|: >
-			GetText()->matchstrpos('word')
-<
-							*max()*
-max({expr})	Return the maximum value of all items in {expr}.
-		{expr} can be a |List| or a |Dictionary|.  For a Dictionary,
-		it returns the maximum of all values in the Dictionary.
-		If {expr} is neither a List nor a Dictionary, or one of the
-		items in {expr} cannot be used as a Number this results in
-                an error.  An empty |List| or |Dictionary| results in zero.
-
-		Can also be used as a |method|: >
-			mylist->max()
-
-menu_get({path} [, {modes}])				*menu_get()*
-		Returns a |List| of |Dictionaries| describing |menus| (defined
-		by |:menu|, |:amenu|, …), including |hidden-menus|.
-
-		{path} matches a menu by name, or all menus if {path} is an
-		empty string.  Example: >
-			:echo menu_get('File','')
-			:echo menu_get('')
-<
-		{modes} is a string of zero or more modes (see |maparg()| or
-		|creating-menus| for the list of modes). "a" means "all".
-
-		Example: >
-			nnoremenu &Test.Test inormal
-			inoremenu Test.Test insert
-			vnoremenu Test.Test x
-			echo menu_get("")
-
-<		returns something like this: >
-
-			[ {
-			  "hidden": 0,
-			  "name": "Test",
-			  "priority": 500,
-			  "shortcut": 84,
-			  "submenus": [ {
-			    "hidden": 0,
-			    "mappings": {
-			      i": {
-				"enabled": 1,
-				"noremap": 1,
-				"rhs": "insert",
-				"sid": 1,
-				"silent": 0
-			      },
-			      n": { ... },
-			      s": { ... },
-			      v": { ... }
-			    },
-			    "name": "Test",
-			    "priority": 500,
-			    "shortcut": 0
-			  } ]
-			} ]
-<
-
-							*min()*
-min({expr})	Return the minimum value of all items in {expr}.
-		{expr} can be a |List| or a |Dictionary|.  For a Dictionary,
-		it returns the minimum of all values in the Dictionary.
-		If {expr} is neither a List nor a Dictionary, or one of the
-		items in {expr} cannot be used as a Number this results in
-		an error.  An empty |List| or |Dictionary| results in zero.
-
-		Can also be used as a |method|: >
-			mylist->min()
-
-<							*mkdir()* *E739*
-mkdir({name} [, {path} [, {prot}]])
-		Create directory {name}.
-		If {path} is "p" then intermediate directories are created as
-		necessary.  Otherwise it must be "".
-		If {prot} is given it is used to set the protection bits of
-		the new directory.  The default is 0o755 (rwxr-xr-x: r/w for
-		the user, readable for others).  Use 0o700 to make it
-		unreadable for others.
-
-		{prot} is applied for all parts of {name}.  Thus if you create
-		/tmp/foo/bar then /tmp/foo will be created with 0700. Example: >
-			:call mkdir($HOME . "/tmp/foo/bar", "p", 0700)
-<		This function is not available in the |sandbox|.
-
-		If you try to create an existing directory with {path} set to
-		"p" mkdir() will silently exit.
-
-		The function result is a Number, which is TRUE if the call was
-		successful or FALSE if the directory creation failed or partly
-		failed.
-
-		Can also be used as a |method|: >
-			GetName()->mkdir()
-<
-							*mode()*
-mode([expr])	Return a string that indicates the current mode.
-		If [expr] is supplied and it evaluates to a non-zero Number or
-		a non-empty String (|non-zero-arg|), then the full mode is
-		returned, otherwise only the first letter is returned.
-
-		   n	    Normal
-		   no	    Operator-pending
-		   nov	    Operator-pending (forced charwise |o_v|)
-		   noV	    Operator-pending (forced linewise |o_V|)
-		   noCTRL-V Operator-pending (forced blockwise |o_CTRL-V|)
-				CTRL-V is one character
-		   niI	    Normal using |i_CTRL-O| in |Insert-mode|
-		   niR	    Normal using |i_CTRL-O| in |Replace-mode|
-		   niV	    Normal using |i_CTRL-O| in |Virtual-Replace-mode|
-		   nt	    Normal in |terminal-emulator| (insert goes to
-				Terminal mode)
-		   v	    Visual by character
-		   vs	    Visual by character using |v_CTRL-O| in Select mode
-		   V	    Visual by line
-		   Vs	    Visual by line using |v_CTRL-O| in Select mode
-		   CTRL-V   Visual blockwise
-		   CTRL-Vs  Visual blockwise using |v_CTRL-O| in Select mode
-		   s	    Select by character
-		   S	    Select by line
-		   CTRL-S   Select blockwise
-		   i	    Insert
-		   ic	    Insert mode completion |compl-generic|
-		   ix	    Insert mode |i_CTRL-X| completion
-		   R	    Replace |R|
-		   Rc	    Replace mode completion |compl-generic|
-		   Rx	    Replace mode |i_CTRL-X| completion
-		   Rv	    Virtual Replace |gR|
-		   Rvc	    Virtual Replace mode completion |compl-generic|
-		   Rvx	    Virtual Replace mode |i_CTRL-X| completion
-		   c	    Command-line editing
-		   cv	    Vim Ex mode |gQ|
-		   r	    Hit-enter prompt
-		   rm	    The -- more -- prompt
-		   r?	    A |:confirm| query of some sort
-		   !	    Shell or external command is executing
-		   t	    Terminal mode: keys go to the job
-
-		This is useful in the 'statusline' option or when used
-		with |remote_expr()| In most other places it always returns
-		"c" or "n".
-		Note that in the future more modes and more specific modes may
-		be added. It's better not to compare the whole string but only
-		the leading character(s).
-		Also see |visualmode()|.
-
-		Can also be used as a |method|: >
-			DoFull()->mode()
-
-msgpackdump({list} [, {type}])				*msgpackdump()*
-		Convert a list of VimL objects to msgpack. Returned value is a
-		|readfile()|-style list. When {type} contains "B", a |Blob| is
-		returned instead. Example: >
-			call writefile(msgpackdump([{}]), 'fname.mpack', 'b')
-<		or, using a |Blob|: >
-			call writefile(msgpackdump([{}], 'B'), 'fname.mpack')
-<
-		This will write the single 0x80 byte to a `fname.mpack` file
-		(dictionary with zero items is represented by 0x80 byte in
-		messagepack).
-
-		Limitations:				*E5004* *E5005*
-		1. |Funcref|s cannot be dumped.
-		2. Containers that reference themselves cannot be dumped.
-		3. Dictionary keys are always dumped as STR strings.
-		4. Other strings and |Blob|s are always dumped as BIN strings.
-		5. Points 3. and 4. do not apply to |msgpack-special-dict|s.
-
-msgpackparse({data})					*msgpackparse()*
-		Convert a |readfile()|-style list or a |Blob| to a list of
-		VimL objects.
-		Example: >
-			let fname = expand('~/.config/nvim/shada/main.shada')
-			let mpack = readfile(fname, 'b')
-			let shada_objects = msgpackparse(mpack)
-<		This will read ~/.config/nvim/shada/main.shada file to
-		`shada_objects` list.
-
-		Limitations:
-		1. Mapping ordering is not preserved unless messagepack
-		   mapping is dumped using generic mapping
-		   (|msgpack-special-map|).
-		2. Since the parser aims to preserve all data untouched
-		   (except for 1.) some strings are parsed to
-		   |msgpack-special-dict| format which is not convenient to
-		   use.
-							*msgpack-special-dict*
-		Some messagepack strings may be parsed to special
-		dictionaries. Special dictionaries are dictionaries which
-
-		1. Contain exactly two keys: `_TYPE` and `_VAL`.
-		2. `_TYPE` key is one of the types found in |v:msgpack_types|
-		   variable.
-		3. Value for `_VAL` has the following format (Key column
-		   contains name of the key from |v:msgpack_types|):
-
-		Key	Value ~
-		nil	Zero, ignored when dumping.  Not returned by
-			|msgpackparse()| since |v:null| was introduced.
-		boolean	One or zero.  When dumping it is only checked that
-			value is a |Number|.  Not returned by |msgpackparse()|
-			since |v:true| and |v:false| were introduced.
-		integer	|List| with four numbers: sign (-1 or 1), highest two
-			bits, number with bits from 62nd to 31st, lowest 31
-			bits. I.e. to get actual number one will need to use
-			code like >
-				_VAL[0] * ((_VAL[1] << 62)
-				           & (_VAL[2] << 31)
-				           & _VAL[3])
-<			Special dictionary with this type will appear in
-			|msgpackparse()| output under one of the following
-			circumstances:
-			1. |Number| is 32-bit and value is either above
-			   INT32_MAX or below INT32_MIN.
-			2. |Number| is 64-bit and value is above INT64_MAX. It
-			   cannot possibly be below INT64_MIN because msgpack
-			   C parser does not support such values.
-		float	|Float|. This value cannot possibly appear in
-			|msgpackparse()| output.
-		string	|readfile()|-style list of strings. This value will
-			appear in |msgpackparse()| output if string contains
-			zero byte or if string is a mapping key and mapping is
-			being represented as special dictionary for other
-			reasons.
-		binary	|String|, or |Blob| if binary string contains zero
-			byte. This value cannot appear in |msgpackparse()|
-			output since blobs were introduced.
-		array	|List|. This value cannot appear in |msgpackparse()|
-			output.
-							*msgpack-special-map*
-		map	|List| of |List|s with two items (key and value) each.
-			This value will appear in |msgpackparse()| output if
-			parsed mapping contains one of the following keys:
-			1. Any key that is not a string (including keys which
-			   are binary strings).
-			2. String with NUL byte inside.
-			3. Duplicate key.
-			4. Empty key.
-		ext	|List| with two values: first is a signed integer
-			representing extension type. Second is
-			|readfile()|-style list of strings.
-
-nextnonblank({lnum})					*nextnonblank()*
-		Return the line number of the first line at or below {lnum}
-		that is not blank.  Example: >
-			if getline(nextnonblank(1)) =~ "Java"
-<		When {lnum} is invalid or there is no non-blank line at or
-		below it, zero is returned.
-		{lnum} is used like with |getline()|.
-		See also |prevnonblank()|.
-
-		Can also be used as a |method|: >
-			GetLnum()->nextnonblank()
-
-nr2char({expr} [, {utf8}])				*nr2char()*
-		Return a string with a single character, which has the number
-		value {expr}.  Examples: >
-			nr2char(64)		returns "@"
-			nr2char(32)		returns " "
-<		Example for "utf-8": >
-			nr2char(300)		returns I with bow character
-<		UTF-8 encoding is always used, {utf8} option has no effect,
-		and exists only for backwards-compatibility.
-		Note that a NUL character in the file is specified with
-		nr2char(10), because NULs are represented with newline
-		characters.  nr2char(0) is a real NUL and terminates the
-		string, thus results in an empty string.
-
-		Can also be used as a |method|: >
-			GetNumber()->nr2char()
-
-nvim_...({...})					*E5555* *nvim_...()* *eval-api*
-		Call nvim |api| functions. The type checking of arguments will
-		be stricter than for most other builtins. For instance,
-		if Integer is expected, a |Number| must be passed in, a
-		|String| will not be autoconverted.
-		Buffer numbers, as returned by |bufnr()| could be used as
-		first argument to nvim_buf_... functions.  All functions
-		expecting an object (buffer, window or tabpage) can
-		also take the numerical value 0 to indicate the current
-		(focused) object.
-
-or({expr}, {expr})					*or()*
-		Bitwise OR on the two arguments.  The arguments are converted
-		to a number.  A List, Dict or Float argument causes an error.
-		Example: >
-			:let bits = or(bits, 0x80)
-<		Can also be used as a |method|: >
-			:let bits = bits->or(0x80)
-
-pathshorten({path})					*pathshorten()*
-		Shorten directory names in the path {path} and return the
-		result.  The tail, the file name, is kept as-is.  The other
-		components in the path are reduced to single letters.  Leading
-		'~' and '.' characters are kept.  Example: >
-			:echo pathshorten('~/.config/nvim/autoload/file1.vim')
-<			~/.c/n/a/file1.vim ~
-		It doesn't matter if the path exists or not.
-
-		Can also be used as a |method|: >
-			GetDirectories()->pathshorten()
-
-perleval({expr})					*perleval()*
-		Evaluate |perl| expression {expr} and return its result
-		converted to Vim data structures.
-		Numbers and strings are returned as they are (strings are
-		copied though).
-		Lists are represented as Vim |List| type.
-		Dictionaries are represented as Vim |Dictionary| type,
-		non-string keys result in error.
-
-		Note: If you want an array or hash, {expr} must return a
-		reference to it.
-		Example: >
-			:echo perleval('[1 .. 4]')
-<			[1, 2, 3, 4]
-
-		Can also be used as a |method|: >
-			GetExpr()->perleval()
-
-pow({x}, {y})						*pow()*
-		Return the power of {x} to the exponent {y} as a |Float|.
-		{x} and {y} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			:echo pow(3, 3)
-<			27.0 >
-			:echo pow(2, 16)
-<			65536.0 >
-			:echo pow(32, 0.20)
-<			2.0
-
-		Can also be used as a |method|: >
-			Compute()->pow(3)
-
-prevnonblank({lnum})					*prevnonblank()*
-		Return the line number of the first line at or above {lnum}
-		that is not blank.  Example: >
-			let ind = indent(prevnonblank(v:lnum - 1))
-<		When {lnum} is invalid or there is no non-blank line at or
-		above it, zero is returned.
-		{lnum} is used like with |getline()|.
-		Also see |nextnonblank()|.
-
-		Can also be used as a |method|: >
-			GetLnum()->prevnonblank()
-
-printf({fmt}, {expr1} ...)				*printf()*
-		Return a String with {fmt}, where "%" items are replaced by
-		the formatted form of their respective arguments.  Example: >
-			printf("%4d: E%d %.30s", lnum, errno, msg)
-<		May result in:
-			"  99: E42 asdfasdfasdfasdfasdfasdfasdfas" ~
-
-		When used as a |method| the base is passed as the second
-		argument: >
-			Compute()->printf("result: %d")
-
-<		Often used items are:
-		  %s	string
-		  %6S	string right-aligned in 6 display cells
-		  %6s	string right-aligned in 6 bytes
-		  %.9s	string truncated to 9 bytes
-		  %c	single byte
-		  %d	decimal number
-		  %5d	decimal number padded with spaces to 5 characters
-		  %b	binary number
-		  %08b	binary number padded with zeros to at least 8 characters
-		  %B	binary number using upper case letters
-		  %x	hex number
-		  %04x	hex number padded with zeros to at least 4 characters
-		  %X	hex number using upper case letters
-		  %o	octal number
-		  %f	floating point number as 12.23, inf, -inf or nan
-		  %F	floating point number as 12.23, INF, -INF or NAN
-		  %e	floating point number as 1.23e3, inf, -inf or nan
-		  %E	floating point number as 1.23E3, INF, -INF or NAN
-		  %g	floating point number, as %f or %e depending on value
-		  %G	floating point number, as %F or %E depending on value
-		  %%	the % character itself
-		  %p	representation of the pointer to the container
-
-		Conversion specifications start with '%' and end with the
-		conversion type.  All other characters are copied unchanged to
-		the result.
-
-		The "%" starts a conversion specification.  The following
-		arguments appear in sequence:
-
-			%  [flags]  [field-width]  [.precision]  type
-
-		flags
-			Zero or more of the following flags:
-
-		    #	      The value should be converted to an "alternate
-			      form".  For c, d, and s conversions, this option
-			      has no effect.  For o conversions, the precision
-			      of the number is increased to force the first
-			      character of the output string to a zero (except
-			      if a zero value is printed with an explicit
-			      precision of zero).
-			      For x and X conversions, a non-zero result has
-			      the string "0x" (or "0X" for X conversions)
-			      prepended to it.
-
-		    0 (zero)  Zero padding.  For all conversions the converted
-			      value is padded on the left with zeros rather
-			      than blanks.  If a precision is given with a
-			      numeric conversion (d, o, x, and X), the 0 flag
-			      is ignored.
-
-		    -	      A negative field width flag; the converted value
-			      is to be left adjusted on the field boundary.
-			      The converted value is padded on the right with
-			      blanks, rather than on the left with blanks or
-			      zeros.  A - overrides a 0 if both are given.
-
-		    ' ' (space)  A blank should be left before a positive
-			      number produced by a signed conversion (d).
-
-		    +	      A sign must always be placed before a number
-			      produced by a signed conversion.  A + overrides
-			      a space if both are used.
-
-		field-width
-			An optional decimal digit string specifying a minimum
-			field width.  If the converted value has fewer bytes
-			than the field width, it will be padded with spaces on
-			the left (or right, if the left-adjustment flag has
-			been given) to fill out the field width.  For the S
-			conversion the count is in cells.
-
-		.precision
-			An optional precision, in the form of a period '.'
-			followed by an optional digit string.  If the digit
-			string is omitted, the precision is taken as zero.
-			This gives the minimum number of digits to appear for
-			d, o, x, and X conversions, the maximum number of
-			bytes to be printed from a string for s conversions,
-			or the maximum number of cells to be printed from a
-			string for S conversions.
-			For floating point it is the number of digits after
-			the decimal point.
-
-		type
-			A character that specifies the type of conversion to
-			be applied, see below.
-
-		A field width or precision, or both, may be indicated by an
-		asterisk '*' instead of a digit string.  In this case, a
-		Number argument supplies the field width or precision.  A
-		negative field width is treated as a left adjustment flag
-		followed by a positive field width; a negative precision is
-		treated as though it were missing.  Example: >
-			:echo printf("%d: %.*s", nr, width, line)
-<		This limits the length of the text used from "line" to
-		"width" bytes.
-
-		The conversion specifiers and their meanings are:
-
-				*printf-d* *printf-b* *printf-B* *printf-o* *printf-x* *printf-X*
-		dbBoxX	The Number argument is converted to signed decimal (d),
-			unsigned binary (b and B), unsigned octal (o), or
-			unsigned hexadecimal (x and X) notation.  The letters
-			"abcdef" are used for x conversions; the letters
-			"ABCDEF" are used for X conversions.  The precision, if
-			any, gives the minimum number of digits that must
-			appear; if the converted value requires fewer digits, it
-			is padded on the left with zeros.  In no case does a
-			non-existent or small field width cause truncation of a
-			numeric field; if the result of a conversion is wider
-			than the field width, the field is expanded to contain
-			the conversion result.
-			The 'h' modifier indicates the argument is 16 bits.
-			The 'l' modifier indicates the argument is 32 bits.
-			The 'L' modifier indicates the argument is 64 bits.
-			Generally, these modifiers are not useful. They are
-			ignored when type is known from the argument.
-
-		i	alias for d
-		D	alias for ld
-		U	alias for lu
-		O	alias for lo
-
-							*printf-c*
-		c	The Number argument is converted to a byte, and the
-			resulting character is written.
-
-							*printf-s*
-		s	The text of the String argument is used.  If a
-			precision is specified, no more bytes than the number
-			specified are used.
-			If the argument is not a String type, it is
-			automatically converted to text with the same format
-			as ":echo".
-							*printf-S*
-		S	The text of the String argument is used.  If a
-			precision is specified, no more display cells than the
-			number specified are used.
-
-							*printf-f* *E807*
-		f F	The Float argument is converted into a string of the
-			form 123.456.  The precision specifies the number of
-			digits after the decimal point.  When the precision is
-			zero the decimal point is omitted.  When the precision
-			is not specified 6 is used.  A really big number
-			(out of range or dividing by zero) results in "inf"
-			 or "-inf" with %f (INF or -INF with %F).
-			 "0.0 / 0.0" results in "nan" with %f (NAN with %F).
-			Example: >
-				echo printf("%.2f", 12.115)
-<				12.12
-			Note that roundoff depends on the system libraries.
-			Use |round()| when in doubt.
-
-							*printf-e* *printf-E*
-		e E	The Float argument is converted into a string of the
-			form 1.234e+03 or 1.234E+03 when using 'E'.  The
-			precision specifies the number of digits after the
-			decimal point, like with 'f'.
-
-							*printf-g* *printf-G*
-		g G	The Float argument is converted like with 'f' if the
-			value is between 0.001 (inclusive) and 10000000.0
-			(exclusive).  Otherwise 'e' is used for 'g' and 'E'
-			for 'G'.  When no precision is specified superfluous
-			zeroes and '+' signs are removed, except for the zero
-			immediately after the decimal point.  Thus 10000000.0
-			results in 1.0e7.
-
-							*printf-%*
-		%	A '%' is written.  No argument is converted.  The
-			complete conversion specification is "%%".
-
-		When a Number argument is expected a String argument is also
-		accepted and automatically converted.
-		When a Float or String argument is expected a Number argument
-		is also accepted and automatically converted.
-		Any other argument type results in an error message.
-
-							*E766* *E767*
-		The number of {exprN} arguments must exactly match the number
-		of "%" items.  If there are not sufficient or too many
-		arguments an error is given.  Up to 18 arguments can be used.
-
-prompt_getprompt({buf})					*prompt_getprompt()*
-		Returns the effective prompt text for buffer {buf}.  {buf} can
-		be a buffer name or number.  See |prompt-buffer|.
-
-		If the buffer doesn't exist or isn't a prompt buffer, an empty
-		string is returned.
-
-		Can also be used as a |method|: >
-			GetBuffer()->prompt_getprompt()
-
-prompt_setcallback({buf}, {expr})			*prompt_setcallback()*
-		Set prompt callback for buffer {buf} to {expr}.  When {expr}
-		is an empty string the callback is removed.  This has only
-		effect if {buf} has 'buftype' set to "prompt".
-
-		The callback is invoked when pressing Enter.  The current
-		buffer will always be the prompt buffer.  A new line for a
-		prompt is added before invoking the callback, thus the prompt
-		for which the callback was invoked will be in the last but one
-		line.
-		If the callback wants to add text to the buffer, it must
-		insert it above the last line, since that is where the current
-		prompt is.  This can also be done asynchronously.
-		The callback is invoked with one argument, which is the text
-		that was entered at the prompt.  This can be an empty string
-		if the user only typed Enter.
-		Example: >
-		   call prompt_setcallback(bufnr(''), function('s:TextEntered'))
-		   func s:TextEntered(text)
-		     if a:text == 'exit' || a:text == 'quit'
-		       stopinsert
-		       close
-		     else
-		       call append(line('$') - 1, 'Entered: "' . a:text . '"')
-		       " Reset 'modified' to allow the buffer to be closed.
-		       set nomodified
-		     endif
-		   endfunc
-
-<		Can also be used as a |method|: >
-			GetBuffer()->prompt_setcallback(callback)
-
-prompt_setinterrupt({buf}, {expr})			*prompt_setinterrupt()*
-		Set a callback for buffer {buf} to {expr}.  When {expr} is an
-		empty string the callback is removed.  This has only effect if
-		{buf} has 'buftype' set to "prompt".
-
-		This callback will be invoked when pressing CTRL-C in Insert
-		mode.  Without setting a callback Vim will exit Insert mode,
-		as in any buffer.
-
-		Can also be used as a |method|: >
-			GetBuffer()->prompt_setinterrupt(callback)
-
-prompt_setprompt({buf}, {text})				*prompt_setprompt()*
-		Set prompt for buffer {buf} to {text}.  You most likely want
-		{text} to end in a space.
-		The result is only visible if {buf} has 'buftype' set to
-		"prompt".  Example: >
-			call prompt_setprompt(bufnr(''), 'command: ')
-<
-		Can also be used as a |method|: >
-			GetBuffer()->prompt_setprompt('command: ')
-
-pum_getpos()						*pum_getpos()*
-		If the popup menu (see |ins-completion-menu|) is not visible,
-		returns an empty |Dictionary|, otherwise, returns a
-		|Dictionary| with the following keys:
-			height		nr of items visible
-			width		screen cells
-			row		top screen row (0 first row)
-			col		leftmost screen column (0 first col)
-			size		total nr of items
-			scrollbar	|TRUE| if scrollbar is visible
-
-  		The values are the same as in |v:event| during |CompleteChanged|.
-
-pumvisible()						*pumvisible()*
-		Returns non-zero when the popup menu is visible, zero
-		otherwise.  See |ins-completion-menu|.
-		This can be used to avoid some things that would remove the
-		popup menu.
-
-py3eval({expr})						*py3eval()*
-		Evaluate Python expression {expr} and return its result
-		converted to Vim data structures.
-		Numbers and strings are returned as they are (strings are
-		copied though, Unicode strings are additionally converted to
-		UTF-8).
-		Lists are represented as Vim |List| type.
-		Dictionaries are represented as Vim |Dictionary| type with
-		keys converted to strings.
-
-		Can also be used as a |method|: >
-			GetExpr()->py3eval()
-<
-							*E858* *E859*
-pyeval({expr})						*pyeval()*
-		Evaluate Python expression {expr} and return its result
-		converted to Vim data structures.
-		Numbers and strings are returned as they are (strings are
-		copied though).
-		Lists are represented as Vim |List| type.
-		Dictionaries are represented as Vim |Dictionary| type,
-		non-string keys result in error.
-
-		Can also be used as a |method|: >
-			GetExpr()->pyeval()
-
-pyxeval({expr})						*pyxeval()*
-		Evaluate Python expression {expr} and return its result
-		converted to Vim data structures.
-		Uses Python 2 or 3, see |python_x| and 'pyxversion'.
-		See also: |pyeval()|, |py3eval()|
-
-		Can also be used as a |method|: >
-			GetExpr()->pyxeval()
-<
-							*E726* *E727*
-range({expr} [, {max} [, {stride}]])				*range()*
-		Returns a |List| with Numbers:
-		- If only {expr} is specified: [0, 1, ..., {expr} - 1]
-		- If {max} is specified: [{expr}, {expr} + 1, ..., {max}]
-		- If {stride} is specified: [{expr}, {expr} + {stride}, ...,
-		  {max}] (increasing {expr} with {stride} each time, not
-		  producing a value past {max}).
-		When the maximum is one before the start the result is an
-		empty list.  When the maximum is more than one before the
-		start this is an error.
-		Examples: >
-			range(4)		" [0, 1, 2, 3]
-			range(2, 4)		" [2, 3, 4]
-			range(2, 9, 3)		" [2, 5, 8]
-			range(2, -2, -1)	" [2, 1, 0, -1, -2]
-			range(0)		" []
-			range(2, 0)		" error!
-<
-		Can also be used as a |method|: >
-			GetExpr()->range()
-<
-							*readdir()*
-readdir({directory} [, {expr}])
-		Return a list with file and directory names in {directory}.
-
-		When {expr} is omitted all entries are included.
-		When {expr} is given, it is evaluated to check what to do:
-			If {expr} results in -1 then no further entries will
-			be handled.
-			If {expr} results in 0 then this entry will not be
-			added to the list.
-			If {expr} results in 1 then this entry will be added
-			to the list.
-		Each time {expr} is evaluated |v:val| is set to the entry name.
-		When {expr} is a function the name is passed as the argument.
-		For example, to get a list of files ending in ".txt": >
-		  readdir(dirname, {n -> n =~ '.txt$'})
-<		To skip hidden and backup files: >
-		  readdir(dirname, {n -> n !~ '^\.\|\~$'})
-
-<		If you want to get a directory tree: >
-                  function! s:tree(dir)
-                      return {a:dir : map(readdir(a:dir),
-		      \ {_, x -> isdirectory(x) ?
-		      \          {x : s:tree(a:dir . '/' . x)} : x})}
-                  endfunction
-                  echo s:tree(".")
-<
-		Can also be used as a |method|: >
-			GetDirName()->readdir()
-<
-							*readfile()*
-readfile({fname} [, {type} [, {max}]])
-		Read file {fname} and return a |List|, each line of the file
-		as an item.  Lines are broken at NL characters.  Macintosh
-		files separated with CR will result in a single long line
-		(unless a NL appears somewhere).
-		All NUL characters are replaced with a NL character.
-		When {type} contains "b" binary mode is used:
-		- When the last line ends in a NL an extra empty list item is
-		  added.
-		- No CR characters are removed.
-		When {type} contains "B" a |Blob| is returned with the binary
-		data of the file unmodified.
-		Otherwise:
-		- CR characters that appear before a NL are removed.
-		- Whether the last line ends in a NL or not does not matter.
-		- Any UTF-8 byte order mark is removed from the text.
-		When {max} is given this specifies the maximum number of lines
-		to be read.  Useful if you only want to check the first ten
-		lines of a file: >
-			:for line in readfile(fname, '', 10)
-			:  if line =~ 'Date' | echo line | endif
-			:endfor
-<		When {max} is negative -{max} lines from the end of the file
-		are returned, or as many as there are.
-		When {max} is zero the result is an empty list.
-		Note that without {max} the whole file is read into memory.
-		Also note that there is no recognition of encoding.  Read a
-		file into a buffer if you need to.
-		When the file can't be opened an error message is given and
-		the result is an empty list.
-		Also see |writefile()|.
-
-		Can also be used as a |method|: >
-			GetFileName()->readfile()
-
-reg_executing()						*reg_executing()*
-		Returns the single letter name of the register being executed.
-		Returns an empty string when no register is being executed.
-		See |@|.
-
-reg_recorded()						*reg_recorded()*
-		Returns the single letter name of the last recorded register.
-		Returns an empty string string when nothing was recorded yet.
-		See |q| and |Q|.
-
-reg_recording()						*reg_recording()*
-		Returns the single letter name of the register being recorded.
-		Returns an empty string string when not recording.  See |q|.
-
-reltime([{start} [, {end}]])				*reltime()*
-		Return an item that represents a time value.  The item is a
-		list with items that depend on the system.
-		The item can be passed to |reltimestr()| to convert it to a
-		string or |reltimefloat()| to convert to a Float.
-
-		Without an argument it returns the current "relative time", an
-		implementation-defined value meaningful only when used as an
-		argument to |reltime()|, |reltimestr()| and |reltimefloat()|.
-
-		With one argument it returns the time passed since the time
-		specified in the argument.
-		With two arguments it returns the time passed between {start}
-		and {end}.
-
-		The {start} and {end} arguments must be values returned by
-		reltime().
-
-		Can also be used as a |method|: >
-			GetStart()->reltime()
-<
-		Note: |localtime()| returns the current (non-relative) time.
-
-reltimefloat({time})				*reltimefloat()*
-		Return a Float that represents the time value of {time}.
-		Unit of time is seconds.
-		Example:
-			let start = reltime()
-			call MyFunction()
-			let seconds = reltimefloat(reltime(start))
-		See the note of reltimestr() about overhead.
-		Also see |profiling|.
-		If there is an error an empty string is returned
-
-		Can also be used as a |method|: >
-			reltime(start)->reltimefloat()
-
-reltimestr({time})				*reltimestr()*
-		Return a String that represents the time value of {time}.
-		This is the number of seconds, a dot and the number of
-		microseconds.  Example: >
-			let start = reltime()
-			call MyFunction()
-			echo reltimestr(reltime(start))
-<		Note that overhead for the commands will be added to the time.
-		Leading spaces are used to make the string align nicely.  You
-		can use split() to remove it. >
-			echo split(reltimestr(reltime(start)))[0]
-<		Also see |profiling|.
-		If there is an error an empty string is returned
-
-		Can also be used as a |method|: >
-			reltime(start)->reltimestr()
-<
-							*remote_expr()* *E449*
-remote_expr({server}, {string} [, {idvar} [, {timeout}]])
-		Send the {string} to {server}.  The string is sent as an
-		expression and the result is returned after evaluation.
-		The result must be a String or a |List|.  A |List| is turned
-		into a String by joining the items with a line break in
-		between (not at the end), like with join(expr, "\n").
-		If {idvar} is present and not empty, it is taken as the name
-		of a variable and a {serverid} for later use with
-		|remote_read()| is stored there.
-		If {timeout} is given the read times out after this many
-		seconds.  Otherwise a timeout of 600 seconds is used.
-		See also |clientserver| |RemoteReply|.
-		This function is not available in the |sandbox|.
-		Note: Any errors will cause a local error message to be issued
-		and the result will be the empty string.
-
-		Variables will be evaluated in the global namespace,
-		independent of a function currently being active.  Except
-		when in debug mode, then local function variables and
-		arguments can be evaluated.
-
-		Examples: >
-			:echo remote_expr("gvim", "2+2")
-			:echo remote_expr("gvim1", "b:current_syntax")
-<
-
-remote_foreground({server})				*remote_foreground()*
-		Move the Vim server with the name {server} to the foreground.
-		The {server} argument is a string.
-		This works like: >
-			remote_expr({server}, "foreground()")
-<		Except that on Win32 systems the client does the work, to work
-		around the problem that the OS doesn't always allow the server
-		to bring itself to the foreground.
-		Note: This does not restore the window if it was minimized,
-		like foreground() does.
-		This function is not available in the |sandbox|.
-		{only in the Win32 GUI and the Win32 console version}
-
-
-remote_peek({serverid} [, {retvar}])		*remote_peek()*
-		Returns a positive number if there are available strings
-		from {serverid}.  Copies any reply string into the variable
-		{retvar} if specified.  {retvar} must be a string with the
-		name of a variable.
-		Returns zero if none are available.
-		Returns -1 if something is wrong.
-		See also |clientserver|.
-		This function is not available in the |sandbox|.
-		Examples: >
-			:let repl = ""
-			:echo "PEEK: ".remote_peek(id, "repl").": ".repl
-
-remote_read({serverid}, [{timeout}])			*remote_read()*
-		Return the oldest available reply from {serverid} and consume
-		it.  Unless a {timeout} in seconds is given, it blocks until a
-		reply is available.
-		See also |clientserver|.
-		This function is not available in the |sandbox|.
-		Example: >
-			:echo remote_read(id)
-<
-							*remote_send()* *E241*
-remote_send({server}, {string} [, {idvar}])
-		Send the {string} to {server}.  The string is sent as input
-		keys and the function returns immediately.  At the Vim server
-		the keys are not mapped |:map|.
-		If {idvar} is present, it is taken as the name of a variable
-		and a {serverid} for later use with remote_read() is stored
-		there.
-		See also |clientserver| |RemoteReply|.
-		This function is not available in the |sandbox|.
-
-		Note: Any errors will be reported in the server and may mess
-		up the display.
-		Examples: >
-		:echo remote_send("gvim", ":DropAndReply ".file, "serverid").
-		 \ remote_read(serverid)
-
-		:autocmd NONE RemoteReply *
-		 \ echo remote_read(expand("<amatch>"))
-		:echo remote_send("gvim", ":sleep 10 | echo ".
-		 \ 'server2client(expand("<client>"), "HELLO")<CR>')
-<
-					*remote_startserver()* *E941* *E942*
-remote_startserver({name})
-		Become the server {name}.  This fails if already running as a
-		server, when |v:servername| is not empty.
-
-remove({list}, {idx} [, {end}])				*remove()*
-		Without {end}: Remove the item at {idx} from |List| {list} and
-		return the item.
-		With {end}: Remove items from {idx} to {end} (inclusive) and
-		return a |List| with these items.  When {idx} points to the same
-		item as {end} a list with one item is returned.  When {end}
-		points to an item before {idx} this is an error.
-		See |list-index| for possible values of {idx} and {end}.
-		Example: >
-			:echo "last item: " . remove(mylist, -1)
-			:call remove(mylist, 0, 9)
-
-<		Can also be used as a |method|: >
-			mylist->remove(idx)
-
-remove({blob}, {idx} [, {end}])
-		Without {end}: Remove the byte at {idx} from |Blob| {blob} and
-		return the byte.
-		With {end}: Remove bytes from {idx} to {end} (inclusive) and
-		return a |Blob| with these bytes.  When {idx} points to the same
-		byte as {end} a |Blob| with one byte is returned.  When {end}
-		points to a byte before {idx} this is an error.
-		Example: >
-			:echo "last byte: " . remove(myblob, -1)
-			:call remove(mylist, 0, 9)
-
-remove({dict}, {key})
-		Remove the entry from {dict} with key {key} and return it.
-		Example: >
-			:echo "removed " . remove(dict, "one")
-<		If there is no {key} in {dict} this is an error.
-
-		Use |delete()| to remove a file.
-
-rename({from}, {to})					*rename()*
-		Rename the file by the name {from} to the name {to}.  This
-		should also work to move files across file systems.  The
-		result is a Number, which is 0 if the file was renamed
-		successfully, and non-zero when the renaming failed.
-		NOTE: If {to} exists it is overwritten without warning.
-		This function is not available in the |sandbox|.
-
-		Can also be used as a |method|: >
-			GetOldName()->rename(newname)
-
-repeat({expr}, {count})					*repeat()*
-		Repeat {expr} {count} times and return the concatenated
-		result.  Example: >
-			:let separator = repeat('-', 80)
-<		When {count} is zero or negative the result is empty.
-		When {expr} is a |List| the result is {expr} concatenated
-		{count} times.  Example: >
-			:let longlist = repeat(['a', 'b'], 3)
-<		Results in ['a', 'b', 'a', 'b', 'a', 'b'].
-
-		Can also be used as a |method|: >
-			mylist->repeat(count)
-
-resolve({filename})					*resolve()* *E655*
-		On MS-Windows, when {filename} is a shortcut (a .lnk file),
-		returns the path the shortcut points to in a simplified form.
-		On Unix, repeat resolving symbolic links in all path
-		components of {filename} and return the simplified result.
-		To cope with link cycles, resolving of symbolic links is
-		stopped after 100 iterations.
-		On other systems, return the simplified {filename}.
-		The simplification step is done as by |simplify()|.
-		resolve() keeps a leading path component specifying the
-		current directory (provided the result is still a relative
-		path name) and also keeps a trailing path separator.
-
-		Can also be used as a |method|: >
-			GetName()->resolve()
-<
-							*reverse()*
-reverse({object})
-		Reverse the order of items in {object} in-place.
-		{object} can be a |List| or a |Blob|.
-		Returns {object}.
-		If you want an object to remain unmodified make a copy first: >
-			:let revlist = reverse(copy(mylist))
-<		Can also be used as a |method|: >
-			mylist->reverse()
-
-round({expr})							*round()*
-		Round off {expr} to the nearest integral value and return it
-		as a |Float|.  If {expr} lies halfway between two integral
-		values, then use the larger one (away from zero).
-		{expr} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			echo round(0.456)
-<			0.0  >
-			echo round(4.5)
-<			5.0 >
-			echo round(-4.5)
-<			-5.0
-
-		Can also be used as a |method|: >
-			Compute()->round()
-
-rpcnotify({channel}, {event}[, {args}...])			*rpcnotify()*
-		Sends {event} to {channel} via |RPC| and returns immediately.
-		If {channel} is 0, the event is broadcast to all channels.
-		Example: >
-			:au VimLeave call rpcnotify(0, "leaving")
-
-rpcrequest({channel}, {method}[, {args}...])			*rpcrequest()*
-		Sends a request to {channel} to invoke {method} via
-		|RPC| and blocks until a response is received.
-		Example: >
-			:let result = rpcrequest(rpc_chan, "func", 1, 2, 3)
-
-rpcstart({prog}[, {argv}])					*rpcstart()*
-		Deprecated. Replace  >
-			:let id = rpcstart('prog', ['arg1', 'arg2'])
-<		with >
-			:let id = jobstart(['prog', 'arg1', 'arg2'], {'rpc': v:true})
-
-rubyeval({expr})					*rubyeval()*
-		Evaluate Ruby expression {expr} and return its result
-		converted to Vim data structures.
-		Numbers, floats and strings are returned as they are (strings
-		are copied though).
-		Arrays are represented as Vim |List| type.
-		Hashes are represented as Vim |Dictionary| type.
-		Other objects are represented as strings resulted from their
-		"Object#to_s" method.
-
-		Can also be used as a |method|: >
-			GetRubyExpr()->rubyeval()
-
-screenattr({row}, {col})					*screenattr()*
-		Like |screenchar()|, but return the attribute.  This is a rather
-		arbitrary number that can only be used to compare to the
-		attribute at other positions.
-
-		Can also be used as a |method|: >
-			GetRow()->screenattr(col)
-
-screenchar({row}, {col})					*screenchar()*
-		The result is a Number, which is the character at position
-		[row, col] on the screen.  This works for every possible
-		screen position, also status lines, window separators and the
-		command line.  The top left position is row one, column one
-		The character excludes composing characters.  For double-byte
-		encodings it may only be the first byte.
-		This is mainly to be used for testing.
-		Returns -1 when row or col is out of range.
-
-		Can also be used as a |method|: >
-			GetRow()->screenchar(col)
-
-screenchars({row}, {col})					*screenchars()*
-		The result is a List of Numbers.  The first number is the same
-		as what |screenchar()| returns.  Further numbers are
-		composing characters on top of the base character.
-		This is mainly to be used for testing.
-		Returns an empty List when row or col is out of range.
-
-		Can also be used as a |method|: >
-			GetRow()->screenchars(col)
-
-screencol()							*screencol()*
-		The result is a Number, which is the current screen column of
-		the cursor. The leftmost column has number 1.
-		This function is mainly used for testing.
-
-		Note: Always returns the current screen column, thus if used
-		in a command (e.g. ":echo screencol()") it will return the
-		column inside the command line, which is 1 when the command is
-		executed. To get the cursor position in the file use one of
-		the following mappings: >
-			nnoremap <expr> GG ":echom ".screencol()."\n"
-			nnoremap <silent> GG :echom screencol()<CR>
-			noremap GG <Cmd>echom screencol()<Cr>
-<
-screenpos({winid}, {lnum}, {col})				*screenpos()*
-		The result is a Dict with the screen position of the text
-		character in window {winid} at buffer line {lnum} and column
-		{col}.  {col} is a one-based byte index.
-		The Dict has these members:
-			row	screen row
-			col	first screen column
-			endcol	last screen column
-			curscol	cursor screen column
-		If the specified position is not visible, all values are zero.
-		The "endcol" value differs from "col" when the character
-		occupies more than one screen cell.  E.g. for a Tab "col" can
-		be 1 and "endcol" can be 8.
-		The "curscol" value is where the cursor would be placed.  For
-		a Tab it would be the same as "endcol", while for a double
-		width character it would be the same as "col".
-		The |conceal| feature is ignored here, the column numbers are
- 		as if 'conceallevel' is zero.  You can set the cursor to the
- 		right position and use |screencol()| to get the value with
- 		|conceal| taken into account.
-
-		Can also be used as a |method|: >
-			GetWinid()->screenpos(lnum, col)
-
-screenrow()							*screenrow()*
-		The result is a Number, which is the current screen row of the
-		cursor.  The top line has number one.
-		This function is mainly used for testing.
-		Alternatively you can use |winline()|.
-
-		Note: Same restrictions as with |screencol()|.
-
-screenstring({row}, {col})					*screenstring()*
-		The result is a String that contains the base character and
-		any composing characters at position [row, col] on the screen.
-		This is like |screenchars()| but returning a String with the
-		characters.
-		This is mainly to be used for testing.
-		Returns an empty String when row or col is out of range.
-
-		Can also be used as a |method|: >
-			GetRow()->screenstring(col)
-
-search({pattern} [, {flags} [, {stopline} [, {timeout}]]])	*search()*
-		Search for regexp pattern {pattern}.  The search starts at the
-		cursor position (you can use |cursor()| to set it).
-
-		When a match has been found its line number is returned.
-		If there is no match a 0 is returned and the cursor doesn't
-		move.  No error message is given.
-
-		{flags} is a String, which can contain these character flags:
-		'b'	search Backward instead of forward
-		'c'	accept a match at the Cursor position
-		'e'	move to the End of the match
-		'n'	do Not move the cursor
-		'p'	return number of matching sub-Pattern (see below)
-		's'	Set the ' mark at the previous location of the cursor
-		'w'	Wrap around the end of the file
-		'W'	don't Wrap around the end of the file
-		'z'	start searching at the cursor column instead of Zero
-		If neither 'w' or 'W' is given, the 'wrapscan' option applies.
-
-		If the 's' flag is supplied, the ' mark is set, only if the
-		cursor is moved. The 's' flag cannot be combined with the 'n'
-		flag.
-
-		'ignorecase', 'smartcase' and 'magic' are used.
-
-		When the 'z' flag is not given, forward searching always
-		starts in column zero and then matches before the cursor are
-		skipped.  When the 'c' flag is present in 'cpo' the next
-		search starts after the match.  Without the 'c' flag the next
-		search starts one column further.  This matters for
-		overlapping matches.
-		When searching backwards and the 'z' flag is given then the
-		search starts in column zero, thus no match in the current
-		line will be found (unless wrapping around the end of the
-		file).
-
-		When the {stopline} argument is given then the search stops
-		after searching this line.  This is useful to restrict the
-		search to a range of lines.  Examples: >
-			let match = search('(', 'b', line("w0"))
-			let end = search('END', '', line("w$"))
-<		When {stopline} is used and it is not zero this also implies
-		that the search does not wrap around the end of the file.
-		A zero value is equal to not giving the argument.
-
-		When the {timeout} argument is given the search stops when
-		more than this many milliseconds have passed.  Thus when
-		{timeout} is 500 the search stops after half a second.
-		The value must not be negative.  A zero value is like not
-		giving the argument.
-
-							*search()-sub-match*
-		With the 'p' flag the returned value is one more than the
-		first sub-match in \(\).  One if none of them matched but the
-		whole pattern did match.
-		To get the column number too use |searchpos()|.
-
-		The cursor will be positioned at the match, unless the 'n'
-		flag is used.
-
-		Example (goes over all files in the argument list): >
-		    :let n = 1
-		    :while n <= argc()	    " loop over all files in arglist
-		    :  exe "argument " . n
-		    :  " start at the last char in the file and wrap for the
-		    :  " first search to find match at start of file
-		    :  normal G$
-		    :  let flags = "w"
-		    :  while search("foo", flags) > 0
-		    :	 s/foo/bar/g
-		    :	 let flags = "W"
-		    :  endwhile
-		    :  update		    " write the file if modified
-		    :  let n = n + 1
-		    :endwhile
-<
-		Example for using some flags: >
-		    :echo search('\<if\|\(else\)\|\(endif\)', 'ncpe')
-<		This will search for the keywords "if", "else", and "endif"
-		under or after the cursor.  Because of the 'p' flag, it
-		returns 1, 2, or 3 depending on which keyword is found, or 0
-		if the search fails.  With the cursor on the first word of the
-		line:
-		    if (foo == 0) | let foo = foo + 1 | endif ~
-		the function returns 1.  Without the 'c' flag, the function
-		finds the "endif" and returns 3.  The same thing happens
-		without the 'e' flag if the cursor is on the "f" of "if".
-		The 'n' flag tells the function not to move the cursor.
-
-		Can also be used as a |method|: >
-			GetPattern()->search()
-
-searchcount([{options}])					*searchcount()*
-		Get or update the last search count, like what is displayed
-		without the "S" flag in 'shortmess'.  This works even if
-		'shortmess' does contain the "S" flag.
-
-		This returns a Dictionary. The dictionary is empty if the
-		previous pattern was not set and "pattern" was not specified.
-
-		  key		type		meaning ~
-		  current	|Number|	current position of match;
-						0 if the cursor position is
-						before the first match
-		  exact_match	|Boolean|	1 if "current" is matched on
-						"pos", otherwise 0
-		  total		|Number|	total count of matches found
-		  incomplete	|Number|	0: search was fully completed
-						1: recomputing was timed out
-						2: max count exceeded
-
-		For {options} see further down.
-
-		To get the last search count when |n| or |N| was pressed, call
-		this function with `recompute: 0` . This sometimes returns
-		wrong information because |n| and |N|'s maximum count is 99.
-		If it exceeded 99 the result must be max count + 1 (100). If
-		you want to get correct information, specify `recompute: 1`: >
-
-			" result == maxcount + 1 (100) when many matches
-			let result = searchcount(#{recompute: 0})
-
-			" Below returns correct result (recompute defaults
-			" to 1)
-			let result = searchcount()
-<
-		The function is useful to add the count to |statusline|: >
-			function! LastSearchCount() abort
-			  let result = searchcount(#{recompute: 0})
-			  if empty(result)
-			    return ''
-			  endif
-			  if result.incomplete ==# 1     " timed out
-			    return printf(' /%s [?/??]', @/)
-			  elseif result.incomplete ==# 2 " max count exceeded
-			    if result.total > result.maxcount &&
-			    \  result.current > result.maxcount
-			      return printf(' /%s [>%d/>%d]', @/,
-			      \             result.current, result.total)
-			    elseif result.total > result.maxcount
-			      return printf(' /%s [%d/>%d]', @/,
-			      \             result.current, result.total)
-			    endif
-			  endif
-			  return printf(' /%s [%d/%d]', @/,
-			  \             result.current, result.total)
-			endfunction
-			let &statusline .= '%{LastSearchCount()}'
-
-			" Or if you want to show the count only when
-			" 'hlsearch' was on
-			" let &statusline .=
-			" \   '%{v:hlsearch ? LastSearchCount() : ""}'
-<
-		You can also update the search count, which can be useful in a
-		|CursorMoved| or |CursorMovedI| autocommand: >
-
-			autocmd CursorMoved,CursorMovedI *
-			  \ let s:searchcount_timer = timer_start(
-			  \   200, function('s:update_searchcount'))
-			function! s:update_searchcount(timer) abort
-			  if a:timer ==# s:searchcount_timer
-			    call searchcount(#{
-			    \ recompute: 1, maxcount: 0, timeout: 100})
-			    redrawstatus
-			  endif
-			endfunction
-<
-		This can also be used to count matched texts with specified
-		pattern in the current buffer using "pattern":  >
-
-			" Count '\<foo\>' in this buffer
-			" (Note that it also updates search count)
-			let result = searchcount(#{pattern: '\<foo\>'})
-
-			" To restore old search count by old pattern,
-			" search again
-			call searchcount()
-<
-		{options} must be a Dictionary. It can contain:
-		  key		type		meaning ~
-		  recompute	|Boolean|	if |TRUE|, recompute the count
-						like |n| or |N| was executed.
-						otherwise returns the last
-						result by |n|, |N|, or this
-						function is returned.
-						(default: |TRUE|)
-		  pattern	|String|	recompute if this was given
-						and different with |@/|.
-						this works as same as the
-						below command is executed
-						before calling this function >
-						  let @/ = pattern
-<						(default: |@/|)
-		  timeout	|Number|	0 or negative number is no
-						timeout. timeout milliseconds
-						for recomputing the result
-						(default: 0)
-		  maxcount	|Number|	0 or negative number is no
-						limit. max count of matched
-						text while recomputing the
-						result.  if search exceeded
-						total count, "total" value
-						becomes `maxcount + 1`
-						(default: 0)
-		  pos		|List|		`[lnum, col, off]` value
-						when recomputing the result.
-						this changes "current" result
-						value. see |cursor()|, |getpos()
-						(default: cursor's position)
-
-		Can also be used as a |method|: >
-			GetSearchOpts()->searchcount()
-<
-searchdecl({name} [, {global} [, {thisblock}]])			*searchdecl()*
-		Search for the declaration of {name}.
-
-		With a non-zero {global} argument it works like |gD|, find
-		first match in the file.  Otherwise it works like |gd|, find
-		first match in the function.
-
-		With a non-zero {thisblock} argument matches in a {} block
-		that ends before the cursor position are ignored.  Avoids
-		finding variable declarations only valid in another scope.
-
-		Moves the cursor to the found match.
-		Returns zero for success, non-zero for failure.
-		Example: >
-			if searchdecl('myvar') == 0
-			   echo getline('.')
-			endif
-<
-		Can also be used as a |method|: >
-			GetName()->searchdecl()
-<
-							*searchpair()*
-searchpair({start}, {middle}, {end} [, {flags} [, {skip}
-				[, {stopline} [, {timeout}]]]])
-		Search for the match of a nested start-end pair.  This can be
-		used to find the "endif" that matches an "if", while other
-		if/endif pairs in between are ignored.
-		The search starts at the cursor.  The default is to search
-		forward, include 'b' in {flags} to search backward.
-		If a match is found, the cursor is positioned at it and the
-		line number is returned.  If no match is found 0 or -1 is
-		returned and the cursor doesn't move.  No error message is
-		given.
-
-		{start}, {middle} and {end} are patterns, see |pattern|.  They
-		must not contain \( \) pairs.  Use of \%( \) is allowed.  When
-		{middle} is not empty, it is found when searching from either
-		direction, but only when not in a nested start-end pair.  A
-		typical use is: >
-			searchpair('\<if\>', '\<else\>', '\<endif\>')
-<		By leaving {middle} empty the "else" is skipped.
-
-		{flags} 'b', 'c', 'n', 's', 'w' and 'W' are used like with
-		|search()|.  Additionally:
-		'r'	Repeat until no more matches found; will find the
-			outer pair.  Implies the 'W' flag.
-		'm'	Return number of matches instead of line number with
-			the match; will be > 1 when 'r' is used.
-		Note: it's nearly always a good idea to use the 'W' flag, to
-		avoid wrapping around the end of the file.
-
-		When a match for {start}, {middle} or {end} is found, the
-		{skip} expression is evaluated with the cursor positioned on
-		the start of the match.  It should return non-zero if this
-		match is to be skipped.  E.g., because it is inside a comment
-		or a string.
-		When {skip} is omitted or empty, every match is accepted.
-		When evaluating {skip} causes an error the search is aborted
-		and -1 returned.
- 		{skip} can be a string, a lambda, a funcref or a partial.
-		Anything else makes the function fail.
-
-		For {stopline} and {timeout} see |search()|.
-
-		The value of 'ignorecase' is used.  'magic' is ignored, the
-		patterns are used like it's on.
-
-		The search starts exactly at the cursor.  A match with
-		{start}, {middle} or {end} at the next character, in the
-		direction of searching, is the first one found.  Example: >
-			if 1
-			  if 2
-			  endif 2
-			endif 1
-<		When starting at the "if 2", with the cursor on the "i", and
-		searching forwards, the "endif 2" is found.  When starting on
-		the character just before the "if 2", the "endif 1" will be
-		found.  That's because the "if 2" will be found first, and
-		then this is considered to be a nested if/endif from "if 2" to
-		"endif 2".
-		When searching backwards and {end} is more than one character,
-		it may be useful to put "\zs" at the end of the pattern, so
-		that when the cursor is inside a match with the end it finds
-		the matching start.
-
-		Example, to find the "endif" command in a Vim script: >
-
-	:echo searchpair('\<if\>', '\<el\%[seif]\>', '\<en\%[dif]\>', 'W',
-			\ 'getline(".") =~ "^\\s*\""')
-
-<		The cursor must be at or after the "if" for which a match is
-		to be found.  Note that single-quote strings are used to avoid
-		having to double the backslashes.  The skip expression only
-		catches comments at the start of a line, not after a command.
-		Also, a word "en" or "if" halfway through a line is considered
-		a match.
-		Another example, to search for the matching "{" of a "}": >
-
-	:echo searchpair('{', '', '}', 'bW')
-
-<		This works when the cursor is at or before the "}" for which a
-		match is to be found.  To reject matches that syntax
-		highlighting recognized as strings: >
-
-	:echo searchpair('{', '', '}', 'bW',
-	     \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string"')
-<
-							*searchpairpos()*
-searchpairpos({start}, {middle}, {end} [, {flags} [, {skip}
-				[, {stopline} [, {timeout}]]]])
-		Same as |searchpair()|, but returns a |List| with the line and
-		column position of the match. The first element of the |List|
-		is the line number and the second element is the byte index of
-		the column position of the match.  If no match is found,
-		returns [0, 0]. >
-
-			:let [lnum,col] = searchpairpos('{', '', '}', 'n')
-<
-		See |match-parens| for a bigger and more useful example.
-
-searchpos({pattern} [, {flags} [, {stopline} [, {timeout}]]])	*searchpos()*
-		Same as |search()|, but returns a |List| with the line and
-		column position of the match. The first element of the |List|
-		is the line number and the second element is the byte index of
-		the column position of the match. If no match is found,
-		returns [0, 0].
-		Example: >
-	:let [lnum, col] = searchpos('mypattern', 'n')
-
-<		When the 'p' flag is given then there is an extra item with
-		the sub-pattern match number |search()-sub-match|.  Example: >
-	:let [lnum, col, submatch] = searchpos('\(\l\)\|\(\u\)', 'np')
-<		In this example "submatch" is 2 when a lowercase letter is
-		found |/\l|, 3 when an uppercase letter is found |/\u|.
-
-		Can also be used as a |method|: >
-			GetPattern()->searchpos()
-
-server2client({clientid}, {string})			*server2client()*
-		Send a reply string to {clientid}.  The most recent {clientid}
-		that sent a string can be retrieved with expand("<client>").
-		Note:
-		Returns zero for success, -1 for failure.
-		This id has to be stored before the next command can be
-		received.  I.e. before returning from the received command and
-		before calling any commands that waits for input.
-		See also |clientserver|.
-		Example: >
-			:echo server2client(expand("<client>"), "HELLO")
-
-<		Can also be used as a |method|: >
-			GetClientId()->server2client(string)
-<
-serverlist()						*serverlist()*
-		Returns a list of server addresses, or empty if all servers
-		were stopped. |serverstart()| |serverstop()|
-		Example: >
-			:echo serverlist()
-
-serverstart([{address}])				*serverstart()*
-		Opens a socket or named pipe at {address} and listens for
-		|RPC| messages. Clients can send |API| commands to the address
-		to control Nvim. Returns the address string.
-
-		If {address} does not contain a colon ":" it is interpreted as
-		a named pipe or Unix domain socket path.
-
-		Example: >
-			if has('win32')
-			  call serverstart('\\.\pipe\nvim-pipe-1234')
-			else
-			  call serverstart('nvim.sock')
-			endif
-<
-		If {address} contains a colon ":" it is interpreted as a TCP
-		address where the last ":" separates the host and port.
-		Assigns a random port if it is empty or 0. Supports IPv4/IPv6.
-
-		Example: >
-			:call serverstart('::1:12345')
-<
-		If no address is given, it is equivalent to: >
-			:call serverstart(tempname())
-
-< 		|$NVIM_LISTEN_ADDRESS| is set to {address} if not already set.
-
-serverstop({address})					*serverstop()*
-		Closes the pipe or socket at {address}.
-		Returns TRUE if {address} is valid, else FALSE.
-		If |$NVIM_LISTEN_ADDRESS| is stopped it is unset.
-		If |v:servername| is stopped it is set to the next available
-		address returned by |serverlist()|.
-
-setbufline({buf}, {lnum}, {text})			*setbufline()*
-		Set line {lnum} to {text} in buffer {buf}.  This works like
-		|setline()| for the specified buffer.
-
-		This function works only for loaded buffers. First call
-		|bufload()| if needed.
-
-		To insert lines use |appendbufline()|.
-		Any text properties in {lnum} are cleared.
-
-		{text} can be a string to set one line, or a list of strings
-		to set multiple lines.  If the list extends below the last
-		line then those lines are added.
-
-		For the use of {buf}, see |bufname()| above.
-
-		{lnum} is used like with |setline()|.
-		Use "$" to refer to the last line in buffer {buf}.
-		When {lnum} is just below the last line the {text} will be
-		added below the last line.
-		On success 0 is returned, on failure 1 is returned.
-
-		If {buf} is not a valid buffer or {lnum} is not valid, an
-		error message is given.
-
-		Can also be used as a |method|, the base is passed as the
-		third argument: >
-			GetText()->setbufline(buf, lnum)
-
-setbufvar({buf}, {varname}, {val})			*setbufvar()*
-		Set option or local variable {varname} in buffer {buf} to
-		{val}.
-		This also works for a global or local window option, but it
-		doesn't work for a global or local window variable.
-		For a local window option the global value is unchanged.
-		For the use of {buf}, see |bufname()| above.
-		The {varname} argument is a string.
-		Note that the variable name without "b:" must be used.
-		Examples: >
-			:call setbufvar(1, "&mod", 1)
-			:call setbufvar("todo", "myvar", "foobar")
-<		This function is not available in the |sandbox|.
-
-		Can also be used as a |method|, the base is passed as the
-		third argument: >
-			GetValue()->setbufvar(buf, varname)
-
-setcharsearch({dict})					*setcharsearch()*
-		Set the current character search information to {dict},
-		which contains one or more of the following entries:
-
-		    char	character which will be used for a subsequent
-				|,| or |;| command; an empty string clears the
-				character search
-		    forward	direction of character search; 1 for forward,
-				0 for backward
-		    until	type of character search; 1 for a |t| or |T|
-				character search, 0 for an |f| or |F|
-				character search
-
-		This can be useful to save/restore a user's character search
-		from a script: >
-			:let prevsearch = getcharsearch()
-			:" Perform a command which clobbers user's search
-			:call setcharsearch(prevsearch)
-<		Also see |getcharsearch()|.
-
-		Can also be used as a |method|: >
-			SavedSearch()->setcharsearch()
-
-setcmdpos({pos})					*setcmdpos()*
-		Set the cursor position in the command line to byte position
-		{pos}.  The first position is 1.
-		Use |getcmdpos()| to obtain the current position.
-		Only works while editing the command line, thus you must use
-		|c_CTRL-\_e|, |c_CTRL-R_=| or |c_CTRL-R_CTRL-R| with '='.  For
-		|c_CTRL-\_e| and |c_CTRL-R_CTRL-R| with '=' the position is
-		set after the command line is set to the expression.  For
-		|c_CTRL-R_=| it is set after evaluating the expression but
-		before inserting the resulting text.
-		When the number is too big the cursor is put at the end of the
-		line.  A number smaller than one has undefined results.
-		Returns FALSE when successful, TRUE when not editing the
-		command line.
-
-		Can also be used as a |method|: >
-			GetPos()->setcmdpos()
-
-setenv({name}, {val})						*setenv()*
-		Set environment variable {name} to {val}.  Example: >
-			call setenv('HOME', '/home/myhome')
-
-<		When {val} is |v:null| the environment variable is deleted.
-		See also |expr-env|.
-
-		Can also be used as a |method|, the base is passed as the
-		second argument: >
-			GetPath()->setenv('PATH')
-
-setfperm({fname}, {mode})				*setfperm()* *chmod*
-		Set the file permissions for {fname} to {mode}.
-		{mode} must be a string with 9 characters.  It is of the form
-		"rwxrwxrwx", where each group of "rwx" flags represent, in
-		turn, the permissions of the owner of the file, the group the
-		file belongs to, and other users.  A '-' character means the
-		permission is off, any other character means on.  Multi-byte
-		characters are not supported.
-
-		For example "rw-r-----" means read-write for the user,
-		readable by the group, not accessible by others.  "xx-x-----"
-		would do the same thing.
-
-		Returns non-zero for success, zero for failure.
-
-		Can also be used as a |method|: >
-			GetFilename()->setfperm(mode)
-<
-		To read permissions see |getfperm()|.
-
-setline({lnum}, {text})					*setline()*
-		Set line {lnum} of the current buffer to {text}.  To insert
-		lines use |append()|. To set lines in another buffer use
-		|setbufline()|.
-
-		{lnum} is used like with |getline()|.
-		When {lnum} is just below the last line the {text} will be
-		added below the last line.
-
-		If this succeeds, FALSE is returned.  If this fails (most likely
-		because {lnum} is invalid) TRUE is returned.
-
-		Example: >
-			:call setline(5, strftime("%c"))
-
-<		When {text} is a |List| then line {lnum} and following lines
-		will be set to the items in the list.  Example: >
-			:call setline(5, ['aaa', 'bbb', 'ccc'])
-<		This is equivalent to: >
-			:for [n, l] in [[5, 'aaa'], [6, 'bbb'], [7, 'ccc']]
-			:  call setline(n, l)
-			:endfor
-
-<		Note: The '[ and '] marks are not set.
-
-		Can also be used as a |method|, the base is passed as the
-		second argument: >
-			GetText()->setline(lnum)
-
-setloclist({nr}, {list} [, {action} [, {what}]])		*setloclist()*
-		Create or replace or add to the location list for window {nr}.
-		{nr} can be the window number or the |window-ID|.
-		When {nr} is zero the current window is used.
-
-		For a location list window, the displayed location list is
-		modified.  For an invalid window number {nr}, -1 is returned.
-		Otherwise, same as |setqflist()|.
-		Also see |location-list|.
-
-		For {action} see |setqflist-action|.
-
-		If the optional {what} dictionary argument is supplied, then
-		only the items listed in {what} are set. Refer to |setqflist()|
-		for the list of supported keys in {what}.
-
-		Can also be used as a |method|, the base is passed as the
-		second argument: >
-			GetLoclist()->setloclist(winnr)
-
-setmatches({list} [, {win}])				*setmatches()*
-		Restores a list of matches saved by |getmatches() for the
-		current window|.  Returns 0 if successful, otherwise -1.  All
-		current matches are cleared before the list is restored.  See
-		example for |getmatches()|.
-		If {win} is specified, use the window with this number or
-		window ID instead of the current window.
-
-		Can also be used as a |method|: >
-			GetMatches()->setmatches()
-<
-							*setpos()*
-setpos({expr}, {list})
-		Set the position for String {expr}.  Possible values:
-			.	the cursor
-			'x	mark x
-
-		{list} must be a |List| with four or five numbers:
-		    [bufnum, lnum, col, off]
-		    [bufnum, lnum, col, off, curswant]
-
-		"bufnum" is the buffer number.	Zero can be used for the
-		current buffer.  When setting an uppercase mark "bufnum" is
-		used for the mark position.  For other marks it specifies the
-		buffer to set the mark in.  You can use the |bufnr()| function
-		to turn a file name into a buffer number.
-		For setting the cursor and the ' mark "bufnum" is ignored,
-		since these are associated with a window, not a buffer.
-		Does not change the jumplist.
-
-		"lnum" and "col" are the position in the buffer.  The first
-		column is 1.  Use a zero "lnum" to delete a mark.  If "col" is
-		smaller than 1 then 1 is used.
-
-		The "off" number is only used when 'virtualedit' is set. Then
-		it is the offset in screen columns from the start of the
-		character.  E.g., a position within a <Tab> or after the last
-		character.
-
-		The "curswant" number is only used when setting the cursor
-		position.  It sets the preferred column for when moving the
-		cursor vertically.  When the "curswant" number is missing the
-		preferred column is not set.  When it is present and setting a
-		mark position it is not used.
-
-		Note that for '< and '> changing the line number may result in
-		the marks to be effectively be swapped, so that '< is always
-		before '>.
-
-		Returns 0 when the position could be set, -1 otherwise.
-		An error message is given if {expr} is invalid.
-
-		Also see |getpos()| and |getcurpos()|.
-
-		This does not restore the preferred column for moving
-		vertically; if you set the cursor position with this, |j| and
-		|k| motions will jump to previous columns!  Use |cursor()| to
-		also set the preferred column.  Also see the "curswant" key in
-		|winrestview()|.
-
-		Can also be used as a |method|: >
-			GetPosition()->setpos('.')
-
-setqflist({list} [, {action} [, {what}]])		*setqflist()*
-		Create or replace or add to the quickfix list.
-
-		If the optional {what} dictionary argument is supplied, then
-		only the items listed in {what} are set. The first {list}
-		argument is ignored.  See below for the supported items in
-		{what}.
-							*setqflist-what*
-		When {what} is not present, the items in {list} are used.  Each
-		item must be a dictionary.  Non-dictionary items in {list} are
-		ignored.  Each dictionary item can contain the following
-		entries:
-
-		    bufnr	buffer number; must be the number of a valid
-				buffer
-		    filename	name of a file; only used when "bufnr" is not
-				present or it is invalid.
-		    module	name of a module; if given it will be used in
-				quickfix error window instead of the filename
-		    lnum	line number in the file
-		    pattern	search pattern used to locate the error
-		    col		column number
-		    vcol	when non-zero: "col" is visual column
-				when zero: "col" is byte index
-		    nr		error number
-		    text	description of the error
-		    type	single-character error type, 'E', 'W', etc.
-		    valid	recognized error message
-
-		The "col", "vcol", "nr", "type" and "text" entries are
-		optional.  Either "lnum" or "pattern" entry can be used to
-		locate a matching error line.
-		If the "filename" and "bufnr" entries are not present or
-		neither the "lnum" or "pattern" entries are present, then the
-		item will not be handled as an error line.
-		If both "pattern" and "lnum" are present then "pattern" will
-		be used.
-		If the "valid" entry is not supplied, then the valid flag is
-		set when "bufnr" is a valid buffer or "filename" exists.
-		If you supply an empty {list}, the quickfix list will be
-		cleared.
-		Note that the list is not exactly the same as what
-		|getqflist()| returns.
-
-		{action} values:		*setqflist-action* *E927*
-		'a'	The items from {list} are added to the existing
-			quickfix list. If there is no existing list, then a
-			new list is created.
-
-		'r'	The items from the current quickfix list are replaced
-			with the items from {list}.  This can also be used to
-			clear the list: >
-				:call setqflist([], 'r')
-<
-		'f'	All the quickfix lists in the quickfix stack are
-			freed.
-
-		If {action} is not present or is set to ' ', then a new list
-		is created. The new quickfix list is added after the current
-		quickfix list in the stack and all the following lists are
-		freed. To add a new quickfix list at the end of the stack,
-		set "nr" in {what} to "$".
-
-		The following items can be specified in dictionary {what}:
-		    context	quickfix list context. See |quickfix-context|
-		    efm		errorformat to use when parsing text from
-				"lines". If this is not present, then the
-				'errorformat' option value is used.
-				See |quickfix-parse|
-		    id		quickfix list identifier |quickfix-ID|
-		    idx		index of the current entry in the quickfix
-				list specified by 'id' or 'nr'. If set to '$',
-				then the last entry in the list is set as the
-				current entry.  See |quickfix-index|
-		    items	list of quickfix entries. Same as the {list}
-				argument.
-		    lines	use 'errorformat' to parse a list of lines and
-				add the resulting entries to the quickfix list
-				{nr} or {id}.  Only a |List| value is supported.
-				See |quickfix-parse|
-		    nr		list number in the quickfix stack; zero
-				means the current quickfix list and "$" means
-				the last quickfix list.
-		    quickfixtextfunc
-				function to get the text to display in the
-				quickfix window.  The value can be the name of
-				a function or a funcref or a lambda.  Refer to
-				|quickfix-window-function| for an explanation
-				of how to write the function and an example.
-		    title	quickfix list title text. See |quickfix-title|
-		Unsupported keys in {what} are ignored.
-		If the "nr" item is not present, then the current quickfix list
-		is modified. When creating a new quickfix list, "nr" can be
-		set to a value one greater than the quickfix stack size.
-		When modifying a quickfix list, to guarantee that the correct
-		list is modified, "id" should be used instead of "nr" to
-		specify the list.
-
-		Examples (See also |setqflist-examples|): >
-		   :call setqflist([], 'r', {'title': 'My search'})
-		   :call setqflist([], 'r', {'nr': 2, 'title': 'Errors'})
-		   :call setqflist([], 'a', {'id':qfid, 'lines':["F1:10:L10"]})
-<
-		Returns zero for success, -1 for failure.
-
-		This function can be used to create a quickfix list
-		independent of the 'errorformat' setting.  Use a command like
-		`:cc 1` to jump to the first position.
-
-		Can also be used as a |method|, the base is passed as the
-		second argument: >
-			GetErrorlist()->setqflist()
-<
-							*setreg()*
-setreg({regname}, {value} [, {options}])
-		Set the register {regname} to {value}.
-		The {regname} argument is a string.
-
-		{value} may be any value returned by |getreg()| or
-		|getreginfo()|, including a |List| or |Dict|.
-		If {options} contains "a" or {regname} is upper case,
-		then the value is appended.
-
-		{options} can also contain a register type specification:
-		    "c" or "v"	      |charwise| mode
-		    "l" or "V"	      |linewise| mode
-		    "b" or "<CTRL-V>" |blockwise-visual| mode
-		If a number immediately follows "b" or "<CTRL-V>" then this is
-		used as the width of the selection - if it is not specified
-		then the width of the block is set to the number of characters
-		in the longest line (counting a <Tab> as 1 character).
-		If {options} contains "u" or '"', then the unnamed register is
-		set to point to register {regname}.
-
-		If {options} contains no register settings, then the default
-		is to use character mode unless {value} ends in a <NL> for
-		string {value} and linewise mode for list {value}. Blockwise
-		mode is never selected automatically.
-		Returns zero for success, non-zero for failure.
-
-							*E883*
-		Note: you may not use |List| containing more than one item to
-		      set search and expression registers. Lists containing no
-		      items act like empty strings.
-
-		Examples: >
-			:call setreg(v:register, @*)
-			:call setreg('*', @%, 'ac')
-			:call setreg('a', "1\n2\n3", 'b5')
-			:call setreg('"', { 'points_to': 'a'})
-
-<		This example shows using the functions to save and restore a
-		register: >
-			:let var_a = getreginfo()
-			:call setreg('a', var_a)
-<		or: >
-			:let var_a = getreg('a', 1, 1)
-			:let var_amode = getregtype('a')
-			    ....
-			:call setreg('a', var_a, var_amode)
-<		Note: you may not reliably restore register value
-		without using the third argument to |getreg()| as without it
-		newlines are represented as newlines AND Nul bytes are
-		represented as newlines as well, see |NL-used-for-Nul|.
-
-		You can also change the type of a register by appending
-		nothing: >
-			:call setreg('a', '', 'al')
-
-<		Can also be used as a |method|, the base is passed as the
-		second argument: >
-			GetText()->setreg('a')
-
-settabvar({tabnr}, {varname}, {val})			*settabvar()*
-		Set tab-local variable {varname} to {val} in tab page {tabnr}.
-		|t:var|
-		The {varname} argument is a string.
-		Note that the variable name without "t:" must be used.
-		Tabs are numbered starting with one.
-		This function is not available in the |sandbox|.
-
-		Can also be used as a |method|, the base is passed as the
-		third argument: >
-			GetValue()->settabvar(tab, name)
-
-settabwinvar({tabnr}, {winnr}, {varname}, {val})	*settabwinvar()*
-		Set option or local variable {varname} in window {winnr} to
-		{val}.
-		Tabs are numbered starting with one.  For the current tabpage
-		use |setwinvar()|.
-		{winnr} can be the window number or the |window-ID|.
-		When {winnr} is zero the current window is used.
-		This also works for a global or local buffer option, but it
-		doesn't work for a global or local buffer variable.
-		For a local buffer option the global value is unchanged.
-		Note that the variable name without "w:" must be used.
-		Examples: >
-			:call settabwinvar(1, 1, "&list", 0)
-			:call settabwinvar(3, 2, "myvar", "foobar")
-<		This function is not available in the |sandbox|.
-
-		Can also be used as a |method|, the base is passed as the
-		fourth argument: >
-			GetValue()->settabwinvar(tab, winnr, name)
-
-settagstack({nr}, {dict} [, {action}])			*settagstack()*
-		Modify the tag stack of the window {nr} using {dict}.
-		{nr} can be the window number or the |window-ID|.
-
-		For a list of supported items in {dict}, refer to
-		|gettagstack()|. "curidx" takes effect before changing the tag
-		stack.
-							*E962*
-		How the tag stack is modified depends on the {action}
-		argument:
-		- If {action} is not present or is set to 'r', then the tag
-		  stack is replaced.
-		- If {action} is set to 'a', then new entries from {dict} are
-		  pushed (added) onto the tag stack.
-		- If {action} is set to 't', then all the entries from the
-		  current entry in the tag stack or "curidx" in {dict} are
-		  removed and then new entries are pushed to the stack.
-
-		The current index is set to one after the length of the tag
-		stack after the modification.
-
-		Returns zero for success, -1 for failure.
-
-		Examples (for more examples see |tagstack-examples|):
-		    Empty the tag stack of window 3: >
-			call settagstack(3, {'items' : []})
-
-<		    Save and restore the tag stack: >
-			let stack = gettagstack(1003)
-			" do something else
-			call settagstack(1003, stack)
-			unlet stack
-<
-		Can also be used as a |method|, the base is passed as the
-		second argument: >
-			GetStack()->settagstack(winnr)
-
-setwinvar({nr}, {varname}, {val})			*setwinvar()*
-		Like |settabwinvar()| for the current tab page.
-		Examples: >
-			:call setwinvar(1, "&list", 0)
-			:call setwinvar(2, "myvar", "foobar")
-
-<		Can also be used as a |method|, the base is passed as the
-		third argument: >
-			GetValue()->setwinvar(winnr, name)
-
-sha256({string})						*sha256()*
-		Returns a String with 64 hex characters, which is the SHA256
-		checksum of {string}.
-
-		Can also be used as a |method|: >
-			GetText()->sha256()
-
-shellescape({string} [, {special}])			*shellescape()*
-		Escape {string} for use as a shell command argument.
-
-		On Windows when 'shellslash' is not set, encloses {string} in
-		double-quotes and doubles all double-quotes within {string}.
-		Otherwise encloses {string} in single-quotes and replaces all
-		"'" with "'\''".
-
-		If {special} is a |non-zero-arg|:
-		- Special items such as "!", "%", "#" and "<cword>" will be
-		  preceded by a backslash. The backslash will be removed again
-		  by the |:!| command.
-		- The <NL> character is escaped.
-
-		If 'shell' contains "csh" in the tail:
-		- The "!" character will be escaped. This is because csh and
-		  tcsh use "!" for history replacement even in single-quotes.
-		- The <NL> character is escaped (twice if {special} is
-		  a |non-zero-arg|).
-
-		If 'shell' contains "fish" in the tail, the "\" character will
-		be escaped because in fish it is used as an escape character
-		inside single quotes.
-
-		Example of use with a |:!| command: >
-		    :exe '!dir ' . shellescape(expand('<cfile>'), 1)
-<		This results in a directory listing for the file under the
-		cursor.  Example of use with |system()|: >
-		    :call system("chmod +w -- " . shellescape(expand("%")))
-<		See also |::S|.
-
-		Can also be used as a |method|: >
-			GetCommand()->shellescape()
-
-shiftwidth([{col}])						*shiftwidth()*
-		Returns the effective value of 'shiftwidth'. This is the
-		'shiftwidth' value unless it is zero, in which case it is the
-		'tabstop' value.  To be backwards compatible in indent
-		plugins, use this: >
-			if exists('*shiftwidth')
-			  func s:sw()
-			    return shiftwidth()
-			  endfunc
-			else
-			  func s:sw()
-			    return &sw
-			  endfunc
-			endif
-<		And then use s:sw() instead of &sw.
-
-		When there is one argument {col} this is used as column number
-		for which to return the 'shiftwidth' value. This matters for the
-		'vartabstop' feature. If no {col} argument is given, column 1
-		will be assumed.
-
-		Can also be used as a |method|: >
-			GetColumn()->shiftwidth()
-
-sign_ functions are documented here: |sign-functions-details|
-
-simplify({filename})					*simplify()*
-		Simplify the file name as much as possible without changing
-		the meaning.  Shortcuts (on MS-Windows) or symbolic links (on
-		Unix) are not resolved.  If the first path component in
-		{filename} designates the current directory, this will be
-		valid for the result as well.  A trailing path separator is
-		not removed either. On Unix "//path" is unchanged, but
-		"///path" is simplified to "/path" (this follows the Posix
-		standard).
-		Example: >
-			simplify("./dir/.././/file/") == "./file/"
-<		Note: The combination "dir/.." is only removed if "dir" is
-		a searchable directory or does not exist.  On Unix, it is also
-		removed when "dir" is a symbolic link within the same
-		directory.  In order to resolve all the involved symbolic
-		links before simplifying the path name, use |resolve()|.
-
-		Can also be used as a |method|: >
-			GetName()->simplify()
-
-sin({expr})						*sin()*
-		Return the sine of {expr}, measured in radians, as a |Float|.
-		{expr} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			:echo sin(100)
-<			-0.506366 >
-			:echo sin(-4.01)
-<			0.763301
-
-		Can also be used as a |method|: >
-			Compute()->sin()
-
-sinh({expr})						*sinh()*
-		Return the hyperbolic sine of {expr} as a |Float| in the range
-		[-inf, inf].
-		{expr} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			:echo sinh(0.5)
-<			0.521095 >
-			:echo sinh(-0.9)
-<			-1.026517
-
-		Can also be used as a |method|: >
-			Compute()->sinh()
-
-sockconnect({mode}, {address} [, {opts}])		 *sockconnect()*
-		Connect a socket to an address. If {mode} is "pipe" then
-		{address} should be the path of a named pipe. If {mode} is
-		"tcp" then {address} should be of the form "host:port" where
-		the host should be an ip adderess or host name, and port the
-		port number.
-
-		Returns a |channel| ID. Close the socket with |chanclose()|.
-		Use |chansend()| to send data over a bytes socket, and
-		|rpcrequest()| and |rpcnotify()| to communicate with a RPC
-		socket.
-
-		{opts} is an optional dictionary with these keys:
-		  |on_data| : callback invoked when data was read from socket
-		  data_buffered : read socket data in |channel-buffered| mode.
-		  rpc     : If set, |msgpack-rpc| will be used to communicate
-			    over the socket.
-		Returns:
-		  - The channel ID on success (greater than zero)
-		  - 0 on invalid arguments or connection failure.
-
-sort({list} [, {func} [, {dict}]])			*sort()* *E702*
-		Sort the items in {list} in-place.  Returns {list}.
-
-		If you want a list to remain unmodified make a copy first: >
-			:let sortedlist = sort(copy(mylist))
-
-<		When {func} is omitted, is empty or zero, then sort() uses the
-		string representation of each item to sort on.  Numbers sort
-		after Strings, |Lists| after Numbers.  For sorting text in the
-		current buffer use |:sort|.
-
-		When {func} is given and it is '1' or 'i' then case is
-		ignored.
-
-		When {func} is given and it is 'l' then the current collation
-		locale is used for ordering. Implementation details: strcoll()
-		is used to compare strings. See |:language| check or set the
-		collation locale. |v:collate| can also be used to check the
-		current locale. Sorting using the locale typically ignores
-		case. Example: >
-			" ö is sorted similarly to o with English locale.
-			:language collate en_US.UTF8
-			:echo sort(['n', 'o', 'O', 'ö', 'p', 'z'], 'l')
-<			['n', 'o', 'O', 'ö', 'p', 'z'] ~
->
-			" ö is sorted after z with Swedish locale.
-			:language collate sv_SE.UTF8
-			:echo sort(['n', 'o', 'O', 'ö', 'p', 'z'], 'l')
-<			['n', 'o', 'O', 'p', 'z', 'ö'] ~
-		This does not work properly on Mac.
-
-		When {func} is given and it is 'n' then all items will be
-		sorted numerical (Implementation detail: this uses the
-		strtod() function to parse numbers, Strings, Lists, Dicts and
-		Funcrefs will be considered as being 0).
-
-		When {func} is given and it is 'N' then all items will be
-		sorted numerical. This is like 'n' but a string containing
-		digits will be used as the number they represent.
-
-		When {func} is given and it is 'f' then all items will be
-		sorted numerical. All values must be a Number or a Float.
-
-		When {func} is a |Funcref| or a function name, this function
-		is called to compare items.  The function is invoked with two
-		items as argument and must return zero if they are equal, 1 or
-		bigger if the first one sorts after the second one, -1 or
-		smaller if the first one sorts before the second one.
-
-		{dict} is for functions with the "dict" attribute.  It will be
-		used to set the local variable "self". |Dictionary-function|
-
-		The sort is stable, items which compare equal (as number or as
-		string) will keep their relative position. E.g., when sorting
-		on numbers, text strings will sort next to each other, in the
-		same order as they were originally.
-
-		Can also be used as a |method|: >
-			mylist->sort()
-
-<		Also see |uniq()|.
-
-		Example: >
-			func MyCompare(i1, i2)
-			   return a:i1 == a:i2 ? 0 : a:i1 > a:i2 ? 1 : -1
-			endfunc
-			eval mylist->sort("MyCompare")
-<		A shorter compare version for this specific simple case, which
-		ignores overflow: >
-			func MyCompare(i1, i2)
-			   return a:i1 - a:i2
-			endfunc
-<		For a simple expression you can use a lambda: >
-			eval mylist->sort({i1, i2 -> i1 - i2})
-<
-							*soundfold()*
-soundfold({word})
-		Return the sound-folded equivalent of {word}.  Uses the first
-		language in 'spelllang' for the current window that supports
-		soundfolding.  'spell' must be set.  When no sound folding is
-		possible the {word} is returned unmodified.
-		This can be used for making spelling suggestions.  Note that
-		the method can be quite slow.
-
-		Can also be used as a |method|: >
-			GetWord()->soundfold()
-<
-							*spellbadword()*
-spellbadword([{sentence}])
-		Without argument: The result is the badly spelled word under
-		or after the cursor.  The cursor is moved to the start of the
-		bad word.  When no bad word is found in the cursor line the
-		result is an empty string and the cursor doesn't move.
-
-		With argument: The result is the first word in {sentence} that
-		is badly spelled.  If there are no spelling mistakes the
-		result is an empty string.
-
-		The return value is a list with two items:
-		- The badly spelled word or an empty string.
-		- 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
-		Example: >
-			echo spellbadword("the quik brown fox")
-<			['quik', 'bad'] ~
-
-		The spelling information for the current window and the value
-		of 'spelllang' are used.
-
-		Can also be used as a |method|: >
-			GetText()->spellbadword()
-<
-							*spellsuggest()*
-spellsuggest({word} [, {max} [, {capital}]])
-		Return a |List| with spelling suggestions to replace {word}.
-		When {max} is given up to this number of suggestions are
-		returned.  Otherwise up to 25 suggestions are returned.
-
-		When the {capital} argument is given and it's non-zero only
-		suggestions with a leading capital will be given.  Use this
-		after a match with 'spellcapcheck'.
-
-		{word} can be a badly spelled word followed by other text.
-		This allows for joining two words that were split.  The
-		suggestions also include the following text, thus you can
-		replace a line.
-
-		{word} may also be a good word.  Similar words will then be
-		returned.  {word} itself is not included in the suggestions,
-		although it may appear capitalized.
-
-		The spelling information for the current window is used.  The
-		values of 'spelllang' and 'spellsuggest' are used.
-
-		Can also be used as a |method|: >
-			GetWord()->spellsuggest()
-
-split({string} [, {pattern} [, {keepempty}]])			*split()*
-		Make a |List| out of {string}.  When {pattern} is omitted or
-		empty each white-separated sequence of characters becomes an
-		item.
-		Otherwise the string is split where {pattern} matches,
-		removing the matched characters. 'ignorecase' is not used
-		here, add \c to ignore case. |/\c|
-		When the first or last item is empty it is omitted, unless the
-		{keepempty} argument is given and it's non-zero.
-		Other empty items are kept when {pattern} matches at least one
-		character or when {keepempty} is non-zero.
-		Example: >
-			:let words = split(getline('.'), '\W\+')
-<		To split a string in individual characters: >
-			:for c in split(mystring, '\zs')
-<		If you want to keep the separator you can also use '\zs' at
-		the end of the pattern: >
-			:echo split('abc:def:ghi', ':\zs')
-<			['abc:', 'def:', 'ghi'] ~
-		Splitting a table where the first element can be empty: >
-			:let items = split(line, ':', 1)
-<		The opposite function is |join()|.
-
-		Can also be used as a |method|: >
-			GetString()->split()
-
-sqrt({expr})						*sqrt()*
-		Return the non-negative square root of Float {expr} as a
-		|Float|.
-		{expr} must evaluate to a |Float| or a |Number|.  When {expr}
-		is negative the result is NaN (Not a Number).
-		Examples: >
-			:echo sqrt(100)
-<			10.0 >
-			:echo sqrt(-4.01)
-<			nan
-		"nan" may be different, it depends on system libraries.
-
-		Can also be used as a |method|: >
-			Compute()->sqrt()
-
-stdioopen({opts})			 *stdioopen()*
-		With |--headless| this opens stdin and stdout as a |channel|.
-		May be called only once. See |channel-stdio|. stderr is not
-		handled by this function, see |v:stderr|.
-
-		Close the stdio handles with |chanclose()|. Use |chansend()|
-		to send data to stdout, and |rpcrequest()| and |rpcnotify()|
-		to communicate over RPC.
-
-		{opts} is a dictionary with these keys:
-		  |on_stdin| : callback invoked when stdin is written to.
-		  stdin_buffered : read stdin in |channel-buffered| mode.
-		  rpc      : If set, |msgpack-rpc| will be used to communicate
-			     over stdio
-		Returns:
-		  - |channel-id| on success (value is always 1)
-		  - 0 on invalid arguments
-
-
-stdpath({what})					*stdpath()* *E6100*
-		Returns |standard-path| locations of various default files and
-		directories.
-
-		{what}       Type    Description ~
-		cache        String  Cache directory. Arbitrary temporary
-		                     storage for plugins, etc.
-		config       String  User configuration directory. The
-		                     |init.vim| is stored here.
-		config_dirs  List    Additional configuration directories.
-		data         String  User data directory. The |shada-file|
-		                     is stored here.
-		data_dirs    List    Additional data directories.
-
-		Example: >
-			:echo stdpath("config")
-
-
-str2float({string} [, {quoted}])				*str2float()*
- 		Convert String {string} to a Float.  This mostly works the
- 		same as when using a floating point number in an expression,
- 		see |floating-point-format|.  But it's a bit more permissive.
- 		E.g., "1e40" is accepted, while in an expression you need to
- 		write "1.0e40".  The hexadecimal form "0x123" is also
- 		accepted, but not others, like binary or octal.
- 		When {quoted} is present and non-zero then embedded single
- 		quotes before the dot are ignored, thus "1'000.0" is a
- 		thousand.
-		Text after the number is silently ignored.
-		The decimal point is always '.', no matter what the locale is
-		set to.  A comma ends the number: "12,345.67" is converted to
-		12.0.  You can strip out thousands separators with
-		|substitute()|: >
-			let f = str2float(substitute(text, ',', '', 'g'))
-<
-		Can also be used as a |method|: >
-			let f = text->substitute(',', '', 'g')->str2float()
-
-str2list({string} [, {utf8}])				*str2list()*
-		Return a list containing the number values which represent
-		each character in String {string}.  Examples: >
-			str2list(" ")		returns [32]
-			str2list("ABC")		returns [65, 66, 67]
-<		|list2str()| does the opposite.
-
-		UTF-8 encoding is always used, {utf8} option has no effect,
-		and exists only for backwards-compatibility.
-		With UTF-8 composing characters are handled properly: >
-			str2list("á")		returns [97, 769]
-
-<		Can also be used as a |method|: >
-			GetString()->str2list()
-
-str2nr({string} [, {base}])			*str2nr()*
-		Convert string {string} to a number.
-		{base} is the conversion base, it can be 2, 8, 10 or 16.
-		When {quoted} is present and non-zero then embedded single
-		quotes are ignored, thus "1'000'000" is a million.
-
-		When {base} is omitted base 10 is used.  This also means that
-		a leading zero doesn't cause octal conversion to be used, as
-		with the default String to Number conversion.  Example: >
-			let nr = str2nr('0123')
-<
-		When {base} is 16 a leading "0x" or "0X" is ignored.  With a
-		different base the result will be zero. Similarly, when
-		{base} is 8 a leading "0", "0o" or "0O" is ignored, and when
-		{base} is 2 a leading "0b" or "0B" is ignored.
-		Text after the number is silently ignored.
-
-		Can also be used as a |method|: >
-			GetText()->str2nr()
-
-strcharpart({src}, {start} [, {len}])			*strcharpart()*
-		Like |strpart()| but using character index and length instead
-		of byte index and length.  Composing characters are counted
-		separately.
-		When a character index is used where a character does not
-		exist it is assumed to be one character.  For example: >
-			strcharpart('abc', -1, 2)
-<		results in 'a'.
-
-		Can also be used as a |method|: >
-			GetText()->strcharpart(5)
-
-strchars({string} [, {skipcc}])					*strchars()*
-		The result is a Number, which is the number of characters
-		in String {string}.
-		When {skipcc} is omitted or zero, composing characters are
-		counted separately.
-		When {skipcc} set to 1, Composing characters are ignored.
-		Also see |strlen()|, |strdisplaywidth()| and |strwidth()|.
-
-		{skipcc} is only available after 7.4.755.  For backward
-		compatibility, you can define a wrapper function: >
-		    if has("patch-7.4.755")
-		      function s:strchars(str, skipcc)
-			return strchars(a:str, a:skipcc)
-		      endfunction
-		    else
-		      function s:strchars(str, skipcc)
-			if a:skipcc
-			  return strlen(substitute(a:str, ".", "x", "g"))
-			else
-			  return strchars(a:str)
-			endif
-		      endfunction
-		    endif
-<
-		Can also be used as a |method|: >
-			GetText()->strchars()
-
-strdisplaywidth({string} [, {col}])			*strdisplaywidth()*
-		The result is a Number, which is the number of display cells
-		String {string} occupies on the screen when it starts at {col}
-		(first column is zero).  When {col} is omitted zero is used.
-		Otherwise it is the screen column where to start.  This
-		matters for Tab characters.
-		The option settings of the current window are used.  This
-		matters for anything that's displayed differently, such as
-		'tabstop' and 'display'.
-		When {string} contains characters with East Asian Width Class
-		Ambiguous, this function's return value depends on 'ambiwidth'.
-		Also see |strlen()|, |strwidth()| and |strchars()|.
-
-		Can also be used as a |method|: >
-			GetText()->strdisplaywidth()
-
-strftime({format} [, {time}])				*strftime()*
-		The result is a String, which is a formatted date and time, as
-		specified by the {format} string.  The given {time} is used,
-		or the current time if no time is given.  The accepted
-		{format} depends on your system, thus this is not portable!
-		See the manual page of the C function strftime() for the
-		format.  The maximum length of the result is 80 characters.
-		See also |localtime()|, |getftime()| and |strptime()|.
-		The language can be changed with the |:language| command.
-		Examples: >
-		  :echo strftime("%c")		   Sun Apr 27 11:49:23 1997
-		  :echo strftime("%Y %b %d %X")	   1997 Apr 27 11:53:25
-		  :echo strftime("%y%m%d %T")	   970427 11:53:55
-		  :echo strftime("%H:%M")	   11:55
-		  :echo strftime("%c", getftime("file.c"))
-						   Show mod time of file.c.
-
-<		Can also be used as a |method|: >
-			GetFormat()->strftime()
-
-strgetchar({str}, {index})				*strgetchar()*
-		Get character {index} from {str}.  This uses a character
-		index, not a byte index.  Composing characters are considered
-		separate characters here.
-		Also see |strcharpart()| and |strchars()|.
-
-		Can also be used as a |method|: >
-			GetText()->strgetchar(5)
-
-stridx({haystack}, {needle} [, {start}])		*stridx()*
-		The result is a Number, which gives the byte index in
-		{haystack} of the first occurrence of the String {needle}.
-		If {start} is specified, the search starts at index {start}.
-		This can be used to find a second match: >
-			:let colon1 = stridx(line, ":")
-			:let colon2 = stridx(line, ":", colon1 + 1)
-<		The search is done case-sensitive.
-		For pattern searches use |match()|.
-		-1 is returned if the {needle} does not occur in {haystack}.
-		See also |strridx()|.
-		Examples: >
-		  :echo stridx("An Example", "Example")	     3
-		  :echo stridx("Starting point", "Start")    0
-		  :echo stridx("Starting point", "start")   -1
-<						*strstr()* *strchr()*
-		stridx() works similar to the C function strstr().  When used
-		with a single character it works similar to strchr().
-
-		Can also be used as a |method|: >
-			GetHaystack()->stridx(needle)
-
-							*string()*
-string({expr})	Return {expr} converted to a String.  If {expr} is a Number,
-		Float, String, Blob or a composition of them, then the result
-		can be parsed back with |eval()|.
-			{expr} type	result ~
-			String		'string'
-			Number		123
-			Float		123.123456 or 1.123456e8 or
-					`str2float('inf')`
-			Funcref		`function('name')`
-			Blob		0z00112233.44556677.8899
-			List		[item, item]
-			Dictionary	{key: value, key: value}
-		Note that in String values the ' character is doubled.
-		Also see |strtrans()|.
-		Note 2: Output format is mostly compatible with YAML, except
-		for infinite and NaN floating-point values representations
-		which use |str2float()|.  Strings are also dumped literally,
-		only single quote is escaped, which does not allow using YAML
-		for parsing back binary strings.  |eval()| should always work for
-		strings and floats though and this is the only official
-		method, use |msgpackdump()| or |json_encode()| if you need to
-		share data with other application.
-
-		Can also be used as a |method|: >
-			mylist->string()
-
-strlen({string})						*strlen()*
-		The result is a Number, which is the length of the String
-		{string} in bytes.
-		If the argument is a Number it is first converted to a String.
-		For other types an error is given.
-		If you want to count the number of multibyte characters use
-		|strchars()|.
-		Also see |len()|, |strdisplaywidth()| and |strwidth()|.
-
-		Can also be used as a |method|: >
-			GetString()->strlen()
-
-strpart({src}, {start} [, {len} [, {chars}]])			*strpart()*
-		The result is a String, which is part of {src}, starting from
-		byte {start}, with the byte length {len}.
-		When {chars} is present and TRUE then {len} is the number of
-		characters positions (composing characters are not counted
-		separately, thus "1" means one base character and any
-		following composing characters).
-		To count {start} as characters instead of bytes use
-		|strcharpart()|.
-
-		When bytes are selected which do not exist, this doesn't
-		result in an error, the bytes are simply omitted.
-		If {len} is missing, the copy continues from {start} till the
-		end of the {src}. >
-			strpart("abcdefg", 3, 2)    == "de"
-			strpart("abcdefg", -2, 4)   == "ab"
-			strpart("abcdefg", 5, 4)    == "fg"
-			strpart("abcdefg", 3)	    == "defg"
-
-<		Note: To get the first character, {start} must be 0.  For
-		example, to get the character under the cursor: >
-			strpart(getline("."), col(".") - 1, 1, v:true)
-<
-		Can also be used as a |method|: >
-			GetText()->strpart(5)
-
-strptime({format}, {timestring})				*strptime()*
-		The result is a Number, which is a unix timestamp representing
-		the date and time in {timestring}, which is expected to match
-		the format specified in {format}.
-
-		The accepted {format} depends on your system, thus this is not
-		portable!  See the manual page of the C function strptime()
-		for the format.  Especially avoid "%c".  The value of $TZ also
-		matters.
-
-		If the {timestring} cannot be parsed with {format} zero is
-		returned.  If you do not know the format of {timestring} you
-		can try different {format} values until you get a non-zero
-		result.
-
-		See also |strftime()|.
-		Examples: >
-		  :echo strptime("%Y %b %d %X", "1997 Apr 27 11:49:23")
-<		  862156163 >
-		  :echo strftime("%c", strptime("%y%m%d %T", "970427 11:53:55"))
-<		  Sun Apr 27 11:53:55 1997 >
-		  :echo strftime("%c", strptime("%Y%m%d%H%M%S", "19970427115355") + 3600)
-<		  Sun Apr 27 12:53:55 1997
-
-		Can also be used as a |method|: >
-			GetFormat()->strptime(timestring)
-<
-strridx({haystack}, {needle} [, {start}])			*strridx()*
-		The result is a Number, which gives the byte index in
-		{haystack} of the last occurrence of the String {needle}.
-		When {start} is specified, matches beyond this index are
-		ignored.  This can be used to find a match before a previous
-		match: >
-			:let lastcomma = strridx(line, ",")
-			:let comma2 = strridx(line, ",", lastcomma - 1)
-<		The search is done case-sensitive.
-		For pattern searches use |match()|.
-		-1 is returned if the {needle} does not occur in {haystack}.
-		If the {needle} is empty the length of {haystack} is returned.
-		See also |stridx()|.  Examples: >
-		  :echo strridx("an angry armadillo", "an")	     3
-<							*strrchr()*
-		When used with a single character it works similar to the C
-		function strrchr().
-
-		Can also be used as a |method|: >
-			GetHaystack()->strridx(needle)
-
-strtrans({string})					*strtrans()*
-		The result is a String, which is {string} with all unprintable
-		characters translated into printable characters |'isprint'|.
-		Like they are shown in a window.  Example: >
-			echo strtrans(@a)
-<		This displays a newline in register a as "^@" instead of
-		starting a new line.
-
-		Can also be used as a |method|: >
-			GetString()->strtrans()
-
-strwidth({string})					*strwidth()*
-		The result is a Number, which is the number of display cells
-		String {string} occupies.  A Tab character is counted as one
-		cell, alternatively use |strdisplaywidth()|.
-		When {string} contains characters with East Asian Width Class
-		Ambiguous, this function's return value depends on 'ambiwidth'.
-		Also see |strlen()|, |strdisplaywidth()| and |strchars()|.
-
-		Can also be used as a |method|: >
-			GetString()->strwidth()
-
-submatch({nr} [, {list}])			*submatch()* *E935*
-		Only for an expression in a |:substitute| command or
-		substitute() function.
-		Returns the {nr}'th submatch of the matched text.  When {nr}
-		is 0 the whole matched text is returned.
-		Note that a NL in the string can stand for a line break of a
-		multi-line match or a NUL character in the text.
-		Also see |sub-replace-expression|.
-
-		If {list} is present and non-zero then submatch() returns
-		a list of strings, similar to |getline()| with two arguments.
-		NL characters in the text represent NUL characters in the
-		text.
-		Only returns more than one item for |:substitute|, inside
-		|substitute()| this list will always contain one or zero
-		items, since there are no real line breaks.
-
-		When substitute() is used recursively only the submatches in
-		the current (deepest) call can be obtained.
-
-		Examples: >
-			:s/\d\+/\=submatch(0) + 1/
-			:echo substitute(text, '\d\+', '\=submatch(0) + 1', '')
-<		This finds the first number in the line and adds one to it.
-		A line break is included as a newline character.
-
-		Can also be used as a |method|: >
-			GetNr()->submatch()
-
-substitute({string}, {pat}, {sub}, {flags})		*substitute()*
-		The result is a String, which is a copy of {string}, in which
-		the first match of {pat} is replaced with {sub}.
-		When {flags} is "g", all matches of {pat} in {string} are
-		replaced.  Otherwise {flags} should be "".
-
-		This works like the ":substitute" command (without any flags).
-		But the matching with {pat} is always done like the 'magic'
-		option is set and 'cpoptions' is empty (to make scripts
-		portable).  'ignorecase' is still relevant, use |/\c| or |/\C|
-		if you want to ignore or match case and ignore 'ignorecase'.
-		'smartcase' is not used.  See |string-match| for how {pat} is
-		used.
-
-		A "~" in {sub} is not replaced with the previous {sub}.
-		Note that some codes in {sub} have a special meaning
-		|sub-replace-special|.  For example, to replace something with
-		"\n" (two characters), use "\\\\n" or '\\n'.
-
-		When {pat} does not match in {string}, {string} is returned
-		unmodified.
-
-		Example: >
-			:let &path = substitute(&path, ",\\=[^,]*$", "", "")
-<		This removes the last component of the 'path' option. >
-			:echo substitute("testing", ".*", "\\U\\0", "")
-<		results in "TESTING".
-
-		When {sub} starts with "\=", the remainder is interpreted as
-		an expression. See |sub-replace-expression|.  Example: >
-			:echo substitute(s, '%\(\x\x\)',
-			   \ '\=nr2char("0x" . submatch(1))', 'g')
-
-<		When {sub} is a Funcref that function is called, with one
-		optional argument.  Example: >
-		   :echo substitute(s, '%\(\x\x\)', SubNr, 'g')
-<		The optional argument is a list which contains the whole
-		matched string and up to nine submatches, like what
-		|submatch()| returns.  Example: >
-		   :echo substitute(s, '%\(\x\x\)', {m -> '0x' . m[1]}, 'g')
-
-<		Can also be used as a |method|: >
-			GetString()->substitute(pat, sub, flags)
-
-swapinfo({fname})					*swapinfo()*
-		The result is a dictionary, which holds information about the
-		swapfile {fname}. The available fields are:
-			version VIM version
-			user	user name
-			host	host name
-			fname	original file name
-			pid	PID of the VIM process that created the swap
-				file
-			mtime	last modification time in seconds
-			inode	Optional: INODE number of the file
-			dirty	1 if file was modified, 0 if not
-		In case of failure an "error" item is added with the reason:
-			Cannot open file: file not found or in accessible
-			Cannot read file: cannot read first block
-			Not a swap file: does not contain correct block ID
-			Magic number mismatch: Info in first block is invalid
-
-		Can also be used as a |method|: >
-			GetFilename()->swapinfo()
-
-swapname({buf})						*swapname()*
-		The result is the swap file path of the buffer {buf}.
-		For the use of {buf}, see |bufname()| above.
-		If buffer {buf} is the current buffer, the result is equal to
-		|:swapname| (unless there is no swap file).
-		If buffer {buf} has no swap file, returns an empty string.
-
-		Can also be used as a |method|: >
-			GetBufname()->swapname()
-
-synID({lnum}, {col}, {trans})				*synID()*
-		The result is a Number, which is the syntax ID at the position
-		{lnum} and {col} in the current window.
-		The syntax ID can be used with |synIDattr()| and
-		|synIDtrans()| to obtain syntax information about text.
-
-		{col} is 1 for the leftmost column, {lnum} is 1 for the first
-		line.  'synmaxcol' applies, in a longer line zero is returned.
-		Note that when the position is after the last character,
-		that's where the cursor can be in Insert mode, synID() returns
-		zero.  {lnum} is used like with |getline()|.
-
-		When {trans} is |TRUE|, transparent items are reduced to the
-		item that they reveal.  This is useful when wanting to know
-		the effective color.  When {trans} is |FALSE|, the transparent
-		item is returned.  This is useful when wanting to know which
-		syntax item is effective (e.g. inside parens).
-		Warning: This function can be very slow.  Best speed is
-		obtained by going through the file in forward direction.
-
-		Example (echoes the name of the syntax item under the cursor): >
-			:echo synIDattr(synID(line("."), col("."), 1), "name")
-<
-
-synIDattr({synID}, {what} [, {mode}])			*synIDattr()*
-		The result is a String, which is the {what} attribute of
-		syntax ID {synID}.  This can be used to obtain information
-		about a syntax item.
-		{mode} can be "gui", "cterm" or "term", to get the attributes
-		for that mode.  When {mode} is omitted, or an invalid value is
-		used, the attributes for the currently active highlighting are
-		used (GUI, cterm or term).
-		Use synIDtrans() to follow linked highlight groups.
-		{what}		result
-		"name"		the name of the syntax item
-		"fg"		foreground color (GUI: color name used to set
-				the color, cterm: color number as a string,
-				term: empty string)
-		"bg"		background color (as with "fg")
-		"font"		font name (only available in the GUI)
-				|highlight-font|
-		"sp"		special color (as with "fg") |highlight-guisp|
-		"fg#"		like "fg", but for the GUI and the GUI is
-				running the name in "#RRGGBB" form
-		"bg#"		like "fg#" for "bg"
-		"sp#"		like "fg#" for "sp"
-		"bold"		"1" if bold
-		"italic"	"1" if italic
-		"reverse"	"1" if reverse
-		"inverse"	"1" if inverse (= reverse)
-		"standout"	"1" if standout
-		"underline"	"1" if underlined
-		"undercurl"	"1" if undercurled
-		"strikethrough"	"1" if struckthrough
-
-		Example (echoes the color of the syntax item under the
-		cursor): >
-	:echo synIDattr(synIDtrans(synID(line("."), col("."), 1)), "fg")
-<
-		Can also be used as a |method|: >
-	:echo synID(line("."), col("."), 1)->synIDtrans()->synIDattr("fg")
-
-synIDtrans({synID})					*synIDtrans()*
-		The result is a Number, which is the translated syntax ID of
-		{synID}.  This is the syntax group ID of what is being used to
-		highlight the character.  Highlight links given with
-		":highlight link" are followed.
-
-		Can also be used as a |method|: >
-	:echo synID(line("."), col("."), 1)->synIDtrans()->synIDattr("fg")
-
-synconcealed({lnum}, {col})				*synconcealed()*
-		The result is a |List| with currently three items:
-		1. The first item in the list is 0 if the character at the
-		   position {lnum} and {col} is not part of a concealable
-		   region, 1 if it is.  {lnum} is used like with |getline()|.
-		2. The second item in the list is a string. If the first item
-		   is 1, the second item contains the text which will be
-		   displayed in place of the concealed text, depending on the
-		   current setting of 'conceallevel' and 'listchars'.
-		3. The third and final item in the list is a number
-		   representing the specific syntax region matched in the
-		   line. When the character is not concealed the value is
-		   zero. This allows detection of the beginning of a new
-		   concealable region if there are two consecutive regions
-		   with the same replacement character.  For an example, if
-		   the text is "123456" and both "23" and "45" are concealed
-		   and replaced by the character "X", then:
-			call			returns ~
-		   	synconcealed(lnum, 1)   [0, '', 0]
-		   	synconcealed(lnum, 2)   [1, 'X', 1]
-		   	synconcealed(lnum, 3)   [1, 'X', 1]
-		   	synconcealed(lnum, 4)   [1, 'X', 2]
-		   	synconcealed(lnum, 5)   [1, 'X', 2]
-		   	synconcealed(lnum, 6)   [0, '', 0]
-
-
-synstack({lnum}, {col})					*synstack()*
-		Return a |List|, which is the stack of syntax items at the
-		position {lnum} and {col} in the current window.  {lnum} is
-		used like with |getline()|.  Each item in the List is an ID
-		like what |synID()| returns.
-		The first item in the List is the outer region, following are
-		items contained in that one.  The last one is what |synID()|
-		returns, unless not the whole item is highlighted or it is a
-		transparent item.
-		This function is useful for debugging a syntax file.
-		Example that shows the syntax stack under the cursor: >
-			for id in synstack(line("."), col("."))
-			   echo synIDattr(id, "name")
-			endfor
-<		When the position specified with {lnum} and {col} is invalid
-		nothing is returned.  The position just after the last
-		character in a line and the first column in an empty line are
-		valid positions.
-
-system({cmd} [, {input}])				*system()* *E677*
-		Gets the output of {cmd} as a |string| (|systemlist()| returns
-		a |List|) and sets |v:shell_error| to the error code.
-		{cmd} is treated as in |jobstart()|:
-		If {cmd} is a List it runs directly (no 'shell').
-		If {cmd} is a String it runs in the 'shell', like this: >
-		  :call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}'])
-
-<		Not to be used for interactive commands.
-
-		Result is a String, filtered to avoid platform-specific quirks:
-		- <CR><NL> is replaced with <NL>
-		- NUL characters are replaced with SOH (0x01)
-
-		Example: >
-		    :echo system(['ls', expand('%:h')])
-
-<		If {input} is a string it is written to a pipe and passed as
-		stdin to the command.  The string is written as-is, line
-		separators are not changed.
-		If {input} is a |List| it is written to the pipe as
-		|writefile()| does with {binary} set to "b" (i.e. with
-		a newline between each list item, and newlines inside list
-		items converted to NULs).
-		When {input} is given and is a valid buffer id, the content of
-		the buffer is written to the file line by line, each line
-		terminated by NL (and NUL where the text has NL).
-								*E5677*
-		Note: system() cannot write to or read from backgrounded ("&")
-		shell commands, e.g.: >
-		    :echo system("cat - &", "foo")
-<		which is equivalent to: >
-		    $ echo foo | bash -c 'cat - &'
-<		The pipes are disconnected (unless overridden by shell
-		redirection syntax) before input can reach it. Use
-		|jobstart()| instead.
-
-		Note: Use |shellescape()| or |::S| with |expand()| or
-		|fnamemodify()| to escape special characters in a command
-		argument. 'shellquote' and 'shellxquote' must be properly
-		configured. Example: >
-		    :echo system('ls '..shellescape(expand('%:h')))
-		    :echo system('ls '..expand('%:h:S'))
-
-<		Unlike ":!cmd" there is no automatic check for changed files.
-		Use |:checktime| to force a check.
-
-		Can also be used as a |method|: >
-			:echo GetCmd()->system()
-
-systemlist({cmd} [, {input} [, {keepempty}]])		*systemlist()*
-		Same as |system()|, but returns a |List| with lines (parts of
-		output separated by NL) with NULs transformed into NLs. Output
-		is the same as |readfile()| will output with {binary} argument
-		set to "b", except that a final newline is not preserved,
-		unless {keepempty} is non-zero.
-		Note that on MS-Windows you may get trailing CR characters.
-
-		To see the difference between "echo hello" and "echo -n hello"
-		use |system()| and |split()|: >
-			echo split(system('echo hello'), '\n', 1)
-<
-		Returns an empty string on error.
-
-		Can also be used as a |method|: >
-			:echo GetCmd()->systemlist()
-
-tabpagebuflist([{arg}])					*tabpagebuflist()*
-		The result is a |List|, where each item is the number of the
-		buffer associated with each window in the current tab page.
-		{arg} specifies the number of the tab page to be used. When
-		omitted the current tab page is used.
-		When {arg} is invalid the number zero is returned.
-		To get a list of all buffers in all tabs use this: >
-			let buflist = []
-			for i in range(tabpagenr('$'))
-			   call extend(buflist, tabpagebuflist(i + 1))
-			endfor
-<		Note that a buffer may appear in more than one window.
-
-		Can also be used as a |method|: >
-			GetTabpage()->tabpagebuflist()
-
-tabpagenr([{arg}])					*tabpagenr()*
-		The result is a Number, which is the number of the current
-		tab page.  The first tab page has number 1.
-		The optional argument {arg} supports the following values:
-			$	the number of the last tab page (the tab page
-				count).
-			#	the number of the last accessed tab page (where
-				|g<Tab>| goes to).  If there is no previous
-				tab page, 0 is returned.
-		The number can be used with the |:tab| command.
-
-
-tabpagewinnr({tabarg} [, {arg}])			*tabpagewinnr()*
-		Like |winnr()| but for tab page {tabarg}.
-		{tabarg} specifies the number of tab page to be used.
-		{arg} is used like with |winnr()|:
-		- When omitted the current window number is returned.  This is
-		  the window which will be used when going to this tab page.
-		- When "$" the number of windows is returned.
-		- When "#" the previous window nr is returned.
-		Useful examples: >
-		    tabpagewinnr(1)	    " current window of tab page 1
-		    tabpagewinnr(4, '$')    " number of windows in tab page 4
-<		When {tabarg} is invalid zero is returned.
-
-		Can also be used as a |method|: >
-			GetTabpage()->tabpagewinnr()
-<
-							*tagfiles()*
-tagfiles()	Returns a |List| with the file names used to search for tags
-		for the current buffer.  This is the 'tags' option expanded.
-
-
-taglist({expr} [, {filename}])				*taglist()*
-		Returns a |List| of tags matching the regular expression {expr}.
-
-		If {filename} is passed it is used to prioritize the results
-		in the same way that |:tselect| does. See |tag-priority|.
-		{filename} should be the full path of the file.
-
-		Each list item is a dictionary with at least the following
-		entries:
-			name		Name of the tag.
-			filename	Name of the file where the tag is
-					defined.  It is either relative to the
-					current directory or a full path.
-			cmd		Ex command used to locate the tag in
-					the file.
-			kind		Type of the tag.  The value for this
-					entry depends on the language specific
-					kind values.  Only available when
-					using a tags file generated by
-					Exuberant ctags or hdrtag.
-			static		A file specific tag.  Refer to
-					|static-tag| for more information.
-		More entries may be present, depending on the content of the
-		tags file: access, implementation, inherits and signature.
-		Refer to the ctags documentation for information about these
-		fields.  For C code the fields "struct", "class" and "enum"
-		may appear, they give the name of the entity the tag is
-		contained in.
-
-		The ex-command "cmd" can be either an ex search pattern, a
-		line number or a line number followed by a byte number.
-
-		If there are no matching tags, then an empty list is returned.
-
-		To get an exact tag match, the anchors '^' and '$' should be
-		used in {expr}.  This also make the function work faster.
-		Refer to |tag-regexp| for more information about the tag
-		search regular expression pattern.
-
-		Refer to |'tags'| for information about how the tags file is
-		located by Vim. Refer to |tags-file-format| for the format of
-		the tags file generated by the different ctags tools.
-
-		Can also be used as a |method|: >
-			GetTagpattern()->taglist()
-
-tempname()					*tempname()* *temp-file-name*
-		The result is a String, which is the name of a file that
-		doesn't exist.  It can be used for a temporary file.  Example: >
-			:let tmpfile = tempname()
-			:exe "redir > " . tmpfile
-<		For Unix, the file will be in a private directory |tempfile|.
-		For MS-Windows forward slashes are used when the 'shellslash'
-		option is set or when 'shellcmdflag' starts with '-'.
-
-termopen({cmd}[, {opts}])			*termopen()*
-		Spawns {cmd} in a new pseudo-terminal session connected
-		to the current buffer.  {cmd} is the same as the one passed to
-		|jobstart()|.  This function fails if the current buffer is
-		modified (all buffer contents are destroyed).
-
-		The {opts} dict is similar to the one passed to |jobstart()|,
-		but the `pty`, `width`, `height`, and `TERM` fields are
-		ignored: `height`/`width` are taken from the current window
-		and `$TERM` is set to "xterm-256color".
-		Returns the same values as |jobstart()|.
-
-		See |terminal| for more information.
-
-test_ functions are documented here: |test-functions-details|
-
-tan({expr})						*tan()*
-		Return the tangent of {expr}, measured in radians, as a |Float|
-		in the range [-inf, inf].
-		{expr} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			:echo tan(10)
-<			0.648361 >
-			:echo tan(-4.01)
-<			-1.181502
-
-		Can also be used as a |method|: >
-			Compute()->tan()
-
-tanh({expr})						*tanh()*
-		Return the hyperbolic tangent of {expr} as a |Float| in the
-		range [-1, 1].
-		{expr} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			:echo tanh(0.5)
-<			0.462117 >
-			:echo tanh(-1)
-<			-0.761594
-
-		Can also be used as a |method|: >
-			Compute()->tanh()
-<
-							*timer_info()*
-timer_info([{id}])
-		Return a list with information about timers.
-		When {id} is given only information about this timer is
-		returned.  When timer {id} does not exist an empty list is
-		returned.
-		When {id} is omitted information about all timers is returned.
-
-		For each timer the information is stored in a |Dictionary| with
-		these items:
-		    "id"	    the timer ID
-		    "time"	    time the timer was started with
-		    "repeat"	    number of times the timer will still fire;
-				    -1 means forever
-		    "callback"	    the callback
-
-		Can also be used as a |method|: >
-			GetTimer()->timer_info()
-<
-timer_pause({timer}, {paused})				*timer_pause()*
-		Pause or unpause a timer.  A paused timer does not invoke its
-		callback when its time expires.  Unpausing a timer may cause
-		the callback to be invoked almost immediately if enough time
-		has passed.
-
-		Pausing a timer is useful to avoid the callback to be called
-		for a short time.
-
-		If {paused} evaluates to a non-zero Number or a non-empty
-		String, then the timer is paused, otherwise it is unpaused.
-		See |non-zero-arg|.
-
-		Can also be used as a |method|: >
-			GetTimer()->timer_pause(1)
-<
-						*timer_start()* *timer* *timers*
-timer_start({time}, {callback} [, {options}])
-		Create a timer and return the timer ID.
-
-		{time} is the waiting time in milliseconds. This is the
-		minimum time before invoking the callback.  When the system is
-		busy or Vim is not waiting for input the time will be longer.
-
-		{callback} is the function to call.  It can be the name of a
-		function or a |Funcref|.  It is called with one argument, which
-		is the timer ID.  The callback is only invoked when Vim is
-		waiting for input.
-
-		{options} is a dictionary.  Supported entries:
-		   "repeat"	Number of times to repeat the callback.
-				-1 means forever.  Default is 1.
-				If the timer causes an error three times in a
-				row the repeat is cancelled.
-
-		Example: >
-			func MyHandler(timer)
-			  echo 'Handler called'
-			endfunc
-			let timer = timer_start(500, 'MyHandler',
-				\ {'repeat': 3})
-<		This invokes MyHandler() three times at 500 msec intervals.
-
-		Can also be used as a |method|: >
-			GetMsec()->timer_start(callback)
-
-<		Not available in the |sandbox|.
-
-timer_stop({timer})					*timer_stop()*
-		Stop a timer.  The timer callback will no longer be invoked.
-		{timer} is an ID returned by timer_start(), thus it must be a
-		Number.  If {timer} does not exist there is no error.
-
-		Can also be used as a |method|: >
-			GetTimer()->timer_stop()
-<
-timer_stopall()						*timer_stopall()*
-		Stop all timers.  The timer callbacks will no longer be
-		invoked.  Useful if some timers is misbehaving.  If there are
-		no timers there is no error.
-
-tolower({expr})						*tolower()*
-		The result is a copy of the String given, with all uppercase
-		characters turned into lowercase (just like applying |gu| to
-		the string).
-
-		Can also be used as a |method|: >
-			GetText()->tolower()
-
-toupper({expr})						*toupper()*
-		The result is a copy of the String given, with all lowercase
-		characters turned into uppercase (just like applying |gU| to
-		the string).
-
-		Can also be used as a |method|: >
-			GetText()->toupper()
-
-tr({src}, {fromstr}, {tostr})				*tr()*
-		The result is a copy of the {src} string with all characters
-		which appear in {fromstr} replaced by the character in that
-		position in the {tostr} string.  Thus the first character in
-		{fromstr} is translated into the first character in {tostr}
-		and so on.  Exactly like the unix "tr" command.
-		This code also deals with multibyte characters properly.
-
-		Examples: >
-			echo tr("hello there", "ht", "HT")
-<		returns "Hello THere" >
-			echo tr("<blob>", "<>", "{}")
-<		returns "{blob}"
-
-		Can also be used as a |method|: >
-			GetText()->tr(from, to)
-
-trim({text} [, {mask} [, {dir}]])				*trim()*
-		Return {text} as a String where any character in {mask} is
-		removed from the beginning and/or end of {text}.
-		If {mask} is not given, {mask} is all characters up to 0x20,
-		which includes Tab, space, NL and CR, plus the non-breaking
-		space character 0xa0.
-		The optional {dir} argument specifies where to remove the
-		characters:
-			0	remove from the beginning and end of {text}
-			1	remove only at the beginning of {text}
-			2	remove only at the end of {text}
-		When omitted both ends are trimmed.
-		This function deals with multibyte characters properly.
-		Examples: >
-			echo trim("   some text ")
-<		returns "some text" >
-			echo trim("  \r\t\t\r RESERVE \t\n\x0B\xA0") . "_TAIL"
-<		returns "RESERVE_TAIL" >
-			echo trim("rm<Xrm<>X>rrm", "rm<>")
-<		returns "Xrm<>X" (characters in the middle are not removed) >
-			echo trim("  vim  ", " ", 2)
-<		returns "  vim"
-
-		Can also be used as a |method|: >
-			GetText()->trim()
-
-trunc({expr})							*trunc()*
-		Return the largest integral value with magnitude less than or
-		equal to {expr} as a |Float| (truncate towards zero).
-		{expr} must evaluate to a |Float| or a |Number|.
-		Examples: >
-			echo trunc(1.456)
-<			1.0  >
-			echo trunc(-5.456)
-<			-5.0  >
-			echo trunc(4.0)
-<			4.0
-
-		Can also be used as a |method|: >
-			Compute()->trunc()
-
-type({expr})							*type()*
-		The result is a Number representing the type of {expr}.
-		Instead of using the number directly, it is better to use the
-		v:t_ variable that has the value:
-		        Number:     0 (|v:t_number|)
-			String:     1 (|v:t_string|)
-			Funcref:    2 (|v:t_func|)
-			List:       3 (|v:t_list|)
-			Dictionary: 4 (|v:t_dict|)
-			Float:      5 (|v:t_float|)
-			Boolean:    6 (|v:true| and |v:false|)
-			Null:       7 (|v:null|)
-			Blob:      10 (|v:t_blob|)
-		For backward compatibility, this method can be used: >
-			:if type(myvar) == type(0)
-			:if type(myvar) == type("")
-			:if type(myvar) == type(function("tr"))
-			:if type(myvar) == type([])
-			:if type(myvar) == type({})
-			:if type(myvar) == type(0.0)
-			:if type(myvar) == type(v:true)
-<		In place of checking for |v:null| type it is better to check
-		for |v:null| directly as it is the only value of this type: >
-			:if myvar is v:null
-<               To check if the v:t_ variables exist use this: >
-                        :if exists('v:t_number')
-
-<		Can also be used as a |method|: >
-			mylist->type()
-
-undofile({name})					*undofile()*
-		Return the name of the undo file that would be used for a file
-		with name {name} when writing.  This uses the 'undodir'
-		option, finding directories that exist.  It does not check if
-		the undo file exists.
-		{name} is always expanded to the full path, since that is what
-		is used internally.
-		If {name} is empty undofile() returns an empty string, since a
-		buffer without a file name will not write an undo file.
-		Useful in combination with |:wundo| and |:rundo|.
-
-		Can also be used as a |method|: >
-			GetFilename()->undofile()
-
-undotree()						*undotree()*
-		Return the current state of the undo tree in a dictionary with
-		the following items:
-		  "seq_last"	The highest undo sequence number used.
-		  "seq_cur"	The sequence number of the current position in
-				the undo tree.  This differs from "seq_last"
-				when some changes were undone.
-		  "time_cur"	Time last used for |:earlier| and related
-				commands.  Use |strftime()| to convert to
-				something readable.
-		  "save_last"	Number of the last file write.  Zero when no
-				write yet.
-		  "save_cur"	Number of the current position in the undo
-				tree.
-		  "synced"	Non-zero when the last undo block was synced.
-				This happens when waiting from input from the
-				user.  See |undo-blocks|.
-		  "entries"	A list of dictionaries with information about
-				undo blocks.
-
-		The first item in the "entries" list is the oldest undo item.
-		Each List item is a |Dictionary| with these items:
-		  "seq"		Undo sequence number.  Same as what appears in
-				|:undolist|.
-		  "time"	Timestamp when the change happened.  Use
-				|strftime()| to convert to something readable.
-		  "newhead"	Only appears in the item that is the last one
-				that was added.  This marks the last change
-				and where further changes will be added.
-		  "curhead"	Only appears in the item that is the last one
-				that was undone.  This marks the current
-				position in the undo tree, the block that will
-				be used by a redo command.  When nothing was
-				undone after the last change this item will
-				not appear anywhere.
-		  "save"	Only appears on the last block before a file
-				write.  The number is the write count.  The
-				first write has number 1, the last one the
-				"save_last" mentioned above.
-		  "alt"		Alternate entry.  This is again a List of undo
-				blocks.  Each item may again have an "alt"
-				item.
-
-uniq({list} [, {func} [, {dict}]])			*uniq()* *E882*
-		Remove second and succeeding copies of repeated adjacent
-		{list} items in-place.  Returns {list}.  If you want a list
-		to remain unmodified make a copy first: >
-			:let newlist = uniq(copy(mylist))
-<		The default compare function uses the string representation of
-		each item.  For the use of {func} and {dict} see |sort()|.
-
-		Can also be used as a |method|: >
-			mylist->uniq()
-
-values({dict})						*values()*
-		Return a |List| with all the values of {dict}.  The |List| is
-		in arbitrary order.  Also see |items()| and |keys()|.
-
-		Can also be used as a |method|: >
-			mydict->values()
-
-virtcol({expr})						*virtcol()*
-		The result is a Number, which is the screen column of the file
-		position given with {expr}.  That is, the last screen position
-		occupied by the character at that position, when the screen
-		would be of unlimited width.  When there is a <Tab> at the
-		position, the returned Number will be the column at the end of
-		the <Tab>.  For example, for a <Tab> in column 1, with 'ts'
-		set to 8, it returns 8. |conceal| is ignored.
-		For the byte position use |col()|.
-		For the use of {expr} see |col()|.
-		When 'virtualedit' is used {expr} can be [lnum, col, off], where
-		"off" is the offset in screen columns from the start of the
-		character.  E.g., a position within a <Tab> or after the last
-		character.  When "off" is omitted zero is used.
-		When Virtual editing is active in the current mode, a position
-		beyond the end of the line can be returned. |'virtualedit'|
-		The accepted positions are:
-		    .	    the cursor position
-		    $	    the end of the cursor line (the result is the
-			    number of displayed characters in the cursor line
-			    plus one)
-		    'x	    position of mark x (if the mark is not set, 0 is
-			    returned)
-		    v       In Visual mode: the start of the Visual area (the
-			    cursor is the end).  When not in Visual mode
-			    returns the cursor position.  Differs from |'<| in
-			    that it's updated right away.
-		Note that only marks in the current file can be used.
-		Examples: >
-  virtcol(".")	   with text "foo^Lbar", with cursor on the "^L", returns 5
-  virtcol("$")	   with text "foo^Lbar", returns 9
-  virtcol("'t")    with text "	  there", with 't at 'h', returns 6
-<		The first column is 1.  0 is returned for an error.
-		A more advanced example that echoes the maximum length of
-		all lines: >
-		    echo max(map(range(1, line('$')), "virtcol([v:val, '$'])"))
-
-<		Can also be used as a |method|: >
-			GetPos()->virtcol()
-
-visualmode([{expr}])						*visualmode()*
-		The result is a String, which describes the last Visual mode
-		used in the current buffer.  Initially it returns an empty
-		string, but once Visual mode has been used, it returns "v",
-		"V", or "<CTRL-V>" (a single CTRL-V character) for
-		character-wise, line-wise, or block-wise Visual mode
-		respectively.
-		Example: >
-			:exe "normal " . visualmode()
-<		This enters the same Visual mode as before.  It is also useful
-		in scripts if you wish to act differently depending on the
-		Visual mode that was used.
-		If Visual mode is active, use |mode()| to get the Visual mode
-		(e.g., in a |:vmap|).
-		If {expr} is supplied and it evaluates to a non-zero Number or
-		a non-empty String, then the Visual mode will be cleared and
-		the old value is returned.  See |non-zero-arg|.
-
-wait({timeout}, {condition}[, {interval}])			*wait()*
-		Waits until {condition} evaluates to |TRUE|, where {condition}
-		is a |Funcref| or |string| containing an expression.
-
-		{timeout} is the maximum waiting time in milliseconds, -1
-		means forever.
-
-		Condition is evaluated on user events, internal events, and
-		every {interval} milliseconds (default: 200).
-
-		Returns a status integer:
-			0 if the condition was satisfied before timeout
-			-1 if the timeout was exceeded
-			-2 if the function was interrupted (by |CTRL-C|)
-			-3 if an error occurred
-
-wildmenumode()					*wildmenumode()*
-		Returns |TRUE| when the wildmenu is active and |FALSE|
-		otherwise.  See 'wildmenu' and 'wildmode'.
-		This can be used in mappings to handle the 'wildcharm' option
-		gracefully. (Makes only sense with |mapmode-c| mappings).
-
-		For example to make <c-j> work like <down> in wildmode, use: >
-    :cnoremap <expr> <C-j> wildmenumode() ? "\<Down>\<Tab>" : "\<c-j>"
-<
-		(Note, this needs the 'wildcharm' option set appropriately).
-
-win_execute({id}, {command} [, {silent}])		*win_execute()*
-		Like `execute()` but in the context of window {id}.
-		The window will temporarily be made the current window,
-		without triggering autocommands or changing directory.  When
-		executing {command} autocommands will be triggered, this may
-		have unexpected side effects.  Use |:noautocmd| if needed.
-		Example: >
-			call win_execute(winid, 'syntax enable')
-<
-		Can also be used as a |method|, the base is passed as the
-		second argument: >
-			GetCommand()->win_execute(winid)
-
-win_findbuf({bufnr})					*win_findbuf()*
-		Returns a |List| with |window-ID|s for windows that contain
-		buffer {bufnr}.  When there is none the list is empty.
-
-		Can also be used as a |method|: >
-			GetBufnr()->win_findbuf()
-
-win_getid([{win} [, {tab}]])				*win_getid()*
-		Get the |window-ID| for the specified window.
-		When {win} is missing use the current window.
-		With {win} this is the window number.  The top window has
-		number 1.
-		Without {tab} use the current tab, otherwise the tab with
-		number {tab}.  The first tab has number one.
-		Return zero if the window cannot be found.
-
-		Can also be used as a |method|: >
-			GetWinnr()->win_getid()
-
-win_gettype([{nr}])					*win_gettype()*
-		Return the type of the window:
-			"autocmd"	autocommand window. Temporary window
-					used to execute autocommands.
-			"command"	command-line window |cmdwin|
-			(empty)		normal window
-			"loclist"	|location-list-window|
-			"popup"		popup window |popup|
-			"preview"	preview window |preview-window|
-			"quickfix"	|quickfix-window|
-			"unknown"	window {nr} not found
-
-		When {nr} is omitted return the type of the current window.
-		When {nr} is given return the type of this window by number or
-		|window-ID|.
-
-		Also see the 'buftype' option.  When running a terminal in a
-		popup window then 'buftype' is "terminal" and win_gettype()
-		returns "popup".
-
-		Can also be used as a |method|: >
-			GetWinid()->win_gettype()
-<
-win_gotoid({expr})					*win_gotoid()*
-		Go to window with ID {expr}.  This may also change the current
-		tabpage.
-		Return TRUE if successful, FALSE if the window cannot be found.
-
-		Can also be used as a |method|: >
-			GetWinid()->win_gotoid()
-
-win_id2tabwin({expr})					*win_id2tabwin()*
-		Return a list with the tab number and window number of window
-		with ID {expr}: [tabnr, winnr].
-		Return [0, 0] if the window cannot be found.
-
-		Can also be used as a |method|: >
-			GetWinid()->win_id2tabwin()
-
-win_id2win({expr})					*win_id2win()*
-		Return the window number of window with ID {expr}.
-		Return 0 if the window cannot be found in the current tabpage.
-
-		Can also be used as a |method|: >
-			GetWinid()->win_id2win()
-
-win_screenpos({nr})					*win_screenpos()*
-		Return the screen position of window {nr} as a list with two
-		numbers: [row, col].  The first window always has position
-		[1, 1], unless there is a tabline, then it is [2, 1].
-		{nr} can be the window number or the |window-ID|.  Use zero
-		for the current window.
-		Returns [0, 0] if the window cannot be found in the current
-		tabpage.
-
-		Can also be used as a |method|: >
-			GetWinid()->win_screenpos()
-<
-win_splitmove({nr}, {target} [, {options}])		*win_splitmove()*
-		Move the window {nr} to a new split of the window {target}.
-		This is similar to moving to {target}, creating a new window
-		using |:split| but having the same contents as window {nr}, and
-		then closing {nr}.
-
-		Both {nr} and {target} can be window numbers or |window-ID|s.
-		Both must be in the current tab page.
-
-		Returns zero for success, non-zero for failure.
-
-		{options} is a |Dictionary| with the following optional entries:
-		  "vertical"	When TRUE, the split is created vertically,
-				like with |:vsplit|.
-		  "rightbelow"	When TRUE, the split is made below or to the
-				right (if vertical).  When FALSE, it is done
-				above or to the left (if vertical).  When not
-				present, the values of 'splitbelow' and
-				'splitright' are used.
-
-		Can also be used as a |method|: >
-			GetWinid()->win_splitmove(target)
-<
-							*winbufnr()*
-winbufnr({nr})	The result is a Number, which is the number of the buffer
-		associated with window {nr}.  {nr} can be the window number or
-		the |window-ID|.
-		When {nr} is zero, the number of the buffer in the current
-		window is returned.
-		When window {nr} doesn't exist, -1 is returned.
-		Example: >
-  :echo "The file in the current window is " . bufname(winbufnr(0))
-<
-		Can also be used as a |method|: >
-			FindWindow()->winbufnr()->bufname()
-<
-							*wincol()*
-wincol()	The result is a Number, which is the virtual column of the
-		cursor in the window.  This is counting screen cells from the
-		left side of the window.  The leftmost column is one.
-
-							*windowsversion()*
-windowsversion()
-		The result is a String.  For MS-Windows it indicates the OS
-		version.  E.g, Windows 10 is "10.0", Windows 8 is "6.2",
-		Windows XP is "5.1".  For non-MS-Windows systems the result is
-		an empty string.
-
-winheight({nr})						*winheight()*
-		The result is a Number, which is the height of window {nr}.
-		{nr} can be the window number or the |window-ID|.
-		When {nr} is zero, the height of the current window is
-		returned.  When window {nr} doesn't exist, -1 is returned.
-		An existing window always has a height of zero or more.
-		This excludes any window toolbar line.
-		Examples: >
-  :echo "The current window has " . winheight(0) . " lines."
-
-<		Can also be used as a |method|: >
-			GetWinid()->winheight()
-<
-winlayout([{tabnr}])					*winlayout()*
-		The result is a nested List containing the layout of windows
-		in a tabpage.
-
-		Without {tabnr} use the current tabpage, otherwise the tabpage
-		with number {tabnr}. If the tabpage {tabnr} is not found,
-		returns an empty list.
-
-		For a leaf window, it returns:
-			['leaf', {winid}]
-		For horizontally split windows, which form a column, it
-		returns:
-			['col', [{nested list of windows}]]
-		For vertically split windows, which form a row, it returns:
-			['row', [{nested list of windows}]]
-
-		Example: >
-			" Only one window in the tab page
-			:echo winlayout()
-			['leaf', 1000]
-			" Two horizontally split windows
-			:echo winlayout()
-			['col', [['leaf', 1000], ['leaf', 1001]]]
-			" The second tab page, with three horizontally split
-			" windows, with two vertically split windows in the
-			" middle window
-			:echo winlayout(2)
-			['col', [['leaf', 1002], ['row', [['leaf', 1003],
-					    ['leaf', 1001]]], ['leaf', 1000]]]
-<
-		Can also be used as a |method|: >
-			GetTabnr()->winlayout()
-<
-							*winline()*
-winline()	The result is a Number, which is the screen line of the cursor
-		in the window.  This is counting screen lines from the top of
-		the window.  The first line is one.
-		If the cursor was moved the view on the file will be updated
-		first, this may cause a scroll.
-
-							*winnr()*
-winnr([{arg}])	The result is a Number, which is the number of the current
-		window.  The top window has number 1.
-		Returns zero for a popup window.
-
-		The optional argument {arg} supports the following values:
-			$	the number of the last window (the window
-				count).
-			#	the number of the last accessed window (where
-				|CTRL-W_p| goes to).  If there is no previous
-				window or it is in another tab page 0 is
-				returned.
-			{N}j	the number of the Nth window below the
-				current window (where |CTRL-W_j| goes to).
-			{N}k	the number of the Nth window above the current
-				window (where |CTRL-W_k| goes to).
-			{N}h	the number of the Nth window left of the
-				current window (where |CTRL-W_h| goes to).
-			{N}l	the number of the Nth window right of the
-				current window (where |CTRL-W_l| goes to).
-		The number can be used with |CTRL-W_w| and ":wincmd w"
-		|:wincmd|.
-		Also see |tabpagewinnr()| and |win_getid()|.
-		Examples: >
-			let window_count = winnr('$')
-			let prev_window = winnr('#')
-			let wnum = winnr('3k')
-
-<		Can also be used as a |method|: >
-			GetWinval()->winnr()
-<
-							*winrestcmd()*
-winrestcmd()	Returns a sequence of |:resize| commands that should restore
-		the current window sizes.  Only works properly when no windows
-		are opened or closed and the current window and tab page is
-		unchanged.
-		Example: >
-			:let cmd = winrestcmd()
-			:call MessWithWindowSizes()
-			:exe cmd
-<
-							*winrestview()*
-winrestview({dict})
-		Uses the |Dictionary| returned by |winsaveview()| to restore
-		the view of the current window.
-		Note: The {dict} does not have to contain all values, that are
-		returned by |winsaveview()|. If values are missing, those
-		settings won't be restored. So you can use: >
-		    :call winrestview({'curswant': 4})
-<
-		This will only set the curswant value (the column the cursor
-		wants to move on vertical movements) of the cursor to column 5
-		(yes, that is 5), while all other settings will remain the
-		same. This is useful, if you set the cursor position manually.
-
-		If you have changed the values the result is unpredictable.
-		If the window size changed the result won't be the same.
-
-		Can also be used as a |method|: >
-			GetView()->winrestview()
-<
-							*winsaveview()*
-winsaveview()	Returns a |Dictionary| that contains information to restore
-		the view of the current window.  Use |winrestview()| to
-		restore the view.
-		This is useful if you have a mapping that jumps around in the
-		buffer and you want to go back to the original view.
-		This does not save fold information.  Use the 'foldenable'
-		option to temporarily switch off folding, so that folds are
-		not opened when moving around. This may have side effects.
-		The return value includes:
-			lnum		cursor line number
-			col		cursor column (Note: the first column
-					zero, as opposed to what getpos()
-					returns)
-			coladd		cursor column offset for 'virtualedit'
-			curswant	column for vertical movement
-			topline		first line in the window
-			topfill		filler lines, only in diff mode
-			leftcol		first column displayed; only used when
-					'wrap' is off
-			skipcol		columns skipped
-		Note that no option values are saved.
-
-
-winwidth({nr})						*winwidth()*
-		The result is a Number, which is the width of window {nr}.
-		{nr} can be the window number or the |window-ID|.
-		When {nr} is zero, the width of the current window is
-		returned.  When window {nr} doesn't exist, -1 is returned.
-		An existing window always has a width of zero or more.
-		Examples: >
-  :echo "The current window has " . winwidth(0) . " columns."
-  :if winwidth(0) <= 50
-  :  50 wincmd |
-  :endif
-<		For getting the terminal or screen size, see the 'columns'
-		option.
-
-		Can also be used as a |method|: >
-			GetWinid()->winwidth()
-
-wordcount()						*wordcount()*
-		The result is a dictionary of byte/chars/word statistics for
-		the current buffer.  This is the same info as provided by
-		|g_CTRL-G|
-		The return value includes:
-			bytes		Number of bytes in the buffer
-			chars		Number of chars in the buffer
-			words		Number of words in the buffer
-			cursor_bytes    Number of bytes before cursor position
-					(not in Visual mode)
-			cursor_chars    Number of chars before cursor position
-					(not in Visual mode)
-			cursor_words    Number of words before cursor position
-					(not in Visual mode)
-			visual_bytes    Number of bytes visually selected
-					(only in Visual mode)
-			visual_chars    Number of chars visually selected
-					(only in Visual mode)
-			visual_words    Number of words visually selected
-					(only in Visual mode)
-
-
-							*writefile()*
-writefile({object}, {fname} [, {flags}])
-		When {object} is a |List| write it to file {fname}.  Each list
-		item is separated with a NL.  Each list item must be a String
-		or Number.
-		When {flags} contains "b" then binary mode is used: There will
-		not be a NL after the last list item.  An empty item at the
-		end does cause the last line in the file to end in a NL.
-
-		When {object} is a |Blob| write the bytes to file {fname}
-		unmodified.
-
-		When {flags} contains "a" then append mode is used, lines are
-		appended to the file: >
-			:call writefile(["foo"], "event.log", "a")
-			:call writefile(["bar"], "event.log", "a")
-<
-		When {flags} contains "S" fsync() call is not used, with "s"
-		it is used, 'fsync' option applies by default. No fsync()
-		means that writefile() will finish faster, but writes may be
-		left in OS buffers and not yet written to disk. Such changes
-		will disappear if system crashes before OS does writing.
-
-		All NL characters are replaced with a NUL character.
-		Inserting CR characters needs to be done before passing {list}
-		to writefile().
-		An existing file is overwritten, if possible.
-		When the write fails -1 is returned, otherwise 0.  There is an
-		error message if the file can't be created or when writing
-		fails.
-		Also see |readfile()|.
-		To copy a file byte for byte: >
-			:let fl = readfile("foo", "b")
-			:call writefile(fl, "foocopy", "b")
-
-<		Can also be used as a |method|: >
-			GetText()->writefile("thefile")
-
-xor({expr}, {expr})					*xor()*
-		Bitwise XOR on the two arguments.  The arguments are converted
-		to a number.  A List, Dict or Float argument causes an error.
-		Example: >
-			:let bits = xor(bits, 0x80)
-<
-		Can also be used as a |method|: >
-			:let bits = bits->xor(0x80)
-<
-
-							*string-match*
-Matching a pattern in a String
-
-A regexp pattern as explained at |pattern| is normally used to find a match in
-the buffer lines.  When a pattern is used to find a match in a String, almost
-everything works in the same way.  The difference is that a String is handled
-like it is one line.  When it contains a "\n" character, this is not seen as a
-line break for the pattern.  It can be matched with a "\n" in the pattern, or
-with ".".  Example: >
-	:let a = "aaaa\nxxxx"
-	:echo matchstr(a, "..\n..")
-	aa
-	xx
-	:echo matchstr(a, "a.x")
-	a
-	x
-
-Don't forget that "^" will only match at the first character of the String and
-"$" at the last character of the string.  They don't match after or before a
-"\n".
+The alphabetic list of all builtin functions and details are in a separate
+help file: |builtin-functions|.
 
 ==============================================================================
 5. Defining functions					*user-function*
@@ -11163,9 +2548,9 @@ Example: >
   :  echohl Title
   :  echo a:title
   :  echohl None
-  :  echo a:0 . " items:"
+  :  echo a:0 .. " items:"
   :  for s in a:000
-  :    echon ' ' . s
+  :    echon ' ' .. s
   :  endfor
   :endfunction
 
@@ -11204,7 +2589,7 @@ This function can then be called with: >
 		this works:
 						*function-range-example*  >
 	:function Mynumber(arg)
-	:  echo line(".") . " " . a:arg
+	:  echo line(".") .. " " .. a:arg
 	:endfunction
 	:1,5call Mynumber(getline("."))
 <
@@ -11215,7 +2600,7 @@ This function can then be called with: >
 		Example of a function that handles the range itself: >
 
 	:function Cont() range
-	:  execute (a:firstline + 1) . "," . a:lastline . 's/^/\t\\ '
+	:  execute (a:firstline + 1) .. "," .. a:lastline .. 's/^/\t\\ '
 	:endfunction
 	:4,8call Cont()
 <
@@ -11377,7 +2762,7 @@ This does NOT work: >
 			This cannot be used to add an item to a |List|.
 			This cannot be used to set a byte in a String.  You
 			can do that like this: >
-				:let var = var[0:2] . 'X' . var[4:]
+				:let var = var[0:2] .. 'X' .. var[4:]
 <			When {var-name} is a |Blob| then {idx} can be the
 			length of the blob, in which case one byte is
 			appended.
@@ -11439,7 +2824,7 @@ This does NOT work: >
 			is just like using the |:set| command: both the local
 			value and the global value are changed.
 			Example: >
-				:let &path = &path . ',/usr/local/include'
+				:let &path = &path .. ',/usr/local/include'
 
 :let &{option-name} .= {expr1}
 			For a string option: Append {expr1} to the value.
@@ -11694,14 +3079,17 @@ text...
 			opposite of |:lockvar|.
 
 :if {expr1}			*:if* *:end* *:endif* *:en* *E171* *E579* *E580*
-:en[dif]		Execute the commands until the next matching ":else"
-			or ":endif" if {expr1} evaluates to non-zero.
+:en[dif]		Execute the commands until the next matching `:else`
+			or `:endif` if {expr1} evaluates to non-zero.
+			Although the short forms work, it is recommended to
+			always use `:endif` to avoid confusion and to make
+			auto-indenting work properly.
 
 			From Vim version 4.5 until 5.0, every Ex command in
-			between the ":if" and ":endif" is ignored.  These two
+			between the `:if` and `:endif` is ignored.  These two
 			commands were just to allow for future expansions in a
 			backward compatible way.  Nesting was allowed.  Note
-			that any ":else" or ":elseif" was ignored, the "else"
+			that any `:else` or `:elseif` was ignored, the `else`
 			part was not executed either.
 
 			You can use this to remain compatible with older
@@ -11710,32 +3098,32 @@ text...
 				:  version-5-specific-commands
 				:endif
 <			The commands still need to be parsed to find the
-			"endif".  Sometimes an older Vim has a problem with a
-			new command.  For example, ":silent" is recognized as
-			a ":substitute" command.  In that case ":execute" can
+			`endif`.  Sometimes an older Vim has a problem with a
+			new command.  For example, `:silent` is recognized as
+			a `:substitute` command.  In that case `:execute` can
 			avoid problems: >
 				:if version >= 600
 				:  execute "silent 1,$delete"
 				:endif
 <
-			NOTE: The ":append" and ":insert" commands don't work
-			properly in between ":if" and ":endif".
+			NOTE: The `:append` and `:insert` commands don't work
+			properly in between `:if` and `:endif`.
 
 						*:else* *:el* *E581* *E583*
-:el[se]			Execute the commands until the next matching ":else"
-			or ":endif" if they previously were not being
+:el[se]			Execute the commands until the next matching `:else`
+			or `:endif` if they previously were not being
 			executed.
 
 					*:elseif* *:elsei* *E582* *E584*
-:elsei[f] {expr1}	Short for ":else" ":if", with the addition that there
-			is no extra ":endif".
+:elsei[f] {expr1}	Short for `:else` `:if`, with the addition that there
+			is no extra `:endif`.
 
 :wh[ile] {expr1}			*:while* *:endwhile* *:wh* *:endw*
 						*E170* *E585* *E588* *E733*
-:endw[hile]		Repeat the commands between ":while" and ":endwhile",
+:endw[hile]		Repeat the commands between `:while` and `:endwhile`,
 			as long as {expr1} evaluates to non-zero.
 			When an error is detected from a command inside the
-			loop, execution continues after the "endwhile".
+			loop, execution continues after the `endwhile`.
 			Example: >
 				:let lnum = 1
 				:while lnum <= line("$")
@@ -11743,16 +3131,19 @@ text...
 				   :let lnum = lnum + 1
 				:endwhile
 <
-			NOTE: The ":append" and ":insert" commands don't work
-			properly inside a ":while" and ":for" loop.
+			NOTE: The `:append` and `:insert` commands don't work
+			properly inside a `:while` and `:for` loop.
 
 :for {var} in {object}					*:for* *E690* *E732*
 :endfo[r]						*:endfo* *:endfor*
-			Repeat the commands between ":for" and ":endfor" for
-			each item in {object}.  {object} can be a |List| or
-			a |Blob|.  Variable {var} is set to the value of each
-			item.  When an error is detected for a command inside
-			the loop, execution continues after the "endfor".
+			Repeat the commands between `:for` and `:endfor` for
+			each item in {object}.  {object} can be a |List|,
+			a |Blob| or a |String|.
+
+			Variable {var} is set to the value of each item.
+
+			When an error is detected for a command inside the
+			loop, execution continues after the `endfor`.
 			Changing {object} inside the loop affects what items
 			are used.  Make a copy if this is unwanted: >
 				:for item in copy(mylist)
@@ -11776,7 +3167,7 @@ text...
 
 :for [{var1}, {var2}, ...] in {listlist}
 :endfo[r]
-			Like ":for" above, but each item in {listlist} must be
+			Like `:for` above, but each item in {listlist} must be
 			a list, of which each item is assigned to {var1},
 			{var2}, etc.  Example: >
 				:for [lnum, col] in [[1, 3], [2, 5], [3, 8]]
@@ -11784,38 +3175,39 @@ text...
 				:endfor
 <
 						*:continue* *:con* *E586*
-:con[tinue]		When used inside a ":while" or ":for" loop, jumps back
+:con[tinue]		When used inside a `:while` or `:for` loop, jumps back
 			to the start of the loop.
-			If it is used after a |:try| inside the loop but
-			before the matching |:finally| (if present), the
-			commands following the ":finally" up to the matching
-			|:endtry| are executed first.  This process applies to
-			all nested ":try"s inside the loop.  The outermost
-			":endtry" then jumps back to the start of the loop.
+
+			If it is used after a `:try` inside the loop but
+			before the matching `:finally` (if present), the
+			commands following the `:finally` up to the matching
+			`:endtry` are executed first.  This process applies to
+			all nested `:try`s inside the loop.  The outermost
+			`:endtry` then jumps back to the start of the loop.
 
 						*:break* *:brea* *E587*
-:brea[k]		When used inside a ":while" or ":for" loop, skips to
-			the command after the matching ":endwhile" or
-			":endfor".
-			If it is used after a |:try| inside the loop but
-			before the matching |:finally| (if present), the
-			commands following the ":finally" up to the matching
-			|:endtry| are executed first.  This process applies to
-			all nested ":try"s inside the loop.  The outermost
-			":endtry" then jumps to the command after the loop.
+:brea[k]		When used inside a `:while` or `:for` loop, skips to
+			the command after the matching `:endwhile` or
+			`:endfor`.
+			If it is used after a `:try` inside the loop but
+			before the matching `:finally` (if present), the
+			commands following the `:finally` up to the matching
+			`:endtry` are executed first.  This process applies to
+			all nested `:try`s inside the loop.  The outermost
+			`:endtry` then jumps to the command after the loop.
 
 :try				*:try* *:endt* *:endtry* *E600* *E601* *E602*
 :endt[ry]		Change the error handling for the commands between
-			":try" and ":endtry" including everything being
-			executed across ":source" commands, function calls,
+			`:try` and `:endtry` including everything being
+			executed across `:source` commands, function calls,
 			or autocommand invocations.
 
 			When an error or interrupt is detected and there is
-			a |:finally| command following, execution continues
-			after the ":finally".  Otherwise, or when the
-			":endtry" is reached thereafter, the next
-			(dynamically) surrounding ":try" is checked for
-			a corresponding ":finally" etc.  Then the script
+			a `:finally` command following, execution continues
+			after the `:finally`.  Otherwise, or when the
+			`:endtry` is reached thereafter, the next
+			(dynamically) surrounding `:try` is checked for
+			a corresponding `:finally` etc.  Then the script
 			processing is terminated.  Whether a function
 			definition has an "abort" argument does not matter.
 			Example: >
@@ -11823,9 +3215,9 @@ text...
 		echomsg "not reached"
 <
 			Moreover, an error or interrupt (dynamically) inside
-			":try" and ":endtry" is converted to an exception.  It
-			can be caught as if it were thrown by a |:throw|
-			command (see |:catch|).  In this case, the script
+			`:try` and `:endtry` is converted to an exception.  It
+			can be caught as if it were thrown by a `:throw`
+			command (see `:catch`).  In this case, the script
 			processing is not terminated.
 
 			The value "Vim:Interrupt" is used for an interrupt
@@ -11841,22 +3233,22 @@ text...
 		try | edit | catch /^Vim(edit):E\d\+/ | echo "error" | endtry
 <
 					*:cat* *:catch* *E603* *E604* *E605*
-:cat[ch] /{pattern}/	The following commands until the next |:catch|,
-			|:finally|, or |:endtry| that belongs to the same
-			|:try| as the ":catch" are executed when an exception
+:cat[ch] /{pattern}/	The following commands until the next `:catch`,
+			`:finally`, or `:endtry` that belongs to the same
+			`:try` as the `:catch` are executed when an exception
 			matching {pattern} is being thrown and has not yet
-			been caught by a previous ":catch".  Otherwise, these
+			been caught by a previous `:catch`.  Otherwise, these
 			commands are skipped.
 			When {pattern} is omitted all errors are caught.
 			Examples: >
-		:catch /^Vim:Interrupt$/	" catch interrupts (CTRL-C)
-		:catch /^Vim\%((\a\+)\)\=:E/	" catch all Vim errors
-		:catch /^Vim\%((\a\+)\)\=:/	" catch errors and interrupts
-		:catch /^Vim(write):/		" catch all errors in :write
-		:catch /^Vim\%((\a\+)\)\=:E123/	" catch error E123
-		:catch /my-exception/		" catch user exception
-		:catch /.*/			" catch everything
-		:catch				" same as /.*/
+		:catch /^Vim:Interrupt$/	 " catch interrupts (CTRL-C)
+		:catch /^Vim\%((\a\+)\)\=:E/	 " catch all Vim errors
+		:catch /^Vim\%((\a\+)\)\=:/	 " catch errors and interrupts
+		:catch /^Vim(write):/		 " catch all errors in :write
+		:catch /^Vim\%((\a\+)\)\=:E123:/ " catch error E123
+		:catch /my-exception/		 " catch user exception
+		:catch /.*/			 " catch everything
+		:catch				 " same as /.*/
 <
 			Another character can be used instead of / around the
 			{pattern}, so long as it does not have a special
@@ -11869,27 +3261,27 @@ text...
 			locales.
 
 					*:fina* *:finally* *E606* *E607*
-:fina[lly]		The following commands until the matching |:endtry|
+:fina[lly]		The following commands until the matching `:endtry`
 			are executed whenever the part between the matching
-			|:try| and the ":finally" is left:  either by falling
-			through to the ":finally" or by a |:continue|,
-			|:break|, |:finish|, or |:return|, or by an error or
-			interrupt or exception (see |:throw|).
+			`:try` and the `:finally` is left:  either by falling
+			through to the `:finally` or by a `:continue`,
+			`:break`, `:finish`, or `:return`, or by an error or
+			interrupt or exception (see `:throw`).
 
 							*:th* *:throw* *E608*
 :th[row] {expr1}	The {expr1} is evaluated and thrown as an exception.
-			If the ":throw" is used after a |:try| but before the
-			first corresponding |:catch|, commands are skipped
-			until the first ":catch" matching {expr1} is reached.
-			If there is no such ":catch" or if the ":throw" is
-			used after a ":catch" but before the |:finally|, the
-			commands following the ":finally" (if present) up to
-			the matching |:endtry| are executed.  If the ":throw"
-			is after the ":finally", commands up to the ":endtry"
-			are skipped.  At the ":endtry", this process applies
-			again for the next dynamically surrounding ":try"
+			If the `:throw` is used after a `:try` but before the
+			first corresponding `:catch`, commands are skipped
+			until the first `:catch` matching {expr1} is reached.
+			If there is no such `:catch` or if the `:throw` is
+			used after a `:catch` but before the `:finally`, the
+			commands following the `:finally` (if present) up to
+			the matching `:endtry` are executed.  If the `:throw`
+			is after the `:finally`, commands up to the `:endtry`
+			are skipped.  At the `:endtry`, this process applies
+			again for the next dynamically surrounding `:try`
 			(which may be found in a calling function or sourcing
-			script), until a matching ":catch" has been found.
+			script), until a matching `:catch` has been found.
 			If the exception is not caught, the command processing
 			is terminated.
 			Example: >
@@ -11904,7 +3296,7 @@ text...
 			Also see |:comment|.
 			Use "\n" to start a new line.  Use "\r" to move the
 			cursor to the first column.
-			Uses the highlighting set by the |:echohl| command.
+			Uses the highlighting set by the `:echohl` command.
 			Cannot be followed by a comment.
 			Example: >
 		:echo "the value of 'shell' is" &shell
@@ -11913,9 +3305,9 @@ text...
 			And since Vim mostly postpones redrawing until it's
 			finished with a sequence of commands this happens
 			quite often.  To avoid that a command from before the
-			":echo" causes a redraw afterwards (redraws are often
+			`:echo` causes a redraw afterwards (redraws are often
 			postponed until you type something), force a redraw
-			with the |:redraw| command.  Example: >
+			with the `:redraw` command.  Example: >
 		:new | redraw | echo "there is a new window"
 <							*:echo-self-refer*
 			When printing nested containers echo prints second
@@ -11934,13 +3326,13 @@ text...
 							*:echon*
 :echon {expr1} ..	Echoes each {expr1}, without anything added.  Also see
 			|:comment|.
-			Uses the highlighting set by the |:echohl| command.
+			Uses the highlighting set by the `:echohl` command.
 			Cannot be followed by a comment.
 			Example: >
 				:echon "the value of 'shell' is " &shell
 <
-			Note the difference between using ":echo", which is a
-			Vim command, and ":!echo", which is an external shell
+			Note the difference between using `:echo`, which is a
+			Vim command, and `:!echo`, which is an external shell
 			command: >
 		:!echo %		--> filename
 <			The arguments of ":!" are expanded, see |:_%|. >
@@ -11956,8 +3348,8 @@ text...
 
 							*:echoh* *:echohl*
 :echoh[l] {name}	Use the highlight group {name} for the following
-			|:echo|, |:echon| and |:echomsg| commands.  Also used
-			for the |input()| prompt.  Example: >
+			`:echo`, `:echon` and `:echomsg` commands.  Also used
+			for the `input()` prompt.  Example: >
 		:echohl WarningMsg | echo "Don't panic!" | echohl None
 <			Don't forget to set the group back to "None",
 			otherwise all following echo's will be highlighted.
@@ -11966,14 +3358,14 @@ text...
 :echom[sg] {expr1} ..	Echo the expression(s) as a true message, saving the
 			message in the |message-history|.
 			Spaces are placed between the arguments as with the
-			|:echo| command.  But unprintable characters are
+			`:echo` command.  But unprintable characters are
 			displayed, not interpreted.
-			The parsing works slightly different from |:echo|,
-			more like |:execute|.  All the expressions are first
+			The parsing works slightly different from `:echo`,
+			more like `:execute`.  All the expressions are first
 			evaluated and concatenated before echoing anything.
 			If expressions does not evaluate to a Number or
 			String, string() is used to turn it into a string.
-			Uses the highlighting set by the |:echohl| command.
+			Uses the highlighting set by the `:echohl` command.
 			Example: >
 		:echomsg "It's a Zizzer Zazzer Zuzz, as you can plainly see."
 <			See |:echo-redraw| to avoid the message disappearing
@@ -11983,12 +3375,12 @@ text...
 			message in the |message-history|.  When used in a
 			script or function the line number will be added.
 			Spaces are placed between the arguments as with the
-			|:echomsg| command.  When used inside a try conditional,
+			`:echomsg` command.  When used inside a try conditional,
 			the message is raised as an error exception instead
 			(see |try-echoerr|).
 			Example: >
 		:echoerr "This script just failed!"
-<			If you just want a highlighted message use |:echohl|.
+<			If you just want a highlighted message use `:echohl`.
 			And to get a beep: >
 		:exe "normal \<Esc>"
 <
@@ -12293,7 +3685,7 @@ exception most recently caught as long it is not finished.
 
 	:function! Caught()
 	:  if v:exception != ""
-	:    echo 'Caught "' . v:exception . '" in ' . v:throwpoint
+	:    echo 'Caught "' .. v:exception .. '" in ' .. v:throwpoint
 	:  else
 	:    echo 'Nothing caught'
 	:  endif
@@ -12696,8 +4088,8 @@ a script in order to catch unexpected things.
 	:catch /^Vim:Interrupt$/
 	:    echo "Script interrupted"
 	:catch /.*/
-	:  echo "Internal error (" . v:exception . ")"
-	:  echo " - occurred at " . v:throwpoint
+	:  echo "Internal error (" .. v:exception .. ")"
+	:  echo " - occurred at " .. v:throwpoint
 	:endtry
 	:" end of script
 
@@ -12893,7 +4285,7 @@ parentheses can be cut out from |v:exception| with the ":substitute" command.
 
 	:function! CheckRange(a, func)
 	:  if a:a < 0
-	:    throw "EXCEPT:MATHERR:RANGE(" . a:func . ")"
+	:    throw "EXCEPT:MATHERR:RANGE(" .. a:func .. ")"
 	:  endif
 	:endfunction
 	:
@@ -12920,13 +4312,13 @@ parentheses can be cut out from |v:exception| with the ":substitute" command.
 	:  try
 	:    execute "write" fnameescape(a:file)
 	:  catch /^Vim(write):/
-	:    throw "EXCEPT:IO(" . getcwd() . ", " . a:file . "):WRITEERR"
+	:    throw "EXCEPT:IO(" .. getcwd() .. ", " .. a:file .. "):WRITEERR"
 	:  endtry
 	:endfunction
 	:
 	:try
 	:
-	:  " something with arithmetics and I/O
+	:  " something with arithmetic and I/O
 	:
 	:catch /^EXCEPT:MATHERR:RANGE/
 	:  let function = substitute(v:exception, '.*(\(\a\+\)).*', '\1', "")
@@ -12939,9 +4331,9 @@ parentheses can be cut out from |v:exception| with the ":substitute" command.
 	:  let dir = substitute(v:exception, '.*(\(.\+\),\s*.\+).*', '\1', "")
 	:  let file = substitute(v:exception, '.*(.\+,\s*\(.\+\)).*', '\1', "")
 	:  if file !~ '^/'
-	:    let file = dir . "/" . file
+	:    let file = dir .. "/" .. file
 	:  endif
-	:  echo 'I/O error for "' . file . '"'
+	:  echo 'I/O error for "' .. file .. '"'
 	:
 	:catch /^EXCEPT/
 	:  echo "Unspecified error"
@@ -13009,7 +4401,7 @@ clauses, however, is executed.
 	:    echo "inner finally"
 	:  endtry
 	:catch
-	:  echo 'outer catch-all caught "' . v:exception . '"'
+	:  echo 'outer catch-all caught "' .. v:exception .. '"'
 	:  finally
 	:    echo "outer finally"
 	:endtry
@@ -13071,7 +4463,7 @@ Printing in Binary ~
   :  let n = a:nr
   :  let r = ""
   :  while n
-  :    let r = '01'[n % 2] . r
+  :    let r = '01'[n % 2] .. r
   :    let n = n / 2
   :  endwhile
   :  return r
@@ -13082,7 +4474,7 @@ Printing in Binary ~
   :func String2Bin(str)
   :  let out = ''
   :  for ix in range(strlen(a:str))
-  :    let out = out . '-' . Nr2Bin(char2nr(a:str[ix]))
+  :    let out = out .. '-' .. Nr2Bin(char2nr(a:str[ix]))
   :  endfor
   :  return out[1:]
   :endfunc
diff --git a/runtime/doc/filetype.txt b/runtime/doc/filetype.txt
index fdd9c8c12e..7fff74a963 100644
--- a/runtime/doc/filetype.txt
+++ b/runtime/doc/filetype.txt
@@ -131,26 +131,42 @@ shell script: "#!/bin/csh".
 argument was used.
 
 							*filetype-overrule*
-When the same extension is used for two filetypes, Vim tries to guess what
-kind of file it is.  This doesn't always work.  A number of global variables
-can be used to overrule the filetype used for certain extensions:
+When the same extension is used for multiple filetypes, Vim tries to guess
+what kind of file it is.  This doesn't always work.  A number of global
+variables can be used to overrule the filetype used for certain extensions:
 
 	file name	variable ~
 	*.asa		g:filetype_asa	|ft-aspvbs-syntax| |ft-aspperl-syntax|
 	*.asm		g:asmsyntax	|ft-asm-syntax|
 	*.asp		g:filetype_asp	|ft-aspvbs-syntax| |ft-aspperl-syntax|
-	*.fs		g:filetype_fs   |ft-forth-syntax|
+	*.bas		g:filetype_bas	|ft-basic-syntax|
+	*.cfg		g:filetype_cfg
+	*.cls		g:filetype_cls
+	*.csh		g:filetype_csh	|ft-csh-syntax|
+	*.dat		g:filetype_dat
+	*.frm		g:filetype_frm	|ft-form-syntax|
+	*.fs		g:filetype_fs	|ft-forth-syntax|
 	*.i		g:filetype_i	|ft-progress-syntax|
 	*.inc		g:filetype_inc
 	*.m		g:filetype_m	|ft-mathematica-syntax|
+	*.mod		g:filetype_mod
 	*.p		g:filetype_p	|ft-pascal-syntax|
 	*.pl		g:filetype_pl
 	*.pp		g:filetype_pp	|ft-pascal-syntax|
 	*.prg		g:filetype_prg
+	*.r		g:filetype_r
+	*.sig		g:filetype_sig
+	*.sql		g:filetype_sql	|ft-sql-syntax|
+	*.src		g:filetype_src
+	*.sys		g:filetype_sys
 	*.sh		g:bash_is_sh	|ft-sh-syntax|
 	*.tex		g:tex_flavor	|ft-tex-plugin|
 	*.w		g:filetype_w	|ft-cweb-syntax|
 
+For a few filetypes the global variable is used only when the filetype could
+not be detected:
+	*.r		g:filetype_r	|ft-rexx-syntax|
+
 							*filetype-ignore*
 To avoid that certain files are being inspected, the g:ft_ignore_pat variable
 is used.  The default value is set like this: >
@@ -161,7 +177,9 @@ This means that the contents of compressed files are not inspected.
 If a file type that you want to use is not detected yet, there are a few ways
 to add it.  In any way, it's better not to modify the $VIMRUNTIME/filetype.lua
 or $VIMRUNTIME/filetype.vim files.  They will be overwritten when installing a
-new version of Nvim.
+new version of Nvim. The following explains the legacy Vim mechanism (enabled
+if |do_legacy_filetype| is set). For Nvim's default mechanism, see
+|vim.filetype.add()|.
 
 A. If you want to overrule all default file type checks.
    This works by writing one file for each filetype.  The disadvantage is that
@@ -220,36 +238,8 @@ C. If your file type can be detected by the file name or extension.
       Write this file as "filetype.vim" in your user runtime directory.  For
       example, for Unix: >
 	:w ~/.config/nvim/filetype.vim
-<
-      Alternatively, create a file called "filetype.lua" that adds new
-      filetypes.
-      Example: >
-	vim.filetype.add({
-	  extension = {
-	    foo = "fooscript",
-	  },
-	  filename = {
-	    [".foorc"] = "foorc",
-	  },
-	  pattern = {
-	    [".*/etc/foo/.*%.conf"] = "foorc",
-	  },
-	})
-<
-      See |vim.filetype.add()|.
-						     *g:do_filetype_lua*
-      For now, Lua filetype detection is opt-in. You can enable it by adding
-      the following to your |init.vim|: >
-        let g:do_filetype_lua = 1
-<						     *g:did_load_filetypes*
-      In either case, the builtin filetype detection provided by Nvim can be
-      disabled by setting the did_load_filetypes global variable. If this
-      variable exists, $VIMRUNTIME/filetype.vim will not run.
-      Example: >
-	" Disable filetype.vim
-	let g:did_load_filetypes = 1
 
-<  3. To use the new filetype detection you must restart Vim.
+<   3. To use the new filetype detection you must restart Vim.
 
    Your filetype.vim will be sourced before the default FileType autocommands
    have been installed.  Your autocommands will match first, and the
@@ -296,6 +286,16 @@ the 'runtimepath' for a directory to use.  If there isn't one, set
 'runtimepath' in the |system-vimrc|.  Be careful to keep the default
 directories!
 
+						     *g:do_legacy_filetype*
+To disable Nvim's default filetype detection and revert to Vim's legacy
+filetype detection, add the following to your |init.vim|: >
+  let g:do_legacy_filetype = 1
+<						     *g:did_load_filetypes*
+The builtin filetype detection provided by Nvim can be disabled by setting
+the `did_load_filetypes` global variable. If this variable exists, neither
+the default `$VIMRUNTIME/filetype.lua` nor the legacy `$VIMRUNTIME/filetype.vim`
+will run.
+
 							*plugin-details*
 The "plugin" directory can be in any of the directories in the 'runtimepath'
 option.  All of these directories will be searched for plugins and they are
@@ -534,12 +534,31 @@ Options:
 For further discussion of fortran_have_tabs and the method used for the
 detection of source format see |ft-fortran-syntax|.
 
+
+FREEBASIC						*ft-freebasic-plugin*
+
+This plugin aims to treat the four FreeBASIC dialects, "fb", "qb", "fblite"
+and "deprecated", as distinct languages.
+
+The dialect will be set to the first name found in g:freebasic_forcelang, any
+#lang directive or $lang metacommand in the file being edited, or finally
+g:freebasic_lang.  These global variables conceptually map to the fbc options
+-forcelang and -lang.  If no dialect is explicitly specified "fb" will be
+used.
+
+For example, to set the dialect to a default of "fblite" but still allow for
+any #lang directive overrides, use the following command: >
+
+     let g:freebasic_lang = "fblite"
+
+
 GIT COMMIT                                              *ft-gitcommit-plugin*
 
 One command, :DiffGitCached, is provided to show a diff of the current commit
 in the preview window.  It is equivalent to calling "git diff --cached" plus
 any arguments given to the command.
 
+
 GPROF							*ft-gprof-plugin*
 
 The gprof filetype plugin defines a mapping <C-]> to jump from a function
@@ -549,6 +568,7 @@ to the details of that function in the call graph.
 The mapping can be disabled with: >
 	let g:no_gprof_maps = 1
 
+
 MAIL							*ft-mail-plugin*
 
 Options:
diff --git a/runtime/doc/fold.txt b/runtime/doc/fold.txt
index 80c934d13b..9e3d78faff 100644
--- a/runtime/doc/fold.txt
+++ b/runtime/doc/fold.txt
@@ -497,11 +497,13 @@ Note the use of backslashes to avoid some characters to be interpreted by the
     :function MyFoldText()
     :  let line = getline(v:foldstart)
     :  let sub = substitute(line, '/\*\|\*/\|{{{\d\=', '', 'g')
-    :  return v:folddashes . sub
+    :  return v:folddashes .. sub
     :endfunction
 
 Evaluating 'foldtext' is done in the |sandbox|.  The current window is set to
-the window that displays the line.  Errors are ignored.
+the window that displays the line.
+
+Errors are ignored.  For debugging set the 'debug' option to "throw".
 
 The default value is |foldtext()|.  This returns a reasonable text for most
 types of folding.  If you don't like it, you can specify your own 'foldtext'
diff --git a/runtime/doc/ft_ada.txt b/runtime/doc/ft_ada.txt
index 771ccc3302..f6dfa708fb 100644
--- a/runtime/doc/ft_ada.txt
+++ b/runtime/doc/ft_ada.txt
@@ -89,9 +89,9 @@ file is opened and adds Ada related entries to the main and pop-up menu.
 								 *ft-ada-omni*
 
 The Ada omni-completions (|i_CTRL-X_CTRL-O|) uses tags database created either
-by "gnat xref -v" or the "exuberant Ctags (http://ctags.sourceforge.net).  The
-complete function will automatically detect which tool was used to create the
-tags file.
+by "gnat xref -v" or the "Universal Ctags" (https://ctags.io).  The complete
+function will automatically detect which tool was used to create the tags
+file.
 
 ------------------------------------------------------------------------------
 3.1 Omni Completion with "gnat xref" ~
@@ -125,18 +125,18 @@ NOTE: "gnat xref -v" is very tricky to use as it has almost no diagnostic
 3.2 Omni Completion with "ctags"~
 								   *ada-ctags*
 
-Exuberant Ctags uses its own multi-language code parser. The parser is quite
-fast, produces a lot of extra information (hence the name "Exuberant Ctags")
-and can run on files which currently do not compile.
+Universal/Exuberant Ctags use their own multi-language code parser.  The
+parser is quite fast, produces a lot of extra information and can run on files
+which currently do not compile.
 
-There are also lots of other Vim-tools which use exuberant Ctags.
+There are also lots of other Vim-tools which use Universal/Exuberant Ctags.
+Universal Ctags is preferred, Exuberant Ctags is no longer being developed.
 
-You will need to install a version of the Exuberant Ctags which has Ada
-support patched in. Such a version is available from the GNU Ada Project
-(http://gnuada.sourceforge.net).
+You will need to install Universal Ctags which is available from
+https://ctags.io
 
-The Ada parser for Exuberant Ctags is fairly new - don't expect complete
-support yet.
+The Ada parser for Universal/Exuberant Ctags is fairly new - don't expect
+complete support yet.
 
 ==============================================================================
 4. Compiler Support ~
diff --git a/runtime/doc/ft_raku.txt b/runtime/doc/ft_raku.txt
index 00b140ee9c..3d1179ed4e 100644
--- a/runtime/doc/ft_raku.txt
+++ b/runtime/doc/ft_raku.txt
@@ -47,20 +47,20 @@ Numbers, subscripts and superscripts are available with 's' and 'S':
 
 But some don't come defined by default. Those are digraph definitions you can
 add in your ~/.vimrc file. >
-	exec 'digraph \\ '.char2nr('∖')
-	exec 'digraph \< '.char2nr('≼')
-	exec 'digraph \> '.char2nr('≽')
-	exec 'digraph (L '.char2nr('⊈')
-	exec 'digraph )L '.char2nr('⊉')
-	exec 'digraph (/ '.char2nr('⊄')
-	exec 'digraph )/ '.char2nr('⊅')
-	exec 'digraph )/ '.char2nr('⊅')
-	exec 'digraph U+ '.char2nr('⊎')
-	exec 'digraph 0- '.char2nr('⊖')
+	exec 'digraph \\ ' .. char2nr('∖')
+	exec 'digraph \< ' .. char2nr('≼')
+	exec 'digraph \> ' .. char2nr('≽')
+	exec 'digraph (L ' .. char2nr('⊈')
+	exec 'digraph )L ' .. char2nr('⊉')
+	exec 'digraph (/ ' .. char2nr('⊄')
+	exec 'digraph )/ ' .. char2nr('⊅')
+	exec 'digraph )/ ' .. char2nr('⊅')
+	exec 'digraph U+ ' .. char2nr('⊎')
+	exec 'digraph 0- ' .. char2nr('⊖')
 	" Euler's constant
-	exec 'digraph ne '.char2nr('𝑒')
+	exec 'digraph ne ' .. char2nr('𝑒')
 	" Raku's atomic operations marker
-	exec 'digraph @@ '.char2nr('⚛')
+	exec 'digraph @@ ' .. char2nr('⚛')
 
 Alternatively, you can write Insert mode abbreviations that convert ASCII-
 based operators into their single-character Unicode equivalent. >
diff --git a/runtime/doc/ft_rust.txt b/runtime/doc/ft_rust.txt
index ff2e0ca56f..5c8782ec7a 100644
--- a/runtime/doc/ft_rust.txt
+++ b/runtime/doc/ft_rust.txt
@@ -26,7 +26,7 @@ behavior of the plugin.
 g:rustc_path~
 	Set this option to the path to rustc for use in the |:RustRun| and
 	|:RustExpand| commands. If unset, "rustc" will be located in $PATH: >
-	    let g:rustc_path = $HOME."/bin/rustc"
+	    let g:rustc_path = $HOME .. "/bin/rustc"
 <
 
                                                   *g:rustc_makeprg_no_percent*
@@ -87,7 +87,7 @@ g:rust_bang_comment_leader~
 g:ftplugin_rust_source_path~
 	Set this option to a path that should be prepended to 'path' for Rust
 	source files: >
-	    let g:ftplugin_rust_source_path = $HOME.'/dev/rust'
+	    let g:ftplugin_rust_source_path = $HOME .. '/dev/rust'
 <
 
                                                        *g:rustfmt_command*
diff --git a/runtime/doc/ft_sql.txt b/runtime/doc/ft_sql.txt
index 53a99a9e1d..6972fe0768 100644
--- a/runtime/doc/ft_sql.txt
+++ b/runtime/doc/ft_sql.txt
@@ -109,8 +109,8 @@ must be configurable.  The filetype plugin attempts to define many of the
 standard objects, plus many additional ones.  In order to make this as
 flexible as possible, you can override the list of objects from within your
 |vimrc| with the following: >
-    let g:ftplugin_sql_objects = 'function,procedure,event,table,trigger' .
-		\ ',schema,service,publication,database,datatype,domain' .
+    let g:ftplugin_sql_objects = 'function,procedure,event,table,trigger' ..
+		\ ',schema,service,publication,database,datatype,domain' ..
 		\ ',index,subscription,synchronization,view,variable'
 
 The following |Normal| mode and |Visual| mode maps have been created which use
@@ -131,10 +131,10 @@ Repeatedly pressing ]} will cycle through each of these create statements: >
     create index i1 on t1 (c1);
 
 The default setting for g:ftplugin_sql_objects is: >
-    let g:ftplugin_sql_objects = 'function,procedure,event,' .
-		\ '\\(existing\\\\|global\\s\\+temporary\\s\\+\\)\\\{,1}' .
-		\ 'table,trigger' .
-		\ ',schema,service,publication,database,datatype,domain' .
+    let g:ftplugin_sql_objects = 'function,procedure,event,' ..
+		\ '\\(existing\\\\|global\\s\\+temporary\\s\\+\\)\\\{,1}' ..
+		\ 'table,trigger' ..
+		\ ',schema,service,publication,database,datatype,domain' ..
 		\ ',index,subscription,synchronization,view,variable'
 
 The above will also handle these cases: >
@@ -555,7 +555,7 @@ the SQL completion plugin. >
 <	1. After typing SELECT press <C-C>t to display a list of tables.
 	2. Highlight the table you need the column list for.
 	3. Press <Enter> to choose the table from the list.
-	4. Press <C-C>l to request a comma separated list of all columns
+	4. Press <C-C>l to request a comma-separated list of all columns
 	   for this table.
 	5. Based on the table name chosen in step 3, the plugin attempts to
 	   decide on a reasonable table alias.	You are then prompted to
@@ -609,7 +609,7 @@ your |init.vim|: >
 >
     omni_sql_use_tbl_alias
 <	- Default: a
-	- This setting is only used when generating a comma separated
+	- This setting is only used when generating a comma-separated
 	  column list.	By default the map is <C-C>l.  When generating
 	  a column list, an alias can be prepended to the beginning of each
 	  column, for example:	e.emp_id, e.emp_name.  This option has three
@@ -693,9 +693,9 @@ plugin. >
     <C-C>c
 <       - Displays a list of columns for a specific table. >
     <C-C>l
-<       - Displays a comma separated list of columns for a specific table. >
+<       - Displays a comma-separated list of columns for a specific table. >
     <C-C>L
-<       - Displays a comma separated list of columns for a specific table.
+<       - Displays a comma-separated list of columns for a specific table.
 	  This should only be used when the completion window is active. >
     <Right>
 <	- Displays a list of columns for the table currently highlighted in
diff --git a/runtime/doc/gui.txt b/runtime/doc/gui.txt
index 812259741f..776ff228d6 100644
--- a/runtime/doc/gui.txt
+++ b/runtime/doc/gui.txt
@@ -195,6 +195,10 @@ the mouse button down on this will pop up a menu containing the item
 "Big Changes", which is a sub-menu containing the item "Delete All Spaces",
 which when selected, performs the operation.
 
+To create a menu for terminal mode, use |:tlmenu| instead of |:tmenu| unlike
+key mapping (|:tmap|). This is because |:tmenu| is already used for defining
+tooltips for menus. See |terminal-input|.
+
 Special characters in a menu name:
 
 	&	The next character is the shortcut key.  Make sure each
@@ -214,9 +218,9 @@ this menu can be used.  The second part is shown as "Open     :e".  The ":e"
 is right aligned, and the "O" is underlined, to indicate it is the shortcut.
 
 					*:am*  *:amenu*  *:an*      *:anoremenu*
-The ":amenu" command can be used to define menu entries for all modes at once.
-To make the command work correctly, a character is automatically inserted for
-some modes:
+The ":amenu" command can be used to define menu entries for all modes at once,
+expect for Terminal mode.  To make the command work correctly, a character is
+automatically inserted for some modes:
 	mode		inserted	appended	~
 	Normal		nothing		nothing
 	Visual		<C-C>		<C-\><C-G>
@@ -224,9 +228,6 @@ some modes:
 	Cmdline		<C-C>		<C-\><C-G>
 	Op-pending	<C-C>		<C-\><C-G>
 
-Appending CTRL-\ CTRL-G is for going back to insert mode when 'insertmode' is
-set. |CTRL-\_CTRL-G|
-
 Example: >
 
    :amenu File.Next	:next^M
@@ -440,6 +441,19 @@ You can define the special menu "PopUp".  This is the menu that is displayed
 when the right mouse button is pressed, if 'mousemodel' is set to popup or
 popup_setpos.
 
+The default "PopUp" menu is: >
+    aunmenu PopUp
+    vnoremenu PopUp.Cut                         "+x
+    vnoremenu PopUp.Copy                        "+y
+    anoremenu PopUp.Paste                       "+gP
+    vnoremenu PopUp.Paste                       "+P
+    vnoremenu PopUp.Delete                      "_x
+    nnoremenu PopUp.Select\ All>                ggVG
+    vnoremenu PopUp.Select\ All>                gg0oG$
+    inoremenu PopUp.Select\ All                 <C-Home><C-O>VG
+    anoremenu PopUp.-1-                         <Nop>
+    anoremenu PopUp.How-to\ disable\ mouse      <Cmd>help disable-mouse<CR>
+<
 
 Showing What Menus Are Mapped To			*showing-menus*
 
@@ -472,6 +486,16 @@ Executing Menus						*execute-menus*
 				insert-mode menu Eg: >
 	:emenu File.Exit
 
+:[range]em[enu] {mode} {menu}	Like above, but execute the menu for {mode}:
+				    'n': |:nmenu|  Normal mode
+				    'v': |:vmenu|  Visual mode
+				    's': |:smenu|  Select mode
+				    'o': |:omenu|  Operator-pending mode
+				    't': |:tlmenu| Terminal mode
+				    'i': |:imenu|  Insert mode
+				    'c': |:cmenu|  Cmdline mode
+
+
 You can use :emenu to access useful menu items you may have got used to from
 GUI mode.  See 'wildmenu' for an option that works well with this.  See
 |console-menus| for an example.
@@ -497,7 +521,9 @@ may be used to complete the name of the menu item for the appropriate mode.
 To remove all menus use:			*:unmenu-all*  >
 	:unmenu *	" remove all menus in Normal and visual mode
 	:unmenu! *	" remove all menus in Insert and Command-line mode
-	:aunmenu *	" remove all menus in all modes
+	:aunmenu *	" remove all menus in all modes, except for Terminal
+			" mode
+	:tlunmenu *	" remove all menus in Terminal mode
 
 If you want to get rid of the menu bar: >
 	:set guioptions-=m
@@ -550,6 +576,8 @@ See section |42.4| in the user manual.
 :tu[nmenu] {menupath}		Remove a tip for a menu or tool.
 				{only in X11 and Win32 GUI}
 
+Note: To create menus for terminal mode, use |:tlmenu| instead.
+
 When a tip is defined for a menu item, it appears in the command-line area
 when the mouse is over that item, much like a standard Windows menu hint in
 the status bar.  (Except when Vim is in Command-line mode, when of course
@@ -580,8 +608,8 @@ a menu item - you don't need to do a :tunmenu as well.
 
 5.9 Popup Menus
 
-In the Win32 GUI, you can cause a menu to popup at the cursor.  This behaves
-similarly to the PopUp menus except that any menu tree can be popped up.
+You can cause a menu to popup at the cursor.  This behaves similarly to the
+PopUp menus except that any menu tree can be popped up.
 
 This command is for backwards compatibility, using it is discouraged, because
 it behaves in a strange way.
@@ -590,7 +618,6 @@ it behaves in a strange way.
 :popu[p] {name}			Popup the menu {name}.  The menu named must
 				have at least one subentry, but need not
 				appear on the menu-bar (see |hidden-menus|).
-				{only available for Win32 GUI}
 
 :popu[p]! {name}		Like above, but use the position of the mouse
 				pointer instead of the cursor.
diff --git a/runtime/doc/help.txt b/runtime/doc/help.txt
index 173d3c0cdf..b97c9a2e3f 100644
--- a/runtime/doc/help.txt
+++ b/runtime/doc/help.txt
@@ -129,6 +129,7 @@ Advanced editing ~
 |diff.txt|	working with two to eight versions of the same file
 |autocmd.txt|	automatically executing commands on an event
 |eval.txt|	expression evaluation, conditional commands
+|builtin.txt|	builtin functions
 |fold.txt|	hide (fold) ranges of lines
 |lua.txt|	Lua API
 |api.txt|	Nvim API via RPC, Lua and VimL
diff --git a/runtime/doc/helphelp.txt b/runtime/doc/helphelp.txt
index 03ec8966d4..569995d319 100644
--- a/runtime/doc/helphelp.txt
+++ b/runtime/doc/helphelp.txt
@@ -358,7 +358,7 @@ When referring to a Vim option in the help file, place the option name between
 two single quotes, eg. 'statusline'
 
 When referring to any other technical term, such as a filename or function
-parameter, surround it in backticks (`), eg. `~/.path/to/init.vim`.
+parameter, surround it in backticks, eg. `~/.path/to/init.vim`.
 
 
 HIGHLIGHTING
diff --git a/runtime/doc/if_pyth.txt b/runtime/doc/if_pyth.txt
index fea47de220..9b434e61d7 100644
--- a/runtime/doc/if_pyth.txt
+++ b/runtime/doc/if_pyth.txt
@@ -1,10 +1,10 @@
 *if_pyth.txt*   Nvim
 
 
-		  VIM REFERENCE MANUAL    by Paul Moore
+		  NVIM REFERENCE MANUAL
 
 
-The Python Interface to Vim				*if_pyth* *python* *Python*
+The Python Interface to NVim				*if_pyth* *python* *Python*
 
 See |provider-python| for more information.
 
@@ -134,7 +134,7 @@ Instead, put the Python command in a function and call that function:
 Note that "EOF" must be at the start of the line.
 
 ==============================================================================
-The vim module						*python-vim* *python2*
+The vim module							*python-vim*
 
 Python code gets all of its access to vim (with one exception - see
 |python-output| below) via the "vim" module.  The vim module implements two
@@ -322,14 +322,13 @@ Output from Python					*python-output*
 	supported, and may cause the program to crash.  This should probably be
 	fixed.
 
-		    *python2-directory* *python3-directory* *pythonx-directory*
+				  *python3-directory* *pythonx-directory*
 Python 'runtimepath' handling				*python-special-path*
 
 In python vim.VIM_SPECIAL_PATH special directory is used as a replacement for
 the list of paths found in 'runtimepath': with this directory in sys.path and
 vim.path_hooks in sys.path_hooks python will try to load module from
-{rtp}/python2 (or python3) and {rtp}/pythonx (for both python versions) for
-each {rtp} found in 'runtimepath'.
+{rtp}/python3 and {rtp}/pythonx for each {rtp} found in 'runtimepath'.
 
 Implementation is similar to the following, but written in C: >
 
@@ -401,8 +400,8 @@ vim._get_paths						*python-_get_paths*
 	hook. You should not rely on this method being present in future
 	versions, but can use it for debugging.
 
-	It returns a list of {rtp}/python2 (or {rtp}/python3) and
-	{rtp}/pythonx directories for each {rtp} in 'runtimepath'.
+	It returns a list of {rtp}/python3 and {rtp}/pythonx
+	directories for each {rtp} in 'runtimepath'.
 
 ==============================================================================
 Buffer objects						*python-buffer*
@@ -590,6 +589,11 @@ functions to evaluate Python expressions and pass their values to Vim script.
 ==============================================================================
 Python 3						*python3*
 
+As Python 3 is the only supported version in Nvim, "python" is synonymous
+with "python3" in the current version. However, code that aims to support older
+versions of Neovim, as well as Vim, should prefer to use "python3"
+variants explicitly if Python 3 is required.
+
 							*:py3* *:python3*
 :[range]py3 {stmt}
 :[range]py3 << [endmarker]
@@ -619,31 +623,26 @@ Raising SystemExit exception in python isn't endorsed way to quit vim, use: >
 	:py vim.command("qall!")
 <
 							*has-python*
-You can test what Python version is available with: >
-	if has('python')
-	  echo 'there is Python 2.x'
+You can test if Python is available with: >
+	if has('pythonx')
+	  echo 'there is Python'
 	endif
   	if has('python3')
 	  echo 'there is Python 3.x'
 	endif
 
+Python 2 is no longer supported. Thus `has('python')` always returns
+zero for backwards compatibility reasons.
+
 ==============================================================================
 Python X						*python_x* *pythonx*
 
-Because most python code can be written so that it works with Python 2.6+ and
-Python 3, the pyx* functions and commands have been written.  They work the
-same as the Python 2 and 3 variants, but select the Python version using the
-'pyxversion' setting.
-
-Set 'pyxversion' in your |vimrc| to prefer Python 2 or Python 3 for Python
-commands. Changing this setting at runtime risks losing the state of plugins
-(such as initialization).
-
-If you want to use a module, you can put it in the {rtp}/pythonx directory.
-See |pythonx-directory|.
+The "pythonx" and "pyx" prefixes were introduced for python code which
+works with Python 2.6+ and Python 3. As Nvim only supports Python 3,
+all these commands are now synonymous to their "python3" equivalents.
 
 							*:pyx* *:pythonx*
-`:pyx` and `:pythonx` work similar to `:python`.  To check if `:pyx` works: >
+`:pyx` and `:pythonx` work the same as `:python3`.  To check if `:pyx` works: >
 	:pyx print("Hello")
 
 To see what version of Python is being used: >
@@ -651,33 +650,15 @@ To see what version of Python is being used: >
 	:pyx print(sys.version)
 <
 					*:pyxfile* *python_x-special-comments*
-`:pyxfile` works similar to `:pyfile`.  But you can add a "shebang" comment to
-force Vim to use `:pyfile` or `:py3file`: >
-  #!/any string/python2		" Shebang. Must be the first line of the file.
-  #!/any string/python3		" Shebang. Must be the first line of the file.
-  # requires python 2.x		" Maximum lines depend on 'modelines'.
-  # requires python 3.x		" Maximum lines depend on 'modelines'.
-Unlike normal modelines, the bottom of the file is not checked.
-If none of them are found, the 'pyxversion' option is used.
-							*W20* *W21*
-If Vim does not support the selected Python version a silent message will be
-printed.  Use `:messages` to read them.
+`:pyxfile` works the same as `:py3file`. 
 
 							*:pyxdo*
-`:pyxdo` works similar to `:pydo`.
+`:pyxdo` works the same as `:py3do`.
 
 							*has-pythonx*
-To check if pyx* functions and commands are available: >
+To check if `pyx*` functions and commands are available: >
 	if has('pythonx')
-	  echo 'pyx* commands are available. (Python ' . &pyx . ')'
-	endif
-
-If you prefer Python 2 and want to fallback to Python 3, set 'pyxversion'
-explicitly in your |.vimrc|.  Example: >
-	if has('python')
-	  set pyx=2
-	elseif has('python3')
-	  set pyx=3
+	  echo 'pyx* commands are available. (Python ' .. &pyx .. ')'
 	endif
 
 ==============================================================================
diff --git a/runtime/doc/indent.txt b/runtime/doc/indent.txt
index a76f8636f8..1a1d8e30b0 100644
--- a/runtime/doc/indent.txt
+++ b/runtime/doc/indent.txt
@@ -38,11 +38,12 @@ is not a C compiler: it does not recognize all syntax.  One requirement is
 that toplevel functions have a '{' in the first column.  Otherwise they are
 easily confused with declarations.
 
-These four options control C program indenting:
+These five options control C program indenting:
 'cindent'	Enables Vim to perform C program indenting automatically.
 'cinkeys'	Specifies which keys trigger reindenting in insert mode.
 'cinoptions'	Sets your preferred indent style.
 'cinwords'	Defines keywords that start an extra indent in the next line.
+'cinscopedecls'	Defines strings that are recognized as a C++ scope declaration.
 
 If 'lisp' is not on and 'equalprg' is empty, the "=" operator indents using
 Vim's built-in algorithm rather than calling an external program.
@@ -289,8 +290,9 @@ The examples below assume a 'shiftwidth' of 4.
 <
 							*cino-g*
 	gN    Place C++ scope declarations N characters from the indent of the
-	      block they are in.  (default 'shiftwidth').  A scope declaration
-	      can be "public:", "protected:" or "private:".
+	      block they are in.  (default 'shiftwidth'). By default, a scope
+	      declaration is "public:", "protected:" or "private:". This can
+	      be adjusted with the 'cinscopedecls' option.
 
 		cino=		    cino=g0 >
 		  {		      {
@@ -771,6 +773,15 @@ You can set the indent for the first line after <script> and <style>
       "auto"	auto indent (same indent as the blocktag)
       "inc"	auto indent + one indent step
 
+You can set the indent for attributes after an open <tag line: >
+
+      :let g:html_indent_attribute = 1
+<
+      VALUE	MEANING ~
+      1		auto indent, one indent step more than <tag
+      2		auto indent, two indent steps (default)
+      > 2	auto indent, more indent steps
+
 Many tags increase the indent for what follows per default (see "Add Indent
 Tags" in the script).  You can add further tags with: >
 
diff --git a/runtime/doc/index.txt b/runtime/doc/index.txt
index d8689e2c65..25b98ae4ab 100644
--- a/runtime/doc/index.txt
+++ b/runtime/doc/index.txt
@@ -26,7 +26,7 @@ tag		char		action in Insert mode	~
 				insert
 |i_CTRL-A|	CTRL-A		insert previously inserted text
 |i_CTRL-C|	CTRL-C		quit insert mode, without checking for
-				abbreviation, unless 'insertmode' set.
+				abbreviation
 |i_CTRL-D|	CTRL-D		delete one shiftwidth of indent in the current
 				line
 |i_CTRL-E|	CTRL-E		insert the character which is below the cursor
@@ -50,7 +50,6 @@ tag		char		action in Insert mode	~
 |i_CTRL-J|	CTRL-J		same as <CR>
 |i_CTRL-K|	CTRL-K {char1} {char2}
 				enter digraph
-|i_CTRL-L|	CTRL-L		when 'insertmode' set: Leave Insert mode
 |i_<CR>|	<CR>		begin new line
 |i_CTRL-M|	CTRL-M		same as <CR>
 |i_CTRL-N|	CTRL-N		find next match for keyword in front of the
@@ -86,11 +85,10 @@ tag		char		action in Insert mode	~
 |i_CTRL-W|	CTRL-W		delete word before the cursor
 |i_CTRL-X|	CTRL-X {mode}	enter CTRL-X sub mode, see |i_CTRL-X_index|
 |i_CTRL-Y|	CTRL-Y		insert the character which is above the cursor
-|i_CTRL-Z|	CTRL-Z		when 'insertmode' set: suspend Vim
-|i_<Esc>|	<Esc>		end insert mode (unless 'insertmode' set)
+|i_<Esc>|	<Esc>		end insert mode
 |i_CTRL-[|	CTRL-[		same as <Esc>
 |i_CTRL-\_CTRL-N| CTRL-\ CTRL-N	go to Normal mode
-|i_CTRL-\_CTRL-G| CTRL-\ CTRL-G	go to mode specified with 'insertmode'
+|i_CTRL-\_CTRL-G| CTRL-\ CTRL-G	go to Normal mode
 		CTRL-\ a - z	reserved for extensions
 		CTRL-\ others	not used
 |i_CTRL-]|	CTRL-]		trigger abbreviation
@@ -221,7 +219,7 @@ tag		char	      note action in Normal mode	~
 |CTRL-Z|	CTRL-Z		   suspend program (or start new shell)
 		CTRL-[ <Esc>	   not used
 |CTRL-\_CTRL-N|	CTRL-\ CTRL-N	   go to Normal mode (no-op)
-|CTRL-\_CTRL-G|	CTRL-\ CTRL-G	   go to mode specified with 'insertmode'
+|CTRL-\_CTRL-G|	CTRL-\ CTRL-G	   go to Normal mode (no-op)
 		CTRL-\ a - z	   reserved for extensions
 		CTRL-\ others      not used
 |CTRL-]|	CTRL-]		   :ta to ident under cursor
@@ -284,7 +282,7 @@ tag		char	      note action in Normal mode	~
 |/|		/{pattern}<CR>	1  search forward for the Nth occurrence of
 				   {pattern}
 |/<CR>|		/<CR>		1  search forward for {pattern} of last search
-|count|		0		1  cursor to the first char of the line
+|0|		0		1  cursor to the first char of the line
 |count|		1		   prepend to command to give a count
 |count|		2			"
 |count|		3			"
@@ -353,6 +351,7 @@ tag		char	      note action in Normal mode	~
 				   register x]
 |Y|		["x]Y		   yank N lines [into register x]; synonym for
 				   "yy"
+				   Note: Mapped to "y$" by default. |default-mappings|
 |ZZ|		ZZ		   write if buffer changed and close window
 |ZQ|		ZQ		   close window without writing
 |[|		[{char}		   square bracket command (see |[| below)
@@ -430,6 +429,7 @@ tag		char	      note action in Normal mode	~
 |<C-LeftMouse>|	<C-LeftMouse>	   ":ta" to the keyword at the mouse click
 |<C-Right>|	<C-Right>	1  same as "w"
 |<C-RightMouse>| <C-RightMouse>	   same as "CTRL-T"
+|<C-Tab>|	<C-Tab>		   same as "g<Tab>"
 |<Del>|		["x]<Del>	2  same as "x"
 |N<Del>|	{count}<Del>	   remove the last digit from {count}
 |<Down>|	<Down>		1  same as "j"
@@ -576,7 +576,7 @@ tag		command		   action in Normal mode	~
 				   following the file name.
 |CTRL-W_gt|	CTRL-W g t	   same as `gt`: go to next tab page
 |CTRL-W_gT|	CTRL-W g T	   same as `gT`: go to previous tab page
-|CTRL-W_g<Tab>|	CTRL-W g <Tab>	   same as `g<Tab>` : go to last accessed tab
+|CTRL-W_g<Tab>|	CTRL-W g <Tab>	   same as |g<Tab>|: go to last accessed tab
 				   page
 |CTRL-W_h|	CTRL-W h	   go to Nth left window (stop at first window)
 |CTRL-W_i|	CTRL-W i	   split window and jump to declaration of
@@ -890,7 +890,7 @@ here are those that are different.
 tag		command	      note action in Visual mode	~
 ------------------------------------------------------------------------------
 |v_CTRL-\_CTRL-N| CTRL-\ CTRL-N	   stop Visual mode
-|v_CTRL-\_CTRL-G| CTRL-\ CTRL-G	   go to mode specified with 'insertmode'
+|v_CTRL-\_CTRL-G| CTRL-\ CTRL-G	   go to Normal mode
 |v_CTRL-A|	CTRL-A		2  add N to number in highlighted text
 |v_CTRL-C|	CTRL-C		   stop Visual mode
 |v_CTRL-G|	CTRL-G		   toggle between Visual mode and Select mode
@@ -923,7 +923,9 @@ tag		command	      note action in Visual mode	~
 				   before the highlighted area
 |v_J|		J		2  join the highlighted lines
 |v_K|		K		   run 'keywordprg' on the highlighted area
-|v_O|		O		   Move horizontally to other corner of area.
+|v_O|		O		   move horizontally to other corner of area
+|v_P|		P		   replace highlighted area with register
+				   contents; registers are unchanged
 		Q		   does not start Ex mode
 |v_R|		R		2  delete the highlighted lines and start
 				   insert
@@ -986,6 +988,8 @@ tag		command	      note action in Visual mode	~
 |v_i{|		i{		   same as iB
 |v_i}|		i}		   same as iB
 |v_o|		o		   move cursor to other corner of area
+|v_p|		p		   replace highlighted area with register
+				   contents; deleted text in unnamed register
 |v_r|		r		2  replace highlighted area with a character
 |v_s|		s		2  delete highlighted area and start insert
 |v_u|		u		2  make highlighted area lowercase
@@ -1062,8 +1066,7 @@ tag		command		action in Command-line editing mode	~
 |c_<Esc>|	<Esc>		abandon command-line without executing it
 |c_CTRL-[|	CTRL-[		same as <Esc>
 |c_CTRL-\_CTRL-N| CTRL-\ CTRL-N	go to Normal mode, abandon command-line
-|c_CTRL-\_CTRL-G| CTRL-\ CTRL-G	go to mode specified with 'insertmode',
-				abandon command-line
+|c_CTRL-\_CTRL-G| CTRL-\ CTRL-G	go to Normal mode, abandon command-line
 		CTRL-\ a - d	reserved for extensions
 |c_CTRL-\_e|	CTRL-\ e {expr} replace the command line with the result of
 				{expr}
@@ -1495,8 +1498,9 @@ tag		command		action ~
 |:recover|	:rec[over]	recover a file from a swap file
 |:redo|		:red[o]		redo one undone change
 |:redir|	:redi[r]	redirect messages to a file or register
-|:redraw|	:redr[aw]	  force a redraw of the display
-|:redrawstatus|	:redraws[tatus]	  force a redraw of the status line(s)
+|:redraw|	:redr[aw]	force a redraw of the display
+|:redrawstatus|	:redraws[tatus]	force a redraw of the status line(s) and
+				window bar(s)
 |:redrawtabline|  :redrawt[abline]  force a redraw of the tabline
 |:registers|	:reg[isters]	display the contents of registers
 |:resize|	:res[ize]	change current window height
@@ -1618,17 +1622,20 @@ tag		command		action ~
 |:tjump|	:tj[ump]	like ":tselect", but jump directly when there
 				is only one match
 |:tlast|	:tl[ast]	jump to last matching tag
-|:tmapclear|	:tmapc[lear]	remove all mappings for Terminal-Job mode
-|:tmap|		:tma[p]		like ":map" but for Terminal-Job mode
+|:tlmenu|	:tlm[enu]	add menu for |Terminal-mode|
+|:tlnoremenu|	:tln[oremenu]	like ":noremenu" but for |Terminal-mode|
+|:tlunmenu|	:tlu[nmenu]	remove menu for |Terminal-mode|
+|:tmapclear|	:tmapc[lear]	remove all mappings for |Terminal-mode|
+|:tmap|		:tma[p]		like ":map" but for |Terminal-mode|
 |:tmenu|	:tm[enu]	define menu tooltip
 |:tnext|	:tn[ext]	jump to next matching tag
-|:tnoremap|	:tno[remap]	like ":noremap" but for Terminal-Job mode
+|:tnoremap|	:tno[remap]	like ":noremap" but for |Terminal-mode|
 |:topleft|	:to[pleft]	make split window appear at top or far left
 |:tprevious|	:tp[revious]	jump to previous matching tag
 |:trewind|	:tr[ewind]	jump to first matching tag
 |:try|		:try		execute commands, abort on error or exception
 |:tselect|	:ts[elect]	list matching tags and select one
-|:tunmap|	:tunma[p]	like ":unmap" but for Terminal-Job mode
+|:tunmap|	:tunma[p]	like ":unmap" but for |Terminal-mode|
 |:tunmenu|	:tu[nmenu]	remove menu tooltip
 |:undo|		:u[ndo]		undo last change(s)
 |:undojoin|	:undoj[oin]	join next change with previous undo block
diff --git a/runtime/doc/insert.txt b/runtime/doc/insert.txt
index ae2b9c4418..a16d88b4e9 100644
--- a/runtime/doc/insert.txt
+++ b/runtime/doc/insert.txt
@@ -32,9 +32,6 @@ If you are working in a special language mode when inserting text, see the
 'langmap' option, |'langmap'|, on how to avoid switching this mode on and off
 all the time.
 
-If you have 'insertmode' set, <Esc> and a few other keys get another meaning.
-See |'insertmode'|.
-
 char		action	~
 -----------------------------------------------------------------------
 						*i_CTRL-[* *i_<Esc>*
@@ -192,12 +189,14 @@ CTRL-D		Delete one shiftwidth of indent at the start of the current
 		label.
 
 						*i_CTRL-V*
-CTRL-V		Insert next non-digit literally.  For special keys, the
-		terminal code is inserted.  It's also possible to enter the
-		decimal, octal or hexadecimal value of a character
+CTRL-V		Insert next non-digit literally.  It's also possible to enter
+		the decimal, octal or hexadecimal value of a character
 		|i_CTRL-V_digit|.
 		The characters typed right after CTRL-V are not considered for
 		mapping.
+		For special keys, the CTRL modifier may be included into the
+		key to produce a control character.  If there is no control
+		character for the key then its |key-notation| is inserted.
 		Note: When CTRL-V is mapped (e.g., to paste text) you can
 		often use CTRL-Q instead |i_CTRL-Q|.
 
@@ -206,6 +205,10 @@ CTRL-Q		Same as CTRL-V.
 		Note: Some terminal connections may eat CTRL-Q, it doesn't
 		work then.  It does work in the GUI.
 
+CTRL-SHIFT-V				*i_CTRL-SHIFT-V* *i_CTRL-SHIFT-Q*
+CTRL-SHIFT-Q	Works just like CTRL-V, but do not try to include the CTRL
+		modifier into the key.
+
 CTRL-X		Enter CTRL-X mode.  This is a sub-mode where commands can
 		be given to complete words or scroll the window.  See
 		|i_CTRL-X| and |ins-completion|.
@@ -258,7 +261,7 @@ CTRL-]		Trigger abbreviation, without inserting a character.
 
 						*i_backspacing*
 The effect of the <BS>, CTRL-W, and CTRL-U depend on the 'backspace' option
-(unless 'revins' is set).  This is a comma separated list of items:
+(unless 'revins' is set).  This is a comma-separated list of items:
 
 item	    action ~
 indent	    allow backspacing over autoindent
@@ -269,8 +272,8 @@ start	    allow backspacing over the start position of insert; CTRL-W and
 When 'backspace' is empty, Vi compatible backspacing is used.  You cannot
 backspace over autoindent, before column 1 or before where insert started.
 
-For backwards compatibility the values "0", "1" and "2" are also allowed, see
-|'backspace'|.
+For backwards compatibility the values "0", "1", "2" and "3" are also allowed,
+see |'backspace'|.
 
 If the 'backspace' option does contain "eol" and the cursor is in column 1
 when one of the three keys is used, the current line is joined with the
@@ -329,9 +332,8 @@ that key is interpreted as in Insert mode.
 The following keys are special.  They stop the current insert, do something,
 and then restart insertion.  This means you can do something without getting
 out of Insert mode.  This is very handy if you prefer to use the Insert mode
-all the time, just like editors that don't have a separate Normal mode.  You
-may also want to set the 'insertmode' option.  You can use CTRL-O if you want
-to map a function key to a command.
+all the time, just like editors that don't have a separate Normal mode. You
+can use CTRL-O if you want to map a function key to a command.
 
 The changes (inserted or deleted characters) before and after these keys can
 be undone separately.  Only the last change can be redone and always behaves
@@ -372,7 +374,6 @@ CTRL-G CTRL-J	cursor one line down, insert start column    *i_CTRL-G_CTRL-J*
 <S-ScrollWheelRight> move window one page right		*i_<S-ScrollWheelRight>*
 CTRL-O		execute one command, return to Insert mode   *i_CTRL-O*
 CTRL-\ CTRL-O	like CTRL-O but don't move the cursor	     *i_CTRL-\_CTRL-O*
-CTRL-L		when 'insertmode' is set: go to Normal mode  *i_CTRL-L*
 CTRL-G u	break undo sequence, start new change	     *i_CTRL-G_u*
 CTRL-G U	don't break undo with next left/right cursor *i_CTRL-G_U*
 		movement, if the cursor stays within the
@@ -653,8 +654,10 @@ Note: The keys that are valid in CTRL-X mode are not mapped.  This allows for
 ends CTRL-X mode (any key that is not a valid CTRL-X mode command) is mapped.
 Also, when doing completion with 'complete' mappings apply as usual.
 
-Note: While completion is active Insert mode can't be used recursively.
-Mappings that somehow invoke ":normal i.." will generate an E523 error.
+								*E565*
+Note: While completion is active Insert mode can't be used recursively and
+buffer text cannot be changed.  Mappings that somehow invoke ":normal i.."
+will generate an E565 error.
 
 The following mappings are suggested to make typing the completion commands
 a bit easier (although they will hide other commands): >
@@ -780,7 +783,7 @@ If the previous expansion was split, because it got longer than 'textwidth',
 then just the text in the current line will be used.
 
 If the match found is at the end of a line, then the first word in the next
-line will be inserted and the message "word from next line" displayed, if
+line will be inserted and the message "Word from other line" displayed, if
 this word is accepted the next CTRL-X CTRL-P or CTRL-X CTRL-N will search
 for those lines starting with this word.
 
@@ -798,6 +801,7 @@ CTRL-X CTRL-K		Search the files given with the 'dictionary' option
 			the 'dictionary' option is empty.
 			For suggestions where to find a list of words, see the
 			'dictionary' option.
+			'ignorecase', 'smartcase' and 'infercase' apply.
 
 	CTRL-K	or
 	CTRL-N		Search forward for next matching keyword.  This
@@ -864,7 +868,7 @@ Groß): >
 	    else
 		let res = []
 		let h = ''
-		for l in split(system('aiksaurus '.shellescape(a:base)), '\n')
+		for l in split(system('aiksaurus ' .. shellescape(a:base)), '\n')
 		    if l[:3] == '=== '
 		    	let h = substitute(l[4:], ' =*$', '', '')
 		    elseif l[0] =~ '\a'
@@ -1199,7 +1203,7 @@ An example that completes the names of the months: >
 	    " find months matching with "a:base"
 	    let res = []
 	    for m in split("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec")
-	      if m =~ '^' . a:base
+	      if m =~ '^' .. a:base
 		call add(res, m)
 	      endif
 	    endfor
@@ -1221,7 +1225,7 @@ The same, but now pretending searching for matches is slow: >
 	  else
 	    " find months matching with "a:base"
 	    for m in split("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec")
-	      if m =~ '^' . a:base
+	      if m =~ '^' .. a:base
 		call complete_add(m)
 	      endif
 	      sleep 300m	" simulate searching for next match
@@ -1341,11 +1345,16 @@ in 'runtimepath'.  Thus for "java" it is autoload/javacomplete.vim.
 
 C							*ft-c-omni*
 
-Completion of C code requires a tags file.  You should use Exuberant ctags,
-because it adds extra information that is needed for completion.  You can find
-it here: http://ctags.sourceforge.net/  Version 5.6 or later is recommended.
+Completion of C code requires a tags file.  You should use Universal/
+Exuberant ctags, because it adds extra information that is needed for
+completion.  You can find it here:
+	Universal Ctags: https://ctags.io
+	Exuberant Ctags: http://ctags.sourceforge.net
 
-For version 5.5.4 you should add a patch that adds the "typename:" field:
+Universal Ctags is preferred, Exuberant Ctags is no longer being developed.
+
+For Exuberant ctags, version 5.6 or later is recommended.  For version 5.5.4
+you should add a patch that adds the "typename:" field:
 	ftp://ftp.vim.org/pub/vim/unstable/patches/ctags-5.5.4.patch
 A compiled .exe for MS-Windows can be found at:
 	http://ctags.sourceforge.net/
@@ -1466,8 +1475,11 @@ will be suggested. All other elements are not placed in suggestion list.
 PHP							*ft-php-omni*
 
 Completion of PHP code requires a tags file for completion of data from
-external files and for class aware completion. You should use Exuberant ctags
-version 5.5.4 or newer. You can find it here: http://ctags.sourceforge.net/
+external files and for class aware completion. You should use Universal/
+Exuberant ctags version 5.5.4 or newer. You can find it here:
+
+	Universal Ctags: https://ctags.io
+	Exuberant Ctags: http://ctags.sourceforge.net
 
 Script completes:
 
@@ -1863,14 +1875,10 @@ gi			Insert text in the same position as where Insert mode
 							*o*
 o			Begin a new line below the cursor and insert text,
 			repeat [count] times.
-			When the '#' flag is in 'cpoptions' the count is
-			ignored.
 
 							*O*
 O			Begin a new line above the cursor and insert text,
 			repeat [count] times.
-			When the '#' flag is in 'cpoptions' the count is
-			ignored.
 
 These commands are used to start inserting text.  You can end insert mode with
 <Esc>.  See |mode-ins-repl| for the other special characters in Insert mode.
diff --git a/runtime/doc/intro.txt b/runtime/doc/intro.txt
index 0e0156ac6b..51e823b75f 100644
--- a/runtime/doc/intro.txt
+++ b/runtime/doc/intro.txt
@@ -120,7 +120,7 @@ Vim would never have become what it is now, without the help of these people!
 	Daniel Elstner		GTK+ 2 port
 	Eric Fischer		Mac port, 'cindent', and other improvements
 	Benji Fisher		Answering lots of user questions
-	Bill Foster		Athena GUI port
+	Bill Foster		Athena GUI port (later removed)
 	Google			Lets me work on Vim one day a week
 	Loic Grenie		xvim (ideas for multi windows version)
 	Sven Guckes		Vim promoter and previous WWW page maintainer
@@ -286,10 +286,12 @@ and <> are part of what you type, the context should make this clear.
 
 							*CTRL-{char}*
 CTRL-{char}	{char} typed as a control character; that is, typing {char}
-		while holding the CTRL key down.  The case of {char} does not
-		matter; thus CTRL-A and CTRL-a are equivalent.  But on some
-		terminals, using the SHIFT key will produce another code,
-		don't use it then.
+		while holding the CTRL key down.  The case of {char} is
+		ignored; thus CTRL-A and CTRL-a are equivalent.  But in
+		some terminals and environments, using the SHIFT key will
+		produce a distinct code (e.g. CTRL-SHIFT-a); in these
+		environments using the SHIFT key will not trigger commands
+		such as CTRL-A.
 
 							*'option'*
 'option'	An option, or parameter, that can be set to a value, is
@@ -322,7 +324,6 @@ notation	meaning		    equivalent	decimal value(s)	~
 <Bar>		vertical bar		|	124	*<Bar>*
 <Del>		delete				127
 <CSI>		command sequence intro  ALT-Esc 155	*<CSI>*
-<xCSI>		CSI when typed in the GUI		*<xCSI>*
 
 <EOL>		end-of-line (can be <CR>, <NL> or <CR><NL>,
 		depends on system and 'fileformat')	*<EOL>*
@@ -384,6 +385,8 @@ Note:
   combinations actually work depends on the the UI or host terminal.
 - When a key is pressed using a meta or alt modifier and no mapping exists
   for that keypress, Nvim behaves as though <Esc> was pressed before the key.
+- It is possible to notate combined modifiers (e.g. <C-A-T> for CTRL-ALT-T),
+  but your terminal must encode the input for that to work. |tui-input|
 
 								*<>*
 Examples are often given in the <> notation.  Sometimes this is just to make
@@ -421,8 +424,7 @@ Vim has seven BASIC modes:
 					*Normal* *Normal-mode* *command-mode*
 Normal mode		In Normal mode you can enter all the normal editor
 			commands.  If you start the editor you are in this
-			mode (unless you have set the 'insertmode' option,
-			see below).  This is also known as command mode.
+			mode.  This is also known as command mode.
 
 Visual mode		This is like Normal mode, but the movement commands
 			extend a highlighted area.  When a non-movement
@@ -548,8 +550,6 @@ Ex		 :vi	  --	  --	 --	    --	      --
 *6 Go from Select mode to Insert mode by typing a printable character.  The
    selection is deleted and the character is inserted.
 
-If the 'insertmode' option is on, editing a file will start in Insert mode.
-
 	*CTRL-\_CTRL-N* *i_CTRL-\_CTRL-N* *c_CTRL-\_CTRL-N* *v_CTRL-\_CTRL-N*
 Additionally the command CTRL-\ CTRL-N or <C-\><C-N> can be used to go to
 Normal mode from any other mode.  This can be used to make sure Vim is in
@@ -558,17 +558,14 @@ work in Ex mode.  When used after a command that takes an argument, such as
 |f| or |m|, the timeout set with 'ttimeoutlen' applies.
 
 	*CTRL-\_CTRL-G* *i_CTRL-\_CTRL-G* *c_CTRL-\_CTRL-G* *v_CTRL-\_CTRL-G*
-The command CTRL-\ CTRL-G or <C-\><C-G> can be used to go to Insert mode when
-'insertmode' is set.  Otherwise it goes to Normal mode.  This can be used to
-make sure Vim is in the mode indicated by 'insertmode', without knowing in
-what mode Vim currently is.
+CTRL-\ CTRL-G works the same as |CTRL-\_CTRL-N| for backward compatibility.
 
 				*gQ* *mode-Ex* *Ex-mode* *Ex* *EX* *E501*
 gQ			Switch to Ex mode.  This is like typing ":" commands
 			one after another, except:
 			- You don't have to keep pressing ":".
 			- The screen doesn't get updated after each command.
-			Use the ":vi" command |:visual| to exit this mode.
+			Use the `:vi` command (|:visual|) to exit this mode.
 
 ==============================================================================
 Window contents						*window-contents*
diff --git a/runtime/doc/lsp.txt b/runtime/doc/lsp.txt
index bb42a87034..78100d5277 100644
--- a/runtime/doc/lsp.txt
+++ b/runtime/doc/lsp.txt
@@ -24,88 +24,81 @@ QUICKSTART                                              *lsp-quickstart*
 Nvim provides an LSP client, but the servers are provided by third parties.
 Follow these steps to get LSP features:
 
-  1. Install the nvim-lspconfig plugin.  It provides common configuration for
-     various servers so you can get started quickly.
-     https://github.com/neovim/nvim-lspconfig
-  2. Install a language server. A list of language servers can be found here:
+  1. Install language servers using your package manager or by
+     following the upstream installation instruction.
+
+     A list of language servers is available at:
+
      https://microsoft.github.io/language-server-protocol/implementors/servers/
-     See individual server documentation for installation instructions.
-  3. Add `lua require('lspconfig').xx.setup{…}` to your init.vim, where "xx" is
-     the name of the relevant config. See the nvim-lspconfig README for details.
-     NOTE: Make sure to restart nvim after installing and configuring.
-  4. Check that an LSP client has attached to the current buffer:  >
 
-      :lua print(vim.inspect(vim.lsp.buf_get_clients()))
+  2. Configure the LSP client per language server.
+     A minimal example:
+>
+     vim.lsp.start({
+        name = 'my-server-name',
+        cmd = {'name-of-language-server-executable'},
+        root_dir = vim.fs.dirname(vim.fs.find({'setup.py', 'pyproject.toml'}, { upward = true })[1]),
+     })
+<
+     See |vim.lsp.start| for details.
+
+  3. Configure keymaps and autocmds to utilize LSP features.
+     See |lsp-config|.
 <
                                                         *lsp-config*
-Inline diagnostics are enabled automatically, e.g. syntax errors will be
-annotated in the buffer.  But you probably also want to use other features
-like go-to-definition, hover, etc.
-
-While Nvim does not provide an "auto-completion" framework by default, it is
-still possible to get completions from the LSP server. To incorporate these
-completions, it is recommended to use |vim.lsp.omnifunc|, which is an 'omnifunc'
-handler. When 'omnifunc' is set to `v:lua.vim.lsp.omnifunc`, |i_CTRL-X_CTRL-O|
-will provide completions from the language server.
-
-Example config (in init.vim): >
-
-  lua << EOF
-    local custom_lsp_attach = function(client)
-      -- See `:help nvim_buf_set_keymap()` for more information
-      vim.api.nvim_buf_set_keymap(0, 'n', 'K', '<cmd>lua vim.lsp.buf.hover()<CR>', {noremap = true})
-      vim.api.nvim_buf_set_keymap(0, 'n', '<c-]>', '<cmd>lua vim.lsp.buf.definition()<CR>', {noremap = true})
-      -- ... and other keymappings for LSP
-
-      -- Use LSP as the handler for omnifunc.
-      --    See `:help omnifunc` and `:help ins-completion` for more information.
-      vim.api.nvim_buf_set_option(0, 'omnifunc', 'v:lua.vim.lsp.omnifunc')
-
-      -- Use LSP as the handler for formatexpr.
-      --    See `:help formatexpr` for more information.
-      vim.api.nvim_buf_set_option(0, 'formatexpr', 'v:lua.vim.lsp.formatexpr()')
-
-      -- For plugins with an `on_attach` callback, call them here. For example:
-      -- require('completion').on_attach()
-    end
-
-    -- An example of configuring for `sumneko_lua`,
-    --  a language server for Lua.
-
-    -- set the path to the sumneko installation
-    local system_name = "Linux" -- (Linux, macOS, or Windows)
-    local sumneko_root_path = '/path/to/lua-language-server'
-    local sumneko_binary = sumneko_root_path.."/bin/"..system_name.."/lua-language-server"
-
-    require('lspconfig').sumneko_lua.setup({
-      cmd = {sumneko_binary, "-E", sumneko_root_path .. "/main.lua"};
-      -- An example of settings for an LSP server.
-      --    For more options, see nvim-lspconfig
-      settings = {
-        Lua = {
-          runtime = {
-            -- Tell the language server which version of Lua you're using (most likely LuaJIT in the case of Neovim)
-            version = 'LuaJIT',
-            -- Setup your lua path
-            path = vim.split(package.path, ';'),
-          },
-          diagnostics = {
-            -- Get the language server to recognize the `vim` global
-            globals = {'vim'},
-          },
-          workspace = {
-            -- Make the server aware of Neovim runtime files
-            library = {
-              [vim.fn.expand('$VIMRUNTIME/lua')] = true,
-              [vim.fn.expand('$VIMRUNTIME/lua/vim/lsp')] = true,
-            },
-          },
-        }
-      },
-
-      on_attach = custom_lsp_attach
+
+Starting a LSP client will automatically report diagnostics via
+|vim.diagnostic|. Read |vim.diagnostic.config| to learn how to customize the
+display.
+
+It also sets some buffer options if the options are otherwise empty and if the
+language server supports the functionality.
+
+- |omnifunc| is set to |vim.lsp.omnifunc|. This allows to trigger completion
+  using |i_CTRL-X_CTRL-o|
+- |tagfunc| is set to |vim.lsp.tagfunc|. This enables features like
+  go-to-definition, |:tjump|, and keymaps like |CTRL-]|, |CTRL-W_]|,
+  |CTRL-W_}| to utilize the language server.
+
+To use other LSP features like hover, rename, etc. you can setup some
+additional keymaps. It's recommended to setup them in a |LspAttach| autocmd to
+ensure they're only active if there is a LSP client running. An example:
+>
+    vim.api.nvim_create_autocmd('LspAttach', {
+      callback = function(args)
+        vim.keymap.set('n', 'K', vim.lsp.buf.hover, { buffer = args.buf })
+      end,
     })
-  EOF
+
+<
+The most used functions are:
+
+- |vim.lsp.buf.hover()|
+- |vim.lsp.buf.format()|
+- |vim.lsp.buf.references()|
+- |vim.lsp.buf.implementation()|
+- |vim.lsp.buf.code_action()|
+
+
+Not all language servers provide the same capabilities. To ensure you only set
+keymaps if the language server supports a feature, you can guard the keymap
+calls behind capability checks:
+>
+    vim.api.nvim_create_autocmd('LspAttach', {
+      callback = function(args)
+        local client = vim.lsp.get_client_by_id(args.data.client_id)
+        if client.server_capabilities.hoverProvider then
+          vim.keymap.set('n', 'K', vim.lsp.buf.hover, { buffer = args.buf })
+        end
+      end,
+    })
+<
+
+To learn what capabilities are available you can run the following command in
+a buffer with a started LSP client:
+
+>
+  :lua =vim.lsp.get_active_clients()[1].server_capabilities
 <
 
 Full list of features provided by default can be found in |lsp-buf|.
@@ -355,8 +348,8 @@ To configure the behavior of a builtin |lsp-handler|, the convenient method
                                                       *lsp-handler-resolution*
 Handlers can be set by:
 
-- Setting a field in |vim.lsp.handlers|.                      *vim.lsp.handlers*
-    |vim.lsp.handlers| is a global table that contains the default mapping of
+- Setting a field in vim.lsp.handlers.                      *vim.lsp.handlers*
+    vim.lsp.handlers is a global table that contains the default mapping of
     |lsp-method| names to |lsp-handlers|.
 
     To override the handler for the `"textDocument/definition"` method: >
@@ -461,6 +454,39 @@ LspSignatureActiveParameter
 ==============================================================================
 EVENTS                                                            *lsp-events*
 
+                                                                   *LspAttach*
+After an LSP client attaches to a buffer. The |autocmd-pattern| is the
+name of the buffer. When used from Lua, the client ID is passed to the
+callback in the "data" table. Example: >
+
+    vim.api.nvim_create_autocmd("LspAttach", {
+      callback = function(args)
+        local bufnr = args.buf
+        local client = vim.lsp.get_client_by_id(args.data.client_id)
+        if client.server_capabilities.completionProvider then
+          vim.bo[bufnr].omnifunc = "v:lua.vim.lsp.omnifunc"
+        end
+        if client.server_capabilities.definitionProvider then
+          vim.bo[bufnr].tagfunc = "v:lua.vim.lsp.tagfunc"
+        end
+      end,
+    })
+<
+                                                                   *LspDetach*
+Just before an LSP client detaches from a buffer. The |autocmd-pattern| is the
+name of the buffer. When used from Lua, the client ID is passed to the
+callback in the "data" table. Example: >
+
+    vim.api.nvim_create_autocmd("LspDetach", {
+      callback = function(args)
+        local client = vim.lsp.get_client_by_id(args.data.client_id)
+        -- Do something with the client
+        vim.cmd("setlocal tagfunc< omnifunc<")
+      end,
+    })
+<
+In addition, the following |User| |autocommands| are provided:
+
 LspProgressUpdate                                          *LspProgressUpdate*
    Upon receipt of a progress notification from the server. See
    |vim.lsp.util.get_progress_messages()|.
@@ -495,16 +521,8 @@ buf_detach_client({bufnr}, {client_id})          *vim.lsp.buf_detach_client()*
                 notification.
 
                 Parameters: ~
-                    {bufnr}      number Buffer handle, or 0 for current
-                    {client_id}  number Client id
-
-buf_get_clients({bufnr})                           *vim.lsp.buf_get_clients()*
-                Gets a map of client_id:client pairs for the given buffer,
-                where each value is a |vim.lsp.client| object.
-
-                Parameters: ~
-                    {bufnr}  (optional, number): Buffer handle, or 0 for
-                             current
+                    {bufnr}      (number) Buffer handle, or 0 for current
+                    {client_id}  (number) Client id
 
 buf_is_attached({bufnr}, {client_id})              *vim.lsp.buf_is_attached()*
                 Checks if a buffer is attached for a particular client.
@@ -563,7 +581,7 @@ buf_request_all({bufnr}, {method}, {params}, {callback})
 
                 Return: ~
                     (function) A function that will cancel all requests which
-                    is the same as the one returned from `buf_request` .
+                    is the same as the one returned from `buf_request`.
 
                                                   *vim.lsp.buf_request_sync()*
 buf_request_sync({bufnr}, {method}, {params}, {timeout_ms})
@@ -600,9 +618,9 @@ client()                                                      *vim.lsp.client*
                     {handler} is not specified, If one is not found there,
                     then an error will occur. Returns: {status},
                     {[client_id]}. {status} is a boolean indicating if the
-                    notification was successful. If it is `false` , then it
+                    notification was successful. If it is `false`, then it
                     will always be `false` (the client has shutdown). If
-                    {status} is `true` , the function returns {request_id} as
+                    {status} is `true`, the function returns {request_id} as
                     the second result. You can use this with
                     `client.cancel_request(request_id)` to cancel the request.
                   • request_sync(method, params, timeout_ms, bufnr) Sends a
@@ -612,13 +630,13 @@ client()                                                      *vim.lsp.client*
                     `err` and `result` come from the |lsp-handler|. On
                     timeout, cancel or error, returns `(nil, err)` where `err`
                     is a string describing the failure reason. If the request
-                    was unsuccessful returns `nil` .
+                    was unsuccessful returns `nil`.
                   • notify(method, params) Sends a notification to an LSP
                     server. Returns: a boolean to indicate if the notification
                     was successful. If it is false, then it will always be
                     false (the client has shutdown).
                   • cancel_request(id) Cancels a request with a given request
-                    id. Returns: same as `notify()` .
+                    id. Returns: same as `notify()`.
                   • stop([force]) Stops a client, optionally with force. By
                     default, it will just ask the server to shutdown without
                     force. If you request to stop a client which has
@@ -639,23 +657,20 @@ client()                                                      *vim.lsp.client*
                     interaction with the client. See |vim.lsp.rpc.start()|.
                   • {offset_encoding} (string): The encoding used for
                     communicating with the server. You can modify this in the
-                    `config` 's `on_init` method before text is sent to the
+                    `config`'s `on_init` method before text is sent to the
                     server.
                   • {handlers} (table): The handlers used by the client as
                     described in |lsp-handler|.
                   • {requests} (table): The current pending requests in flight
                     to the server. Entries are key-value pairs with the key
                     being the request ID while the value is a table with
-                    `type` , `bufnr` , and `method` key-value pairs. `type` is
+                    `type`, `bufnr`, and `method` key-value pairs. `type` is
                     either "pending" for an active request, or "cancel" for a
                     cancel request.
                   • {config} (table): copy of the table that was passed by the
                     user to |vim.lsp.start_client()|.
                   • {server_capabilities} (table): Response from the server
                     sent on `initialize` describing the server's capabilities.
-                  • {resolved_capabilities} (table): Normalized table of
-                    capabilities that we have detected based on the initialize
-                    response from the server in `server_capabilities` .
 
 client_is_stopped({client_id})                   *vim.lsp.client_is_stopped()*
                 Checks whether a client is stopped.
@@ -671,11 +686,11 @@ for_each_buffer_client({bufnr}, {fn})
                 Invokes a function for each LSP client attached to a buffer.
 
                 Parameters: ~
-                    {bufnr}  number Buffer number
-                    {fn}     function Function to run on each client attached
-                             to buffer {bufnr}. The function takes the client,
-                             client ID, and buffer number as arguments.
-                             Example: >
+                    {bufnr}  (number) Buffer number
+                    {fn}     (function) Function to run on each client
+                             attached to buffer {bufnr}. The function takes
+                             the client, client ID, and buffer number as
+                             arguments. Example: >
 
                                vim.lsp.for_each_buffer_client(0, function(client, client_id, bufnr)
                                  print(vim.inspect(client))
@@ -686,27 +701,42 @@ formatexpr({opts})                                      *vim.lsp.formatexpr()*
                 Provides an interface between the built-in client and a
                 `formatexpr` function.
 
-                Currently only supports a single client. This can be set via `setlocal formatexpr=v:lua.vim.lsp.formatexpr()` but will typically or in `on_attach` via vim.api.nvim_buf_set_option(bufnr, 'formatexpr , 'v:lua.vim.lsp.formatexpr(#{timeout_ms:250})')`.
+                Currently only supports a single client. This can be set via
+                `setlocal formatexpr=v:lua.vim.lsp.formatexpr()` but will
+                typically or in `on_attach` via
+                `vim.api.nvim_buf_set_option(bufnr, 'formatexpr',
+                'v:lua.vim.lsp.formatexpr(#{timeout_ms:250})')`.
 
                 Parameters: ~
-                    {opts}  table options for customizing the formatting
+                    {opts}  (table) options for customizing the formatting
                             expression which takes the following optional
                             keys:
                             • timeout_ms (default 500ms). The timeout period
                               for the formatting request.
 
-get_active_clients()                            *vim.lsp.get_active_clients()*
-                Gets all active clients.
+get_active_clients({filter})                    *vim.lsp.get_active_clients()*
+                Get active clients.
+
+                Parameters: ~
+                    {filter}  (table|nil) A table with key-value pairs used to
+                              filter the returned clients. The available keys
+                              are:
+                              • id (number): Only return clients with the
+                                given id
+                              • bufnr (number): Only return clients attached
+                                to this buffer
+                              • name (string): Only return clients with the
+                                given name
 
                 Return: ~
-                    Table of |vim.lsp.client| objects
+                    (table) List of |vim.lsp.client| objects
 
                                           *vim.lsp.get_buffers_by_client_id()*
 get_buffers_by_client_id({client_id})
                 Returns list of buffers attached to client_id.
 
                 Parameters: ~
-                    {client_id}  number client id
+                    {client_id}  (number) client id
 
                 Return: ~
                     list of buffer ids
@@ -716,7 +746,7 @@ get_client_by_id({client_id})                     *vim.lsp.get_client_by_id()*
                 client may not yet be fully initialized.
 
                 Parameters: ~
-                    {client_id}  number client id
+                    {client_id}  (number) client id
 
                 Return: ~
                     |vim.lsp.client| object, or nil
@@ -749,8 +779,10 @@ omnifunc({findstart}, {base})                             *vim.lsp.omnifunc()*
 set_log_level({level})                               *vim.lsp.set_log_level()*
                 Sets the global log level for LSP logging.
 
-                Levels by name: "trace", "debug", "info", "warn", "error"
-                Level numbers begin with "trace" at 0
+                Levels by name: "TRACE", "DEBUG", "INFO", "WARN", "ERROR",
+                "OFF"
+
+                Level numbers begin with "TRACE" at 0
 
                 Use `lsp.log_levels` for reverse lookup.
 
@@ -761,6 +793,66 @@ set_log_level({level})                               *vim.lsp.set_log_level()*
                 See also: ~
                     |vim.lsp.log_levels|
 
+start({config}, {opts})                                      *vim.lsp.start()*
+                Create a new LSP client and start a language server or reuses
+                an already running client if one is found matching `name` and
+                `root_dir`. Attaches the current buffer to the client.
+
+                Example:
+>
+
+    vim.lsp.start({
+       name = 'my-server-name',
+       cmd = {'name-of-language-server-executable'},
+       root_dir = vim.fs.dirname(vim.fs.find({'pyproject.toml', 'setup.py'}, { upward = true })[1]),
+    })
+<
+
+                See |lsp.start_client| for all available options. The most
+                important are:
+
+                `name` is an arbitrary name for the LSP client. It should be
+                unique per language server.
+
+                `cmd` the command as list - used to start the language server. The
+                command must be present in the `$PATH` environment variable or an absolute path to the executable.
+                Shell constructs like `~` are NOT expanded.
+
+                `root_dir` path to the project root. By default this is used
+                to decide if an existing client should be re-used. The example
+                above uses |vim.fs.find| and |vim.fs.dirname| to detect the
+                root by traversing the file system upwards starting from the
+                current directory until either a `pyproject.toml` or
+                `setup.py` file is found.
+
+                `workspace_folders` a list of { uri:string, name: string }
+                tables. The project root folders used by the language server.
+                If `nil` the property is derived from the `root_dir` for
+                convenience.
+
+                Language servers use this information to discover metadata
+                like the dependencies of your project and they tend to index
+                the contents within the project folder.
+
+                To ensure a language server is only started for languages it
+                can handle, make sure to call |vim.lsp.start| within a
+                |FileType| autocmd. Either use |:au|, |nvim_create_autocmd()|
+                or put the call in a `ftplugin/<filetype_name>.lua` (See
+                |ftplugin-name|)
+
+                Parameters: ~
+                    {config}  (table) Same configuration as documented in
+                              |lsp.start_client()|
+                    {opts}    nil|table Optional keyword arguments:
+                              • reuse_client (fun(client: client, config:
+                                table): boolean) Predicate used to decide if a
+                                client should be re-used. Used on all running
+                                clients. The default implementation re-uses a
+                                client if name and root_dir matches.
+
+                Return: ~
+                    (number) client_id
+
 start_client({config})                                *vim.lsp.start_client()*
                 Starts and initializes a client with the given configuration.
 
@@ -775,7 +867,7 @@ start_client({config})                                *vim.lsp.start_client()*
                                          initiates the LSP client.
                     {cmd_cwd}            (string, default=|getcwd()|)
                                          Directory to launch the `cmd`
-                                         process. Not related to `root_dir` .
+                                         process. Not related to `root_dir`.
                     {cmd_env}            (table) Environment flags to pass to
                                          the LSP on spawn. Can be specified
                                          using keys like a map or as a list
@@ -784,6 +876,13 @@ start_client({config})                                *vim.lsp.start_client()*
 
                  { "PRODUCTION=true"; "TEST=123"; PORT = 8080; HOST = "0.0.0.0"; }
 <
+                    {detached}           (boolean, default true) Daemonize the
+                                         server process so that it runs in a
+                                         separate process group from Nvim.
+                                         Nvim will shutdown the process on
+                                         exit, but if Nvim fails to exit
+                                         cleanly this could leave behind
+                                         orphaned server processes.
                     {workspace_folders}  (table) List of workspace folders
                                          passed to the language server. For
                                          backwards compatibility rootUri and
@@ -800,17 +899,17 @@ start_client({config})                                *vim.lsp.start_client()*
                                          its result.
                                          • Note: To send an empty dictionary
                                            use
-                                           `{[vim.type_idx]=vim.types.dictionary}`
-                                           , else it will be encoded as an
+                                           `{[vim.type_idx]=vim.types.dictionary}`,
+                                           else it will be encoded as an
                                            array.
                     {handlers}           Map of language server method names
                                          to |lsp-handler|
                     {settings}           Map with language server specific
                                          settings. These are returned to the
                                          language server if requested via
-                                         `workspace/configuration` . Keys are
+                                         `workspace/configuration`. Keys are
                                          case-sensitive.
-                    {commands}           table Table that maps string of
+                    {commands}           (table) Table that maps string of
                                          clientside commands to user-defined
                                          functions. Commands passed to
                                          start_client take precedence over the
@@ -821,7 +920,7 @@ start_client({config})                                *vim.lsp.start_client()*
                                          action, code lenses, ...) triggers
                                          the command.
                     {init_options}       Values to pass in the initialization
-                                         request as `initializationOptions` .
+                                         request as `initializationOptions`.
                                          See `initialize` in the LSP spec.
                     {name}               (string, default=client-id) Name in
                                          log messages.
@@ -890,7 +989,7 @@ start_client({config})                                *vim.lsp.start_client()*
                                            default 150): Debounce didChange
                                            notifications to the server by the
                                            given number in milliseconds. No
-                                           debounce occurs if set to 0.
+                                           debounce occurs if nil
                                          • exit_timeout (number, default 500):
                                            Milliseconds to wait for server to
                                            exit cleanly after sending the
@@ -898,10 +997,10 @@ start_client({config})                                *vim.lsp.start_client()*
                                            kill -15. If set to false, nvim
                                            exits immediately after sending the
                                            'shutdown' request to the server.
-                    {root_dir}           string Directory where the LSP server
-                                         will base its workspaceFolders,
-                                         rootUri, and rootPath on
-                                         initialization.
+                    {root_dir}           (string) Directory where the LSP
+                                         server will base its
+                                         workspaceFolders, rootUri, and
+                                         rootPath on initialization.
 
                 Return: ~
                     Client id. |vim.lsp.get_client_by_id()| Note: client may
@@ -925,7 +1024,7 @@ stop_client({client_id}, {force})                      *vim.lsp.stop_client()*
                 Parameters: ~
                     {client_id}  client id or |vim.lsp.client| object, or list
                                  thereof
-                    {force}      boolean (optional) shutdown forcefully
+                    {force}      (boolean) (optional) shutdown forcefully
 
 tagfunc({...})                                             *vim.lsp.tagfunc()*
                 Provides an interface between the built-in client and
@@ -965,18 +1064,28 @@ add_workspace_folder({workspace_folder})
 clear_references()                            *vim.lsp.buf.clear_references()*
                 Removes document highlights from current buffer.
 
-code_action({context})                             *vim.lsp.buf.code_action()*
+code_action({options})                             *vim.lsp.buf.code_action()*
                 Selects a code action available at the current cursor
                 position.
 
                 Parameters: ~
-                    {context}  table|nil `CodeActionContext` of the LSP specification:
-                               • diagnostics: (table|nil) LSP`Diagnostic[]` . Inferred from the current position if not
-                                 provided.
-                               • only: (string|nil) LSP `CodeActionKind` used
-                                 to filter the code actions. Most language
-                                 servers support values like `refactor` or
-                                 `quickfix` .
+                    {options}  (table|nil) Optional table which holds the
+                               following optional fields:
+                               • context (table|nil): Corresponds to `CodeActionContext` of the LSP specification:
+                                 • diagnostics (table|nil): LSP`Diagnostic[]` . Inferred from the current position if not
+                                   provided.
+                                 • only (table|nil): List of LSP
+                                   `CodeActionKind`s used to filter the code
+                                   actions. Most language servers support
+                                   values like `refactor` or `quickfix`.
+
+                               • filter (function|nil): Predicate function
+                                 taking an `CodeAction` and returning a
+                                 boolean.
+                               • apply (boolean|nil): When set to `true`, and
+                                 there is just one remaining action (after
+                                 filtering), the action is applied without
+                                 user query.
 
                 See also: ~
                     https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_codeAction
@@ -995,20 +1104,30 @@ completion({context})                               *vim.lsp.buf.completion()*
                 See also: ~
                     |vim.lsp.protocol.constants.CompletionTriggerKind|
 
-declaration()                                      *vim.lsp.buf.declaration()*
+declaration({options})                             *vim.lsp.buf.declaration()*
                 Jumps to the declaration of the symbol under the cursor.
                 Note:
                     Many servers do not implement this method. Generally, see
                     |vim.lsp.buf.definition()| instead.
 
-definition()                                        *vim.lsp.buf.definition()*
+                Parameters: ~
+                    {options}  (table|nil) additional options
+                               • reuse_win: (boolean) Jump to existing window
+                                 if buffer is already open.
+
+definition({options})                               *vim.lsp.buf.definition()*
                 Jumps to the definition of the symbol under the cursor.
 
+                Parameters: ~
+                    {options}  (table|nil) additional options
+                               • reuse_win: (boolean) Jump to existing window
+                                 if buffer is already open.
+
 document_highlight()                        *vim.lsp.buf.document_highlight()*
                 Send request to the server to resolve document highlights for
                 the current text document position. This request can be
-                triggered by a key mapping or by events such as `CursorHold` ,
-                eg:
+                triggered by a key mapping or by events such as `CursorHold`,
+                e.g.:
 >
     autocmd CursorHold  <buffer> lua vim.lsp.buf.document_highlight()
     autocmd CursorHoldI <buffer> lua vim.lsp.buf.document_highlight()
@@ -1024,20 +1143,58 @@ document_symbol()                              *vim.lsp.buf.document_symbol()*
                 Lists all symbols in the current buffer in the quickfix
                 window.
 
-execute_command({command})                     *vim.lsp.buf.execute_command()*
+execute_command({command_params})              *vim.lsp.buf.execute_command()*
                 Executes an LSP server command.
 
                 Parameters: ~
-                    {command}  A valid `ExecuteCommandParams` object
+                    {command_params}  (table) A valid `ExecuteCommandParams`
+                                      object
 
                 See also: ~
                     https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_executeCommand
 
+format({options})                                       *vim.lsp.buf.format()*
+                Formats a buffer using the attached (and optionally filtered)
+                language server clients.
+
+                Parameters: ~
+                    {options}  table|nil Optional table which holds the
+                               following optional fields:
+                               • formatting_options (table|nil): Can be used
+                                 to specify FormattingOptions. Some
+                                 unspecified options will be automatically
+                                 derived from the current Neovim options.
+
+                See also: ~
+                    https://microsoft.github.io/language-server-protocol/specification#textDocument_formatting
+                    • timeout_ms (integer|nil, default 1000): Time in
+                      milliseconds to block for formatting requests. No effect
+                      if async=true
+                    • bufnr (number|nil): Restrict formatting to the clients
+                      attached to the given buffer, defaults to the current
+                      buffer (0).
+                    • filter (function|nil): Predicate used to filter clients.
+                      Receives a client as argument and must return a boolean.
+                      Clients matching the predicate are included. Example:    • >
+
+                        -- Never request typescript-language-server for formatting
+                        vim.lsp.buf.format {
+                          filter = function(client) return client.name ~= "tsserver" end
+                        }
+<
+                    • async boolean|nil If true the method won't block.
+                      Defaults to false. Editing the buffer while formatting
+                      asynchronous can lead to unexpected changes.
+                    • id (number|nil): Restrict formatting to the client with
+                      ID (client.id) matching this field.
+                    • name (string|nil): Restrict formatting to the client
+                      with name (client.name) matching this field.
+
 formatting({options})                               *vim.lsp.buf.formatting()*
                 Formats the current buffer.
 
                 Parameters: ~
-                    {options}  (optional, table) Can be used to specify
+                    {options}  (table|nil) Can be used to specify
                                FormattingOptions. Some unspecified options
                                will be automatically derived from the current
                                Neovim options.
@@ -1061,15 +1218,13 @@ formatting_seq_sync({options}, {timeout_ms}, {order})
 <
 
                 Parameters: ~
-                    {options}     (optional, table) `FormattingOptions`
-                                  entries
-                    {timeout_ms}  (optional, number) Request timeout
-                    {order}       (optional, table) List of client names.
-                                  Formatting is requested from clients in the
-                                  following order: first all clients that are
-                                  not in the `order` list, then the remaining
-                                  clients in the order as they occur in the
-                                  `order` list.
+                    {options}     (table|nil) `FormattingOptions` entries
+                    {timeout_ms}  (number|nil) Request timeout
+                    {order}       (table|nil) List of client names. Formatting
+                                  is requested from clients in the following
+                                  order: first all clients that are not in the
+                                  `order` list, then the remaining clients in
+                                  the order as they occur in the `order` list.
 
                                                *vim.lsp.buf.formatting_sync()*
 formatting_sync({options}, {timeout_ms})
@@ -1084,7 +1239,8 @@ formatting_sync({options}, {timeout_ms})
 <
 
                 Parameters: ~
-                    {options}     Table with valid `FormattingOptions` entries
+                    {options}     (table|nil) with valid `FormattingOptions`
+                                  entries
                     {timeout_ms}  (number) Request timeout
 
                 See also: ~
@@ -1117,13 +1273,13 @@ range_code_action({context}, {start_pos}, {end_pos})
                 Performs |vim.lsp.buf.code_action()| for a given range.
 
                 Parameters: ~
-                    {context}    table|nil `CodeActionContext` of the LSP specification:
+                    {context}    (table|nil) `CodeActionContext` of the LSP specification:
                                  • diagnostics: (table|nil) LSP`Diagnostic[]` . Inferred from the current position if not
                                    provided.
-                                 • only: (string|nil) LSP `CodeActionKind`
-                                   used to filter the code actions. Most
-                                   language servers support values like
-                                   `refactor` or `quickfix` .
+                                 • only: (table|nil) List of LSP
+                                   `CodeActionKind`s used to filter the code
+                                   actions. Most language servers support
+                                   values like `refactor` or `quickfix`.
                     {start_pos}  ({number, number}, optional) mark-indexed
                                  position. Defaults to the start of the last
                                  visual selection.
@@ -1160,13 +1316,21 @@ remove_workspace_folder({workspace_folder})
                 {path} is not provided, the user will be prompted for a path
                 using |input()|.
 
-rename({new_name})                                      *vim.lsp.buf.rename()*
+rename({new_name}, {options})                           *vim.lsp.buf.rename()*
                 Renames all references to the symbol under the cursor.
 
                 Parameters: ~
-                    {new_name}  (string) If not provided, the user will be
+                    {new_name}  (string|nil) If not provided, the user will be
                                 prompted for a new name using
                                 |vim.ui.input()|.
+                    {options}   (table|nil) additional options
+                                • filter (function|nil): Predicate used to
+                                  filter clients. Receives a client as
+                                  argument and must return a boolean. Clients
+                                  matching the predicate are included.
+                                • name (string|nil): Restrict clients used for
+                                  rename to ones where client.name matches
+                                  this field.
 
 server_ready()                                    *vim.lsp.buf.server_ready()*
                 Checks whether the language servers attached to the current
@@ -1179,10 +1343,15 @@ signature_help()                                *vim.lsp.buf.signature_help()*
                 Displays signature information about the symbol under the
                 cursor in a floating window.
 
-type_definition()                              *vim.lsp.buf.type_definition()*
+type_definition({options})                     *vim.lsp.buf.type_definition()*
                 Jumps to the definition of the type of the symbol under the
                 cursor.
 
+                Parameters: ~
+                    {options}  (table|nil) additional options
+                               • reuse_win: (boolean) Jump to existing window
+                                 if buffer is already open.
+
 workspace_symbol({query})                     *vim.lsp.buf.workspace_symbol()*
                 Lists all symbols in the current workspace in the quickfix
                 window.
@@ -1204,7 +1373,7 @@ get_namespace({client_id})                *vim.lsp.diagnostic.get_namespace()*
                 |vim.diagnostic|.
 
                 Parameters: ~
-                    {client_id}  number The id of the LSP client
+                    {client_id}  (number) The id of the LSP client
 
                                  *vim.lsp.diagnostic.on_publish_diagnostics()*
 on_publish_diagnostics({_}, {result}, {ctx}, {config})
@@ -1224,8 +1393,8 @@ on_publish_diagnostics({_}, {result}, {ctx}, {config})
                      },
                      -- Use a function to dynamically turn signs off
                      -- and on, using buffer local variables
-                     signs = function(bufnr, client_id)
-                       return vim.bo[bufnr].show_signs == false
+                     signs = function(namespace, bufnr)
+                       return vim.b[bufnr].show_signs == true
                      end,
                      -- Disable a feature
                      update_in_insert = false,
@@ -1234,7 +1403,7 @@ on_publish_diagnostics({_}, {result}, {ctx}, {config})
 <
 
                 Parameters: ~
-                    {config}  table Configuration table (see
+                    {config}  (table) Configuration table (see
                               |vim.diagnostic.config()|).
 
 
@@ -1245,20 +1414,20 @@ display({lenses}, {bufnr}, {client_id})           *vim.lsp.codelens.display()*
                 Display the lenses using virtual text
 
                 Parameters: ~
-                    {lenses}     table of lenses to display ( `CodeLens[] |
-                                 null` )
-                    {bufnr}      number
-                    {client_id}  number
+                    {lenses}     (table) of lenses to display (`CodeLens[] |
+                                 null`)
+                    {bufnr}      (number)
+                    {client_id}  (number)
 
 get({bufnr})                                          *vim.lsp.codelens.get()*
                 Return all lenses for the given buffer
 
                 Parameters: ~
-                    {bufnr}  number Buffer number. 0 can be used for the
+                    {bufnr}  (number) Buffer number. 0 can be used for the
                              current buffer.
 
                 Return: ~
-                    table ( `CodeLens[]` )
+                    (table) (`CodeLens[]`)
 
                                               *vim.lsp.codelens.on_codelens()*
 on_codelens({err}, {result}, {ctx}, {_})
@@ -1280,10 +1449,10 @@ save({lenses}, {bufnr}, {client_id})                 *vim.lsp.codelens.save()*
                 Store lenses for a specific buffer and client
 
                 Parameters: ~
-                    {lenses}     table of lenses to store ( `CodeLens[] |
-                                 null` )
-                    {bufnr}      number
-                    {client_id}  number
+                    {lenses}     (table) of lenses to store (`CodeLens[] |
+                                 null`)
+                    {bufnr}      (number)
+                    {client_id}  (number)
 
 
 ==============================================================================
@@ -1301,7 +1470,7 @@ hover({_}, {result}, {ctx}, {config})               *vim.lsp.handlers.hover()*
 <
 
                 Parameters: ~
-                    {config}  table Configuration table.
+                    {config}  (table) Configuration table.
                               • border: (default=nil)
                                 • Add borders to the floating window
                                 • See |nvim_open_win()|
@@ -1321,7 +1490,7 @@ signature_help({_}, {result}, {ctx}, {config})
 <
 
                 Parameters: ~
-                    {config}  table Configuration table.
+                    {config}  (table) Configuration table.
                               • border: (default=nil)
                                 • Add borders to the floating window
                                 • See |vim.api.nvim_open_win()|
@@ -1331,8 +1500,8 @@ signature_help({_}, {result}, {ctx}, {config})
 Lua module: vim.lsp.util                                            *lsp-util*
 
                                      *vim.lsp.util.apply_text_document_edit()*
-apply_text_document_edit({text_document_edit}, {index})
-                Applies a `TextDocumentEdit` , which is a list of changes to a
+apply_text_document_edit({text_document_edit}, {index}, {offset_encoding})
+                Applies a `TextDocumentEdit`, which is a list of changes to a
                 single document.
 
                 Parameters: ~
@@ -1349,39 +1518,37 @@ apply_text_edits({text_edits}, {bufnr}, {offset_encoding})
                 Applies a list of text edits to a buffer.
 
                 Parameters: ~
-                    {text_edits}       table list of `TextEdit` objects
-                    {bufnr}            number Buffer id
-                    {offset_encoding}  string utf-8|utf-16|utf-32|nil defaults
-                                       to encoding of first client of `bufnr`
+                    {text_edits}       (table) list of `TextEdit` objects
+                    {bufnr}            (number) Buffer id
+                    {offset_encoding}  (string) utf-8|utf-16|utf-32
 
                 See also: ~
                     https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textEdit
 
                                          *vim.lsp.util.apply_workspace_edit()*
-apply_workspace_edit({workspace_edit})
-                Applies a `WorkspaceEdit` .
+apply_workspace_edit({workspace_edit}, {offset_encoding})
+                Applies a `WorkspaceEdit`.
 
                 Parameters: ~
-                    {workspace_edit}  (table) `WorkspaceEdit`
+                    {workspace_edit}   (table) `WorkspaceEdit`
+                    {offset_encoding}  (string) utf-8|utf-16|utf-32 (required)
 
 buf_clear_references({bufnr})            *vim.lsp.util.buf_clear_references()*
                 Removes document highlights from a buffer.
 
                 Parameters: ~
-                    {bufnr}  number Buffer id
+                    {bufnr}  (number) Buffer id
 
                                      *vim.lsp.util.buf_highlight_references()*
 buf_highlight_references({bufnr}, {references}, {offset_encoding})
                 Shows a list of document highlights for a certain buffer.
 
                 Parameters: ~
-                    {bufnr}            number Buffer id
-                    {references}       table List of `DocumentHighlight`
+                    {bufnr}            (number) Buffer id
+                    {references}       (table) List of `DocumentHighlight`
                                        objects to highlight
-                    {offset_encoding}  string One of "utf-8", "utf-16",
-                                       "utf-32", or nil. Defaults to
-                                       `offset_encoding` of first client of
-                                       `bufnr`
+                    {offset_encoding}  (string) One of "utf-8", "utf-16",
+                                       "utf-32".
 
                 See also: ~
                     https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#documentHighlight
@@ -1395,9 +1562,9 @@ character_offset({buf}, {row}, {col}, {offset_encoding})
                     {buf}              buffer id (0 for current)
                     {row}              0-indexed line
                     {col}              0-indexed byte offset in line
-                    {offset_encoding}  string utf-8|utf-16|utf-32|nil defaults
-                                       to `offset_encoding` of first client of
-                                       `buf`
+                    {offset_encoding}  (string) utf-8|utf-16|utf-32|nil
+                                       defaults to `offset_encoding` of first
+                                       client of `buf`
 
                 Return: ~
                     (number, number) `offset_encoding` index of the character
@@ -1408,13 +1575,13 @@ convert_input_to_markdown_lines({input}, {contents})
                 Converts any of `MarkedString` | `MarkedString[]` |
                 `MarkupContent` into a list of lines containing valid
                 markdown. Useful to populate the hover window for
-                `textDocument/hover` , for parsing the result of
-                `textDocument/signatureHelp` , and potentially others.
+                `textDocument/hover`, for parsing the result of
+                `textDocument/signatureHelp`, and potentially others.
 
                 Parameters: ~
-                    {input}     ( `MarkedString` | `MarkedString[]` |
-                                `MarkupContent` )
-                    {contents}  (table, optional, default `{}` ) List of
+                    {input}     (`MarkedString` | `MarkedString[]` |
+                                `MarkupContent`)
+                    {contents}  (table, optional, default `{}`) List of
                                 strings to extend with converted lines
 
                 Return: ~
@@ -1458,28 +1625,32 @@ extract_completion_items({result})
                     https://microsoft.github.io/language-server-protocol/specification#textDocument_completion
 
 get_effective_tabstop({bufnr})          *vim.lsp.util.get_effective_tabstop()*
-                Returns visual width of tabstop.
+                Returns indentation size.
 
                 Parameters: ~
-                    {bufnr}  (optional, number): Buffer handle, defaults to
-                             current
+                    {bufnr}  (number|nil): Buffer handle, defaults to current
 
                 Return: ~
-                    (number) tabstop visual width
+                    (number) indentation size
 
                 See also: ~
-                    |softtabstop|
+                    |shiftwidth|
 
-jump_to_location({location})                 *vim.lsp.util.jump_to_location()*
+                                             *vim.lsp.util.jump_to_location()*
+jump_to_location({location}, {offset_encoding}, {reuse_win})
                 Jumps to a location.
 
                 Parameters: ~
-                    {location}  ( `Location` | `LocationLink` )
+                    {location}         (table) (`Location`|`LocationLink`)
+                    {offset_encoding}  (string) utf-8|utf-16|utf-32 (required)
+                    {reuse_win}        (boolean) Jump to existing window if
+                                       buffer is already opened.
 
                 Return: ~
                     `true` if the jump succeeded
 
-locations_to_items({locations})            *vim.lsp.util.locations_to_items()*
+                                           *vim.lsp.util.locations_to_items()*
+locations_to_items({locations}, {offset_encoding})
                 Returns the items with the byte position calculated correctly
                 and in sorted order, for display in quickfix and location
                 lists.
@@ -1488,8 +1659,10 @@ locations_to_items({locations})            *vim.lsp.util.locations_to_items()*
                 |setqflist()| or |setloclist()|.
 
                 Parameters: ~
-                    {locations}  (table) list of `Location` s or
-                                 `LocationLink` s
+                    {locations}        (table) list of `Location`s or
+                                       `LocationLink`s
+                    {offset_encoding}  (string) offset_encoding for locations
+                                       utf-8|utf-16|utf-32
 
                 Return: ~
                     (table) list of items
@@ -1521,7 +1694,7 @@ make_floating_popup_options({width}, {height}, {opts})
                               • border (string or table) override `border`
                               • focusable (string or table) override
                                 `focusable`
-                              • zindex (string or table) override `zindex` ,
+                              • zindex (string or table) override `zindex`,
                                 defaults to 50
 
                 Return: ~
@@ -1533,7 +1706,8 @@ make_formatting_params({options})
                 buffer and cursor position.
 
                 Parameters: ~
-                    {options}  Table with valid `FormattingOptions` entries
+                    {options}  (table|nil) with valid `FormattingOptions`
+                               entries
 
                 Return: ~
                     `DocumentFormattingParams` object
@@ -1555,13 +1729,13 @@ make_given_range_params({start_pos}, {end_pos}, {bufnr}, {offset_encoding})
                                        end of the last visual selection.
                     {bufnr}            (optional, number): buffer handle or 0
                                        for current, defaults to current
-                    {offset_encoding}  string utf-8|utf-16|utf-32|nil defaults
-                                       to `offset_encoding` of first client of
-                                       `bufnr`
+                    {offset_encoding}  (string) utf-8|utf-16|utf-32|nil
+                                       defaults to `offset_encoding` of first
+                                       client of `bufnr`
 
                 Return: ~
                     { textDocument = { uri = `current_file_uri` }, range = {
-                    start = `start_position` , end = `end_position` } }
+                    start = `start_position`, end = `end_position` } }
 
                                          *vim.lsp.util.make_position_params()*
 make_position_params({window}, {offset_encoding})
@@ -1571,9 +1745,9 @@ make_position_params({window}, {offset_encoding})
                 Parameters: ~
                     {window}           (optional, number): window handle or 0
                                        for current, defaults to current
-                    {offset_encoding}  string utf-8|utf-16|utf-32|nil defaults
-                                       to `offset_encoding` of first client of
-                                       buffer of `window`
+                    {offset_encoding}  (string) utf-8|utf-16|utf-32|nil
+                                       defaults to `offset_encoding` of first
+                                       client of buffer of `window`
 
                 Return: ~
                     `TextDocumentPositionParams` object
@@ -1585,20 +1759,20 @@ make_position_params({window}, {offset_encoding})
 make_range_params({window}, {offset_encoding})
                 Using the current position in the current buffer, creates an
                 object that can be used as a building block for several LSP
-                requests, such as `textDocument/codeAction` ,
-                `textDocument/colorPresentation` ,
-                `textDocument/rangeFormatting` .
+                requests, such as `textDocument/codeAction`,
+                `textDocument/colorPresentation`,
+                `textDocument/rangeFormatting`.
 
                 Parameters: ~
                     {window}           (optional, number): window handle or 0
                                        for current, defaults to current
-                    {offset_encoding}  string utf-8|utf-16|utf-32|nil defaults
-                                       to `offset_encoding` of first client of
-                                       buffer of `window`
+                    {offset_encoding}  (string) utf-8|utf-16|utf-32|nil
+                                       defaults to `offset_encoding` of first
+                                       client of buffer of `window`
 
                 Return: ~
                     { textDocument = { uri = `current_file_uri` }, range = {
-                    start = `current_position` , end = `current_position` } }
+                    start = `current_position`, end = `current_position` } }
 
                                     *vim.lsp.util.make_text_document_params()*
 make_text_document_params({bufnr})
@@ -1628,15 +1802,15 @@ open_floating_preview({contents}, {syntax}, {opts})
                 Shows contents in a floating window.
 
                 Parameters: ~
-                    {contents}  table of lines to show in window
-                    {syntax}    string of syntax to set for opened buffer
-                    {opts}      table with optional fields (additional keys
+                    {contents}  (table) of lines to show in window
+                    {syntax}    (string) of syntax to set for opened buffer
+                    {opts}      (table) with optional fields (additional keys
                                 are passed on to |vim.api.nvim_open_win()|)
                                 • height: (number) height of floating window
                                 • width: (number) width of floating window
                                 • wrap: (boolean, default true) wrap long
                                   lines
-                                • wrap_at: (string) character to wrap at for
+                                • wrap_at: (number) character to wrap at for
                                   computing height when wrap is enabled
                                 • max_width: (number) maximal width of
                                   floating window
@@ -1652,8 +1826,8 @@ open_floating_preview({contents}, {syntax}, {opts})
                                   closes the floating window
                                 • focusable: (boolean, default true) Make
                                   float focusable
-                                • focus: (boolean, default true) If `true` ,
-                                  and if {focusable} is also `true` , focus an
+                                • focus: (boolean, default true) If `true`,
+                                  and if {focusable} is also `true`, focus an
                                   existing floating window with the same
                                   {focus_id}
 
@@ -1665,10 +1839,10 @@ parse_snippet({input})                          *vim.lsp.util.parse_snippet()*
                 Parses snippets in a completion entry.
 
                 Parameters: ~
-                    {input}  string unparsed snippet
+                    {input}  (string) unparsed snippet
 
                 Return: ~
-                    string parsed snippet
+                    (string) parsed snippet
 
 preview_location({location}, {opts})         *vim.lsp.util.preview_location()*
                 Previews a location in a floating window
@@ -1721,7 +1895,7 @@ stylize_markdown({bufnr}, {contents}, {opts})
                 `open_floating_preview` instead
 
                 Parameters: ~
-                    {contents}  table of lines to show in window
+                    {contents}  (table) of lines to show in window
                     {opts}      dictionary with optional fields
                                 • height of floating window
                                 • width of floating window
@@ -1752,7 +1926,7 @@ text_document_completion_list_to_complete_items({result}, {prefix})
                 Parameters: ~
                     {result}  The result of a `textDocument/completion` call,
                               e.g. from |vim.lsp.buf.completion()|, which may
-                              be one of `CompletionItem[]` , `CompletionList`
+                              be one of `CompletionItem[]`, `CompletionList`
                               or `null`
                     {prefix}  (string) the prefix to filter the completion
                               items
@@ -1799,14 +1973,15 @@ get_level()                                          *vim.lsp.log.get_level()*
                 Gets the current log level.
 
                 Return: ~
-                    string current log level
+                    (string) current log level
 
 set_format_func({handle})                      *vim.lsp.log.set_format_func()*
                 Sets formatting function used to format logs
 
                 Parameters: ~
-                    {handle}  function function to apply to logging arguments,
-                              pass vim.inspect for multi-line formatting
+                    {handle}  (function) function to apply to logging
+                              arguments, pass vim.inspect for multi-line
+                              formatting
 
 set_level({level})                                   *vim.lsp.log.set_level()*
                 Sets the current log level.
@@ -1818,7 +1993,7 @@ should_log({level})                                 *vim.lsp.log.should_log()*
                 Checks whether the level is sufficient for logging.
 
                 Parameters: ~
-                    {level}  number log level
+                    {level}  (number) log level
 
                 Return: ~
                     (bool) true if would log, false if not
@@ -1857,8 +2032,8 @@ request({method}, {params}, {callback}, {notify_reply_callback})
                     {params}                 (table) Parameters for the
                                              invoked LSP method
                     {callback}               (function) Callback to invoke
-                    {notify_reply_callback}  (function) Callback to invoke as
-                                             soon as a request is no longer
+                    {notify_reply_callback}  (function|nil) Callback to invoke
+                                             as soon as a request is no longer
                                              pending
 
                 Return: ~
@@ -1918,25 +2093,24 @@ start({cmd}, {cmd_args}, {dispatchers}, {extra_spawn_params})
 Lua module: vim.lsp.sync                                            *lsp-sync*
 
                                                  *vim.lsp.sync.compute_diff()*
-compute_diff({prev_lines}, {curr_lines}, {firstline}, {lastline},
-             {new_lastline}, {offset_encoding}, {line_ending})
+compute_diff({___MissingCloseParenHere___})
                 Returns the range table for the difference between prev and
                 curr lines
 
                 Parameters: ~
-                    {prev_lines}       table list of lines
-                    {curr_lines}       table list of lines
-                    {firstline}        number line to begin search for first
+                    {prev_lines}       (table) list of lines
+                    {curr_lines}       (table) list of lines
+                    {firstline}        (number) line to begin search for first
                                        difference
-                    {lastline}         number line to begin search in
+                    {lastline}         (number) line to begin search in
                                        old_lines for last difference
-                    {new_lastline}     number line to begin search in
+                    {new_lastline}     (number) line to begin search in
                                        new_lines for last difference
-                    {offset_encoding}  string encoding requested by language
+                    {offset_encoding}  (string) encoding requested by language
                                        server
 
                 Return: ~
-                    table TextDocumentContentChangeEvent see https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#textDocumentContentChangeEvent
+                    (table) TextDocumentContentChangeEvent see https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#textDocumentContentChangeEvent
 
 
 ==============================================================================
@@ -1953,10 +2127,10 @@ resolve_capabilities({server_capabilities})
                 capabilities.
 
                 Parameters: ~
-                    {server_capabilities}  table Table of capabilities
+                    {server_capabilities}  (table) Table of capabilities
                                            supported by the server
 
                 Return: ~
-                    table Normalized table of capabilities
+                    (table) Normalized table of capabilities
 
  vim:tw=78:ts=8:ft=help:norl:
diff --git a/runtime/doc/lua.txt b/runtime/doc/lua.txt
index 80c1f58323..089cf0ce9d 100644
--- a/runtime/doc/lua.txt
+++ b/runtime/doc/lua.txt
@@ -4,65 +4,89 @@
                             NVIM REFERENCE MANUAL
 
 
-Lua engine                                              *lua* *Lua*
+Lua engine                                                           *lua* *Lua*
 
-                                      Type |gO| to see the table of contents.
+                                       Type |gO| to see the table of contents.
 
 ==============================================================================
-INTRODUCTION                                            *lua-intro*
+INTRODUCTION                                                       *lua-intro*
 
-The Lua 5.1 language is builtin and always available.  Try this command to get
+The Lua 5.1 language is builtin and always available. Try this command to get
 an idea of what lurks beneath: >
 
     :lua print(vim.inspect(package.loaded))
+<
+Nvim includes a "standard library" |lua-stdlib| for Lua. It complements the
+"editor stdlib" (|builtin-functions| and Ex commands) and the |API|, all of
+which can be used from Lua code. A good overview of using Lua in neovim is
+given by https://github.com/nanotee/nvim-lua-guide.
 
-Nvim includes a "standard library" |lua-stdlib| for Lua.  It complements the
-"editor stdlib" (|functions| and Ex commands) and the |API|, all of which can
-be used from Lua code. A good overview of using Lua in neovim is given by
-https://github.com/nanotee/nvim-lua-guide.
-
-Module conflicts are resolved by "last wins".  For example if both of these
-are on 'runtimepath':
-    runtime/lua/foo.lua
-    ~/.config/nvim/lua/foo.lua
-then `require('foo')` loads "~/.config/nvim/lua/foo.lua", and
-"runtime/lua/foo.lua" is not used.  See |lua-require| to understand how Nvim
-finds and loads Lua modules.  The conventions are similar to those of
-Vimscript |plugin|s, with some extra features.  See |lua-require-example| for
-a walkthrough.
+The |:source| and |:runtime| commands can run Lua scripts as well as Vim
+scripts. Lua modules can be loaded with `require('name')`, which
+conventionally returns a table but can return any value.
 
-==============================================================================
-IMPORTING LUA MODULES                                   *lua-require*
+See |lua-require| for details on how Nvim finds and loads Lua modules.
+See |lua-require-example| for an example of how to write and use a module.
 
-                                                        *lua-package-path*
-Nvim automatically adjusts `package.path` and `package.cpath` according to
-effective 'runtimepath' value.  Adjustment happens whenever 'runtimepath' is
-changed.  `package.path` is adjusted by simply appending `/lua/?.lua` and
+==============================================================================
+IMPORTING LUA MODULES                                            *lua-require*
+
+Modules are searched for under the directories specified in 'runtimepath', in
+the order they appear. 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 on `require()`, see the Lua
+documentation at https://www.lua.org/manual/5.1/manual.html#pdf-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:
+
+    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
+
+Nvim automatically adjusts `package.path` and `package.cpath` according to the
+effective 'runtimepath' value. Adjustment happens whenever 'runtimepath' is
+changed. `package.path` is adjusted by simply appending `/lua/?.lua` and
 `/lua/?/init.lua` to each directory from 'runtimepath' (`/` is actually the
 first character of `package.config`).
 
 Similarly to `package.path`, modified directories from 'runtimepath' are also
-added to `package.cpath`.  In this case, instead of appending `/lua/?.lua` and
+added to `package.cpath`. In this case, instead of appending `/lua/?.lua` and
 `/lua/?/init.lua` to each runtimepath, all unique `?`-containing suffixes of
-the existing `package.cpath` are used.  Example:
+the existing `package.cpath` are used. Example:
 
 1. Given that
    - 'runtimepath' contains `/foo/bar,/xxx;yyy/baz,/abc`;
-   - initial (defined at compile-time or derived from 
-     `$LUA_CPATH`/`$LUA_INIT`) `package.cpath` contains 
+   - initial (defined at compile-time or derived from
+     `$LUA_CPATH`/`$LUA_INIT`) `package.cpath` contains
      `./?.so;/def/ghi/a?d/j/g.elf;/def/?.so`.
-2. It finds `?`-containing suffixes `/?.so`, `/a?d/j/g.elf` and `/?.so`, in 
-   order: parts of the path starting from the first path component containing 
+2. It finds `?`-containing suffixes `/?.so`, `/a?d/j/g.elf` and `/?.so`, in
+   order: parts of the path starting from the first path component containing
    question mark and preceding path separator.
-3. The suffix of `/def/?.so`, namely `/?.so` is not unique, as it’s the same 
-   as the suffix of the first path from `package.path` (i.e. `./?.so`).  Which 
+3. The suffix of `/def/?.so`, namely `/?.so` is not unique, as it’s the same
+   as the suffix of the first path from `package.path` (i.e. `./?.so`). Which
    leaves `/?.so` and `/a?d/j/g.elf`, in this order.
-4. 'runtimepath' has three paths: `/foo/bar`, `/xxx;yyy/baz` and `/abc`.  The 
-   second one contains semicolon which is a paths separator so it is out, 
+4. 'runtimepath' has three paths: `/foo/bar`, `/xxx;yyy/baz` and `/abc`. The
+   second one contains a semicolon which is a paths separator so it is out,
    leaving only `/foo/bar` and `/abc`, in order.
-5. The cartesian product of paths from 4. and suffixes from 3. is taken, 
-   giving four variants. In each variant `/lua` path segment is inserted 
-   between path and suffix, leaving
+5. The cartesian product of paths from 4. and suffixes from 3. is taken,
+   giving four variants. In each variant, a `/lua` path segment is inserted
+   between path and suffix, leaving:
 
    - `/foo/bar/lua/?.so`
    - `/foo/bar/lua/a?d/j/g.elf`
@@ -82,28 +106,28 @@ Note:
 
 - To track 'runtimepath' updates, paths added at previous update are
   remembered and removed at the next update, while all paths derived from the
-  new 'runtimepath' are prepended as described above.  This allows removing
+  new 'runtimepath' are prepended as described above. This allows removing
   paths when path is removed from 'runtimepath', adding paths when they are
   added and reordering `package.path`/`package.cpath` content if 'runtimepath'
   was reordered.
 
 - Although adjustments happen automatically, Nvim does not track current
-  values of `package.path` or `package.cpath`.  If you happen to delete some
+  values of `package.path` or `package.cpath`. If you happen to delete some
   paths from there you can set 'runtimepath' to trigger an update: >
       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.
+  `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 Syntax Information                                         *lua-syntax-help*
+Lua Syntax Information                                       *lua-syntax-help*
 
 While Lua has a simple syntax, there are a few things to understand,
 particularly when looking at the documentation above.
 
-                                                      *lua-syntax-call-function*
+                                                    *lua-syntax-call-function*
 
 Lua functions can be called in multiple ways. Consider the function: >
 
@@ -111,31 +135,30 @@ Lua functions can be called in multiple ways. Consider the function: >
         print("A is: ", a)
         print("B is: ", b)
     end
+<
+The first way to call this function is: >
 
-
-The first way to call a function is: >
-    
     example_func(1, 2)
     -- ==== Result ====
     -- A is: 1
     -- B is: 2
 <
-    This way of calling a function is familiar to most scripting languages.
-    In Lua, it's important to understand that any function arguments that are
-    not supplied are automatically set to `nil`. For example: >
+This way of calling a function is familiar from most scripting languages.
+In Lua, it's important to understand that any function arguments that are
+not supplied are automatically set to `nil`. For example: >
 
     example_func(1)
     -- ==== Result ====
     -- A is: 1
     -- B is: nil
 <
+Additionally, if any extra parameters are passed, they are discarded
+completely.
 
-    Additionally, if any extra parameters are passed, they are discarded
-    completely.
-
-In Lua, it is also possible (when only one argument is passed) to call the
-function without any parentheses. This is most often used to approximate
-"keyword"-style arguments with a single dictionary. For example: >
+In Lua, it is also possible to omit the parentheses (only) if the function
+takes a single string or table literal (`"foo"` or "`{1,2,3}`", respectively).
+The latter is most often used to approximate "keyword-style" arguments with a
+single dictionary, for example: >
 
     local func_with_opts = function(opts)
         local will_do_foo = opts.foo
@@ -146,25 +169,46 @@ function without any parentheses. This is most often used to approximate
 
     func_with_opts { foo = true, filename = "hello.world" }
 <
-
-    In this style, each "parameter" is passed via keyword. It is still valid
-    to call the function in this style: >
+In this style, each "parameter" is passed via keyword. It is still valid
+to call the function in the standard style: >
 
     func_with_opts({ foo = true, filename = "hello.world" })
 <
+But often in the documentation, you will see the former rather than the
+latter style due to its brevity.
+
+==============================================================================
+Lua Patterns                                                    *lua-patterns*
+
+For performance reasons, Lua does not support regular expressions natively.
+Instead, the Lua `string` standard library allows manipulations using a
+restricted set of "patterns", see https://www.lua.org/manual/5.1/manual.html#5.4.1
+
+Examples (`string.match` extracts the first match): >
+
+    print(string.match("foo123bar123", "%d+"))
+    -- -> 123
 
-    But often in the documentation, you will see the former rather than the
-    latter style, due to its brevity (this is vim after all!).
+    print(string.match("foo123bar123", "[^%d]+"))
+    -- -> foo
 
+    print(string.match("foo123bar123", "[abc]+"))
+    -- -> ba
+
+    print(string.match("foo.bar", "%.bar"))
+    -- -> .bar
+
+For more complex matching, Vim regular expressions can be used from Lua
+through |vim.regex()|.
 
 ------------------------------------------------------------------------------
-LUA PLUGIN EXAMPLE                                      *lua-require-example*
+LUA PLUGIN EXAMPLE                                       *lua-require-example*
 
-The following example plugin adds a command `:MakeCharBlob` which transforms 
-current buffer into a long `unsigned char` array.  Lua contains transformation 
-function in a module `lua/charblob.lua` which is imported in 
-`autoload/charblob.vim` (`require("charblob")`).  Example plugin is supposed 
-to be put into any directory from 'runtimepath', e.g. `~/.config/nvim` (in 
+The following example plugin adds a command `:MakeCharBlob` which transforms
+current buffer into a long `unsigned char` array. Lua contains transformation
+function in a module `lua/charblob.lua` which is imported in
+`autoload/charblob.vim` (`require("charblob")`). Example plugin is supposed
+to be put into any directory from 'runtimepath', e.g. `~/.config/nvim` (in
 this case `lua/charblob.lua` means `~/.config/nvim/lua/charblob.lua`).
 
 autoload/charblob.vim: >
@@ -174,7 +218,7 @@ autoload/charblob.vim: >
       \    'require("charblob").encode(unpack(_A))',
       \    [getline(1, '$'), &textwidth, '  ']))
     endfunction
-
+<
 plugin/charblob.vim: >
 
     if exists('g:charblob_loaded')
@@ -183,7 +227,7 @@ plugin/charblob.vim: >
     let g:charblob_loaded = 1
 
     command MakeCharBlob :call charblob#encode_buffer()
-
+<
 lua/charblob.lua: >
 
     local function charblob_bytes_iter(lines)
@@ -233,9 +277,9 @@ lua/charblob.lua: >
       bytes_iter = charblob_bytes_iter,
       encode = charblob_encode,
     }
-
+<
 ==============================================================================
-COMMANDS                                                *lua-commands*
+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
@@ -246,10 +290,10 @@ command calls. The |lua-stdlib| modules, user modules, and anything else on
 The Lua print() function redirects its output to the Nvim message area, with
 arguments separated by " " (space) instead of "\t" (tab).
 
-                                                        *:lua*
-:[range]lua {chunk}
+                                                                        *:lua*
+:lua {chunk}
                         Executes Lua chunk {chunk}.
-                        if {chunk} starts with "=" the rest of the chunk is
+                        If {chunk} starts with "=" the rest of the chunk is
                         evaluated as an expression and printed. `:lua =expr`
                         is equivalent to `:lua print(vim.inspect(expr))`
                         Examples: >
@@ -259,8 +303,8 @@ arguments separated by " " (space) instead of "\t" (tab).
 <                        To see the LuaJIT version: >
                             :lua =jit.version
 <
-                                                        *:lua-heredoc*
-:[range]lua << [endmarker]
+                                                                *:lua-heredoc*
+:lua << [endmarker]
 {script}
 {endmarker}
                         Executes Lua script {script} from within Vimscript.
@@ -279,11 +323,11 @@ arguments separated by " " (space) instead of "\t" (tab).
                                     linenr, #curline))
                             EOF
                             endfunction
-
-<                        Note that the `local` variables will disappear when
+<
+                        Note that the `local` variables will disappear when
                         the block finishes. But not globals.
 
-                                                        *:luado*
+                                                                      *: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
@@ -300,9 +344,8 @@ arguments separated by " " (space) instead of "\t" (tab).
                             :lua bp = lpeg.P{ "(" * ((1 - lpeg.S"()") + lpeg.V(1))^0 * ")" }
                             :luado if bp:match(line) then return "-->\t" .. line end
 <
-
-                                                        *:luafile*
-:[range]luafile {file}
+                                                                    *: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.
@@ -314,19 +357,19 @@ arguments separated by " " (space) instead of "\t" (tab).
 <
 
 ==============================================================================
-luaeval()                                               *lua-eval* *luaeval()*
+luaeval()                                                 *lua-eval* *luaeval()*
 
 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:
->
+"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: >
+
     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.
@@ -338,22 +381,22 @@ Example: >
     42
     :echo luaeval('string.match(_A, "[a-z]+")', 'XYXfoo123')
     foo
-
+<
 Lua tables are used as both dictionaries and lists, so it is impossible to
 determine whether empty table is meant to be empty list or empty dictionary.
 Additionally Lua does not have integer numbers. To distinguish between these
 cases there is the following agreement:
 
 0. Empty table is empty list.
-1. Table with N incrementally growing integral numbers, starting from 1 and 
+1. Table with N incrementally growing integral numbers, starting from 1 and
    ending with N is considered to be a list.
-2. Table with string keys, none of which contains NUL byte, is considered to 
+2. Table with string keys, none of which contains NUL byte, is considered to
    be a dictionary.
-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 
+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*
-4. Table with `vim.type_idx` key may be a dictionary, a list or floating-point 
+                                                             *lua-special-tbl*
+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
@@ -376,14 +419,14 @@ Examples: >
     :  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
+<
+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*
+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 >
@@ -398,7 +441,7 @@ is equivalent to the Lua chunk >
 In addition, functions of packages can be accessed like >
     v:lua.require'mypack'.func(arg1, arg2)
     v:lua.require'mypack.submod'.func(arg1, arg2)
-Note: only single quote form without parens is allowed. Using
+Note: Only single quote form without parens is allowed. Using
 `require"mypack"` or `require('mypack')` as prefixes do NOT work (the latter
 is still valid as a function call of itself, in case require returns a useful
 value).
@@ -406,7 +449,7 @@ value).
 The `v:lua` prefix may be used to call Lua functions as |method|s. For
 example: >
     arg1->v:lua.somemod.func(arg2)
-
+<
 You can use `v:lua` in "func" options like 'tagfunc', 'omnifunc', etc.
 For example consider the following Lua omnifunc handler: >
 
@@ -419,7 +462,7 @@ For example consider the following Lua omnifunc handler: >
     end
     vim.api.nvim_buf_set_option(0, 'omnifunc', 'v:lua.mymod.omnifunc')
 
-Note: the module ("mymod" in the above example) must either be a Lua global,
+Note: The module ("mymod" in the above example) must either be a Lua global,
 or use the require syntax as specified above to access it from a package.
 
 Note: `v:lua` without a call is not allowed in a Vimscript expression:
@@ -429,13 +472,12 @@ Note: `v:lua` without a call is not allowed in a Vimscript expression:
     call SomeFunc(v:lua.mycallback)   " Error
     let g:foo = v:lua                 " Error
     let g:foo = v:['lua']             " Error
-
-
+<
 ==============================================================================
-Lua standard modules                                    *lua-stdlib*
+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")
+various functions and sub-modules. It is always loaded, thus `require("vim")`
 is unnecessary.
 
 You can peek at the module properties: >
@@ -466,34 +508,35 @@ Note that underscore-prefixed functions (e.g. "_os_proc_children") are
 internal/private and must not be used by plugins.
 
 ------------------------------------------------------------------------------
-VIM.LOOP                                                *lua-loop* *vim.loop*
+VIM.LOOP                                                   *lua-loop* *vim.loop*
 
-`vim.loop` exposes all features of the Nvim event-loop.  This is a low-level
+`vim.loop` exposes all features of the Nvim event-loop. This is a low-level
 API that provides functionality for networking, filesystem, and process
-management.  Try this command to see available functions: >
+management. Try this command to see available functions: >
 
     :lua print(vim.inspect(vim.loop))
-
+<
 Reference: https://github.com/luvit/luv/blob/master/docs.md
 Examples:  https://github.com/luvit/luv/tree/master/examples
 
-                                                *E5560* *lua-loop-callbacks*
+                                                    *E5560* *lua-loop-callbacks*
 It is an error to directly invoke `vim.api` functions (except |api-fast|) in
-`vim.loop` callbacks.  For example, this is an error: >
+`vim.loop` callbacks. For example, this is an error: >
 
     local timer = vim.loop.new_timer()
     timer:start(1000, 0, function()
       vim.api.nvim_command('echomsg "test"')
     end)
-
+<
 To avoid the error use |vim.schedule_wrap()| to defer the callback: >
 
     local timer = vim.loop.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.)
+<
+(For one-shot timers, see |vim.defer_fn()|, which automatically adds the
+wrapping.)
 
 Example: repeating timer
     1. Save this code to a file.
@@ -511,9 +554,8 @@ Example: repeating timer
       i = i + 1
     end)
     print('sleeping');
-
-
-Example: File-change detection                          *watch-file*
+<
+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.
@@ -537,9 +579,8 @@ Example: File-change detection                          *watch-file*
     end
     vim.api.nvim_command(
       "command! -nargs=1 Watch call luaeval('watch_file(_A)', expand('<args>'))")
-
-
-Example: TCP echo-server                                *tcp-server*
+<
+Example: TCP echo-server                                          *tcp-server*
     1. Save this code to a file.
     2. Execute it with ":luafile %".
     3. Note the port number.
@@ -567,9 +608,28 @@ Example: TCP echo-server                                *tcp-server*
       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.loop.new_thread`. Note that every thread
+gets its own separate lua interpreter state, with no access to lua globals
+in the main thread. Neither can the state of the editor (buffers, windows,
+etc) be directly accessed from threads.
+
+A subset of the `vim.*` API is available in threads. This includes:
+
+- `vim.loop` 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 |lua-package-path|
+- `print()` and `vim.inspect`
+- `vim.diff`
+- most utility functions in `vim.*` for working with pure lua values
+  like `vim.split`, `vim.tbl_*`, `vim.list_*`, and so on.
+- `vim.is_thread()` returns true from a non-main thread.
 
 ------------------------------------------------------------------------------
-VIM.HIGHLIGHT                                           *lua-highlight*
+VIM.HIGHLIGHT                                                  *lua-highlight*
 
 Nvim includes a function for highlighting a selection on yank (see for example
 https://github.com/machakann/vim-highlightedyank). To enable it, add
@@ -585,8 +645,7 @@ If you want to exclude visual selections from highlighting on yank, use
 >
  au TextYankPost * silent! lua vim.highlight.on_yank {on_visual=false}
 <
-
-vim.highlight.on_yank({opts})                         *vim.highlight.on_yank()*
+vim.highlight.on_yank({opts})                        *vim.highlight.on_yank()*
         Highlights the yanked text. The fields of the optional dict {opts}
         control the highlight:
           - {higroup} highlight group for yanked region (default |hl-IncSearch|)
@@ -595,28 +654,49 @@ vim.highlight.on_yank({opts})                         *vim.highlight.on_yank()*
           - {on_visual} highlight when yanking visual selection (default `true`)
           - {event} event structure (default |v:event|)
 
-vim.highlight.range({bufnr}, {ns}, {higroup}, {start}, {finish}, {rtype}, {inclusive})
+vim.highlight.range({bufnr}, {ns}, {hlgroup}, {start}, {finish}, {opts})
                                                        *vim.highlight.range()*
-        Highlights the range between {start} and {finish} (tuples of {line,col})
-        in buffer {bufnr} with the highlight group {higroup} using the namespace
-        {ns}. Optional arguments are the type of range (characterwise, linewise,
-        or blockwise, see |setreg|; default to characterwise) and whether the
-        range is inclusive (default false).
+
+        Apply highlight group to range of text.
+
+                Parameters: ~
+                    {bufnr}   buffer number
+                    {ns}      namespace for highlights
+                    {hlgroup} highlight group name
+                    {start}   starting position (tuple {line,col})
+                    {finish}  finish position (tuple {line,col})
+                    {opts}    optional parameters:
+                              • `regtype`: type of range (characterwise, linewise,
+                                or blockwise, see |setreg|), default `'v'`
+                              • `inclusive`: range includes end position,
+                                default `false`
+                              • `priority`: priority of highlight, default
+                                `vim.highlight.user` (see below)
+
+vim.highlight.priorities                            *vim.highlight.priorities*
+
+        Table with default priorities used for highlighting:
+            • `syntax`: `50`, used for standard syntax highlighting
+            • `treesitter`: `100`, used for tree-sitter-based 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.REGEX                                                       *lua-regex*
+VIM.REGEX                                                          *lua-regex*
 
 Vim regexes can be used directly from lua. Currently they only allow
 matching within a single line.
 
-vim.regex({re})                                         *vim.regex()*
+vim.regex({re})                                                  *vim.regex()*
         Parse the Vim regex {re} and return a regex object. Regexes are
-        "magic" and case-insensitive by default, regardless of 'magic' and
-        'ignorecase'.  The can be controlled with flags, see |/magic|.
+        "magic" and case-sensitive by default, regardless of 'magic' and
+        'ignorecase'. They can be controlled with flags, see |/magic| and
+        |/ignorecase|.
 
 Methods on the regex object:
 
-regex:match_str({str})                                  *regex:match_str()*
+regex:match_str({str})                                     *regex:match_str()*
         Match the string against the regex. If the string should match the
         regex precisely, surround the regex with `^` and `$`.
         If the was a match, the byte indices for the beginning and end of
@@ -624,7 +704,7 @@ regex:match_str({str})                                  *regex:match_str()*
         As any integer is truth-y, `regex:match()` can be directly used
         as a condition in an if-statement.
 
-regex:match_line({bufnr}, {line_idx}[, {start}, {end}]) *regex:match_line()*
+regex:match_line({bufnr}, {line_idx}[, {start}, {end}])   *regex:match_line()*
         Match line {line_idx} (zero-based) in buffer {bufnr}. If {start} and
         {end} are supplied, match only this byte index range. Otherwise see
         |regex:match_str()|. If {start} is used, then the returned byte
@@ -639,18 +719,19 @@ vim.diff({a}, {b}, {opts})                                        *vim.diff()*
                 1-based.
 
                 Examples: >
-                vim.diff('a\n', 'b\nc\n')
-                -->
-                @@ -1 +1,2 @@
-                -a
-                +b
-                +c
-
-                vim.diff('a\n', 'b\nc\n', {result_type = 'indices'})
-                -->
-                {
-                    {1, 1, 1, 2}
-                }
+
+                    vim.diff('a\n', 'b\nc\n')
+                    -->
+                    @@ -1 +1,2 @@
+                    -a
+                    +b
+                    +c
+
+                    vim.diff('a\n', 'b\nc\n', {result_type = 'indices'})
+                    -->
+                    {
+                        {1, 1, 1, 2}
+                    }
 <
                 Parameters: ~
                     {a}      First string to compare
@@ -668,7 +749,7 @@ vim.diff({a}, {b}, {opts})                                        *vim.diff()*
                              • `result_type` (string): Form of the returned diff:
                                • "unified": (default) String in unified format.
                                • "indices": Array of hunk locations.
-                               Note this option is ignored if `on_hunk` is
+                               Note: This option is ignored if `on_hunk` is
                                used.
                              • `algorithm` (string):
                                Diff algorithm to use. Values:
@@ -703,31 +784,31 @@ VIM.MPACK                                                          *lua-mpack*
 The *vim.mpack* module provides encoding and decoding of Lua objects to and
 from msgpack-encoded strings. Supports |vim.NIL| and |vim.empty_dict()|.
 
-vim.mpack.encode({obj})                                 *vim.mpack.encode*
+vim.mpack.encode({obj})                                     *vim.mpack.encode*
         Encodes (or "packs") Lua object {obj} as msgpack in a Lua string.
 
-vim.mpack.decode({str})                                 *vim.mpack.decode*
+vim.mpack.decode({str})                                     *vim.mpack.decode*
         Decodes (or "unpacks") the msgpack-encoded {str} to a Lua object.
 
 ------------------------------------------------------------------------------
-VIM.SPELL                                                           *lua-spell*
+VIM.SPELL                                                          *lua-spell*
 
-vim.spell.check({str})                                      *vim.spell.check()*
+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()|.
+        'spellfile', 'spellcapcheck' and 'spelloptions' which can all be
+        local to the buffer. Consider calling this with |nvim_buf_call()|.
 
         Example: >
+
             vim.spell.check("the quik brown fox")
             -->
             {
                 {'quik', 'bad', 4}
             }
 <
-
         Parameters: ~
             {str}    String to spell check.
 
@@ -742,24 +823,24 @@ vim.spell.check({str})                                      *vim.spell.check()*
             - The position in {str} where the word begins.
 
 ------------------------------------------------------------------------------
-VIM                                                     *lua-builtin*
+VIM                                                              *lua-builtin*
 
-vim.api.{func}({...})                                   *vim.api*
+vim.api.{func}({...})                                                *vim.api*
         Invokes Nvim |API| function {func} with arguments {...}.
         Example: call the "nvim_get_current_line()" API function: >
             print(tostring(vim.api.nvim_get_current_line()))
 
-vim.version()                                           *vim.version*
+vim.version()                                                    *vim.version*
         Gets the version of the current Nvim build.
 
-vim.in_fast_event()                                     *vim.in_fast_event()*
+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
+        for input. When this is `false` most API functions are callable (but
         may be subject to other restrictions such as |textlock|).
 
-vim.NIL                                                             *vim.NIL*
+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
@@ -771,10 +852,10 @@ vim.empty_dict()                                            *vim.empty_dict()*
         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
+        Note: If numeric keys are present in the table, Nvim ignores the
         metatable marker and converts the dict to a list/array anyway.
 
-vim.rpcnotify({channel}, {method}[, {args}...])             *vim.rpcnotify()*
+vim.rpcnotify({channel}, {method}[, {args}...])              *vim.rpcnotify()*
         Sends {event} to {channel} via |RPC| and returns immediately. If
         {channel} is 0, the event is broadcast to all channels.
 
@@ -787,12 +868,12 @@ vim.rpcrequest({channel}, {method}[, {args}...])            *vim.rpcrequest()*
         Note: NIL values as part of the return value is represented as
         |vim.NIL| special value
 
-vim.stricmp({a}, {b})                                   *vim.stricmp()*
-        Compares strings case-insensitively.  Returns 0, 1 or -1 if strings
+vim.stricmp({a}, {b})                                          *vim.stricmp()*
+        Compares strings case-insensitively. Returns 0, 1 or -1 if strings
         are equal, {a} is greater than {b} or {a} is lesser than {b},
         respectively.
 
-vim.str_utfindex({str}[, {index}])                      *vim.str_utfindex()*
+vim.str_utfindex({str}[, {index}])                        *vim.str_utfindex()*
         Convert byte index to UTF-32 and UTF-16 indices. If {index} is not
         supplied, the length of the string is used. All indices are zero-based.
         Returns two values: the UTF-32 and UTF-16 indices respectively.
@@ -802,21 +883,21 @@ vim.str_utfindex({str}[, {index}])                      *vim.str_utfindex()*
         point each. An {index} in the middle of a UTF-8 sequence is rounded
         upwards to the end of that sequence.
 
-vim.str_byteindex({str}, {index}[, {use_utf16}])	*vim.str_byteindex()*
+vim.str_byteindex({str}, {index}[, {use_utf16}])         *vim.str_byteindex()*
         Convert UTF-32 or UTF-16 {index} to byte index. If {use_utf16} is not
         supplied, it defaults to false (use UTF-32). Returns the byte index.
 
-        Invalid UTF-8 and NUL is treated like by |vim.str_byteindex()|. An {index}
-        in the middle of a UTF-16 sequence is rounded upwards to the end of that
-        sequence.
+        Invalid UTF-8 and NUL is treated like by |vim.str_byteindex()|.
+        An {index} in the middle of a UTF-16 sequence is rounded upwards to
+        the end of that sequence.
 
-vim.schedule({callback})				*vim.schedule()*
+vim.schedule({callback})                                      *vim.schedule()*
         Schedules {callback} to be invoked soon by the main event-loop. Useful
         to avoid |textlock| or other temporary restrictions.
 
 
-vim.defer_fn({fn}, {timeout})                                    *vim.defer_fn*
-    Defers calling {fn} until {timeout} ms passes.  Use to do a one-shot timer
+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_wrap|ped automatically, so API functions are
@@ -880,15 +961,15 @@ vim.wait({time} [, {callback}, {interval}, {fast_only}])          *vim.wait()*
     end
 <
 
-vim.type_idx                                            *vim.type_idx*
-        Type index for use in |lua-special-tbl|.  Specifying one of the values
+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
+        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
+vim.val_idx                                                      *vim.val_idx*
+        Value index for tables representing |Float|s. A table representing
         floating-point value 1.0 looks like this: >
             {
               [vim.type_idx] = vim.types.float,
@@ -896,17 +977,17 @@ vim.val_idx                                             *vim.val_idx*
             }
 <       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
+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`,
+        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`,
+        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
+        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`.
@@ -923,35 +1004,25 @@ Log levels are one of the values defined in `vim.log.levels`:
         vim.log.levels.INFO
         vim.log.levels.TRACE
         vim.log.levels.WARN
+        vim.log.levels.OFF
 
 ------------------------------------------------------------------------------
-LUA-VIMSCRIPT BRIDGE                                    *lua-vimscript*
+LUA-VIMSCRIPT BRIDGE                                           *lua-vimscript*
 
 Nvim Lua provides an interface to Vimscript variables and functions, and
 editor commands and options.
 See also https://github.com/nanotee/nvim-lua-guide.
 
-vim.call({func}, {...})					*vim.call()*
+vim.call({func}, {...})                                           *vim.call()*
         Invokes |vim-function| or |user-function| {func} with arguments {...}.
         See also |vim.fn|.
         Equivalent to: >
             vim.fn[func]({...})
 
-vim.cmd({cmd})                                          *vim.cmd()*
-        Executes multiple lines of Vimscript at once. It is an alias to
-        |nvim_exec()|, where `output` is set to false. Thus it works identical
-        to |:source|.
-        See also |ex-cmd-index|.
-        Example: >
-            vim.cmd('echo 42')
-            vim.cmd([[
-              augroup My_group
-                autocmd!
-                autocmd FileType c setlocal cindent
-              augroup END
-            ]])
-
-vim.fn.{func}({...})					*vim.fn*
+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: >
             vim.fn['some#function']({...})
@@ -967,8 +1038,10 @@ vim.fn.{func}({...})					*vim.fn*
         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*
+                                                           *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
@@ -980,31 +1053,31 @@ Example: >
     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
-
-vim.g                                                   *vim.g*
+<
+vim.g                                                                  *vim.g*
         Global (|g:|) editor variables.
         Key with no value returns `nil`.
 
-vim.b                                                   *vim.b*
+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*
+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*
+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*
+vim.v                                                                  *vim.v*
         |v:| variables.
         Invalid or unset key returns `nil`.
 
-vim.env                                                 *vim.env*
+vim.env                                                              *vim.env*
         Environment variables defined in the editor session.
         See |expand-env| and |:let-environment| for the Vimscript behavior.
         Invalid or unset key returns `nil`.
@@ -1019,7 +1092,7 @@ vim.env                                                 *vim.env*
                                                             *lua-vim-optlocal*
                                                             *lua-vim-setlocal*
 
-In Vimscript, there is an way to set options |set-option|. In Lua, the
+In Vimscript, there is a way to set options |set-option|. In Lua, the
 corresponding method is `vim.opt`.
 
 `vim.opt` provides several conveniences for setting and controlling options
@@ -1043,7 +1116,7 @@ from within Lua.
             `vim.opt.wildignore = '*.o,*.a,__pycache__'`
 
         However, vim.opt also supports a more elegent way of setting
-        list-style options, but using lua tables:
+        list-style options by using lua tables:
             `vim.opt.wildignore = { '*.o', '*.a', '__pycache__' }`
 
     To replicate the behavior of |:set+=|, use: >
@@ -1054,7 +1127,6 @@ from within Lua.
         -- or using the `:append(...)` method
         vim.opt.wildignore:append { "*.pyc", "node_modules" }
 <
-
     To replicate the behavior of |:set^=|, use: >
 
         -- vim.opt supports prepending options via the "^" operator
@@ -1086,7 +1158,7 @@ In any of the above examples, to replicate the behavior |setlocal|, use
 
 |vim.opt| returns an Option object.
 
-For example: `local listchar_object = vim.opt.listchar`
+For example: `local listchar_object = vim.opt.listchars`
 
 An `Option` has the following methods:
 
@@ -1175,14 +1247,13 @@ vim.o           :set                set                set
 vim.bo/vim.wo   :setlocal            -                 set
 vim.go          :setglobal          set                 -
 
-vim.o                                                   *vim.o*
+vim.o                                                                  *vim.o*
         Get or set editor options, like |:set|. Invalid key is an error.
         Example: >
             vim.o.cmdheight = 4
             print(vim.o.columns)
-
-
-vim.go                                                  *vim.go*
+<
+vim.go                                                                *vim.go*
         Get or set an |option|. Invalid key is an error.
 
         This is a wrapper around |nvim_set_option()| and |nvim_get_option()|.
@@ -1194,8 +1265,7 @@ vim.go                                                  *vim.go*
         Example: >
             vim.go.cmdheight = 4
 <
-
-vim.bo                                                  *vim.bo*
+vim.bo                                                                *vim.bo*
         Get or set buffer-scoped |local-options|. Invalid key is an error.
 
         This is a wrapper around |nvim_buf_set_option()| and
@@ -1204,8 +1274,8 @@ vim.bo                                                  *vim.bo*
         Example: >
             vim.bo.buflisted = true
             print(vim.bo.comments)
-
-vim.wo                                                  *vim.wo*
+<
+vim.wo                                                                *vim.wo*
         Get or set window-scoped |local-options|. Invalid key is an error.
 
         This is a wrapper around |nvim_win_set_option()| and
@@ -1214,11 +1284,42 @@ vim.wo                                                  *vim.wo*
         Example: >
             vim.wo.cursorcolumn = true
             print(vim.wo.foldmarker)
-
-
+<
 ==============================================================================
 Lua module: vim                                                      *lua-vim*
 
+cmd({command})                                                     *vim.cmd()*
+                Execute Vim script commands.
+
+                Example: >
+
+                   vim.cmd('echo 42')
+                   vim.cmd([[
+                     augroup My_group
+                       autocmd!
+                       autocmd FileType c setlocal cindent
+                     augroup END
+                   ]])
+                   vim.cmd({ cmd = 'echo', args = { '"foo"' } })
+<
+
+                Parameters: ~
+                    {command}  string|table Command(s) to execute. If a
+                               string, executes multiple lines of Vim script
+                               at once. In this case, it is an alias to
+                               |nvim_exec()|, where `output` is set to false.
+                               Thus it works identical to |:source|. If a
+                               table, executes a single command. In this case,
+                               it is an alias to |nvim_cmd()| where `opts` is
+                               empty.
+
+                See also: ~
+                    |ex-cmd-index|
+
+                                             *vim.connection_failure_errmsg()*
+connection_failure_errmsg({consequence})
+                TODO: Documentation
+
 defer_fn({fn}, {timeout})                                     *vim.defer_fn()*
                 Defers calling `fn` until `timeout` ms passes.
 
@@ -1233,6 +1334,21 @@ defer_fn({fn}, {timeout})                                     *vim.defer_fn()*
                 Return: ~
                     timer luv timer object
 
+                                                             *vim.deprecate()*
+deprecate({name}, {alternative}, {version}, {plugin}, {backtrace})
+                Display a deprecation notification to the user.
+
+                Parameters: ~
+                    {name}         string Deprecated function.
+                    {alternative}  (string|nil) Preferred alternative
+                                   function.
+                    {version}      string Version in which the deprecated
+                                   function will be removed.
+                    {plugin}       string|nil Plugin name that the function
+                                   will be removed from. Defaults to "Nvim".
+                    {backtrace}    boolean|nil Prints backtrace. Defaults to
+                                   true.
+
 inspect({object}, {options})                                   *vim.inspect()*
                 Return a human-readable representation of the given object.
 
@@ -1248,11 +1364,12 @@ notify({msg}, {level}, {opts})                                  *vim.notify()*
                 notification provider). By default, writes to |:messages|.
 
                 Parameters: ~
-                    {msg}    string Content of the notification to show to the
-                             user.
-                    {level}  number|nil One of the values from
+                    {msg}    (string) Content of the notification to show to
+                             the user.
+                    {level}  (number|nil) One of the values from
                              |vim.log.levels|.
-                    {opts}   table|nil Optional parameters. Unused by default.
+                    {opts}   (table|nil) Optional parameters. Unused by
+                             default.
 
 notify_once({msg}, {level}, {opts})                        *vim.notify_once()*
                 Display a notification only one time.
@@ -1261,11 +1378,15 @@ notify_once({msg}, {level}, {opts})                        *vim.notify_once()*
                 message will not display a notification.
 
                 Parameters: ~
-                    {msg}    string Content of the notification to show to the
-                             user.
-                    {level}  number|nil One of the values from
+                    {msg}    (string) Content of the notification to show to
+                             the user.
+                    {level}  (number|nil) One of the values from
                              |vim.log.levels|.
-                    {opts}   table|nil Optional parameters. Unused by default.
+                    {opts}   (table|nil) Optional parameters. Unused by
+                             default.
+
+                Return: ~
+                    (boolean) true if message was displayed, else false
 
 on_key({fn}, {ns_id})                                           *vim.on_key()*
                 Adds Lua function {fn} with namespace id {ns_id} as a listener
@@ -1291,8 +1412,8 @@ on_key({fn}, {ns_id})                                           *vim.on_key()*
                              returns a new |nvim_create_namespace()| id.
 
                 Return: ~
-                    number Namespace id associated with {fn}. Or count of all
-                    callbacks if on_key() is called without arguments.
+                    (number) Namespace id associated with {fn}. Or count of
+                    all callbacks if on_key() is called without arguments.
 
                 Note:
                     {fn} will be removed if an error occurs while calling.
@@ -1346,12 +1467,12 @@ region({bufnr}, {pos1}, {pos2}, {regtype}, {inclusive})         *vim.region()*
                 marked by two points
 
                 Parameters: ~
-                    {bufnr}      number of buffer
+                    {bufnr}      (number) of buffer
                     {pos1}       (line, column) tuple marking beginning of
                                  region
                     {pos2}       (line, column) tuple marking end of region
                     {regtype}    type of selection (:help setreg)
-                    {inclusive}  boolean indicating whether the selection is
+                    {inclusive}  (boolean) indicating whether the selection is
                                  end-inclusive
 
                 Return: ~
@@ -1371,14 +1492,14 @@ schedule_wrap({cb})                                      *vim.schedule_wrap()*
 deep_equal({a}, {b})                                        *vim.deep_equal()*
                 Deep compare values for equality
 
-                Tables are compared recursively unless they both provide the `eq` methamethod. All other types are compared using the equality `==` operator.
+                Tables are compared recursively unless they both provide the `eq` metamethod. All other types are compared using the equality `==` operator.
 
                 Parameters: ~
-                    {a}  first value
-                    {b}  second value
+                    {a}  any First value
+                    {b}  any Second value
 
                 Return: ~
-                    `true` if values are equals, else `false` .
+                    (boolean) `true` if values are equals, else `false`
 
 deepcopy({orig})                                              *vim.deepcopy()*
                 Returns a deep copy of the given object. Non-table objects are
@@ -1389,32 +1510,32 @@ deepcopy({orig})                                              *vim.deepcopy()*
                 and will throw an error.
 
                 Parameters: ~
-                    {orig}  table Table to copy
+                    {orig}  (table) Table to copy
 
                 Return: ~
-                    New table of copied keys and (nested) values.
+                    (table) Table of copied keys and (nested) values.
 
 endswith({s}, {suffix})                                       *vim.endswith()*
-                Tests if `s` ends with `suffix` .
+                Tests if `s` ends with `suffix`.
 
                 Parameters: ~
-                    {s}       (string) a string
-                    {suffix}  (string) a suffix
+                    {s}       (string) String
+                    {suffix}  (string) Suffix to match
 
                 Return: ~
-                    (boolean) true if `suffix` is a suffix of s
+                    (boolean) `true` if `suffix` is a suffix of `s`
 
 gsplit({s}, {sep}, {plain})                                     *vim.gsplit()*
                 Splits a string at each instance of a separator.
 
                 Parameters: ~
-                    {s}      String to split
-                    {sep}    Separator string or pattern
-                    {plain}  If `true` use `sep` literally (passed to
-                             String.find)
+                    {s}      (string) String to split
+                    {sep}    (string) Separator or pattern
+                    {plain}  (boolean) If `true` use `sep` literally (passed
+                             to string.find)
 
                 Return: ~
-                    Iterator over the split components
+                    (function) Iterator over the split components
 
                 See also: ~
                     |vim.split()|
@@ -1425,10 +1546,10 @@ is_callable({f})                                           *vim.is_callable()*
                 Returns true if object `f` can be called as a function.
 
                 Parameters: ~
-                    {f}  Any object
+                    {f}  any Any object
 
                 Return: ~
-                    true if `f` is callable, else false
+                    (boolean) `true` if `f` is callable, else `false`
 
 list_extend({dst}, {src}, {start}, {finish})               *vim.list_extend()*
                 Extends a list-like table with the values of another list-like
@@ -1437,13 +1558,14 @@ list_extend({dst}, {src}, {start}, {finish})               *vim.list_extend()*
                 NOTE: This mutates dst!
 
                 Parameters: ~
-                    {dst}     list which will be modified and appended to.
-                    {src}     list from which values will be inserted.
-                    {start}   Start index on src. defaults to 1
-                    {finish}  Final index on src. defaults to #src
+                    {dst}     (table) List which will be modified and appended
+                              to
+                    {src}     (table) List from which values will be inserted
+                    {start}   (number) Start index on src. Defaults to 1
+                    {finish}  (number) Final index on src. Defaults to `#src`
 
                 Return: ~
-                    dst
+                    (table) dst
 
                 See also: ~
                     |vim.tbl_extend()|
@@ -1453,21 +1575,22 @@ list_slice({list}, {start}, {finish})                       *vim.list_slice()*
                 to end (inclusive)
 
                 Parameters: ~
-                    {list}    table table
-                    {start}   integer Start range of slice
-                    {finish}  integer End range of slice
+                    {list}    (table) Table
+                    {start}   (number) Start range of slice
+                    {finish}  (number) End range of slice
 
                 Return: ~
-                    Copy of table sliced from start to finish (inclusive)
+                    (table) Copy of table sliced from start to finish
+                    (inclusive)
 
 pesc({s})                                                         *vim.pesc()*
                 Escapes magic chars in a Lua pattern.
 
                 Parameters: ~
-                    {s}  String to escape
+                    {s}  (string) String to escape
 
                 Return: ~
-                    %-escaped pattern string
+                    (string) %-escaped pattern string
 
                 See also: ~
                     https://github.com/rxi/lume
@@ -1484,49 +1607,55 @@ split({s}, {sep}, {kwargs})                                      *vim.split()*
 <
 
                 Parameters: ~
-                    {s}       String to split
-                    {sep}     Separator string or pattern
-                    {kwargs}  Keyword arguments:
+                    {s}       (string) String to split
+                    {sep}     (string) Separator or pattern
+                    {kwargs}  (table) Keyword arguments:
                               • plain: (boolean) If `true` use `sep` literally
                                 (passed to string.find)
                               • trimempty: (boolean) If `true` remove empty
                                 items from the front and back of the list
 
                 Return: ~
-                    List-like table of the split components.
+                    (table) List of split components
 
                 See also: ~
                     |vim.gsplit()|
 
 startswith({s}, {prefix})                                   *vim.startswith()*
-                Tests if `s` starts with `prefix` .
+                Tests if `s` starts with `prefix`.
 
                 Parameters: ~
-                    {s}       (string) a string
-                    {prefix}  (string) a prefix
+                    {s}       (string) String
+                    {prefix}  (string) Prefix to match
 
                 Return: ~
-                    (boolean) true if `prefix` is a prefix of s
+                    (boolean) `true` if `prefix` is a prefix of `s`
 
 tbl_add_reverse_lookup({o})                     *vim.tbl_add_reverse_lookup()*
                 Add the reverse lookup values to an existing table. For
-                example: tbl_add_reverse_lookup { A = 1 } == { [1] = 'A , A = 1 }`
+                example: `tbl_add_reverse_lookup { A = 1 } == { [1] = 'A', A =
+                1 }`
+
+                Note that this modifies the input.
 
                 Parameters: ~
-                    {o}  table The table to add the reverse to.
+                    {o}  (table) Table to add the reverse to
+
+                Return: ~
+                    (table) o
 
 tbl_contains({t}, {value})                                *vim.tbl_contains()*
-                Checks if a list-like (vector) table contains `value` .
+                Checks if a list-like (vector) table contains `value`.
 
                 Parameters: ~
-                    {t}      Table to check
-                    {value}  Value to compare
+                    {t}      (table) Table to check
+                    {value}  any Value to compare
 
                 Return: ~
-                    true if `t` contains `value`
+                    (boolean) `true` if `t` contains `value`
 
 tbl_count({t})                                               *vim.tbl_count()*
-                Counts the number of non-nil values in table `t` .
+                Counts the number of non-nil values in table `t`.
 >
 
     vim.tbl_count({ a=1, b=2 }) => 2
@@ -1534,10 +1663,10 @@ tbl_count({t})                                               *vim.tbl_count()*
 <
 
                 Parameters: ~
-                    {t}  Table
+                    {t}  (table) Table
 
                 Return: ~
-                    Number that is the number of the value in table
+                    (number) Number of non-nil values in table
 
                 See also: ~
                     https://github.com/Tieske/Penlight/blob/master/lua/pl/tablex.lua
@@ -1546,12 +1675,15 @@ tbl_deep_extend({behavior}, {...})                     *vim.tbl_deep_extend()*
                 Merges recursively two or more map-like tables.
 
                 Parameters: ~
-                    {behavior}  Decides what to do if a key is found in more
-                                than one map:
+                    {behavior}  (string) Decides what to do if a key is found
+                                in more than one map:
                                 • "error": raise an error
                                 • "keep": use value from the leftmost map
                                 • "force": use value from the rightmost map
-                    {...}       Two or more map-like tables.
+                    {...}       (table) Two or more map-like tables
+
+                Return: ~
+                    (table) Merged table
 
                 See also: ~
                     |tbl_extend()|
@@ -1560,12 +1692,15 @@ tbl_extend({behavior}, {...})                               *vim.tbl_extend()*
                 Merges two or more map-like tables.
 
                 Parameters: ~
-                    {behavior}  Decides what to do if a key is found in more
-                                than one map:
+                    {behavior}  (string) Decides what to do if a key is found
+                                in more than one map:
                                 • "error": raise an error
                                 • "keep": use value from the leftmost map
                                 • "force": use value from the rightmost map
-                    {...}       Two or more map-like tables.
+                    {...}       (table) Two or more map-like tables
+
+                Return: ~
+                    (table) Merged table
 
                 See also: ~
                     |extend()|
@@ -1574,27 +1709,51 @@ tbl_filter({func}, {t})                                     *vim.tbl_filter()*
                 Filter a table using a predicate function
 
                 Parameters: ~
-                    {func}  function or callable table
-                    {t}     table
+                    {func}  function|table Function or callable table
+                    {t}     (table) Table
+
+                Return: ~
+                    (table) Table of filtered values
 
 tbl_flatten({t})                                           *vim.tbl_flatten()*
                 Creates a copy of a list-like table such that any nested
                 tables are "unrolled" and appended to the result.
 
                 Parameters: ~
-                    {t}  List-like table
+                    {t}  (table) List-like table
 
                 Return: ~
-                    Flattened copy of the given list-like table.
+                    (table) Flattened copy of the given list-like table
 
                 See also: ~
                     From https://github.com/premake/premake-core/blob/master/src/base/table.lua
 
+tbl_get({o}, {...})                                            *vim.tbl_get()*
+                Index into a table (first argument) via string keys passed as
+                subsequent arguments. Return `nil` if the key does not exist.
+
+                Examples: >
+
+                  vim.tbl_get({ key = { nested_key = true }}, 'key', 'nested_key') == true
+                  vim.tbl_get({ key = {}}, 'key', 'nested_key') == nil
+<
+
+                Parameters: ~
+                    {o}    (table) Table to index
+                    {...}  (string) Optional strings (0 or more, variadic) via
+                           which to index the table
+
+                Return: ~
+                    any Nested value indexed by key (if it exists), else nil
+
 tbl_isempty({t})                                           *vim.tbl_isempty()*
                 Checks if a table is empty.
 
                 Parameters: ~
-                    {t}  Table to check
+                    {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
@@ -1608,20 +1767,20 @@ tbl_islist({t})                                             *vim.tbl_islist()*
                 |vim.fn|.
 
                 Parameters: ~
-                    {t}  Table
+                    {t}  (table) Table
 
                 Return: ~
-                    `true` if array-like table, else `false` .
+                    (boolean) `true` if array-like table, else `false`
 
 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
+                    {t}  (table) Table
 
                 Return: ~
-                    list of keys
+                    (table) List of keys
 
                 See also: ~
                     From https://github.com/premake/premake-core/blob/master/src/base/table.lua
@@ -1630,28 +1789,32 @@ tbl_map({func}, {t})                                           *vim.tbl_map()*
                 Apply a function to all values of a table.
 
                 Parameters: ~
-                    {func}  function or callable table
-                    {t}     table
+                    {func}  function|table Function or callable table
+                    {t}     (table) Table
+
+                Return: ~
+                    (table) Table of transformed values
 
 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
+                    {t}  (table) Table
 
                 Return: ~
-                    list of values
+                    (table) List of values
 
 trim({s})                                                         *vim.trim()*
                 Trim whitespace (Lua pattern "%s") from both sides of a
                 string.
 
                 Parameters: ~
-                    {s}  String to trim
+                    {s}  (string) String to trim
 
                 Return: ~
-                    String with whitespace removed from its beginning and end
+                    (string) String with whitespace removed from its beginning
+                    and end
 
                 See also: ~
                     https://www.lua.org/pil/20.2.html
@@ -1693,7 +1856,7 @@ validate({opt})                                               *vim.validate()*
 <
 
                 Parameters: ~
-                    {opt}  table of parameter names to validations. Each key
+                    {opt}  (table) Names of parameters to validate. Each key
                            is a parameter name; each value is a tuple in one
                            of these forms:
                            1. (arg_value, type_name, optional)
@@ -1723,38 +1886,38 @@ uri_from_bufnr({bufnr})                                 *vim.uri_from_bufnr()*
                 Get a URI from a bufnr
 
                 Parameters: ~
-                    {bufnr}  number
+                    {bufnr}  (number)
 
                 Return: ~
-                    string URI
+                    (string) URI
 
 uri_from_fname({path})                                  *vim.uri_from_fname()*
                 Get a URI from a file path.
 
                 Parameters: ~
-                    {path}  string Path to file
+                    {path}  (string) Path to file
 
                 Return: ~
-                    string URI
+                    (string) URI
 
 uri_to_bufnr({uri})                                       *vim.uri_to_bufnr()*
                 Get the buffer for a uri. Creates a new unloaded buffer if no
                 buffer for the uri already exists.
 
                 Parameters: ~
-                    {uri}  string
+                    {uri}  (string)
 
                 Return: ~
-                    number bufnr
+                    (number) bufnr
 
 uri_to_fname({uri})                                       *vim.uri_to_fname()*
                 Get a filename from a URI
 
                 Parameters: ~
-                    {uri}  string
+                    {uri}  (string)
 
                 Return: ~
-                    string filename or unchanged URI for non-file URIs
+                    (string) filename or unchanged URI for non-file URIs
 
 
 ==============================================================================
@@ -1763,10 +1926,16 @@ Lua module: ui                                                        *lua-ui*
 input({opts}, {on_confirm})                                   *vim.ui.input()*
                 Prompts the user for input
 
+                Example: >
+
+                 vim.ui.input({ prompt = 'Enter value for shiftwidth: ' }, function(input)
+                     vim.o.shiftwidth = tonumber(input)
+                 end)
+<
+
                 Parameters: ~
-                    {opts}        table Additional options. See |input()|
-                                  • prompt (string|nil) Text of the prompt.
-                                    Defaults to `Input:` .
+                    {opts}        (table) Additional options. See |input()|
+                                  • prompt (string|nil) Text of the prompt
                                   • default (string|nil) Default reply to the
                                     input
                                   • completion (string|nil) Specifies type of
@@ -1777,32 +1946,48 @@ input({opts}, {on_confirm})                                   *vim.ui.input()*
                                     |:command-completion|
                                   • highlight (function) Function that will be
                                     used for highlighting user inputs.
-                    {on_confirm}  function ((input|nil) -> ()) Called once the
-                                  user confirms or abort the input. `input` is
-                                  what the user typed. `nil` if the user
-                                  aborted the dialog.
+                    {on_confirm}  (function) ((input|nil) -> ()) Called once
+                                  the user confirms or abort the input.
+                                  `input` is what the user typed. `nil` if the
+                                  user aborted the dialog.
 
 select({items}, {opts}, {on_choice})                         *vim.ui.select()*
                 Prompts the user to pick a single item from a collection of
                 entries
 
+                Example: >
+
+                 vim.ui.select({ 'tabs', 'spaces' }, {
+                     prompt = 'Select tabs or spaces:',
+                     format_item = function(item)
+                         return "I'd like to choose " .. item
+                     end,
+                 }, function(choice)
+                     if choice == 'spaces' then
+                         vim.o.expandtab = true
+                     else
+                         vim.o.expandtab = false
+                     end
+                 end)
+<
+
                 Parameters: ~
-                    {items}      table Arbitrary items
-                    {opts}       table Additional options
+                    {items}      (table) Arbitrary items
+                    {opts}       (table) Additional options
                                  • prompt (string|nil) Text of the prompt.
                                    Defaults to `Select one of:`
                                  • format_item (function item -> text)
                                    Function to format an individual item from
-                                   `items` . Defaults to `tostring` .
+                                   `items`. Defaults to `tostring`.
                                  • kind (string|nil) Arbitrary hint string
                                    indicating the item shape. Plugins
                                    reimplementing `vim.ui.select` may wish to
                                    use this to infer the structure or
-                                   semantics of `items` , or the context in
+                                   semantics of `items`, or the context in
                                    which select() was called.
-                    {on_choice}  function ((item|nil, idx|nil) -> ()) Called
+                    {on_choice}  (function) ((item|nil, idx|nil) -> ()) Called
                                  once the user made a choice. `idx` is the
-                                 1-based index of `item` within `item` . `nil`
+                                 1-based index of `item` within `items`. `nil`
                                  if the user aborted the dialog.
 
 
@@ -1816,16 +2001,19 @@ add({filetypes})                                          *vim.filetype.add()*
                 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 patterns (sorted by priority)
-                until a match is found. Lastly, if pattern matching does not
-                find a filetype, then the file extension is used.
+                matched against the list of |lua-patterns| (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.
+                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.
 
                 Filename patterns can specify an optional priority to resolve
                 cases when a file path matches multiple patterns. Higher
@@ -1834,8 +2022,8 @@ add({filetypes})                                          *vim.filetype.add()*
 
                 See $VIMRUNTIME/lua/vim/filetype.lua for more examples.
 
-                Note that Lua filetype detection is only enabled when
-                |g:do_filetype_lua| is set to 1.
+                Note that Lua filetype detection is disabled when
+                |g:do_legacy_filetype| is set.
 
                 Example: >
 
@@ -1844,7 +2032,10 @@ add({filetypes})                                          *vim.filetype.add()*
                       foo = "fooscript",
                       bar = function(path, bufnr)
                         if some_condition() then
-                          return "barscript"
+                          return "barscript", function(bufnr)
+                            -- Set a buffer variable
+                            vim.b[bufnr].barscript_version = 2
+                          end
                         end
                         return "bar"
                       end,
@@ -1868,10 +2059,87 @@ add({filetypes})                                          *vim.filetype.add()*
                   })
 <
 
+                To add a fallback match on contents (see
+                |new-filetype-scripts|), use >
+
+                 vim.filetype.add {
+                   pattern = {
+                     ['.*'] = {
+                       priority = -math.huge,
+                       function(path, bufnr)
+                         local content = vim.filetype.getlines(bufnr, 1)
+                         if vim.filetype.matchregex(content, { [[^#!.*\<mine\>]] }) then
+                           return 'mine'
+                         elseif vim.filetype.matchregex(content, { [[\<drawing\>]] }) then
+                           return 'drawing'
+                         end
+                       end,
+                     },
+                   },
+                 }
+<
+
                 Parameters: ~
-                    {filetypes}  table A table containing new filetype maps
+                    {filetypes}  (table) A table containing new filetype maps
                                  (see example).
 
+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:
+>
+
+    -- 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 (number): Buffer number to use for matching.
+                              Mutually exclusive with {contents}
+                            • 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.
+                            • contents (table): An array of lines representing
+                              file contents to use for matching. Can be used
+                              with {filename}. Mutually exclusive with {buf}.
+
+                Return: ~
+                    (string|nil) If a match was found, the matched filetype.
+                    (function|nil) A function that modifies buffer state when
+                    called (for example, to set some filetype specific buffer
+                    variables). The function accepts a buffer number as its
+                    only argument.
+
 
 ==============================================================================
 Lua module: keymap                                                *lua-keymap*
@@ -1885,7 +2153,7 @@ del({modes}, {lhs}, {opts})                                 *vim.keymap.del()*
 <
 
                 Parameters: ~
-                    {opts}  table A table of optional arguments:
+                    {opts}  (table) A table of optional arguments:
                             • buffer: (number or boolean) Remove a mapping
                               from the given buffer. When "true" or 0, use the
                               current buffer.
@@ -1918,9 +2186,9 @@ set({mode}, {lhs}, {rhs}, {opts})                           *vim.keymap.set()*
                     vim.keymap.set('n', 'asdf', require('jkl').my_fun)
 <
 
-                the require('jkl') gets evaluated during this call in order to
-                access the function. If you want to avoid this cost at startup
-                you can wrap it in a function, for example: >
+                the `require('jkl')` gets evaluated during this call in order to access the
+                function. If you want to avoid this cost at startup you can
+                wrap it in a function, for example: >
 
                     vim.keymap.set('n', 'asdf', function() return require('jkl').my_fun() end)
 <
@@ -1929,24 +2197,152 @@ set({mode}, {lhs}, {rhs}, {opts})                           *vim.keymap.set()*
                     {mode}  string|table Same mode short names as
                             |nvim_set_keymap()|. Can also be list of modes to
                             create mapping on multiple modes.
-                    {lhs}   string Left-hand side |{lhs}| of the mapping.
+                    {lhs}   (string) Left-hand side |{lhs}| of the mapping.
                     {rhs}   string|function Right-hand side |{rhs}| of the
-                            mapping. Can also be a Lua function.
-                    {opts}  table A table of |:map-arguments| such as
+                            mapping. Can also be a Lua function. If a Lua
+                            function and `opts.expr == true`, returning `nil`
+                            is equivalent to an empty string.
+                    {opts}  (table) A table of |:map-arguments| such as
                             "silent". In addition to the options listed in
                             |nvim_set_keymap()|, this table also accepts the
                             following keys:
+                            • buffer: (number or boolean) Add a mapping to the
+                              given buffer. When "true" or 0, use the current
+                              buffer.
                             • replace_keycodes: (boolean, default true) When
                               both this and expr is "true",
                               |nvim_replace_termcodes()| is applied to the
                               result of Lua expr maps.
                             • remap: (boolean) Make the mapping recursive.
                               This is the inverse of the "noremap" option from
-                              |nvim_set_keymap()|. Default `true` if `lhs` is
-                              a string starting with `<plug>`
-                              (case-insensitive), `false` otherwise.
+                              |nvim_set_keymap()|. Default `false`.
 
                 See also: ~
                     |nvim_set_keymap()|
 
+
+==============================================================================
+Lua module: fs                                                        *lua-fs*
+
+basename({file})                                           *vim.fs.basename()*
+                Return the basename of the given file or directory
+
+                Parameters: ~
+                    {file}  (string) File or directory
+
+                Return: ~
+                    (string) Basename of {file}
+
+dir({path})                                                     *vim.fs.dir()*
+                Return an iterator over the files and directories located in
+                {path}
+
+                Parameters: ~
+                    {path}  (string) An absolute or relative path to the
+                            directory to iterate over. The path is first
+                            normalized |vim.fs.normalize()|.
+
+                Return: ~
+                    Iterator over files and directories in {path}. Each
+                    iteration yields two values: name and type. Each "name" is
+                    the basename of the file or directory relative to {path}.
+                    Type is one of "file" or "directory".
+
+dirname({file})                                             *vim.fs.dirname()*
+                Return the parent directory of the given file or directory
+
+                Parameters: ~
+                    {file}  (string) File or directory
+
+                Return: ~
+                    (string) Parent directory of {file}
+
+find({names}, {opts})                                          *vim.fs.find()*
+                Find files or directories in the given path.
+
+                Finds any files or directories 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. The search can be narrowed to find only
+                files or or only directories by specifying {type} to be "file"
+                or "directory", respectively.
+
+                Parameters: ~
+                    {names}  (string|table) Names of the files and directories
+                             to find. Must be base names, paths and globs are
+                             not supported.
+                    {opts}   (table) Optional keyword arguments:
+                             • path (string): Path to begin searching from. If
+                               omitted, the current working directory is used.
+                             • upward (boolean, default false): If true,
+                               search upward through parent directories.
+                               Otherwise, search through child directories
+                               (recursively).
+                             • stop (string): Stop searching when this
+                               directory is reached. The directory itself is
+                               not searched.
+                             • type (string): Find only files ("file") or
+                               directories ("directory"). If omitted, both
+                               files and directories that match {name} are
+                               included.
+                             • limit (number, default 1): Stop the search
+                               after finding this many matches. Use
+                               `math.huge` to place no limit on the number of
+                               matches.
+
+                Return: ~
+                    (table) The paths of all matching files or directories
+
+normalize({path})                                         *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 any backslash (\) characters are converted to
+                forward slashes (/). Environment variables are also expanded.
+
+                Example: >
+
+                 vim.fs.normalize('C:\Users\jdoe')
+                 => 'C:/Users/jdoe'
+
+                 vim.fs.normalize('~/src/neovim')
+                 => '/home/jdoe/src/neovim'
+
+                 vim.fs.normalize('$XDG_CONFIG_HOME/nvim/init.vim')
+                 => '/Users/jdoe/.config/nvim/init.vim'
+<
+
+                Parameters: ~
+                    {path}  (string) Path to normalize
+
+                Return: ~
+                    (string) Normalized path
+
+parents({start})                                            *vim.fs.parents()*
+                Iterate over all the parents of the given file or directory.
+
+                Example: >
+
+                 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
+<
+
+                Parameters: ~
+                    {start}  (string) Initial file or directory.
+
+                Return: ~
+                    (function) Iterator
+
  vim:tw=78:ts=8:ft=help:norl:
diff --git a/runtime/doc/map.txt b/runtime/doc/map.txt
index e2c274e040..7e94167e07 100644
--- a/runtime/doc/map.txt
+++ b/runtime/doc/map.txt
@@ -48,6 +48,7 @@ modes.
 			allows for nested and recursive use of mappings.
 			Note: Trailing spaces are included in the {rhs},
 			because space is a valid Normal mode command.
+			See |map-trailing-white|.
 
 						*:nore* *:norem*
 :no[remap]  {lhs} {rhs}		|mapmode-nvo|	*:no*  *:noremap* *:nor*
@@ -65,6 +66,8 @@ modes.
 			where the map command applies.  Disallow mapping of
 			{rhs}, to avoid nested and recursive mappings.  Often
 			used to redefine a command.
+			Note: When <Plug> appears in the {rhs} this part is
+			always applied even if remapping is disallowed.
 
 
 :unm[ap]  {lhs}			|mapmode-nvo|		*:unm*  *:unmap*
@@ -83,10 +86,8 @@ modes.
 			for other modes where it applies.
 			It also works when {lhs} matches the {rhs} of a
 			mapping. This is for when an abbreviation applied.
-			Note: Trailing spaces are included in the {lhs}.  This
-			unmap does NOT work: >
-				:map @@ foo
-				:unmap @@ | print
+			Note: Trailing spaces are included in the {lhs}.
+			See |map-trailing-white|.
 
 :mapc[lear]			|mapmode-nvo|		*:mapc*   *:mapclear*
 :nmapc[lear]			|mapmode-n|		*:nmapc*  *:nmapclear*
@@ -103,7 +104,7 @@ modes.
 			command applies.
 			Use the <buffer> argument to remove buffer-local
 			mappings |:map-<buffer>|
-			Warning: This also removes the default mappings.
+			Warning: This also removes the |default-mappings|.
 
 :map				|mapmode-nvo|
 :nm[ap]				|mapmode-n|
@@ -150,6 +151,24 @@ that mapping won't get expanded yet, Vim is waiting for another character.
 If you type a space, then "foo" will get inserted, plus the space.  If you
 type "a", then "bar" will get inserted.
 
+Trailing white space ~
+							*map-trailing-white*
+This unmap command does NOT work: >
+	:map @@ foo
+	:unmap @@ | print
+
+Because it tries to unmap "@@ ", including the white space before the command
+separator "|".  Other examples with trailing white space: >
+	unmap @@ 
+	unmap @@     " comment
+
+An error will be issued, which is very hard to identify, because the ending
+whitespace character in `unmap @@ ` is not visible.
+
+A generic solution is to put the command separator "|" right after the mapped
+keys.  After that white space and a comment may follow: >
+	unmap @@|    " comment
+
 
 1.2 SPECIAL ARGUMENTS					*:map-arguments*
 
@@ -157,7 +176,8 @@ type "a", then "bar" will get inserted.
 "<unique>" can be used in any order.  They must appear right after the
 command, before any other arguments.
 
-			*:map-local* *:map-<buffer>* *:map-buffer* *E224* *E225*
+					*:map-local* *:map-<buffer>* *:map-buffer*
+					*E224* *E225*
 If the first argument to one of these commands is "<buffer>" the mapping will
 be effective in the current buffer only.  Example: >
 	:map <buffer>  ,w  /[.,;]<CR>
@@ -244,7 +264,7 @@ go through the main loop (e.g. to update the display), return "\<Ignore>".
 This is similar to "nothing" but makes Vim return from the loop that waits for
 input.
 
-Also, keep in mind that the expression may be evaluated when looking for
+Keep in mind that the expression may be evaluated when looking for
 typeahead, before the previous command has been executed.  For example: >
 	func StoreColumn()
 	  let g:column = col('.')
@@ -285,7 +305,7 @@ Here is an example that inserts a list number that increases: >
 
 	func ListItem()
 	  let g:counter += 1
-	  return g:counter . '. '
+	  return g:counter .. '. '
 	endfunc
 
 	func ListReset()
@@ -326,8 +346,6 @@ Note:
   mapping is recursive.
 - In Visual mode  you can use `line('v')` and `col('v')` to get one end of the
   Visual area, the cursor is at the other end.
-- In select-mode, |:map| and |:vmap| command mappings are executed in
-  visual-mode.  Use |:smap| to handle select-mode.
 
 							*E5520*
 <Cmd> commands must terminate, that is, they must be followed by <CR> in the
@@ -502,7 +520,9 @@ Note: When using mappings for Visual mode, you can use the "'<" mark, which
 is the start of the last selected Visual area in the current buffer |'<|.
 
 The |:filter| command can be used to select what mappings to list.  The
-pattern is matched against the {lhs} and {rhs} in the raw form.
+pattern is matched against the {lhs} and {rhs} in the raw form.  If a
+description was added using |nvim_set_keymap()| or |nvim_buf_set_keymap()|
+then the pattern is also matched against it.
 
 							*:map-verbose*
 When 'verbose' is non-zero, listing a key map will also display where it was
@@ -792,9 +812,8 @@ command.  For example: >
    :noremap j k
 This will exchange the cursor up and down commands.
 
-With the normal :map command, when the 'remap' option is on, mapping takes
-place until the text is found not to be a part of a {lhs}.  For example, if
-you use: >
+With the normal :map command mapping takes place until the text is found not
+to be a part of a {lhs}.  For example, if you use: >
    :map x y
    :map y x
 Vim will replace x with y, and then y with x, etc.  When this has happened
@@ -1217,7 +1236,7 @@ scripts.
 
 							*:command-verbose*
 When 'verbose' is non-zero, listing a command will also display where it was
-last defined. Example: >
+last defined and any completion argument. Example: >
 
     :verbose command TOhtml
 <	Name	    Args Range Complete  Definition ~
@@ -1241,6 +1260,10 @@ See |:verbose-cmd| for more information.
 :delc[ommand] {cmd}				*:delc* *:delcommand* *E184*
 			Delete the user-defined command {cmd}.
 
+:delc[ommand] -buffer {cmd}					*E1237*
+			Delete the user-defined command {cmd} that was defined
+			for the current buffer.
+
 :comc[lear]						*:comc* *:comclear*
 			Delete all user-defined commands.
 
@@ -1332,6 +1355,8 @@ completion can be enabled:
 	-complete=custom,{func} custom completion, defined via {func}
 	-complete=customlist,{func} custom completion, defined via {func}
 
+If you specify completion while there is nothing to complete (-nargs=0, the
+default) then you get error *E1208* .
 Note: That some completion methods might expand environment variables.
 
 
@@ -1411,7 +1436,7 @@ which by default correspond to the current line, last line and the whole
 buffer, relate to arguments, (loaded) buffers, windows or tab pages.
 
 Possible values are (second column is the short name used in listing):
-    -addr=lines		  	Range of lines (this is the default)
+    -addr=lines		  line	Range of lines (this is the default)
     -addr=arguments	  arg	Range for arguments
     -addr=buffers	  buf	Range for buffers (also not loaded buffers)
     -addr=loaded_buffers  load	Range for loaded buffers
@@ -1421,6 +1446,112 @@ Possible values are (second column is the short name used in listing):
     -addr=other		  ?	other kind of range
 
 
+Incremental preview ~
+                                                  *:command-preview* {nvim-api}
+Commands can show an 'inccommand' (as-you-type) preview by defining a preview
+handler (only from Lua, see |nvim_create_user_command()|).
+
+The preview callback must be a Lua function with this signature: >
+
+    function cmdpreview(opts, ns, buf)
+<
+where "opts" has the same form as that given to |nvim_create_user_command()|
+callbacks, "ns" is the preview namespace id for highlights, and "buf" is the
+buffer that your preview routine will directly modify to show the previewed
+results (for "inccommand=split", or nil for  "inccommand=nosplit").
+
+Your command preview routine must implement this protocol:
+
+1. Modify the current buffer as required for the preview (see
+   |nvim_buf_set_text()| and |nvim_buf_set_lines()|).
+2. If preview buffer is provided, add necessary text to the preview buffer.
+3. Add required highlights to the current buffer. If preview buffer is
+   provided, add required highlights to the preview buffer as well. All
+   highlights must be added to the preview namespace which is provided as an
+   argument to the preview callback (see |nvim_buf_add_highlight()| and
+   |nvim_buf_set_extmark()| for help on how to add highlights to a namespace).
+4. Return an integer (0, 1, 2) which controls how Nvim behaves as follows:
+   0: No preview is shown.
+   1: Preview is shown without preview window (even with "inccommand=split").
+   2: Preview is shown and preview window is opened (if "inccommand=split").
+      For "inccommand=nosplit" this is the same as 1.
+
+After preview ends, Nvim discards all changes to the buffer and all highlights
+in the preview namespace.
+
+Here's an example of a command to trim trailing whitespace from lines that
+supports incremental command preview:
+>
+	-- Trims trailing whitespace in the current buffer.
+	-- Also performs 'inccommand' preview if invoked as a preview callback
+	-- (preview_ns is non-nil).
+	local function trim_space(opts, preview_ns, preview_buf)
+	  local line1 = opts.line1
+	  local line2 = opts.line2
+	  local buf = vim.api.nvim_get_current_buf()
+	  local lines = vim.api.nvim_buf_get_lines(buf, line1 - 1, line2, 0)
+	  local new_lines = {}
+	  local preview_buf_line = 0
+
+	  for i, line in ipairs(lines) do
+	    local startidx, endidx = string.find(line, '%s+$')
+
+	    if startidx ~= nil then
+	      -- Highlight the match if in command preview mode
+	      if preview_ns ~= nil then
+		vim.api.nvim_buf_add_highlight(
+		  buf, preview_ns, 'Substitute', line1 + i - 2, startidx - 1,
+		  endidx
+		)
+
+		-- Add lines and highlight to the preview buffer
+		-- if inccommand=split
+		if preview_buf ~= nil then
+		  local prefix = string.format('|%d| ', line1 + i - 1)
+
+		  vim.api.nvim_buf_set_lines(
+		    preview_buf, preview_buf_line, preview_buf_line, 0,
+		    { prefix .. line }
+		  )
+		  vim.api.nvim_buf_add_highlight(
+		    preview_buf, preview_ns, 'Substitute', preview_buf_line,
+		    #prefix + startidx - 1, #prefix + endidx
+		  )
+
+		  preview_buf_line = preview_buf_line + 1
+		end
+	      end
+	    end
+
+	    if not preview_ns then
+	      new_lines[#new_lines+1] = string.gsub(line, '%s+$', '')
+	    end
+	  end
+
+	  -- Don't make any changes to the buffer if previewing
+	  if not preview_ns then
+	    vim.api.nvim_buf_set_lines(buf, line1 - 1, line2, 0, new_lines)
+	  end
+
+	  -- When called as a preview callback, return the value of the
+	  -- preview type
+	  if preview_ns ~= nil then
+	    return 2
+	  end
+	end
+
+	-- Create the user command
+	vim.api.nvim_create_user_command(
+	  'TrimTrailingWhitespace',
+	  trim_space,
+	  { nargs = '?', range = '%', addr = 'lines', preview = trim_space }
+	)
+<
+Note that in the above example, the same function is used as both the command
+callback and the preview callback, but you could instead use separate
+functions.
+
+
 Special cases ~
 					*:command-bang* *:command-bar*
 					*:command-register* *:command-buffer*
@@ -1434,6 +1565,9 @@ There are some special cases as well:
 	-register   The first argument to the command can be an optional
 		    register name (like :del, :put, :yank).
 	-buffer	    The command will only be available in the current buffer.
+	-keepscript Do not use the location of where the user command was
+		    defined for verbose messages, use the location of where
+		    the user command was invoked.
 
 In the cases of the -count and -register attributes, if the optional argument
 is supplied, it is removed from the argument list and is available to the
@@ -1471,19 +1605,19 @@ The valid escape sequences are
 		nothing. Supported modifiers are |:aboveleft|, |:belowright|,
 		|:botright|, |:browse|, |:confirm|, |:hide|, |:keepalt|,
 		|:keepjumps|, |:keepmarks|, |:keeppatterns|, |:leftabove|,
-		|:lockmarks|, |:noswapfile| |:rightbelow|, |:silent|, |:tab|,
-		|:topleft|, |:verbose|, and |:vertical|.
-		Note that these are not yet supported: |:noautocmd|,
-		|:sandbox| and |:unsilent|.
+		|:lockmarks|, |:noautocmd|, |:noswapfile| |:rightbelow|,
+		|:sandbox|, |:silent|, |:tab|, |:topleft|, |:unsilent|,
+		|:verbose|, and |:vertical|.
+		Note that |:filter| is not supported.
 		Examples: >
 		    command! -nargs=+ -complete=file MyEdit
 				\ for f in expand(<q-args>, 0, 1) |
-				\ exe '<mods> split ' . f |
+				\ exe '<mods> split ' .. f |
 				\ endfor
 
 		    function! SpecialEdit(files, mods)
 			for f in expand(a:files, 0, 1)
-			    exe a:mods . ' split ' . f
+			    exe a:mods .. ' split ' .. f
 			endfor
 		    endfunction
 		    command! -nargs=+ -complete=file Sedit
@@ -1559,7 +1693,7 @@ This will invoke: >
    :   let i = 0
    :   while i < argc()
    :	  if filereadable(argv(i))
-   :	     execute "e " . argv(i)
+   :	     execute "e " .. argv(i)
    :	     execute a:command
    :      endif
    :      let i = i + 1
diff --git a/runtime/doc/message.txt b/runtime/doc/message.txt
index 950028d9cc..dac4df5ee9 100644
--- a/runtime/doc/message.txt
+++ b/runtime/doc/message.txt
@@ -27,8 +27,7 @@ depends on the 'shortmess' option.
 				Clear messages, keeping only the {count} most
 				recent ones.
 
-The number of remembered messages is fixed at 20 for the tiny version and 200
-for other versions.
+The number of remembered messages is fixed at 200.
 
 								*g<*
 The "g<" command can be used to see the last page of previous command output.
@@ -62,7 +61,7 @@ If you are lazy, it also works without the shift key: >
 
 When an error message is displayed, but it is removed before you could read
 it, you can see it again with: >
-  :echo errmsg
+  :echo v:errmsg
 Or view a list of recent messages with: >
   :messages
 See `:messages` above.
diff --git a/runtime/doc/motion.txt b/runtime/doc/motion.txt
index c473244827..9655d07a84 100644
--- a/runtime/doc/motion.txt
+++ b/runtime/doc/motion.txt
@@ -735,6 +735,11 @@ Jumping to a mark can be done in two ways:
 2. With ' (single quote): The cursor is positioned on the first non-blank
 			  character in the line of the specified location and
 			  the motion is linewise.
+						*mark-view*
+3. Apart from the above if 'jumpoptions' contains "view", they will also try to
+restore the mark view. This is the number of lines between the cursor position
+and the window topline (first buffer line displayed in the window) when it was
+set.
 
 						*m* *mark* *Mark*
 m{a-zA-Z}		Set mark {a-zA-Z} at cursor position (does not move
@@ -993,7 +998,7 @@ These commands are not marks themselves, but jump to a mark:
 				:let lnum = line(".")
 				:keepjumps normal gg
 				:call SetLastChange()
-				:keepjumps exe "normal " . lnum . "G"
+				:keepjumps exe "normal " .. lnum .. "G"
 <
 			Note that ":keepjumps" must be used for every command.
 			When invoking a function the commands in that function
@@ -1044,6 +1049,9 @@ The "file/text" column shows the file name, or the text at the jump if it is
 in the current file (an indent is removed and a long line is truncated to fit
 in the window).
 
+The marker ">" indicates the current position in the jumplist.  It may not be
+shown when filtering the |:jumps| command using |:filter|
+
 You are currently in line 1167.  If you then use the CTRL-O command, the
 cursor is put in line 1154.  This results in:
 
diff --git a/runtime/doc/nvim_terminal_emulator.txt b/runtime/doc/nvim_terminal_emulator.txt
index bfacbe19f5..a7be9ff98f 100644
--- a/runtime/doc/nvim_terminal_emulator.txt
+++ b/runtime/doc/nvim_terminal_emulator.txt
@@ -25,31 +25,30 @@ Start						*terminal-start*
 
 There are several ways to create a terminal buffer:
 
-- Invoke the |:terminal| command.
-- Call the |termopen()| function.
-- Edit a file with a name matching `term://(.{-}//(\d+:)?)?\zs.*`.
-  For example:
->
+- Run the |:terminal| command.
+- Call the |nvim_open_term()| or |termopen()| function.
+- Edit a "term://" buffer. Examples: >
     :edit term://bash
     :vsplit term://top
-<
-    Note: The "term://" pattern is handled by a BufReadCmd handler, so the
-    |autocmd-nested| modifier is required to use it in an autocmd. >
+
+<    Note: To open a "term://" buffer from an autocmd, the |autocmd-nested|
+    modifier is required. >
         autocmd VimEnter * ++nested split term://sh
-<    This is only mentioned for reference; use |:terminal| instead.
+<    (This is only mentioned for reference; use |:terminal| instead.)
 
 When the terminal starts, the buffer contents are updated and the buffer is
 named in the form of `term://{cwd}//{pid}:{cmd}`. This naming scheme is used
 by |:mksession| to restore a terminal buffer (by restarting the {cmd}).
 
+The terminal environment is initialized as in |jobstart-env|.
+
 ==============================================================================
 Input						*terminal-input*
 
-To send input, enter |Terminal-mode| using any command that would enter "insert
-mode" in a normal buffer, such as |i| or |:startinsert|. In this mode all keys
-except <C-\> are sent to the underlying program. If <C-\> is pressed, the
-next key is sent unless it is <C-N>. Use <C-\><C-N> to return to normal-mode.
-|CTRL-\_CTRL-N|
+To send input, enter |Terminal-mode| with |i|, |I|, |a|, |A| or
+|:startinsert|. In this mode all keys except <C-\> are sent to the underlying
+program. If <C-\> is pressed, the next key is sent unless it is <C-N>. Use
+<C-\><C-N> to return to normal-mode. |CTRL-\_CTRL-N|
 
 Terminal-mode forces these local options:
 
@@ -81,6 +80,9 @@ To use `ALT+{h,j,k,l}` to navigate windows from any mode: >
     :nnoremap <A-k> <C-w>k
     :nnoremap <A-l> <C-w>l
 
+You can also create menus similar to terminal mode mappings, but you have to
+use |:tlmenu| instead of |:tmenu|.
+
 Mouse input has the following behavior:
 
 - If the program has enabled mouse events, the corresponding events will be
@@ -162,12 +164,11 @@ command name, for example: >
 This opens two windows:
 
 gdb window	A terminal window in which "gdb vim" is executed.  Here you
-		can directly interact with gdb.  The buffer name is "!gdb".
+		can directly interact with gdb.
 
 program window	A terminal window for the executed program.  When "run" is
 		used in gdb the program I/O will happen in this window, so
-		that it does not interfere with controlling gdb.  The buffer
-		name is "gdb program".
+		that it does not interfere with controlling gdb.
 
 The current window is used to show the source code.  When gdb pauses the
 source file location will be displayed, if possible.  A sign is used to
@@ -267,6 +268,8 @@ Put focus on the gdb window to type commands there.  Some common ones are:
 - next		execute the current line and stop at the next line
 - step		execute the current line and stop at the next statement,
 		entering functions
+- until		execute until past the current cursor line or past a specified
+		position or the current stack frame returns
 - finish	execute until leaving the current function
 - where		show the stack
 - frame N	go to the Nth stack frame
@@ -283,6 +286,7 @@ gdb:
 
  *:Step*	execute the gdb "step" command
  *:Over*	execute the gdb "next" command (`:Next` is a Vim command)
+ *:Until*	execute the gdb "until" command
  *:Finish*	execute the gdb "finish" command
  *:Continue*	execute the gdb "continue" command
  *:Stop*	interrupt the program
@@ -303,7 +307,7 @@ breakpoint, or use the "Clear breakpoint" right-click menu entry.
 Inspecting variables ~
 					*termdebug-variables* *:Evaluate*
  `:Evaluate`	    evaluate the expression under the cursor
- `K`		    same
+ `K`		    same (see |termdebug_map_K| to disable)
  `:Evaluate` {expr}   evaluate {expr}
  `:'<,'>Evaluate`     evaluate the Visually selected text
 
@@ -332,7 +336,7 @@ Four autocommands can be used: >
 						*TermdebugStartPre*
 TermdebugStartPre		Before starting debugging.
 				Not triggered if the debugger is already
-				running or |g:termdebugger| cannot be
+				running or the debugger command cannot be
 				executed.
 						*TermdebugStartPost*
 TermdebugStartPost		After debugging has initialized.
@@ -361,14 +365,24 @@ This works slightly differently:
 
 						*termdebug_use_prompt*
 Prompt mode can be used with: >
+	let g:termdebug_config['use_prompt'] = 1
+Or if there is no g:termdebug_config: >
 	let g:termdebug_use_prompt = 1
-
+<
+						*termdebug_map_K*
+The K key is normally mapped to :Evaluate. If you do not want this use: >
+	let g:termdebug_config['map_K'] = 0
+Or if there is no g:termdebug_config: >
+	let g:termdebug_map_K = 0
 <
 						*termdebug_disasm_window*
-If you want the Asm window shown by default, set this to 1. Setting to
-any value greater than 1 will set the Asm window height to that value: >
+If you want the Asm window shown by default, set the flag to 1.
+the "disasm_window_height" entry can be used to set the window height: >
+	let g:termdebug_config['disasm_window'] = 1
+	let g:termdebug_config['disasm_window_height'] = 15
+or, if there is no g:termdebug_config: >
 	let g:termdebug_disasm_window = 15
-<
+Any value greater than 1 will set the Asm window height to that value.
 
 Communication ~
 						*termdebug-communication*
@@ -385,13 +399,24 @@ communication channel.
 
 
 Customizing ~
+				*termdebug-customizing* *g:termdebug_config*
+In the past several global variables were used for configuration.  These are
+deprecated, using the g:termdebug_config dictionary is preferred.  When
+g:termdebug_config exists the other global variables will not be used.
+
 
-GDB command						 *termdebug-customizing*
+GDB command ~
+							*g:termdebugger*
+To change the name of the gdb command, set "debugger" entry in
+g:termdebug_config or the "g:termdebugger" variable before invoking
+`:Termdebug`: >
+	let g:termdebug_config['command'] = "mygdb"
+Or if there is no g:termdebug_config: >
+	let g:termdebugger = "mygdb"
 
-To change the name of the gdb command, set the "termdebugger" variable before
-invoking `:Termdebug`: >
-	let termdebugger = "mygdb"
 If the command needs an argument use a List: >
+	let g:termdebug_config['command'] = ['rr', 'replay', '--']
+Or if there is no g:termdebug_config: >
 	let g:termdebugger = ['rr', 'replay', '--']
 
 To not use neovim floating windows for previewing variable evaluation, set the
@@ -405,7 +430,17 @@ cursor: >
 or set/unset a breakpoint: >
 	nnoremap <RightMouse> :Break<CR>
 
-<							*gdb-version*
+
+Several arguments will be added to make gdb work well for the debugger.
+If you want to modify them, add a function to filter the argument list: >
+	let g:termdebug_config['command_filter'] = MyDebugFilter
+
+If you do not want the arguments to be added, but you do need to set the
+"pty", use a function to add the necessary arguments: >
+	let g:termdebug_config['command_add_args'] = MyAddArguments
+The function will be called with the list of arguments so far, and a second
+argument that is the name of the pty.
+							*gdb-version*
 Only debuggers fully compatible with gdb will work.  Vim uses the GDB/MI
 interface.  The "new-ui" command  requires gdb version 7.12 or later.  if you
 get this error:
@@ -413,8 +448,8 @@ get this error:
 Then your gdb is too old.
 
 
-Colors						*hl-debugPC* *hl-debugBreakpoint*
-
+Colors ~
+						*hl-debugPC* *hl-debugBreakpoint*
 The color of the signs can be adjusted with these highlight groups:
 - debugPC		the current position
 - debugBreakpoint	a breakpoint
@@ -428,7 +463,8 @@ When 'background' is "dark":
   hi debugBreakpoint term=reverse ctermbg=red guibg=red
 
 
-Shortcuts						*termdebug_shortcuts*
+Shortcuts ~
+							*termdebug_shortcuts*
 
 You can define your own shortcuts (mappings) to control gdb, that can work in
 any window, using the TermDebugSendCommand() function.  Example: >
@@ -436,18 +472,37 @@ any window, using the TermDebugSendCommand() function.  Example: >
 The argument is the gdb command.
 
 
-Vim window width						*termdebug_wide*
+Popup menu ~
+							*termdebug_popup*
+
+By default the Termdebug plugin sets 'mousemodel' to "popup_setpos" and adds
+these entries to the popup menu:
+	Set breakpoint		`:Break`
+	Clear breakpoint	`:Clear`
+	Evaluate		`:Evaluate`
+If you don't want this then disable it with: >
+	let g:termdebug_config['popup'] = 0
+or if there is no g:termdebug_config: >
+	let g:termdebug_popup = 0
+
+
+Vim window width ~
+							*termdebug_wide*
+
+To change the width of the Vim window when debugging starts and use a vertical
+split: >
+	let g:termdebug_config['wide'] = 163
+Or if there is no g:termdebug_config: >
+	let g:termdebug_wide = 163
+
+This will set 'columns' to 163 when `:Termdebug` is used.  The value is
+restored when quitting the debugger.
 
-To change the width of the Vim window when debugging starts, and use a
-vertical split: >
-  let g:termdebug_wide = 163
-This will set &columns to 163 when `:Termdebug` is used.  The value is restored
-when quitting the debugger.
-If g:termdebug_wide is set and &columns is already larger than
-g:termdebug_wide then a vertical split will be used without changing &columns.
-Set it to 1 to get a vertical split without every changing &columns (useful
-for when the terminal can't be resized by Vim).
+If the wide value is set and 'columns' is already a greater value, then a
+vertical split will be used without modifying 'columns'.
 
+Set the wide value to 1 to use a vertical split without ever changing
+'columns'.  This is useful when the terminal can't be resized by Vim.
 
 
  vim:tw=78:ts=8:noet:ft=help:norl:
diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt
index 7dea475801..eda596bf71 100644
--- a/runtime/doc/options.txt
+++ b/runtime/doc/options.txt
@@ -20,9 +20,13 @@ achieve special effects.  These options come in three forms:
 1. Setting options					*set-option* *E764*
 
 							*:se* *:set*
-:se[t]			Show all options that differ from their default value.
+:se[t][!]		Show all options that differ from their default value.
+			When [!] is present every option is on a separate
+			line.
 
-:se[t] all		Show all options.
+:se[t][!] all		Show all options.
+			When [!] is present every option is on a separate
+			line.
 
 								*E518* *E519*
 :se[t] {option}?	Show value of {option}.
@@ -65,7 +69,7 @@ achieve special effects.  These options come in three forms:
 :se[t] {option}+={value}				*:set+=*
 			Add the {value} to a number option, or append the
 			{value} to a string option.  When the option is a
-			comma separated list, a comma is added, unless the
+			comma-separated list, a comma is added, unless the
 			value was empty.
 			If the option is a list of flags, superfluous flags
 			are removed.  When adding a flag that was already
@@ -75,7 +79,7 @@ achieve special effects.  These options come in three forms:
 :se[t] {option}^={value}				*:set^=*
 			Multiply the {value} to a number option, or prepend
 			the {value} to a string option.  When the option is a
-			comma separated list, a comma is added, unless the
+			comma-separated list, a comma is added, unless the
 			value was empty.
 			Also see |:set-args| above.
 
@@ -83,7 +87,7 @@ achieve special effects.  These options come in three forms:
 			Subtract the {value} from a number option, or remove
 			the {value} from a string option, if it is there.
 			If the {value} is not found in a string option, there
-			is no error or warning.  When the option is a comma
+			is no error or warning.  When the option is a comma-
 			separated list, a comma is deleted, unless the option
 			becomes empty.
 			When the option is a list of flags, {value} must be
@@ -235,7 +239,7 @@ happens when the buffer is not loaded, but they are lost when the buffer is
 wiped out |:bwipe|.
 
 							*:setl* *:setlocal*
-:setl[ocal] ...		Like ":set" but set only the value local to the
+:setl[ocal][!] ...	Like ":set" but set only the value local to the
 			current buffer or window.  Not all options have a
 			local value.  If the option does not have a local
 			value the global value is set.
@@ -257,7 +261,7 @@ wiped out |:bwipe|.
 			{option}, so that the global value will be used.
 
 							*:setg* *:setglobal*
-:setg[lobal] ...	Like ":set" but set only the global value for a local
+:setg[lobal][!] ...	Like ":set" but set only the global value for a local
 			option without changing the local value.
 			When displaying an option, the global value is shown.
 			With the "all" argument: display global values for all
@@ -747,7 +751,8 @@ A jump table for the options with a short description can be found at |Q_op|.
 	nostop	like start, except CTRL-W and CTRL-U do not stop at the start of
 		insert.
 
-	When the value is empty, Vi compatible backspacing is used.
+	When the value is empty, Vi compatible backspacing is used, none of
+	the ways mentioned for the items above are possible.
 
 	For backwards compatibility with version 5.4 and earlier:
 	value	effect	~
@@ -771,10 +776,10 @@ A jump table for the options with a short description can be found at |Q_op|.
 	oldest version of a file.
 
 						*'backupcopy'* *'bkc'*
-'backupcopy' 'bkc'	string	(Vi default for Unix: "yes", otherwise: "auto")
+'backupcopy' 'bkc'	string	(default: "auto")
 			global or local to buffer |global-local|
 	When writing a file and a backup is made, this option tells how it's
-	done.  This is a comma separated list of words.
+	done.  This is a comma-separated list of words.
 
 	The main values are:
 	"yes"	make a copy of the file and overwrite the original one
@@ -798,10 +803,10 @@ A jump table for the options with a short description can be found at |Q_op|.
 	  file.
 	- When the file is a link the new file will not be a link.
 
-	The "auto" value is the middle way: When Vim sees that renaming file
-	is possible without side effects (the attributes can be passed on and
-	the file is not a link) that is used.  When problems are expected, a
-	copy will be made.
+	The "auto" value is the middle way: When Vim sees that renaming the
+	file is possible without side effects (the attributes can be passed on
+	and the file is not a link) that is used.  When problems are expected,
+	a copy will be made.
 
 	The "breaksymlink" and "breakhardlink" values can be used in
 	combination with any of "yes", "no" and "auto".  When included, they
@@ -820,13 +825,13 @@ A jump table for the options with a short description can be found at |Q_op|.
 
 	When a copy is made, the original file is truncated and then filled
 	with the new text.  This means that protection bits, owner and
-	symbolic links of the original file are unmodified.  The backup file
+	symbolic links of the original file are unmodified.  The backup file,
 	however, is a new file, owned by the user who edited the file.  The
 	group of the backup is set to the group of the original file.  If this
 	fails, the protection bits for the group are made the same as for
 	others.
 
-	When the file is renamed this is the other way around: The backup has
+	When the file is renamed, this is the other way around: The backup has
 	the same attributes of the original file, and the newly written file
 	is owned by the current user.  When the file was a (hard/symbolic)
 	link, the new file will not!  That's why the "auto" value doesn't
@@ -836,7 +841,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	again not rename the file.
 
 						*'backupdir'* *'bdir'*
-'backupdir' 'bdir'	string	(default ".,$XDG_DATA_HOME/nvim/backup//")
+'backupdir' 'bdir'	string	(default ".,$XDG_STATE_HOME/nvim/backup//")
 			global
 	List of directories for the backup file, separated with commas.
 	- The backup file will be created in the first directory in the list
@@ -888,12 +893,12 @@ A jump table for the options with a short description can be found at |Q_op|.
 	accidentally overwriting existing files with a backup file.  You might
 	prefer using ".bak", but make sure that you don't have files with
 	".bak" that you want to keep.
-	Only normal file name characters can be used, "/\*?[|<>" are illegal.
+	Only normal file name characters can be used; "/\*?[|<>" are illegal.
 
 	If you like to keep a lot of backups, you could use a BufWritePre
 	autocommand to change 'backupext' just before writing the file to
 	include a timestamp. >
-		:au BufWritePre * let &bex = '-' . strftime("%Y%b%d%X") . '~'
+		:au BufWritePre * let &bex = '-' .. strftime("%Y%b%d%X") .. '~'
 <	Use 'backupdir' to put the backup in a different directory.
 
 						*'backupskip'* *'bsk'*
@@ -916,25 +921,16 @@ A jump table for the options with a short description can be found at |Q_op|.
 
 	Note that environment variables are not expanded.  If you want to use
 	$HOME you must expand it explicitly, e.g.: >
-		:let backupskip = escape(expand('$HOME'), '\') . '/tmp/*'
+		:let &backupskip = escape(expand('$HOME'), '\') .. '/tmp/*'
 
 <	Note that the default also makes sure that "crontab -e" works (when a
 	backup would be made by renaming the original file crontab won't see
 	the newly created file).  Also see 'backupcopy' and |crontab|.
 
-						*'balloondelay'* *'bdlay'*
-'balloondelay' 'bdlay'	Removed.
-
-			*'ballooneval'* *'beval'* *'noballooneval'* *'nobeval'*
-'ballooneval' 'beval'	Removed.
-
-						*'balloonexpr'* *'bexpr'*
-'balloonexpr' 'bexpr'	Removed.
-
 						*'belloff'* *'bo'*
 'belloff' 'bo'		string	(default "all")
 			global
-	Specifies for which events the bell will not be rung. It is a comma
+	Specifies for which events the bell will not be rung. It is a comma-
 	separated list of items. For each item that is present, the bell
 	will be silenced. This is most useful to specify specific events in
 	insert mode to be silenced.
@@ -954,7 +950,6 @@ A jump table for the options with a short description can be found at |Q_op|.
 		    (mostly used in |Normal-mode| or |Cmdline-mode|).
 	esc	    hitting <Esc> in |Normal-mode|.
 	hangul	    Ignored.
-	insertmode  Pressing <Esc> in 'insertmode'.
 	lang	    Calling the beep module for Lua/Mzscheme/TCL.
 	mess	    No output available for |g<|.
 	showmatch   Error occurred for 'showmatch' function.
@@ -1025,7 +1020,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	This option lets you choose which characters might cause a line
 	break if 'linebreak' is on.  Only works for ASCII characters.
 
-						*'breakindent'* *'bri'*
+			*'breakindent'* *'bri'* *'nobreakindent'* *'nobri'*
 'breakindent' 'bri'	boolean (default off)
 			local to window
 	Every wrapped line will continue visually indented (same amount of
@@ -1072,16 +1067,16 @@ A jump table for the options with a short description can be found at |Q_op|.
 	This option specifies what happens when a buffer is no longer
 	displayed in a window:
 	  <empty>	follow the global 'hidden' option
-	  hide		hide the buffer (don't unload it), also when 'hidden'
-			is not set
-	  unload	unload the buffer, also when 'hidden' is set or using
-			|:hide|
-	  delete	delete the buffer from the buffer list, also when
-			'hidden' is set or using |:hide|, like using
-			|:bdelete|
-	  wipe		wipe out the buffer from the buffer list, also when
-			'hidden' is set or using |:hide|, like using
-			|:bwipeout|
+	  hide		hide the buffer (don't unload it), even if 'hidden' is
+			not set
+	  unload	unload the buffer, even if 'hidden' is set; the
+			|:hide| command will also unload the buffer
+	  delete	delete the buffer from the buffer list, even if
+			'hidden' is set; the |:hide| command will also delete
+			the buffer, making it behave like |:bdelete|
+	  wipe		wipe the buffer from the buffer list, even if
+			'hidden' is set; the |:hide| command will also wipe
+			out the buffer, making it behave like |:bwipeout|
 
 	CAREFUL: when "unload", "delete" or "wipe" is used changes in a buffer
 	are lost without a warning.  Also, these values may break autocommands
@@ -1181,13 +1176,13 @@ A jump table for the options with a short description can be found at |Q_op|.
 	If the default value taken from $CDPATH is not what you want, include
 	a modified version of the following command in your vimrc file to
 	override it: >
-	  :let &cdpath = ',' . substitute(substitute($CDPATH, '[, ]', '\\\0', 'g'), ':', ',', 'g')
+	  :let &cdpath = ',' .. substitute(substitute($CDPATH, '[, ]', '\\\0', 'g'), ':', ',', 'g')
 <	This option cannot be set from a |modeline| or in the |sandbox|, for
 	security reasons.
 	(parts of 'cdpath' can be passed to the shell to expand file names).
 
 						*'cedit'*
-'cedit'			string	(Vim default: CTRL-F, Vi default: "")
+'cedit'			string	(default: CTRL-F)
 			global
 	The key used in Command-line Mode to open the command-line window.
 	Only non-printable keys are allowed.
@@ -1216,8 +1211,8 @@ A jump table for the options with a short description can be found at |Q_op|.
 	preferred, because it is much faster.
 	'charconvert' is not used when reading stdin |--|, because there is no
 	file to convert from.  You will have to save the text in a file first.
-	The expression must return zero or an empty string for success,
-	non-zero for failure.
+	The expression must return zero, false or an empty string for success,
+	non-zero or true for failure.
 	See |encoding-names| for possible encoding names.
 	Additionally, names given in 'fileencodings' and 'fileencoding' are
 	used.
@@ -1228,8 +1223,8 @@ A jump table for the options with a short description can be found at |Q_op|.
 		set charconvert=CharConvert()
 		fun CharConvert()
 		  system("recode "
-			\ . v:charconvert_from . ".." . v:charconvert_to
-			\ . " <" . v:fname_in . " >" v:fname_out)
+			\ .. v:charconvert_from .. ".." .. v:charconvert_to
+			\ .. " <" .. v:fname_in .. " >" .. v:fname_out)
 		  return v:shell_error
 		endfun
 <	The related Vim variables are:
@@ -1283,10 +1278,18 @@ A jump table for the options with a short description can be found at |Q_op|.
 	matter, include the keyword both the uppercase and lowercase:
 	"if,If,IF".
 
-						*'clipboard'* *'cb'*
+						*'cinscopedecls'* *'cinsd'*
+'cinscopedecls' 'cinsd'	string	(default "public,protected,private")
+			local to buffer
+	Keywords that are interpreted as a C++ scope declaration by |cino-g|.
+	Useful e.g. for working with the Qt framework that defines additional
+	scope declarations "signals", "public slots" and "private slots": >
+		set cinscopedecls+=signals,public\ slots,private\ slots
+
+<						*'clipboard'* *'cb'*
 'clipboard' 'cb'	string	(default "")
 			global
-	This option is a list of comma separated names.
+	This option is a list of comma-separated names.
 	These names are recognized:
 
 						*clipboard-unnamed*
@@ -1317,6 +1320,9 @@ A jump table for the options with a short description can be found at |Q_op|.
 	The value of this option is stored with the tab page, so that each tab
 	page can have a different value.
 
+	When 'cmdheight' is zero, it disables echo area and all outputs need
+	|hit-enter| prompt.
+
 						*'cmdwinheight'* *'cwh'*
 'cmdwinheight' 'cwh'	number	(default 7)
 			global
@@ -1325,10 +1331,11 @@ A jump table for the options with a short description can be found at |Q_op|.
 						*'colorcolumn'* *'cc'*
 'colorcolumn' 'cc'	string	(default "")
 			local to window
-	'colorcolumn' is a comma separated list of screen columns that are
+	'colorcolumn' is a comma-separated list of screen columns that are
 	highlighted with ColorColumn |hl-ColorColumn| and drawn using the
 	colocol option from 'fillchars'.  Useful to align text.  Will make
 	screen redrawing slower.
+
 	The screen column can be an absolute number, or a number preceded with
 	'+' or '-', which is added to or subtracted from 'textwidth'. >
 
@@ -1359,7 +1366,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 'comments' 'com'	string	(default
 				"s1:/*,mb:*,ex:*/,://,b:#,:%,:XCOMM,n:>,fb:-")
 			local to buffer
-	A comma separated list of strings that can start a comment line.  See
+	A comma-separated list of strings that can start a comment line.  See
 	|format-comments|.  See |option-backslash| about using backslashes to
 	insert a space.
 
@@ -1376,7 +1383,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	This option specifies how keyword completion |ins-completion| works
 	when CTRL-P or CTRL-N are used.  It is also used for whole-line
 	completion |i_CTRL-X_CTRL-L|.  It indicates the type of completion
-	and the places to scan.  It is a comma separated list of flags:
+	and the places to scan.  It is a comma-separated list of flags:
 	.	scan the current buffer ('wrapscan' is ignored)
 	w	scan buffers from other windows
 	b	scan other loaded buffers that are in the buffer list
@@ -1433,7 +1440,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 						*'completeopt'* *'cot'*
 'completeopt' 'cot'	string	(default: "menu,preview")
 			global
-	A comma separated list of options for Insert mode completion
+	A comma-separated list of options for Insert mode completion
 	|ins-completion|.  The supported values are:
 
 	   menu	    Use a popup menu to show the possible completions.  The
@@ -1531,8 +1538,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	See 'preserveindent'.
 
 						*'cpoptions'* *'cpo'* *cpo*
-'cpoptions' 'cpo'	string	(Vim default: "aABceFs_",
-				 Vi default: all flags)
+'cpoptions' 'cpo'	string	(default: "aABceFs_")
 			global
 	A sequence of single character flags.  When a character is present
 	this indicates Vi-compatible behavior.  This is used for things where
@@ -1838,7 +1844,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 						*'cursorlineopt'* *'culopt'*
 'cursorlineopt' 'culopt' string (default: "number,line")
 			local to window
-	Comma separated list of settings for how 'cursorline' is displayed.
+	Comma-separated list of settings for how 'cursorline' is displayed.
 	Valid values:
 	"line"		Highlight the text line of the cursor with
 			CursorLine |hl-CursorLine|.
@@ -2049,7 +2055,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	{char2}.  See |digraphs|.
 
 						*'directory'* *'dir'*
-'directory' 'dir'	string	(default "$XDG_DATA_HOME/nvim/swap//")
+'directory' 'dir'	string	(default "$XDG_STATE_HOME/nvim/swap//")
 			global
 	List of directory names for the swap file, separated with commas.
 
@@ -2101,9 +2107,9 @@ A jump table for the options with a short description can be found at |Q_op|.
 	security reasons.
 
 					*'display'* *'dy'*
-'display' 'dy'		string	(default "lastline,msgsep", Vi default: "")
+'display' 'dy'		string	(default "lastline,msgsep")
 			global
-	Change the way text is displayed.  This is comma separated list of
+	Change the way text is displayed.  This is comma-separated list of
 	flags:
 	lastline	When included, as much as possible of the last line
 			in a window will be displayed.  "@@@" is put in the
@@ -2129,7 +2135,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 		hor	horizontally, height of windows is not affected
 		both	width and height of windows is affected
 
-						*'emoji'* *'emo'*
+					*'emoji'* *'emo'* *'noemoji'* *'noemo'*
 'emoji' 'emo'	boolean (default: on)
 			global
 	When on all Unicode emoji characters are considered to be full width.
@@ -2221,7 +2227,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	A list of autocommand event names, which are to be ignored.
 	When set to "all" or when "all" is one of the items, all autocommand
 	events are ignored, autocommands will not be executed.
-	Otherwise this is a comma separated list of event names.  Example: >
+	Otherwise this is a comma-separated list of event names.  Example: >
 	    :set ei=WinEnter,WinLeave
 <
 				 *'expandtab'* *'et'* *'noexpandtab'* *'noet'*
@@ -2347,9 +2353,8 @@ A jump table for the options with a short description can be found at |Q_op|.
 
 					*'fileformats'* *'ffs'*
 'fileformats' 'ffs'	string (default:
-				Vim+Vi	Win32: "dos,unix",
-				Vim	Unix: "unix,dos",
-				Vi	others: "")
+				Win32: "dos,unix",
+				Unix: "unix,dos")
 			global
 	This gives the end-of-line (<EOL>) formats that will be tried when
 	starting to edit a new buffer and when reading a file into an existing
@@ -2433,12 +2438,20 @@ A jump table for the options with a short description can be found at |Q_op|.
 'fillchars' 'fcs'	string	(default "")
 			global or local to window |global-local|
 	Characters to fill the statuslines and vertical separators.
-	It is a comma separated list of items:
+	It is a comma-separated list of items:
 
 	  item		default		Used for ~
 	  stl:c		' ' or '^'	statusline of the current window
 	  stlnc:c	' ' or '='	statusline of the non-current windows
+	  wbr:c		' '		window bar
+	  horiz:c	'─' or '-'	horizontal separators |:split|
+	  horizup:c	'┴' or '-'	upwards facing horizontal separator
+	  horizdown:c	'┬' or '-'	downwards facing horizontal separator
 	  vert:c	'│' or '|'	vertical separators |:vsplit|
+	  vertleft:c	'┤' or '|'	left facing vertical separator
+	  vertright:c	'├' or '|'	right facing vertical separator
+	  verthoriz:c	'┼' or '+'	overlapping vertical and horizontal
+					separator
 	  fold:c	'·' or '-'	filling 'foldtext'
 	  foldopen:c	'-'		mark the beginning of a fold
 	  foldclose:c	'+'		show a closed fold
@@ -2452,21 +2465,35 @@ A jump table for the options with a short description can be found at |Q_op|.
 	"stlnc" the space will be used when there is highlighting, '^' or '='
 	otherwise.
 
-	If 'ambiwidth' is "double" then "vert", "foldsep" and "fold" default to
-	single-byte alternatives.
+	Note that "horiz", "horizup", "horizdown", "vertleft", "vertright" and
+	"verthoriz" are only used when 'laststatus' is 3, since only vertical
+	window separators are used otherwise.
+
+	If 'ambiwidth' is "double" then "horiz", "horizup", "horizdown",
+	"vert", "vertleft", "vertright", "verthoriz", "foldsep" and "fold"
+	default to single-byte alternatives.
 
 	Example: >
 	    :set fillchars=stl:^,stlnc:=,vert:│,fold:·,diff:-
 <	This is similar to the default, except that these characters will also
 	be used when there is highlighting.
 
-	for "stl" and "stlnc" only single-byte values are supported.
+	For the "stl", "stlnc", "foldopen", "foldclose" and "foldsep" items
+	single-byte and multibyte characters are supported.  But double-width
+	characters are not supported.
 
 	The highlighting used for these items:
 	  item		highlight group ~
 	  stl:c		StatusLine		|hl-StatusLine|
 	  stlnc:c	StatusLineNC		|hl-StatusLineNC|
-	  vert:c	VertSplit		|hl-VertSplit|
+	  wbr:c		WinBar			|hl-WinBar| or |hl-WinBarNC|
+	  horiz:c	WinSeparator		|hl-WinSeparator|
+	  horizup:c	WinSeparator		|hl-WinSeparator|
+	  horizdown:c	WinSeparator		|hl-WinSeparator|
+	  vert:c	WinSeparator		|hl-WinSeparator|
+	  vertleft:c	WinSeparator		|hl-WinSeparator|
+	  vertright:c	WinSeparator		|hl-WinSeparator|
+	  verthoriz:c	WinSeparator		|hl-WinSeparator|
 	  fold:c	Folded			|hl-Folded|
 	  diff:c	DiffDelete		|hl-DiffDelete|
 	  eob:c		EndOfBuffer		|hl-EndOfBuffer|
@@ -2597,7 +2624,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 							     search,tag,undo")
 			global
 	Specifies for which type of commands folds will be opened, if the
-	command moves the cursor into a closed fold.  It is a comma separated
+	command moves the cursor into a closed fold.  It is a comma-separated
 	list of items.
 	NOTE: When the command is part of a mapping this option is not used.
 	Add the |zv| command to the mapping to get the same effect.
@@ -2688,7 +2715,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	character and white space.
 
 					*'formatoptions'* *'fo'*
-'formatoptions' 'fo'	string (default: "tcqj", Vi default: "vt")
+'formatoptions' 'fo'	string (default: "tcqj")
 			local to buffer
 	This is a sequence of letters which describes how automatic
 	formatting is to be done.  See |fo-table|.  When the 'paste' option is
@@ -2712,7 +2739,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	This option cannot be set from a |modeline| or in the |sandbox|, for
 	security reasons.
 
-						*'fsync'* *'fs'*
+					*'fsync'* *'fs'* *'nofsync'* *'nofs'*
 'fsync' 'fs'		boolean	(default off)
 			global
 	When on, the OS function fsync() will be called after saving a file
@@ -2788,7 +2815,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 		  \,a:blinkwait700-blinkoff400-blinkon250-Cursor/lCursor
 		  \,sm:block-blinkwait175-blinkoff150-blinkon175
 
-<	The option is a comma separated list of parts.  Each part consists of a
+<	The option is a comma-separated list of parts.  Each part consists of a
 	mode-list and an argument-list:
 		mode-list:argument-list,mode-list:argument-list,..
 	The mode-list is a dash separated list of these modes:
@@ -3038,7 +3065,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 						*'guitablabel'* *'gtl'*
 'guitablabel' 'gtl'	string	(default empty)
 			global
-	When nonempty describes the text to use in a label of the GUI tab
+	When non-empty describes the text to use in a label of the GUI tab
 	pages line.  When empty and when the result is empty Vim will use a
 	default label.  See |setting-guitablabel| for more info.
 
@@ -3055,7 +3082,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 						*'guitabtooltip'* *'gtt'*
 'guitabtooltip' 'gtt'	string	(default empty)
 			global
-	When nonempty describes the text to use in a tooltip for the GUI tab
+	When non-empty describes the text to use in a tooltip for the GUI tab
 	pages line.  When empty Vim will use a default tooltip.
 	This option is otherwise just like 'guitablabel' above.
 	You can include a line break.  Simplest method is to use |:let|: >
@@ -3088,7 +3115,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 						*'helplang'* *'hlg'*
 'helplang' 'hlg'	string	(default: messages language or empty)
 			global
-	Comma separated list of languages.  Vim will use the first language
+	Comma-separated list of languages.  Vim will use the first language
 	for which the desired help can be found.  The English help will always
 	be used as a last resort.  You can add "en" to prefer English over
 	another language, but that will only find tags that exist in that
@@ -3108,15 +3135,19 @@ A jump table for the options with a short description can be found at |Q_op|.
 	when it is |abandon|ed.  When on a buffer becomes hidden when it is
 	|abandon|ed.  A buffer displayed in another window does not become
 	hidden, of course.
+
 	Commands that move through the buffer list sometimes hide a buffer
-	although the 'hidden' option is off: when the buffer is modified,
-	'autowrite' is off or writing is not possible, and the '!' flag was
-	used.  See also |windows|.
+	although the 'hidden' option is off when these three are true:
+	- the buffer is modified
+	- 'autowrite' is off or writing is not possible
+	- the '!' flag was used
+	Also see |windows|.
+
 	To hide a specific buffer use the 'bufhidden' option.
 	'hidden' is set for one command with ":hide {command}" |:hide|.
 
 						*'history'* *'hi'*
-'history' 'hi'		number	(Vim default: 10000, Vi default: 0)
+'history' 'hi'		number	(default: 10000)
 			global
 	A history of ":" commands, and a history of previous search patterns
 	is remembered.  This option decides how many entries may be stored in
@@ -3141,8 +3172,12 @@ A jump table for the options with a short description can be found at |Q_op|.
 'hlsearch' 'hls'	boolean	(default on)
 			global
 	When there is a previous search pattern, highlight all its matches.
-	The |hl-Search| highlight group determines the highlighting. Note that
-	only the matching text is highlighted, any offsets are not applied.
+	The |hl-Search| highlight group determines the highlighting for all
+	matches not under the cursor while the |hl-CurSearch| highlight group
+	(if defined) determines the highlighting for the match under the
+	cursor. If |hl-CurSearch| is not defined, then |hl-Search| is used for
+	both. Note that only the matching text is highlighted, any offsets
+	are not applied.
 	See also: 'incsearch' and |:match|.
 	When you get bored looking at the highlighted matches, you can turn it
 	off with |:nohlsearch|.  This does not change the option value, as
@@ -3239,8 +3274,9 @@ A jump table for the options with a short description can be found at |Q_op|.
 'inccommand' 'icm'	string	(default "nosplit")
 			global
 
-	When nonempty, shows the effects of |:substitute|, |:smagic|, and
-	|:snomagic| as you type.
+	When nonempty, shows the effects of |:substitute|, |:smagic|,
+	|:snomagic| and user commands with the |:command-preview| flag as you
+	type.
 
 	Possible values:
 		nosplit	Shows the effects of a command incrementally in the
@@ -3248,8 +3284,9 @@ A jump table for the options with a short description can be found at |Q_op|.
 		split	Like "nosplit", but also shows partial off-screen
 			results in a preview window.
 
-	If the preview is too slow (exceeds 'redrawtime') then 'inccommand' is
-	automatically disabled until |Command-line-mode| is done.
+	If the preview for built-in commands is too slow (exceeds
+	'redrawtime') then 'inccommand' is automatically disabled until
+	|Command-line-mode| is done.
 
 						*'include'* *'inc'*
 'include' 'inc'		string	(default "^\s*#\s*include")
@@ -3375,31 +3412,6 @@ A jump table for the options with a short description can be found at |Q_op|.
 	and there is a letter before it, the completed part is made uppercase.
 	With 'noinfercase' the match is used as-is.
 
-			*'insertmode'* *'im'* *'noinsertmode'* *'noim'*
-'insertmode' 'im'	boolean	(default off)
-			global
-	Makes Vim work in a way that Insert mode is the default mode.  Useful
-	if you want to use Vim as a modeless editor.
-	These Insert mode commands will be useful:
-	- Use the cursor keys to move around.
-	- Use CTRL-O to execute one Normal mode command |i_CTRL-O|.  When
-	  this is a mapping, it is executed as if 'insertmode' was off.
-	  Normal mode remains active until the mapping is finished.
-	- Use CTRL-L to execute a number of Normal mode commands, then use
-	  <Esc> to get back to Insert mode.  Note that CTRL-L moves the cursor
-	  left, like <Esc> does when 'insertmode' isn't set.  |i_CTRL-L|
-
-	These items change when 'insertmode' is set:
-	- when starting to edit of a file, Vim goes to Insert mode.
-	- <Esc> in Insert mode is a no-op and beeps.
-	- <Esc> in Normal mode makes Vim go to Insert mode.
-	- CTRL-L in Insert mode is a command, it is not inserted.
-	- CTRL-Z in Insert mode suspends Vim, see |CTRL-Z|.	*i_CTRL-Z*
-	However, when <Esc> is used inside a mapping, it behaves like
-	'insertmode' was not set.  This was done to be able to use the same
-	mappings with 'insertmode' set or not set.
-	When executing commands with |:normal| 'insertmode' is not used.
-
 						*'isfname'* *'isf'*
 'isfname' 'isf'		string	(default for Windows:
 			     "@,48-57,/,\,.,-,_,+,,,#,$,%,{,},[,],:,@-@,!,~,="
@@ -3463,12 +3475,11 @@ A jump table for the options with a short description can be found at |Q_op|.
 	option.  For '@' only characters up to 255 are used.
 	Careful: If you change this option, it might break expanding
 	environment variables.  E.g., when '/' is included and Vim tries to
-	expand "$HOME/.local/share/nvim/shada/main.shada".  Maybe you should 
+	expand "$HOME/.local/state/nvim/shada/main.shada".  Maybe you should
 	change 'iskeyword' instead.
 
 						*'iskeyword'* *'isk'*
-'iskeyword' 'isk'	string (default: @,48-57,_,192-255
-				Vi default: @,48-57,_)
+'iskeyword' 'isk'	string (default: @,48-57,_,192-255)
 			local to buffer
 	Keywords are used in searching and recognizing with many commands:
 	"w", "*", "[i", etc.  It is also used for "\k" in a |pattern|.  See
@@ -3524,6 +3535,10 @@ A jump table for the options with a short description can be found at |Q_op|.
 			jumplist and then jumping to a location.
 			|jumplist-stack|
 
+	  view          When moving through the jumplist, |changelist|,
+			|alternate-file| or using |mark-motions| try to
+			restore the |mark-view| in which the action occurred.
+
 			*'joinspaces'* *'js'* *'nojoinspaces'* *'nojs'*
 'joinspaces' 'js'	boolean	(default off)
 			global
@@ -3542,7 +3557,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 					*'keymodel'* *'km'*
 'keymodel' 'km'		string	(default "")
 			global
-	List of comma separated words, which enable special things that keys
+	List of comma-separated words, which enable special things that keys
 	can do.  These values can be used:
 	   startsel	Using a shifted special key starts selection (either
 			Select mode or Visual mode, depending on "key" being
@@ -3618,7 +3633,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 			global
 	Language to use for menu translation.  Tells which file is loaded
 	from the "lang" directory in 'runtimepath': >
-		"lang/menu_" . &langmenu . ".vim"
+		"lang/menu_" .. &langmenu .. ".vim"
 <	(without the spaces).  For example, to always use the Dutch menus, no
 	matter what $LANG is set to: >
 		:set langmenu=nl_NL.ISO_8859-1
@@ -3650,6 +3665,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 		0: never
 		1: only if there are at least two windows
 		2: always
+		3: always and ONLY the last window
 	The screen looks nicer with a status line if you have several
 	windows, but it takes another screen line. |status-line|
 
@@ -3660,6 +3676,9 @@ A jump table for the options with a short description can be found at |Q_op|.
 	executing macros, registers and other commands that have not been
 	typed.  Also, updating the window title is postponed.  To force an
 	update use |:redraw|.
+	This may occasionally cause display errors.  It is only meant to be set
+	temporarily when performing an operation where redrawing may cause
+	flickering or cause a slow down.
 
 			*'linebreak'* *'lbr'* *'nolinebreak'* *'nolbr'*
 'linebreak' 'lbr'	boolean	(default off)
@@ -3716,7 +3735,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 						*'lispwords'* *'lw'*
 'lispwords' 'lw'	string	(default is very long)
 			global or local to buffer |global-local|
-	Comma separated list of words that influence the Lisp indenting.
+	Comma-separated list of words that influence the Lisp indenting.
 	|'lisp'|
 
 						*'list'* *'nolist'*
@@ -3737,11 +3756,10 @@ A jump table for the options with a short description can be found at |Q_op|.
 	changing the way tabs are displayed.
 
 						*'listchars'* *'lcs'*
-'listchars' 'lcs'	string	(default: "tab:> ,trail:-,nbsp:+"
-				 Vi default: "eol:$")
+'listchars' 'lcs'	string	(default: "tab:> ,trail:-,nbsp:+")
 			global or local to window |global-local|
 	Strings to use in 'list' mode and for the |:list| command.  It is a
-	comma separated list of string settings.
+	comma-separated list of string settings.
 
 							*lcs-eol*
 	  eol:c		Character to show at the end of each line.  When
@@ -3779,14 +3797,24 @@ A jump table for the options with a short description can be found at |Q_op|.
 			"space" setting is used.  For example,
 			`:set listchars=multispace:---+` shows ten consecutive
 			spaces as:
-				---+---+--
+				---+---+-- ~
 							*lcs-lead*
 	  lead:c	Character to show for leading spaces.  When omitted,
 			leading spaces are blank.  Overrides the "space" and
 			"multispace" settings for leading spaces.  You can
 			combine it with "tab:", for example: >
 				:set listchars+=tab:>-,lead:.
-<							*lcs-trail*
+<							*lcs-leadmultispace*
+	  leadmultispace:c...
+			Like the |lcs-multispace| value, but for leading
+			spaces only.  Also overrides |lcs-lead| for leading
+			multiple spaces.
+			`:set listchars=leadmultispace:---+` shows ten
+			consecutive leading spaces as:
+				---+---+--XXX ~
+			Where "XXX" denotes the first non-blank characters in
+			the line.
+							*lcs-trail*
 	  trail:c	Character to show for trailing spaces.  When omitted,
 			trailing spaces are blank.  Overrides the "space" and
 			"multispace" settings for trailing spaces.
@@ -3918,12 +3946,6 @@ A jump table for the options with a short description can be found at |Q_op|.
 	set.  Note that this is not in milliseconds, like other options that
 	set a time.  This is to be compatible with Nvi.
 
-						*'maxcombine'* *'mco'*
-'maxcombine' 'mco'	Removed. |vim-differences|
-	Nvim always displays up to 6 combining characters.  You can still edit
-    text with more than 6 combining characters, you just can't see them.
-    Use |g8| or |ga|.  See |mbyte-combining|.
-
 						*'maxfuncdepth'* *'mfd'*
 'maxfuncdepth' 'mfd'	number	(default 100)
 			global
@@ -4006,8 +4028,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	This option cannot be set from a |modeline| or in the |sandbox|.
 
 				   *'modeline'* *'ml'* *'nomodeline'* *'noml'*
-'modeline' 'ml'		boolean	(Vim default: on (off for root),
-				 Vi default: off)
+'modeline' 'ml'		boolean	(default: on (off for root))
 			local to buffer
 	If 'modeline' is on 'modelines' gives the number of lines that is
 	checked for set commands.  If 'modeline' is off or 'modelines' is zero
@@ -4062,14 +4083,14 @@ A jump table for the options with a short description can be found at |Q_op|.
 	when using "rA" on an "A".
 
 						*'more'* *'nomore'*
-'more'			boolean	(Vim default: on, Vi default: off)
+'more'			boolean	(default: on)
 			global
 	When on, listings pause when the whole screen is filled.  You will get
 	the |more-prompt|.  When this option is off there are no pauses, the
 	listing continues until finished.
 
 						*'mouse'*
-'mouse'			string	(default "")
+'mouse'			string	(default "nvi")
 			global
 
 	Enables mouse support. For example, to enable the mouse in Normal mode
@@ -4141,7 +4162,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	The mouse pointer is restored when the mouse is moved.
 
 						*'mousemodel'* *'mousem'*
-'mousemodel' 'mousem'	string	(default "extend")
+'mousemodel' 'mousem'	string	(default "popup_setpos")
 			global
 	Sets the model to use for the mouse.  The name mostly specifies what
 	the right mouse button is used for:
@@ -4167,7 +4188,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	middle click	    paste		paste
 
 	In the "popup" model the right mouse button produces a pop-up menu.
-	You need to define this first, see |popup-menu|.
+	Nvim creates a default |popup-menu| but you can redefine it.
 
 	Note that you can further refine the meaning of buttons with mappings.
 	See |mouse-overview|.  But mappings are NOT used for modeless selection.
@@ -4193,12 +4214,32 @@ A jump table for the options with a short description can be found at |Q_op|.
 
 	The 'mousemodel' option is set by the |:behave| command.
 
+					*mousescroll*
+'mousescroll'		string	(default "ver:3,hor:6")
+			global
+	This option controls the number of lines / columns to scroll by when
+	scrolling with a mouse. The option is a comma separated list of parts.
+	Each part consists of a direction and a count as follows:
+		direction:count,direction:count
+	Direction is one of either "hor" or "ver", "hor" controls horizontal
+	scrolling and "ver" controls vertical scrolling. Count sets the amount
+	to scroll by for the given direction, it should be a non negative
+	integer. Each direction should be set at most once. If a direction
+	is omitted, a default value is used (6 for horizontal scrolling and 3
+	for vertical scrolling). You can disable mouse scrolling by using
+	a count of 0.
+
+	Example: >
+		:set mousescroll=ver:5,hor:2
+<	Will make Nvim scroll 5 lines at a time when scrolling vertically, and
+	scroll 2 columns at a time when scrolling horizontally.
+
 					*'mouseshape'* *'mouses'* *E547*
 'mouseshape' 'mouses'	string	(default "i:beam,r:beam,s:updown,sd:cross,
 					m:no,ml:up-arrow,v:rightup-arrow")
 			global
 	This option tells Vim what the mouse pointer should look like in
-	different modes.  The option is a comma separated list of parts, much
+	different modes.  The option is a comma-separated list of parts, much
 	like used for 'guicursor'.  Each part consist of a mode/location-list
 	and an argument-list:
 		mode-list:shape,mode-list:shape,..
@@ -4317,7 +4358,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	    |there          |  4 there      |  1 there      |  1 there
 
 						*'numberwidth'* *'nuw'*
-'numberwidth' 'nuw'	number	(Vim default: 4  Vi default: 8)
+'numberwidth' 'nuw'	number	(default: 4)
 			local to window
 	Minimal number of columns to use for the line number.  Only relevant
 	when the 'number' or 'relativenumber' option is set or printing lines
@@ -4443,8 +4484,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	Note that typing <F10> in paste mode inserts "<F10>", since in paste
 	mode everything is inserted literally, except the 'pastetoggle' key
 	sequence.
-	No timeout is used, this means that a multi-key 'pastetoggle' can not
-	be triggered manually.
+	When the value has several bytes 'ttimeoutlen' applies.
 
 						*'pex'* *'patchexpr'*
 'patchexpr' 'pex'	string	(default "")
@@ -4520,7 +4560,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 <	To use an environment variable, you probably need to replace the
 	separator.  Here is an example to append $INCL, in which directory
 	names are separated with a semi-colon: >
-		:let &path = &path . "," . substitute($INCL, ';', ',', 'g')
+		:let &path = &path .. "," .. substitute($INCL, ';', ',', 'g')
 <	Replace the ';' with a ':' or whatever separator is used.  Note that
 	this doesn't work when $INCL contains a comma or white space.
 
@@ -4636,26 +4676,11 @@ A jump table for the options with a short description can be found at |Q_op|.
 	nudged to fit on the screen.
 
 						*'pyxversion'* *'pyx'*
-'pyxversion' 'pyx'	number	(default depends on the build)
+'pyxversion' 'pyx'	number	(default 3)
 			global
 	Specifies the python version used for pyx* functions and commands
-	|python_x|.  The default value is as follows:
-
-		|provider| installed	    Default ~
-		|+python| and |+python3|	0
-		only |+python|			2
-		only |+python3|			3
-
-	Available values are 0, 2 and 3.
-	If 'pyxversion' is 0, it is set to 2 or 3 after the first execution of
-	any python2/3 commands or functions.  E.g. `:py` sets to 2, and `:py3`
-	sets to 3. `:pyx` sets it to 3 if Python 3 is available, otherwise sets
-	to 2 if Python 2 is available.
-	See also: |has-pythonx|
-
-	If only |+python| or |+python3| are available,
-	'pyxversion' has no effect. The pyx* functions and commands are
-	always the same as the installed version.
+	|python_x|.  As only Python 3 is supported, this always has the value
+	`3`. Setting any other value is an error.
 
 	This option cannot be set from a |modeline| or in the |sandbox|, for
 	security reasons.
@@ -4774,15 +4799,6 @@ A jump table for the options with a short description can be found at |Q_op|.
 	'number', see |number_relativenumber| for all combinations of the two
 	options.
 
-						*'remap'* *'noremap'*
-'remap'			boolean	(default on)
-			global
-	Allows for mappings to work recursively.  If you do not want this for
-	a single entry, use the :noremap[!] command.
-	NOTE: To avoid portability problems with Vim scripts, always keep
-	this option at the default "on".  Only switch it off when working with
-	old Vi scripts.
-
 						*'report'*
 'report'		number	(default 2)
 			global
@@ -4837,9 +4853,11 @@ A jump table for the options with a short description can be found at |Q_op|.
 		45%	relative position in the file
 	If 'rulerformat' is set, it will determine the contents of the ruler.
 	Each window has its own ruler.  If a window has a status line, the
-	ruler is shown there.  Otherwise it is shown in the last line of the
-	screen.  If the statusline is given by 'statusline' (i.e. not empty),
-	this option takes precedence over 'ruler' and 'rulerformat'
+	ruler is shown there.  If a window doesn't have a status line and
+	'cmdheight' is 0, the ruler is not shown.  Otherwise it is shown in
+	the last line of the screen.  If the statusline is given by
+	'statusline' (i.e. not empty), this option takes precedence over
+	'ruler' and 'rulerformat'.
 	If the number of characters displayed is different from the number of
 	bytes in the text (e.g., for a TAB or a multibyte character), both
 	the text column (byte number) and the screen column are shown,
@@ -4918,9 +4936,12 @@ A jump table for the options with a short description can be found at |Q_op|.
 	   but are not part of the Nvim distribution. XDG_DATA_DIRS defaults
 	   to /usr/local/share/:/usr/share/, so system administrators are
 	   expected to install site plugins to /usr/share/nvim/site.
-	5. $VIMRUNTIME, for files distributed with Neovim.
+	5. Applications state home directory, for files that contain your
+	   session state (eg. backupdir, viewdir, undodir, etc).
+	   Given by `stdpath("state")`.  |$XDG_STATE_HOME|
+	6. $VIMRUNTIME, for files distributed with Neovim.
 							*after-directory*
-	6, 7, 8, 9. In after/ subdirectories of 1, 2, 3 and 4, with reverse 
+	7, 8, 9, 10. In after/ subdirectories of 1, 2, 3 and 4, with reverse
 	   ordering.  This is for preferences to overrule or add to the 
 	   distributed defaults or system-wide settings (rarely needed).
 
@@ -5084,7 +5105,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 						*'selectmode'* *'slm'*
 'selectmode' 'slm'	string	(default "")
 			global
-	This is a comma separated list of words, which specifies when to start
+	This is a comma-separated list of words, which specifies when to start
 	Select mode instead of Visual mode, when a selection is started.
 	Possible values:
 	   mouse	when using the mouse
@@ -5095,11 +5116,9 @@ A jump table for the options with a short description can be found at |Q_op|.
 
 						*'sessionoptions'* *'ssop'*
 'sessionoptions' 'ssop'	string	(default: "blank,buffers,curdir,folds,
-					       help,tabpages,winsize"
-				 Vi default: "blank,buffers,curdir,folds,
-					       help,options,tabpages,winsize")
+					       help,tabpages,winsize")
 			global
-	Changes the effect of the |:mksession| command.  It is a comma
+	Changes the effect of the |:mksession| command.  It is a comma-
 	separated list of words.  Each word enables saving and restoring
 	something:
 	   word		save and restore ~
@@ -5137,13 +5156,12 @@ A jump table for the options with a short description can be found at |Q_op|.
 	If you leave out "options" many things won't work well after restoring
 	the session.
 				*'shada'* *'sd'* *E526* *E527* *E528*
-'shada' 'sd'		string	(Vim default for
+'shada' 'sd'		string	(default for
 				   Win32:  !,'100,<50,s10,h,rA:,rB:
-				   others: !,'100,<50,s10,h
-				 Vi default: "")
+				   others: !,'100,<50,s10,h)
 			global
 	When non-empty, the shada file is read upon startup and written
-	when exiting Vim (see |shada-file|).  The string should be a comma
+	when exiting Vim (see |shada-file|).  The string should be a comma-
 	separated list of parameters, each consisting of a single character
 	identifying the particular parameter, followed by a number or string
 	which specifies the value of that parameter.  If a particular
@@ -5303,9 +5321,9 @@ A jump table for the options with a short description can be found at |Q_op|.
 	unescaping, so to keep yourself sane use |:let-&| like shown above.
 							*shell-powershell*
 	To use PowerShell: >
-		let &shell = has('win32') ? 'powershell' : 'pwsh'
+		let &shell = executable('pwsh') ? 'pwsh' : 'powershell'
 		let &shellcmdflag = '-NoLogo -NoProfile -ExecutionPolicy RemoteSigned -Command [Console]::InputEncoding=[Console]::OutputEncoding=[System.Text.Encoding]::UTF8;'
-		let &shellredir = '2>&1 | Out-File -Encoding UTF8 %s; exit $LastExitCode'
+		let &shellredir = '-RedirectStandardOutput %s -NoNewWindow -Wait'
 		let &shellpipe = '2>&1 | Out-File -Encoding UTF8 %s; exit $LastExitCode'
 		set shellquote= shellxquote=
 
@@ -5418,7 +5436,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 <	Also see 'completeslash'.
 
 			*'shelltemp'* *'stmp'* *'noshelltemp'* *'nostmp'*
-'shelltemp' 'stmp'	boolean	(Vim default on, Vi default off)
+'shelltemp' 'stmp'	boolean	(default on)
 			global
 	When on, use temp files for shell commands.  When off use a pipe.
 	When using a pipe is not possible temp files are used anyway.
@@ -5467,7 +5485,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	function to get the effective shiftwidth value.
 
 						*'shortmess'* *'shm'*
-'shortmess' 'shm'	string	(Vim default "filnxtToOF", Vi default: "S")
+'shortmess' 'shm'	string	(default "filnxtToOF")
 			global
 	This option helps to avoid all the |hit-enter| prompts caused by file
 	messages, for example  with CTRL-G, and to avoid some other messages.
@@ -5475,7 +5493,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	 flag	meaning when present	~
 	  f	use "(3 of 5)" instead of "(file 3 of 5)"
 	  i	use "[noeol]" instead of "[Incomplete last line]"
-	  l	use "999L, 888C" instead of "999 lines, 888 characters"
+	  l	use "999L, 888B" instead of "999 lines, 888 bytes"
 	  m	use "[+]" instead of "[Modified]"
 	  n	use "[New]" instead of "[New File]"
 	  r	use "[RO]" instead of "[readonly]"
@@ -5507,8 +5525,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 		"Pattern not found", "Back at original", etc.
 	  q	use "recording" instead of "recording @a"
 	  F	don't give the file info when editing a file, like `:silent`
-		was used for the command; note that this also affects messages
-		from autocommands
+		was used for the command
 	  S     do not show search count message when searching, e.g.
 	        "[1/5]"
 
@@ -5542,10 +5559,11 @@ A jump table for the options with a short description can be found at |Q_op|.
 		:setlocal showbreak=NONE
 <
 				     *'showcmd'* *'sc'* *'noshowcmd'* *'nosc'*
-'showcmd' 'sc'		boolean	(Vim default: on, Vi default: off)
+'showcmd' 'sc'		boolean	(default: on)
 			global
 	Show (partial) command in the last line of the screen.  Set this
 	option off if your terminal is slow.
+	The option is disabled if 'cmdheight' is 0.
 	In Visual mode the size of the selected area is shown:
 	- When selecting characters within a line, the number of characters.
 	  If the number of bytes is different it is also displayed: "2-6"
@@ -5588,10 +5606,11 @@ A jump table for the options with a short description can be found at |Q_op|.
 	Note: Use of the short form is rated PG.
 
 				 *'showmode'* *'smd'* *'noshowmode'* *'nosmd'*
-'showmode' 'smd'	boolean	(Vim default: on, Vi default: off)
+'showmode' 'smd'	boolean	(default: on)
 			global
 	If in Insert, Replace or Visual mode put a message on the last line.
 	The |hl-ModeMsg| highlight group determines the highlighting.
+	The option is disabled if 'cmdheight' is 0.
 
 						*'showtabline'* *'stal'*
 'showtabline' 'stal'	number	(default 1)
@@ -5660,7 +5679,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	Note regarding 'orphaned signs': with signcolumn numbers higher than
 	1, deleting lines will also remove the associated signs automatically,
 	in contrast to the default Vim behavior of keeping and grouping them.
-	This is done in order for the signcolumn appearence not appear weird
+	This is done in order for the signcolumn appearance not appear weird
 	during line deletion.
 
 
@@ -5762,7 +5781,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	commands.  It must end in ".{encoding}.add".  You need to include the
 	path, otherwise the file is placed in the current directory.
 								*E765*
-	It may also be a comma separated list of names.  A count before the
+	It may also be a comma-separated list of names.  A count before the
 	|zg| and |zw| commands can be used to access each.  This allows using
 	a personal word list file and a project word list file.
 	When a word is added while this option is empty Vim will set it for
@@ -5782,7 +5801,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 						*'spelllang'* *'spl'*
 'spelllang' 'spl'	string	(default "en")
 			local to buffer
-	A comma separated list of word list names.  When the 'spell' option is
+	A comma-separated list of word list names.  When the 'spell' option is
 	on spellchecking will be done for these languages.  Example: >
 		set spelllang=en_us,nl,medical
 <	This means US English, Dutch and medical words are recognized.  Words
@@ -5822,7 +5841,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 						*'spelloptions'* *'spo'*
 'spelloptions' 'spo'	string	(default "")
 			local to buffer
-	A comma separated list of options for spell checking:
+	A comma-separated list of options for spell checking:
 	   camel	When a word is CamelCased, assume "Cased" is a
 			separate word: every upper-case character in a word
 			that comes after a lower case character indicates the
@@ -5919,7 +5938,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 			   *'statusline'* *'stl'* *E540* *E542*
 'statusline' 'stl'	string	(default empty)
 			global or local to window |global-local|
-	When nonempty, this option determines the content of the status line.
+	When non-empty, this option determines the content of the status line.
 	Also see |status-line|.
 
 	The option consists of printf style '%' items interspersed with
@@ -5942,7 +5961,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	empty to avoid further errors.  Otherwise screen updating would loop.
 
 	Note that the only effect of 'ruler' when this option is set (and
-	'laststatus' is 2) is controlling the output of |CTRL-G|.
+	'laststatus' is 2 or 3) is controlling the output of |CTRL-G|.
 
 	field	    meaning ~
 	-	    Left justify the item.  The default is right justified
@@ -6026,7 +6045,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	      the label, e.g.: %3Xclose%X.  Use %999X for a "close current 
 	      tab" label.    Clicking this label with left mouse button closes 
 	      specified tab page.
-	@ N   For 'tabline': start of execute function label. Use %X or %T to 
+	@ N   Start of execute function label. Use %X or %T to 
 	      end the label, e.g.: %10@SwitchBuffer@foo.c%X.  Clicking this 
 	      label runs specified function: in the example when clicking once 
 	      using left mouse button on "foo.c" "SwitchBuffer(10, 1, 'l', 
@@ -6050,8 +6069,6 @@ A jump table for the options with a short description can be found at |Q_op|.
 	         is a bug that denotes that new mouse button recognition was 
 	         added without modifying code that reacts on mouse clicks on 
 	         this label.
-	      Note: to test whether your version of Neovim contains this 
-	            feature use `has('tablineat')`.
 	< -   Where to truncate line if too long.  Default is at the start.
 	      No width fields allowed.
 	= -   Separation point between alignment sections. Each section will
@@ -6095,10 +6112,9 @@ A jump table for the options with a short description can be found at |Q_op|.
 
 	If the statusline is not updated when you want it (e.g., after setting
 	a variable that's used in an expression), you can force an update by
-	setting an option without changing its value.  Example: >
-		:let &ro = &ro
+	using `:redrawstatus`.
 
-<	A result of all digits is regarded a number for display purposes.
+	A result of all digits is regarded a number for display purposes.
 	Otherwise the result is taken as flag text and applied to the rules
 	described above.
 
@@ -6142,7 +6158,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 						*'suffixesadd'* *'sua'*
 'suffixesadd' 'sua'	string	(default "")
 			local to buffer
-	Comma separated list of suffixes, which are used when searching for a
+	Comma-separated list of suffixes, which are used when searching for a
 	file for the "gf", "[I", etc. commands.  Example: >
 		:set suffixesadd=.java
 <
@@ -6174,7 +6190,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	This option controls the behavior when switching between buffers.
 	Mostly for |quickfix| commands some values are also used for other
  	commands, as mentioned below.
-	Possible values (comma separated list):
+	Possible values (comma-separated list):
 	   useopen	If included, jump to the first open window that
 			contains the specified buffer (if there is one).
 			Otherwise: Do not examine other windows.
@@ -6235,7 +6251,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 						*'tabline'* *'tal'*
 'tabline' 'tal'		string	(default empty)
 			global
-	When nonempty, this option determines the content of the tab pages
+	When non-empty, this option determines the content of the tab pages
 	line at the top of the Vim window.  When empty Vim will use a default
 	tab pages line.  See |setting-tabline| for more info.
 
@@ -6268,10 +6284,11 @@ A jump table for the options with a short description can be found at |Q_op|.
 'tabstop' 'ts'		number	(default 8)
 			local to buffer
 	Number of spaces that a <Tab> in the file counts for.  Also see
-	|:retab| command, and 'softtabstop' option.
+	the |:retab| command, and the 'softtabstop' option.
 
 	Note: Setting 'tabstop' to any other value than 8 can make your file
-	appear wrong in many places (e.g., when printing it).
+	appear wrong in many places, e.g., when printing it.
+	The value must be more than 0 and less than 10000.
 
 	There are four main ways to use tabs in Vim:
 	1. Always keep 'tabstop' at 8, set 'softtabstop' and 'shiftwidth' to 4
@@ -6325,9 +6342,10 @@ A jump table for the options with a short description can be found at |Q_op|.
 	linear search can be avoided when case is ignored.  Use a value of '2'
 	in the "!_TAG_FILE_SORTED" line for this.  A tag file can be case-fold
 	sorted with the -f switch to "sort" in most unices, as in the command:
-	"sort -f -o tags tags".  For "Exuberant ctags" version 5.x or higher
-	(at least 5.5) the --sort=foldcase switch can be used for this as
-	well.  Note that case must be folded to uppercase for this to work.
+	"sort -f -o tags tags".  For Universal ctags and Exuberant ctags
+	version 5.x or higher (at least 5.5) the --sort=foldcase switch can be
+	used for this as well.  Note that case must be folded to uppercase for
+	this to work.
 
 	By default, tag searches are case-sensitive.  Case is ignored when
 	'ignorecase' is set and 'tagcase' is "followic", or when 'tagcase' is
@@ -6370,7 +6388,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	If non-zero, tags are significant up to this number of characters.
 
 			*'tagrelative'* *'tr'* *'notagrelative'* *'notr'*
-'tagrelative' 'tr'	boolean	(Vim default: on, Vi default: off)
+'tagrelative' 'tr'	boolean	(default: on)
 			global
 	If on and using a tags file in another directory, file names in that
 	tags file are relative to the directory where the tags file is.
@@ -6420,7 +6438,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	'arabicshape' is ignored, but 'rightleft' isn't changed automatically.
 	For further details see |arabic.txt|.
 
-						*'termguicolors'* *'tgc'*
+			*'termguicolors'* *'tgc'* *'notermguicolors'* *'notgc'*
 'termguicolors' 'tgc'	boolean (default off)
 			global
 	Enables 24-bit RGB color in the |TUI|.  Uses "gui" |:highlight|
@@ -6430,7 +6448,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 						*'termpastefilter'* *'tpf'*
 'termpastefilter' 'tpf'	string	(default: "BS,HT,ESC,DEL")
 			global
-	A comma separated list of options for specifying control characters
+	A comma-separated list of options for specifying control characters
 	to be removed from the text pasted into the terminal window. The
 	supported values are:
 
@@ -6450,13 +6468,6 @@ A jump table for the options with a short description can be found at |Q_op|.
 	   C1	    Control characters 0x80...0x9F
 
 
-						*'terse'* *'noterse'*
-'terse'			boolean	(default off)
-			global
-	When set: Add 's' flag to 'shortmess' option (this makes the message
-	for a search that hits the start or end of the file not being
-	displayed).  When reset: Remove 's' flag from 'shortmess' option.
-
 						*'textwidth'* *'tw'*
 'textwidth' 'tw'	number	(default 0)
 			local to buffer
@@ -6582,7 +6593,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	This option cannot be set in a modeline when 'modelineexpr' is off.
 
 	Example: >
-	    :auto BufEnter * let &titlestring = hostname() . "/" . expand("%:p")
+	    :auto BufEnter * let &titlestring = hostname() .. "/" .. expand("%:p")
 	    :set title titlestring=%<%F%=%l/%L-%P titlelen=70
 <	The value of 'titlelen' is used to align items in the middle or right
 	of the available space.
@@ -6594,11 +6605,8 @@ A jump table for the options with a short description can be found at |Q_op|.
 	NOTE: Use of special characters in 'titlestring' may cause the display
 	to be garbled (e.g., when it contains a CR or NL character).
 
-				     *'ttyfast'* *'tf'* *'nottyfast'* *'notf'*
-'ttyfast' 'tf'		Removed. |vim-differences|
-
 						*'undodir'* *'udir'* *E5003*
-'undodir' 'udir'	string	(default "$XDG_DATA_HOME/nvim/undo//")
+'undodir' 'udir'	string	(default "$XDG_STATE_HOME/nvim/undo//")
 			global
 	List of directory names for undo files, separated with commas.
 	See 'backupdir' for details of the format.
@@ -6766,8 +6774,8 @@ A jump table for the options with a short description can be found at |Q_op|.
 			global
 	When bigger than zero, Vim will give messages about what it is doing.
 	Currently, these messages are given:
-	>= 1	When the shada file is read or written.
-	>= 2	When a file is ":source"'ed.
+	>= 1	Lua assignments to options, mappings, etc.
+	>= 2	When a file is ":source"'ed and when the shada file is read or written..
 	>= 3	UI info, terminal capabilities
 	>= 4	Shell commands.
 	>= 5	Every searched tags file and include file.
@@ -6799,7 +6807,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	displayed when 'verbosefile' is set.
 
 						*'viewdir'* *'vdir'*
-'viewdir' 'vdir'	string	(default: "$XDG_DATA_HOME/nvim/view//")
+'viewdir' 'vdir'	string	(default: "$XDG_STATE_HOME/nvim/view//")
 			global
 	Name of the directory where to store files for |:mkview|.
 	This option cannot be set from a |modeline| or in the |sandbox|, for
@@ -6808,7 +6816,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 						*'viewoptions'* *'vop'*
 'viewoptions' 'vop'	string	(default: "folds,cursor,curdir")
 			global
-	Changes the effect of the |:mkview| command.  It is a comma separated
+	Changes the effect of the |:mkview| command.  It is a comma-separated
 	list of words.  Each word enables saving and restoring something:
 	   word		save and restore ~
 	   cursor	cursor position in file and in window
@@ -6823,12 +6831,16 @@ A jump table for the options with a short description can be found at |Q_op|.
 
 					    *'virtualedit'* *'ve'*
 'virtualedit' 've'	string	(default "")
-			global
-	A comma separated list of these words:
+			global or local to window |global-local|
+	A comma-separated list of these words:
 	    block	Allow virtual editing in Visual block mode.
 	    insert	Allow virtual editing in Insert mode.
 	    all		Allow virtual editing in all modes.
 	    onemore	Allow the cursor to move just past the end of the line
+	    none	When used as the local value, do not allow virtual
+			editing even when the global value is set.  When used
+			as the global value, "none" is the same as "".
+	    NONE	Alternative spelling of "none".
 
 	Virtual editing means that the cursor can be positioned where there is
 	no actual character.  This can be halfway into a tab or beyond the end
@@ -6859,7 +6871,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	has been changed.
 
 						*'whichwrap'* *'ww'*
-'whichwrap' 'ww'	string	(Vim default: "b,s", Vi default: "")
+'whichwrap' 'ww'	string	(default: "b,s")
 			global
 	Allow specified keys that move the cursor left/right to move to the
 	previous/next line when the cursor is on the first/last character in
@@ -6889,7 +6901,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	makes "dl", "cl", "yl" etc. work normally.
 
 						*'wildchar'* *'wc'*
-'wildchar' 'wc'		number	(Vim default: <Tab>, Vi default: CTRL-E)
+'wildchar' 'wc'		number	(default: <Tab>)
 			global
 	Character you have to type to start wildcard expansion in the
 	command-line, as specified with 'wildmode'.
@@ -6977,7 +6989,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 'wildmode' 'wim'	string	(default: "full")
 			global
 	Completion mode that is used for the character specified with
-	'wildchar'.  It is a comma separated list of up to four parts.  Each
+	'wildchar'.  It is a comma-separated list of up to four parts.  Each
 	part specifies what to do for each consecutive use of 'wildchar'.  The
 	first part specifies the behavior for the first use of 'wildchar',
 	The second part for the second use, etc.
@@ -7024,7 +7036,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 'wildoptions' 'wop'	string	(default "pum,tagfile")
 			global
 	List of words that change how |cmdline-completion| is done.
-	  pum		Display the completion matches using the popupmenu
+	  pum		Display the completion matches using the popup menu
 			in the same style as the |ins-completion-menu|.
 	  tagfile	When using CTRL-D to list matching tags, the kind of
 			tag and the file of the tag is listed.	Only one match
@@ -7051,6 +7063,23 @@ A jump table for the options with a short description can be found at |Q_op|.
 	key is never used for the menu.
 	This option is not used for <F10>; on Win32.
 
+						*'winbar'* *'wbr'*
+'winbar' 'wbr'		string (default empty)
+			global or local to window |global-local|
+	When non-empty, this option enables the window bar and determines its
+	contents. The window bar is a bar that's shown at the top of every
+	window with it enabled. The value of 'winbar' is evaluated like with
+	'statusline'.
+
+	When changing something that is used in 'winbar' that does not trigger
+	it to be updated, use |:redrawstatus|.
+
+	Floating windows do not use the global value of 'winbar'. The
+	window-local value of 'winbar' must be set for a floating window to
+	have a window bar.
+
+	This option cannot be set in a modeline when 'modelineexpr' is off.
+
 						*'winblend'* *'winbl'*
 'winblend' 'winbl'		number	(default 0)
 			local to window
@@ -7192,7 +7221,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	starts.  When typing text beyond this limit, an <EOL> will be inserted
 	and inserting continues on the next line.
 	Options that add a margin, such as 'number' and 'foldcolumn', cause
-	the text width to be further reduced.  This is Vi compatible.
+	the text width to be further reduced.
 	When 'textwidth' is non-zero, this option is not used.
 	See also 'formatoptions' and |ins-textwidth|.
 
diff --git a/runtime/doc/pattern.txt b/runtime/doc/pattern.txt
index 634145da3e..371a210847 100644
--- a/runtime/doc/pattern.txt
+++ b/runtime/doc/pattern.txt
@@ -71,12 +71,18 @@ N			Repeat the latest "/" or "?" [count] times in
 			Only whole keywords are searched for, like with the
 			command "/\<keyword\>".  |exclusive|
 			'ignorecase' is used, 'smartcase' is not.
+							*v_star-default*
+			In Visual mode, search forward for the current selection.
+			|default-mappings|
 
 							*#*
 #			Same as "*", but search backward.  The pound sign
 			(character 163) also works.  If the "#" key works as
 			backspace, try using "stty erase <BS>" before starting
 			Vim (<BS> is CTRL-H or a real backspace).
+							*v_#-default*
+			In Visual mode, search backward for the current selection.
+			|default-mappings|
 
 							*gstar*
 g*			Like "*", but don't put "\<" and "\>" around the word.
@@ -153,9 +159,10 @@ index, on which the cursor is. This can look like this: >
 Note: the count does not take offset into account.
 
 When no match is found you get the error: *E486* Pattern not found
-Note that for the |:global| command this behaves like a normal message, for Vi
-compatibility.  For the |:s| command the "e" flag can be used to avoid the
-error message |:s_flags|.
+Note that for the `:global` command, you get a normal message "Pattern not
+found", for Vi compatibility.
+For the |:s| command the "e" flag can be used to avoid the error message
+|:s_flags|.
 
 					*search-offset* *{offset}*
 These commands search for the specified pattern.  With "/" and "?" an
@@ -913,17 +920,24 @@ $	At end of pattern or in front of "\|", "\)" or "\n" ('magic' on):
 	becomes invalid.  Vim doesn't automatically update the matches.
 	Similar to moving the cursor for "\%#" |/\%#|.
 
-						*/\%l* */\%>l* */\%<l* *E951*
+					*/\%l* */\%>l* */\%<l* *E951* *E1204*
 \%23l	Matches in a specific line.
 \%<23l	Matches above a specific line (lower line number).
 \%>23l	Matches below a specific line (higher line number).
-	These three can be used to match specific lines in a buffer.  The "23"
+\%.l	Matches at the cursor line.
+\%<.l	Matches above the cursor line.
+\%>.l	Matches below the cursor line.
+	These six can be used to match specific lines in a buffer.  The "23"
 	can be any line number.  The first line is 1.
 	WARNING: When inserting or deleting lines Vim does not automatically
 	update the matches.  This means Syntax highlighting quickly becomes
-	wrong.
+	wrong.  Also when referring to the cursor position (".") and
+	the cursor moves the display isn't updated for this change.  An update
+	is done when using the |CTRL-L| command (the whole screen is updated).
 	Example, to highlight the line where the cursor currently is: >
-		:exe '/\%' . line(".") . 'l.*'
+		:exe '/\%' .. line(".") .. 'l'
+<	Alternatively use: >
+		/\%.l
 <	When 'hlsearch' is set and you move the cursor around and make changes
 	this will clearly show when the match is updated or not.
 
@@ -931,15 +945,22 @@ $	At end of pattern or in front of "\|", "\)" or "\n" ('magic' on):
 \%23c	Matches in a specific column.
 \%<23c	Matches before a specific column.
 \%>23c	Matches after a specific column.
-	These three can be used to match specific columns in a buffer or
-	string.  The "23" can be any column number.  The first column is 1.
-	Actually, the column is the byte number (thus it's not exactly right
-	for multibyte characters).
+\%.c	Matches at the cursor column.
+\%<.c	Matches before the cursor column.
+\%>.c	Matches after the cursor column.
+	These six can be used to match specific columns in a buffer or string.
+	The "23" can be any column number.  The first column is 1.  Actually,
+	the column is the byte number (thus it's not exactly right for
+	multibyte characters).
 	WARNING: When inserting or deleting text Vim does not automatically
 	update the matches.  This means Syntax highlighting quickly becomes
-	wrong.
+	wrong.  Also when referring to the cursor position (".") and
+	the cursor moves the display isn't updated for this change.  An update
+	is done when using the |CTRL-L| command (the whole screen is updated).
 	Example, to highlight the column where the cursor currently is: >
-		:exe '/\%' . col(".") . 'c'
+		:exe '/\%' .. col(".") .. 'c'
+<	Alternatively use: >
+		/\%.c
 <	When 'hlsearch' is set and you move the cursor around and make changes
 	this will clearly show when the match is updated or not.
 	Example for matching a single byte in column 44: >
@@ -950,8 +971,11 @@ $	At end of pattern or in front of "\|", "\)" or "\n" ('magic' on):
 \%23v	Matches in a specific virtual column.
 \%<23v	Matches before a specific virtual column.
 \%>23v	Matches after a specific virtual column.
-	These three can be used to match specific virtual columns in a buffer
-	or string.  When not matching with a buffer in a window, the option
+\%.v	Matches at the current virtual column.
+\%<.v	Matches before the current virtual column.
+\%>.v	Matches after the current virtual column.
+	These six can be used to match specific virtual columns in a buffer or
+	string.  When not matching with a buffer in a window, the option
 	values of the current window are used (e.g., 'tabstop').
 	The "23" can be any column number.  The first column is 1.
 	Note that some virtual column positions will never match, because they
@@ -959,13 +983,18 @@ $	At end of pattern or in front of "\|", "\)" or "\n" ('magic' on):
 	one screen character.
 	WARNING: When inserting or deleting text Vim does not automatically
 	update highlighted matches.  This means Syntax highlighting quickly
-	becomes wrong.
+	becomes wrong.  Also when referring to the cursor position (".") and
+	the cursor moves the display isn't updated for this change.  An update
+	is done when using the |CTRL-L| command (the whole screen is updated).
 	Example, to highlight all the characters after virtual column 72: >
 		/\%>72v.*
 <	When 'hlsearch' is set and you move the cursor around and make changes
 	this will clearly show when the match is updated or not.
 	To match the text up to column 17: >
 		/^.*\%17v
+<	To match all characters after the current virtual column (where the
+	cursor is): >
+		/\%>.v.*
 <	Column 17 is not included, because this is a |/zero-width| match. To
 	include the column use: >
 		/^.*\%17v.
@@ -1421,5 +1450,38 @@ Finally, these constructs are unique to Perl:
 		are suggested to use ":match" for manual matching and
 		":2match" for another plugin.
 
+==============================================================================
+11. Fuzzy matching					*fuzzy-matching*
+
+Fuzzy matching refers to matching strings using a non-exact search string.
+Fuzzy matching will match a string, if all the characters in the search string
+are present anywhere in the string in the same order. Case is ignored.  In a
+matched string, other characters can be present between two consecutive
+characters in the search string. If the search string has multiple words, then
+each word is matched separately. So the words in the search string can be
+present in any order in a string.
+
+Fuzzy matching assigns a score for each matched string based on the following
+criteria:
+    - The number of sequentially matching characters.
+    - The number of characters (distance) between two consecutive matching
+      characters.
+    - Matches at the beginning of a word
+    - Matches at a camel case character (e.g. Case in CamelCase)
+    - Matches after a path separator or a hyphen.
+    - The number of unmatched characters in a string.
+The matching string with the highest score is returned first.
+
+For example, when you search for the "get pat" string using fuzzy matching, it
+will match the strings "GetPattern", "PatternGet", "getPattern", "patGetter",
+"getSomePattern", "MatchpatternGet" etc.
+
+The functions |matchfuzzy()| and |matchfuzzypos()| can be used to fuzzy search
+a string in a List of strings. The matchfuzzy() function returns a List of
+matching strings. The matchfuzzypos() functions returns the List of matches,
+the matching positions and the fuzzy match scores.
+
+The "f" flag of `:vimgrep` enables fuzzy matching.
+
 
  vim:tw=78:ts=8:noet:ft=help:norl:
diff --git a/runtime/doc/pi_health.txt b/runtime/doc/pi_health.txt
index 179c1066cd..04e04b5165 100644
--- a/runtime/doc/pi_health.txt
+++ b/runtime/doc/pi_health.txt
@@ -48,27 +48,26 @@ Commands                                *health-commands*
                         :checkhealth vim*
 <
 ==============================================================================
-Lua Functions                           *health-functions-lua* *health-lua*
+Lua Functions                       *health-functions-lua* *health-lua* *vim.health*
 
 The Lua "health" module can be used to create new healthchecks (see also
-|health-functions-vim|). To get started, simply use:  >
-        local health = require('health')
-<
-health.report_start({name})                             *health.report_start()*
+|health-functions-vim|). To get started, simply use:
+
+vim.health.report_start({name})                         *vim.health.report_start()*
         Starts a new report. Most plugins should call this only once, but if
         you want different sections to appear in your report, call this once
         per section.
 
-health.report_info({msg})                               *health.report_info()*
+vim.health.report_info({msg})                           *vim.health.report_info()*
         Reports an informational message.
 
-health.report_ok({msg})                                 *health.report_ok()*
+vim.health.report_ok({msg})                             *vim.health.report_ok()*
         Reports a "success" message.
 
-health.report_warn({msg} [, {advice}])                  *health.report_warn()*
+vim.health.report_warn({msg} [, {advice}])              *vim.health.report_warn()*
         Reports a warning. {advice} is an optional List of suggestions.
 
-health.report_error({msg} [, {advice}])                 *health.report_error()*
+vim.health.report_error({msg} [, {advice}])             *vim.health.report_error()*
         Reports an error. {advice} is an optional List of suggestions.
 
 ==============================================================================
@@ -98,15 +97,14 @@ Copy this sample code into `lua/foo/health/init.lua` or `lua/foo/health.lua`,
 replacing "foo" in the path with your plugin name: >
 
         local M = {}
-        local health = require("health")
 
         M.check = function()
-          health.report_start("my_plugin report")
+          vim.health.report_start("my_plugin report")
           -- make sure setup function parameters are ok
           if check_setup() then
-            health.report_ok("Setup function is correct")
+            vim.health.report_ok("Setup function is correct")
           else
-            health.report_error("Setup function is incorrect")
+            vim.health.report_error("Setup function is incorrect")
           end
           -- do some more checking
           -- ...
diff --git a/runtime/doc/pi_msgpack.txt b/runtime/doc/pi_msgpack.txt
index 1dbd268038..801c56e49f 100644
--- a/runtime/doc/pi_msgpack.txt
+++ b/runtime/doc/pi_msgpack.txt
@@ -88,7 +88,7 @@ msgpack#type({msgpack-value})				*msgpack#type()*
 	Returns name of the key in |v:msgpack_types| that represents 
 	{msgpack-value} type.  Never returns zero: this function returns 
 	msgpack type which will be dumped by |msgpackdump()| should it receive 
-	a list with singe {msgpack-value} as input.
+	a list with single {msgpack-value} as input.
 
 msgpack#deepcopy({msgpack-value})			*msgpack#deepcopy()*
 	Like |deepcopy()|, but works correctly with |msgpack-special-dict| 
diff --git a/runtime/doc/pi_netrw.txt b/runtime/doc/pi_netrw.txt
index 3ac61be6f2..6f7b53722c 100644
--- a/runtime/doc/pi_netrw.txt
+++ b/runtime/doc/pi_netrw.txt
@@ -440,11 +440,11 @@ settings are described below, in |netrw-browser-options|, and in
 
  *g:netrw_use_errorwindow* =2: messages from netrw will use a popup window
 			     Move the mouse and pause to remove the popup window.
-			     (default value if popup windows are availble)
+			     (default value if popup windows are available)
 			 =1 : messages from netrw will use a separate one
 			      line window.  This window provides reliable
 			      delivery of messages.
-			     (default value if popup windows are not availble)
+			     (default value if popup windows are not available)
 			 =0 : messages from netrw will use echoerr ;
 			      messages don't always seem to show up this
 			      way, but one doesn't have to quit the window.
@@ -968,7 +968,7 @@ itself:
      fun! NetReadFixup(method, line1, line2)
        if method == 3   " ftp (no <.netrc>)
         let fourblanklines= line2 - 3
-        silent fourblanklines.",".line2."g/^\s*/d"
+        silent fourblanklines .. "," .. line2 .. "g/^\s*/d"
        endif
      endfunction
     endif
@@ -1198,7 +1198,7 @@ If there are marked files and/or directories, mb will add them to the bookmark
 list.
 
 								*netrw-:NetrwMB*
-Addtionally, one may use :NetrwMB to bookmark files or directories. >
+Additionally, one may use :NetrwMB to bookmark files or directories. >
 
 	:NetrwMB[!] [files/directories]
 
@@ -1975,7 +1975,7 @@ To use this function, simply assign its output to |g:netrw_list_hide| option.  >
 	Example: let g:netrw_list_hide= netrw_gitignore#Hide('my_gitignore_file')
 		Function can take additional files with git-ignore patterns.
 
-	Example: g:netrw_list_hide= netrw_gitignore#Hide() . '.*\.swp$'
+	Example: let g:netrw_list_hide= netrw_gitignore#Hide() .. '.*\.swp$'
 		Combining 'netrw_gitignore#Hide' with custom patterns.
 <
 
@@ -2814,7 +2814,7 @@ your browsing preferences.  (see also: |netrw-settings|)
 				= 2: wide listing (multiple files in columns)
 				= 3: tree style listing
 
-  *g:netrw_list_hide*		comma separated pattern list for hiding files
+  *g:netrw_list_hide*		comma-separated pattern list for hiding files
 				Patterns are regular expressions (see |regexp|)
 				There's some special support for git-ignore
 				files: you may add the output from the helper
@@ -2824,7 +2824,7 @@ your browsing preferences.  (see also: |netrw-settings|)
 
 				Examples:
 				 let g:netrw_list_hide= '.*\.swp$'
-				 let g:netrw_list_hide= netrw_gitignore#Hide().'.*\.swp$'
+				 let g:netrw_list_hide= netrw_gitignore#Hide() .. '.*\.swp$'
 				default: ""
 
   *g:netrw_localcopycmd*	="cp"           Linux/Unix/MacOS/Cygwin
diff --git a/runtime/doc/print.txt b/runtime/doc/print.txt
index f54d0429a6..924fab175e 100644
--- a/runtime/doc/print.txt
+++ b/runtime/doc/print.txt
@@ -127,21 +127,21 @@ file: >
     system(['lpr']
            + (empty(&printdevice)?[]:['-P', &printdevice])
            + [v:fname_in])
-    . delete(v:fname_in)
+    .. delete(v:fname_in)
     + v:shell_error
 
 On MS-Dos and MS-Windows machines the default is to copy the file to the
 currently specified printdevice: >
 
     system(['copy', v:fname_in, empty(&printdevice)?'LPT1':&printdevice])
-    . delete(v:fname_in)
+    .. delete(v:fname_in)
 
 If you change this option, using a function is an easy way to avoid having to
 escape all the spaces.  Example: >
 
 	:set printexpr=PrintFile(v:fname_in)
 	:function PrintFile(fname)
-	:  call system("ghostview " . a:fname)
+	:  call system("ghostview " .. a:fname)
 	:  call delete(a:fname)
 	:  return v:shell_error
 	:endfunc
diff --git a/runtime/doc/provider.txt b/runtime/doc/provider.txt
index b785010699..9fd35f19c5 100644
--- a/runtime/doc/provider.txt
+++ b/runtime/doc/provider.txt
@@ -20,11 +20,12 @@ Run the |:checkhealth| command, and review the sections below.
 ==============================================================================
 Python integration				*provider-python*
 
-Nvim supports Python |remote-plugin|s and the Vim legacy |python2| and
-|python3| interfaces (which are implemented as remote-plugins).
+Nvim supports Python |remote-plugin|s and the Vim legacy |python3| and
+|pythonx| interfaces (which are implemented as remote-plugins).
 
 Note: Only the Vim 7.3 legacy interface is supported, not later features such
-as |python-bindeval| (Vim 7.4); use the Nvim API instead.
+as |python-bindeval| (Vim 7.4); use the Nvim API instead. Python 2 is not
+supported.
 
 
 PYTHON QUICKSTART ~
@@ -38,11 +39,6 @@ For Python 3 plugins:
 2. Install the module (try "python" if "python3" is missing): >
    python3 -m pip install --user --upgrade pynvim
 
-For Python 2 plugins:
-1. Make sure Python 2.7 is available in your $PATH.
-2. Install the module (try "python" if "python2" is missing): >
-   python2 -m pip install --user --upgrade pynvim
-
 The pip `--upgrade` flag ensures that you get the latest version even if
 a previous version was already installed.
 
@@ -56,22 +52,12 @@ If you run into problems, uninstall _both_ then install "pynvim" again: >
 
 
 PYTHON PROVIDER CONFIGURATION ~
-						*g:python_host_prog*
-Command to start Python 2 (executable, not directory). Setting this makes
-startup faster. Useful for working with virtualenvs. Must be set before any
-check for has("python2").  >
-    let g:python_host_prog  = '/path/to/python'
-<
 						*g:python3_host_prog*
 Command to start Python 3 (executable, not directory). Setting this makes
 startup faster. Useful for working with virtualenvs. Must be set before any
 check for has("python3").  >
     let g:python3_host_prog = '/path/to/python3'
 <
-						*g:loaded_python_provider*
-To disable Python 2 support: >
-    let g:loaded_python_provider = 0
-<
 						*g:loaded_python3_provider*
 To disable Python 3 support: >
     let g:loaded_python3_provider = 0
@@ -81,8 +67,8 @@ PYTHON VIRTUALENVS ~
 						*python-virtualenv*
 If you plan to use per-project virtualenvs often, you should assign one
 virtualenv for Neovim and hard-code the interpreter path via
-|g:python3_host_prog| (or |g:python_host_prog|) so that the "pynvim" package
-is not required for each virtualenv.
+|g:python3_host_prog| so that the "pynvim" package is not required
+for each virtualenv.
 
 Example using pyenv: >
     pyenv install 3.4.4
diff --git a/runtime/doc/quickfix.txt b/runtime/doc/quickfix.txt
index 873fbd8971..dab3bfa280 100644
--- a/runtime/doc/quickfix.txt
+++ b/runtime/doc/quickfix.txt
@@ -341,7 +341,7 @@ processing a quickfix or location list command, it will be aborted.
 			cursor position will not be changed. See |:cexpr| for
 			more information.
 			Example: >
-    :g/mypattern/caddexpr expand("%") . ":" . line(".") .  ":" . getline(".")
+    :g/mypattern/caddexpr expand("%") .. ":" .. line(".") ..  ":" .. getline(".")
 <
 						*:lad* *:addd* *:laddexpr*
 :lad[dexpr] {expr}	Same as ":caddexpr", except the location list for the
@@ -497,7 +497,6 @@ EXECUTE A COMMAND IN ALL THE BUFFERS IN QUICKFIX OR LOCATION LIST:
 			autocommand event is disabled by adding it to
 			'eventignore'.  This considerably speeds up editing
 			each buffer.
-			{not in Vi}
 			Also see |:bufdo|, |:tabdo|, |:argdo|, |:windo|,
 			|:ldo|, |:cfdo| and |:lfdo|.
 
@@ -510,7 +509,6 @@ EXECUTE A COMMAND IN ALL THE BUFFERS IN QUICKFIX OR LOCATION LIST:
 				:{cmd}
 				etc.
 <			Otherwise it works the same as `:cdo`.
-			{not in Vi}
 
 							*:ldo*
 :ld[o][!] {cmd}		Execute {cmd} in each valid entry in the location list
@@ -523,7 +521,6 @@ EXECUTE A COMMAND IN ALL THE BUFFERS IN QUICKFIX OR LOCATION LIST:
 				etc.
 <			Only valid entries in the location list are used.
 			Otherwise it works the same as `:cdo`.
-			{not in Vi}
 
 							*:lfdo*
 :lfdo[!] {cmd}		Execute {cmd} in each file in the location list for
@@ -535,7 +532,6 @@ EXECUTE A COMMAND IN ALL THE BUFFERS IN QUICKFIX OR LOCATION LIST:
 				:{cmd}
 				etc.
 <			Otherwise it works the same as `:ldo`.
-			{not in Vi}
 
 FILTERING A QUICKFIX OR LOCATION LIST:
 				    *cfilter-plugin* *:Cfilter* *:Lfilter*
@@ -560,6 +556,9 @@ pattern is used.
 The |:Lfilter| command does the same as |:Cfilter| but operates on the current
 location list.
 
+The current quickfix/location list is not modified by these commands, so you
+can go back to the unfiltered list using the |:colder|/|:lolder| command.
+
 =============================================================================
 2. The error window					*quickfix-window*
 
@@ -575,6 +574,7 @@ location list.
 			second quickfix window.  If [height] is given the
 			existing window will be resized to it.
 
+							*quickfix-buffer*
 			The window will contain a special buffer, with
 			'buftype' equal to "quickfix".  Don't change this!
 			The window will have the w:quickfix_title variable set
@@ -583,7 +583,11 @@ location list.
 			status line if the value of 'statusline' is adjusted
 			properly. Whenever this buffer is modified by a
 			quickfix command or function, the |b:changedtick|
-			variable is incremented.
+			variable is incremented.  You can get the number of
+			this buffer using the getqflist() and getloclist()
+			functions by passing the 'qfbufnr' item. For a
+			location list, this buffer is wiped out when the
+			location list is removed.
 
 							*:lop* *:lopen*
 :lop[en] [height]	Open a window to show the location list for the
@@ -641,6 +645,27 @@ quickfix window.  If there already is a window for that file, it is used
 instead.  If the buffer in the used window has changed, and the error is in
 another file, jumping to the error will fail.  You will first have to make
 sure the window contains a buffer which can be abandoned.
+
+When you select a file from the quickfix window, the following steps are used
+to find a window to edit the file:
+
+1. If a window displaying the selected file is present in the current tabpage
+   (starting with the window before the quickfix window), then that window is
+   used.
+2. If the above step fails and if 'switchbuf' contains "usetab" and a window
+   displaying the selected file is present in any one of the tabpages
+   (starting with the first tabpage) then that window is used.
+3. If the above step fails then a window in the current tabpage displaying a
+   buffer with 'buftype' not set (starting with the window before the quickfix
+   window) is used.
+4. If the above step fails and if 'switchbuf' contains "uselast", then the
+   previously accessed window is used.
+5. If the above step fails then the window before the quickfix window is used.
+   If there is no previous window, then the window after the quickfix window
+   is used.
+6. If the above step fails, then a new horizontally split window above the
+   quickfix window is used.
+
 					*CTRL-W_<Enter>* *CTRL-W_<CR>*
 You can use CTRL-W <Enter> to open a new window and jump to the error there.
 
@@ -650,7 +675,7 @@ FileType event (also see |qf.vim|).  Then the BufReadPost event is triggered,
 using "quickfix" for the buffer name.  This can be used to perform some action
 on the listed errors.  Example: >
 	au BufReadPost quickfix  setlocal modifiable
-		\ | silent exe 'g/^/s//\=line(".")." "/'
+		\ | silent exe 'g/^/s//\=line(".") .. " "/'
 		\ | setlocal nomodifiable
 This prepends the line number to each line.  Note the use of "\=" in the
 substitute string of the ":s" command, which is used to evaluate an
@@ -679,13 +704,15 @@ this window, the displayed location list is used.
 When you select a file from the location list window, the following steps are
 used to find a window to edit the file:
 
-1. If a window with the location list displayed in the location list window is
-   present, then the file is opened in that window.
-2. If the above step fails and if the file is already opened in another
-   window, then that window is used.
-3. If the above step fails then an existing window showing a buffer with
-   'buftype' not set is used.
-4. If the above step fails, then the file is edited in a new window.
+1. If a non-quickfix window associated with the location list is present in
+   the current tabpage, then that window is used.
+2. If the above step fails and if the file is already opened in another window
+   in the current tabpage, then that window is used.
+3. If the above step fails and 'switchbuf' contains "usetab" and if the file
+   is opened in a window in any one of the tabpages, then that window is used.
+4. If the above step fails then a window in the current tabpage showing a
+   buffer with 'buftype' not set is used.
+5. If the above step fails, then the file is edited in a new window.
 
 In all of the above cases, if the location list for the selected window is not
 yet set, then it is set to the location list displayed in the location list
@@ -749,12 +776,18 @@ using these functions are below:
     " get the quickfix list window id
     :echo getqflist({'winid' : 0}).winid
 
+    " get the quickfix list window buffer number
+    :echo getqflist({'qfbufnr' : 0}).qfbufnr
+
     " get the context of the current location list
     :echo getloclist(0, {'context' : 0}).context
 
     " get the location list window id of the third window
     :echo getloclist(3, {'winid' : 0}).winid
 
+    " get the location list window buffer number of the third window
+    :echo getloclist(3, {'qfbufnr' : 0}).qfbufnr
+
     " get the file window id of a location list window (winnr: 4)
     :echo getloclist(4, {'filewinid' : 0}).filewinid
 <
@@ -989,7 +1022,7 @@ commands can be combined to create a NewGrep command: >
 5.1 using Vim's internal grep
 
 					*:vim* *:vimgrep* *E682* *E683*
-:vim[grep][!] /{pattern}/[g][j] {file} ...
+:vim[grep][!] /{pattern}/[g][j][f] {file} ...
 			Search for {pattern} in the files {file} ... and set
 			the error list to the matches.  Files matching
 			'wildignore' are ignored; files in 'suffixes' are
@@ -1014,6 +1047,13 @@ commands can be combined to create a NewGrep command: >
 			     updated.  With the [!] any changes in the current
 			     buffer are abandoned.
 
+			'f'  When the 'f' flag is specified, fuzzy string
+			     matching is used to find matching lines. In this
+			     case, {pattern} is treated as a literal string
+			     instead of a regular expression.  See
+			     |fuzzy-matching| for more information about fuzzy
+			     matching strings.
+
 			|QuickFixCmdPre| and |QuickFixCmdPost| are triggered.
 			A file that is opened for matching may use a buffer
 			number, but it is reused if possible to avoid
@@ -1042,20 +1082,20 @@ commands can be combined to create a NewGrep command: >
 				:vimgrep Error *.c
 <
 							*:lv* *:lvimgrep*
-:lv[imgrep][!] /{pattern}/[g][j] {file} ...
+:lv[imgrep][!] /{pattern}/[g][j][f] {file} ...
 :lv[imgrep][!] {pattern} {file} ...
 			Same as ":vimgrep", except the location list for the
 			current window is used instead of the quickfix list.
 
 						*:vimgrepa* *:vimgrepadd*
-:vimgrepa[dd][!] /{pattern}/[g][j] {file} ...
+:vimgrepa[dd][!] /{pattern}/[g][j][f] {file} ...
 :vimgrepa[dd][!] {pattern} {file} ...
 			Just like ":vimgrep", but instead of making a new list
 			of errors the matches are appended to the current
 			list.
 
 						*:lvimgrepa* *:lvimgrepadd*
-:lvimgrepa[dd][!] /{pattern}/[g][j] {file} ...
+:lvimgrepa[dd][!] /{pattern}/[g][j][f] {file} ...
 :lvimgrepa[dd][!] {pattern} {file} ...
 			Same as ":vimgrepadd", except the location list for
 			the current window is used instead of the quickfix
@@ -1332,12 +1372,17 @@ Basic items
 	%f		file name (finds a string)
 	%o		module name (finds a string)
 	%l		line number (finds a number)
+	%e		end line number (finds a number)
 	%c		column number (finds a number representing character
 			column of the error, byte index, a <tab> is 1
 			character column)
 	%v		virtual column number (finds a number representing
 			screen column of the error (1 <tab> == 8 screen
 			columns))
+	%k		end column number (finds a number representing
+			the character column of the error, byte index, or a
+			number representing screen end column of the error if
+			it's used with %v)
 	%t		error type (finds a single character):
 			    e - error message
 			    w - warning message
@@ -1446,7 +1491,7 @@ error message (line numbers are not part of the actual output):
      4	Traceback (most recent call last):
      5	  File "unittests/dbfacadeTest.py", line 89, in testFoo
      6	    self.assertEquals(34, dtid)
-     7	  File "/usr/lib/python2.2/unittest.py", line 286, in
+     7	  File "/usr/lib/python3.8/unittest.py", line 286, in
      8	 failUnlessEqual
      9	    raise self.failureException, \
     10	AssertionError: 34 != 33
diff --git a/runtime/doc/quickref.txt b/runtime/doc/quickref.txt
index af8301f1a0..6f16db5cc2 100644
--- a/runtime/doc/quickref.txt
+++ b/runtime/doc/quickref.txt
@@ -356,6 +356,7 @@ In Insert or Command-line mode:
 |v_y|	     {visual}y	yank the highlighted text into a register
 |yy|	  N  yy		yank N lines into a register
 |Y|	  N  Y		yank N lines into a register
+			Note: Mapped to "y$" by default. |default-mappings|
 |p|	  N  p		put a register after the cursor position (N times)
 |P|	  N  P		put a register before the cursor position (N times)
 |]p|	  N  ]p		like p, but adjust indent to current line
@@ -637,6 +638,7 @@ Short explanation of each option:		*option-list*
 'cinkeys'	  'cink'    keys that trigger indent when 'cindent' is set
 'cinoptions'	  'cino'    how to do indenting when 'cindent' is set
 'cinwords'	  'cinw'    words where 'si' and 'cin' add an indent
+'cinscopedecls'	  'cinsd'   words that are recognized by 'cino-g'
 'clipboard'	  'cb'	    use the clipboard as the unnamed register
 'cmdheight'	  'ch'	    number of lines to use for the command-line
 'cmdwinheight'	  'cwh'     height of the command-line window
@@ -739,7 +741,6 @@ Short explanation of each option:		*option-list*
 'indentexpr'	  'inde'    expression used to obtain the indent of a line
 'indentkeys'	  'indk'    keys that trigger indenting with 'indentexpr'
 'infercase'	  'inf'     adjust case of match for keyword completion
-'insertmode'	  'im'	    start the edit of a file in Insert mode
 'isfname'	  'isf'     characters included in file names and pathnames
 'isident'	  'isi'     characters included in identifiers
 'iskeyword'	  'isk'     characters included in keywords
@@ -784,6 +785,7 @@ Short explanation of each option:		*option-list*
 'mousefocus'	  'mousef'  keyboard focus follows the mouse
 'mousehide'	  'mh'	    hide mouse pointer while typing
 'mousemodel'	  'mousem'  changes meaning of mouse buttons
+'mousescroll'		    amount to scroll by when scrolling with a mouse
 'mouseshape'	  'mouses'  shape of the mouse pointer in different modes
 'mousetime'	  'mouset'  max time between mouse double-click
 'nrformats'	  'nf'	    number formats recognized for CTRL-A command
@@ -822,7 +824,6 @@ Short explanation of each option:		*option-list*
 'redrawtime'	  'rdt'     timeout for 'hlsearch' and |:match| highlighting
 'regexpengine'	  're'	    default regexp engine to use
 'relativenumber'  'rnu'	    show relative line number in front of each line
-'remap'			    allow mappings to work recursively
 'report'		    threshold for reporting nr. of lines changed
 'revins'	  'ri'	    inserting characters will work backwards
 'rightleft'	  'rl'	    window is right-to-left oriented
@@ -894,7 +895,6 @@ Short explanation of each option:		*option-list*
 'tagstack'	  'tgst'    push tags onto the tag stack
 'term'			    name of the terminal
 'termbidi'	  'tbidi'   terminal takes care of bi-directionality
-'terse'			    shorten some messages
 'textwidth'	  'tw'	    maximum width of text that is being inserted
 'thesaurus'	  'tsr'     list of thesaurus files for keyword completion
 'thesaurusfunc'	  'tsrfu'   function to be used for thesaurus completion
@@ -1267,7 +1267,7 @@ Context-sensitive completion on the command-line:
 |CTRL-W_^|	CTRL-W ^		split window and edit alternate file
 |CTRL-W_n|	CTRL-W n  or  :new	create new empty window
 |CTRL-W_q|	CTRL-W q  or  :q[uit]	quit editing and close window
-|CTRL-W_c|	CTRL-W c  or  :cl[ose]	make buffer hidden and close window
+|CTRL-W_c|	CTRL-W c  or  :clo[se]	make buffer hidden and close window
 |CTRL-W_o|	CTRL-W o  or  :on[ly]	make current window only one on the
 					   screen
 
diff --git a/runtime/doc/recover.txt b/runtime/doc/recover.txt
index 9ef5a37452..d9aaa757ad 100644
--- a/runtime/doc/recover.txt
+++ b/runtime/doc/recover.txt
@@ -108,7 +108,7 @@ command:
 					*:pre* *:preserve* *E313* *E314*
 :pre[serve]		Write all text for the current buffer into its swap
 			file.  The original file is no longer needed for
-			recovery.  This sets a flag in the current buffer.
+			recovery.
 
 A Vim swap file can be recognized by the first six characters: "b0VIM ".
 After that comes the version number, e.g., "3.0".
diff --git a/runtime/doc/remote.txt b/runtime/doc/remote.txt
new file mode 100644
index 0000000000..0c1e3438de
--- /dev/null
+++ b/runtime/doc/remote.txt
@@ -0,0 +1,131 @@
+*remote.txt*    Nvim
+
+
+		  VIM REFERENCE MANUAL    by Bram Moolenaar
+
+
+Vim client-server communication				*client-server*
+
+                                      Type |gO| to see the table of contents.
+
+==============================================================================
+1. Common functionality					*clientserver*
+
+Nvim's |RPC| functionality allows clients to programmatically control Nvim. Nvim
+itself takes command-line arguments that cause it to become a client to another
+Nvim running as a server. These arguments match those provided by Vim's
+clientserver option.
+
+The following command line arguments are available:
+
+    argument			meaning	~
+
+   --remote [+{cmd}] {file} ...					*--remote*
+				Open the file list in a remote Vim.  When
+				there is no Vim server, execute locally.
+				Vim allows one init command: +{cmd}.
+				This must be an Ex command that can be
+				followed by "|". It's not yet supported by
+				Nvim.
+				The rest of the command line is taken as the
+				file list.  Thus any non-file arguments must
+				come before this.
+				You cannot edit stdin this way |--|.
+				The remote Vim is raised.  If you don't want
+				this use >
+				 nvim --remote-send "<C-\><C-N>:n filename<CR>"
+<
+   --remote-silent [+{cmd}] {file} ...			*--remote-silent*
+				As above, but don't complain if there is no
+				server and the file is edited locally.
+							*--remote-tab*
+   --remote-tab			Like --remote but open each file in a new
+				tabpage.
+							*--remote-tab-silent*
+   --remote-tab-silent		Like --remote-silent but open each file in a
+				new tabpage.
+								*--remote-send*
+   --remote-send {keys}		Send {keys} to server and exit.  The {keys}
+   				are not mapped.  Special key names are
+				recognized, e.g., "<CR>" results in a CR
+				character.
+								*--remote-expr*
+   --remote-expr {expr}		Evaluate {expr} in server and print the result
+				on stdout.
+								*--server*
+   --server {addr}		Connect to the named pipe or socket at the
+				given address for executing remote commands.
+				See |--listen| for specifying an address when
+				starting a server.
+
+Examples ~
+
+Start an Nvim server listening on a named pipe at '~/.cache/nvim/server.pipe': >
+    nvim --listen ~/.cache/nvim/server.pipe
+
+Edit "file.txt" in an Nvim server listening at '~/.cache/nvim/server.pipe': >
+    nvim --server ~/.cache/nvim/server.pipe --remote file.txt
+
+This doesn't work, all arguments after --remote will be used as file names: >
+    nvim --remote --server ~/.cache/nvim/server.pipe file.txt
+
+Tell the remote server to write all files and exit: >
+    nvim --server ~/.cache/nvim/server.pipe --remote-send '<C-\><C-N>:wqa<CR>'
+
+
+REMOTE EDITING
+
+The --remote argument will cause a |:drop| command to be constructed from the
+rest of the command line and sent as described above.
+Note that the --remote and --remote-wait arguments will consume the rest of
+the command line.  I.e. all remaining arguments will be regarded as filenames.
+You can not put options there!
+
+
+==============================================================================
+2. Missing functionality			*E5600* *clientserver-missing*
+
+Vim supports additional functionality in clientserver that's not yet
+implemented in Nvim. In particular, none of the "wait" variants are supported
+yet. The following command line arguments are not yet available:
+
+    argument			meaning	~
+
+   --remote-wait [+{cmd}] {file} ...				*--remote-wait*
+				Not yet supported by Nvim.
+				As --remote, but wait for files to complete
+				(unload) in remote Vim.
+   --remote-wait-silent [+{cmd}] {file} ...		*--remote-wait-silent*
+				Not yet supported by Nvim.
+				As --remote-wait, but don't complain if there
+				is no server.
+							*--remote-tab-wait*
+   --remote-tab-wait		Not yet supported by Nvim.
+				Like --remote-wait but open each file in a new
+				tabpage.
+						*--remote-tab-wait-silent*
+   --remote-tab-wait-silent	Not yet supported by Nvim.
+				Like --remote-wait-silent but open each file
+				in a new tabpage.
+							    *--servername*
+   --servername {name}          Not yet supported by Nvim.
+				Become the server {name}.  When used together
+                                with one of the --remote commands: connect to
+                                server {name} instead of the default (see
+                                below).  The name used will be uppercase.
+
+								*--serverlist*
+   --serverlist			Not yet supported by Nvim.
+				Output a list of server names.
+
+
+
+
+SERVER NAME						*client-server-name*
+
+By default Vim will try to register the name under which it was invoked (gvim,
+egvim ...).  This can be overridden with the --servername argument.  Nvim
+either listens on a named pipe or a socket and does not yet support this
+--servername functionality.
+
+ vim:tw=78:sw=4:ts=8:noet:ft=help:norl:
diff --git a/runtime/doc/repeat.txt b/runtime/doc/repeat.txt
index c7481ad290..508565dea4 100644
--- a/runtime/doc/repeat.txt
+++ b/runtime/doc/repeat.txt
@@ -161,6 +161,11 @@ Q			Repeat the last recorded register [count] times.
 			result of evaluating the expression is executed as an
 			Ex command.
 			Mappings are not recognized in these commands.
+			When the |line-continuation| character (\) is present
+			at the beginning of a line in a linewise register,
+			then it is combined with the previous line. This is
+			useful for yanking and executing parts of a Vim
+			script.
 
 							*:@:*
 :[addr]@:		Repeat last command-line.  First set cursor at line
@@ -177,8 +182,7 @@ For writing a Vim script, see chapter 41 of the user manual |usr_41.txt|.
 
 					*:so* *:source* *load-vim-script*
 :[range]so[urce] [file]	Runs |Ex| commands or Lua code (".lua" files) from
-			[file], or from the current buffer if no [file] is
-			given.
+			[file], or current buffer if no [file].
 			Triggers the |SourcePre| autocommand.
 							*:source!*
 :[range]so[urce]! {file}
@@ -253,21 +257,22 @@ For writing a Vim script, see chapter 41 of the user manual |usr_41.txt|.
 			below "plugin", just like with plugins in
 			'runtimepath'.
 
-			If the filetype detection was not enabled yet (this
+			If the filetype detection was already enabled (this
 			is usually done with a "syntax enable" or "filetype
-			on" command in your .vimrc file), this will also look
+			on" command in your |init.vim|, or automatically during
+			|initialization|), and the package was found in
+			"pack/*/opt/{name}", this command will also look
 			for "{name}/ftdetect/*.vim" files.
 
 			When the optional ! is added no plugin files or
 			ftdetect scripts are loaded, only the matching
 			directories are added to 'runtimepath'.  This is
-			useful in your .vimrc.  The plugins will then be
-			loaded during initialization, see |load-plugins| (note
+			useful in your |init.vim|.  The plugins will then be
+			loaded during |initialization|, see |load-plugins| (note
 			that the loading order will be reversed, because each
-			directory is inserted before others).
-			Note that for ftdetect scripts to be loaded
-			you will need to write `filetype plugin indent on`
-			AFTER all `packadd!` commands.
+			directory is inserted before others). In this case, the
+			ftdetect scripts will be loaded during |initialization|,
+			before the |load-plugins| step.
 
 			Also see |pack-add|.
 
@@ -465,8 +470,8 @@ flag when defining the function, it is not relevant when executing it. >
    :set cpo-=C
 <
 					*line-continuation-comment*
-To add a comment in between the lines start with '\" '.  Notice the space
-after the double quote.  Example: >
+To add a comment in between the lines start with '"\ '.  Notice the space
+after the backslash.  Example: >
 	let array = [
 		"\ first entry comment
 		\ 'first',
diff --git a/runtime/doc/scroll.txt b/runtime/doc/scroll.txt
index 7d1da3b409..170c87a1a4 100644
--- a/runtime/doc/scroll.txt
+++ b/runtime/doc/scroll.txt
@@ -239,12 +239,16 @@ the "h" flag in 'guioptions' is set, the cursor moves to the longest visible
 line if the cursor line is about to be scrolled off the screen (similarly to
 how the horizontal scrollbar works).
 
-You can modify the default behavior by mapping the keys.  For example, to make
-the scroll wheel move one line or half a page in Normal mode: >
-   :map <ScrollWheelUp> <C-Y>
-   :map <S-ScrollWheelUp> <C-U>
-   :map <ScrollWheelDown> <C-E>
-   :map <S-ScrollWheelDown> <C-D>
-You can also use Alt and Ctrl modifiers.
+You can control the number of lines / columns to scroll by using the
+'mousescroll' option. You can also modify the default behavior by mapping
+the keys. For example, to scroll a page at a time in normal mode: >
+   :map <ScrollWheelUp> <C-B>
+   :map <ScrollWheelDown> <C-F>
+Scroll keys can also be combined with modifiers such as Shift, Ctrl, and Alt.
+
+When scrolling with a mouse, the window currently under the cursor is
+scrolled. This allows you to scroll inactive windows. Note that when scroll
+keys are remapped to keyboard keys, the active window is affected regardless
+of the current cursor position.
 
  vim:tw=78:ts=8:noet:ft=help:norl:
diff --git a/runtime/doc/sign.txt b/runtime/doc/sign.txt
index 5cfa06c33c..a2a5645baa 100644
--- a/runtime/doc/sign.txt
+++ b/runtime/doc/sign.txt
@@ -87,7 +87,7 @@ the delete is undone the sign does not move back.
 Here is an example that places a sign "piet", displayed with the text ">>", in
 line 23 of the current file: >
 	:sign define piet text=>> texthl=Search
-	:exe ":sign place 2 line=23 name=piet file=" . expand("%:p")
+	:exe ":sign place 2 line=23 name=piet file=" .. expand("%:p")
 
 And here is the command to delete it again: >
 	:sign unplace 2
diff --git a/runtime/doc/spell.txt b/runtime/doc/spell.txt
index 03c00c8495..bc45b0e511 100644
--- a/runtime/doc/spell.txt
+++ b/runtime/doc/spell.txt
@@ -120,8 +120,8 @@ zuG			Undo |zW| and |zG|, remove the word from the internal
 			rare as this is a fairly uncommon command and all
 			intuitive commands for this are already taken. If you
 			want you can add mappings with e.g.: >
-		nnoremap z?  :exe ':spellrare  ' . expand('<cWORD>')<CR>
-		nnoremap z/  :exe ':spellrare! ' . expand('<cWORD>')<CR>
+		nnoremap z?  :exe ':spellrare  ' .. expand('<cWORD>')<CR>
+		nnoremap z/  :exe ':spellrare! ' .. expand('<cWORD>')<CR>
 <			|:spellundo|, |zuw|, or |zuW| can be used to undo this.
 
 :spellr[rare]! {word}	Add {word} as a rare word to the internal word
diff --git a/runtime/doc/starting.txt b/runtime/doc/starting.txt
index bb775ec884..d57a85423c 100644
--- a/runtime/doc/starting.txt
+++ b/runtime/doc/starting.txt
@@ -188,7 +188,7 @@ argument.
 		changes and writing.
 
 -e							*-e* *-E*
--E		Start Nvim in Ex mode |gQ|.
+-E		Start Nvim in Ex mode |gQ|, see |Ex-mode|.
 
 		If stdin is not a TTY:
 		  -e reads/executes stdin as Ex commands.
@@ -367,7 +367,7 @@ argument.
 							*--headless*
 --headless 	Start without UI, and do not wait for `nvim_ui_attach`. The
 		builtin TUI is not used, so stdio works as an arbitrary
-		communication channel. |channel-stdio| 
+		communication channel. |channel-stdio|
 
 		Also useful for scripting (tests) to see messages that would
 		not be printed by |-es|.
@@ -407,9 +407,14 @@ accordingly, proceeding as follows:
 	Nvim started with |--embed| waits for the UI to connect before
 	proceeding to load user configuration.
 
-4. Setup |default-mappings| and  |default-autocmds|.
+4. Setup |default-mappings| and |default-autocmds|.  Create |popup-menu|.
 
-5. Load user config (execute Ex commands from files, environment, …).
+5. Enable filetype and indent plugins.
+	This does the same as the command: >
+		:runtime! ftplugin.vim indent.vim
+<	Skipped if the "-u NONE" command line argument was given.
+
+6. Load user config (execute Ex commands from files, environment, …).
 	$VIMINIT environment variable is read as one Ex command line (separate
 	multiple commands with '|' or <NL>).
 					*config* *init.vim* *init.lua* *vimrc* *exrc*
@@ -453,21 +458,19 @@ accordingly, proceeding as follows:
 	-  The file ".nvimrc"
 	-  The file ".exrc"
 
-6. Enable filetype and indent plugins.
-	This does the same as the commands: >
-		:runtime! filetype.vim
-		:runtime! ftplugin.vim
-		:runtime! indent.vim
-<	Skipped if ":filetype … off" was called or if the "-u NONE" command
-	line argument was given.
+7. Enable filetype detection.
+	This does the same as the command: >
+		:runtime! filetype.lua filetype.vim
+<	Skipped if ":filetype off" was called or if the "-u NONE" command line
+	argument was given.
 
-7. Enable syntax highlighting.
+8. Enable syntax highlighting.
 	This does the same as the command: >
 		:runtime! syntax/syntax.vim
 <	Skipped if ":syntax off" was called or if the "-u NONE" command
 	line argument was given.
 
-8. Load the plugin scripts.					*load-plugins*
+9. Load the plugin scripts.					*load-plugins*
 	This does the same as the command: >
 		:runtime! plugin/**/*.vim
 		:runtime! plugin/**/*.lua
@@ -497,21 +500,21 @@ accordingly, proceeding as follows:
 	if packages have been found, but that should not add a directory
 	ending in "after".
 
-9. Set 'shellpipe' and 'shellredir'
+10. Set 'shellpipe' and 'shellredir'
 	The 'shellpipe' and 'shellredir' options are set according to the
 	value of the 'shell' option, unless they have been set before.
 	This means that Nvim will figure out the values of 'shellpipe' and
 	'shellredir' for you, unless you have set them yourself.
 
-10. Set 'updatecount' to zero, if "-n" command argument used
+11. Set 'updatecount' to zero, if "-n" command argument used
 
-11. Set binary options if the |-b| flag was given.
+12. Set binary options if the |-b| flag was given.
 
-12. Read the |shada-file|.
+13. Read the |shada-file|.
 
-13. Read the quickfix file if the |-q| flag was given, or exit on failure.
+14. Read the quickfix file if the |-q| flag was given, or exit on failure.
 
-14. Open all windows
+15. Open all windows
 	When the |-o| flag was given, windows will be opened (but not
 	displayed yet).
 	When the |-p| flag was given, tab pages will be created (but not
@@ -521,10 +524,9 @@ accordingly, proceeding as follows:
 	Buffers for all windows will be loaded, without triggering |BufAdd|
 	autocommands.
 
-15. Execute startup commands
+16. Execute startup commands
 	If a |-t| flag was given, the tag is jumped to.
 	Commands given with |-c| and |+cmd| are executed.
-	If the 'insertmode' option is set, Insert mode is entered.
 	The starting flag is reset, has("vim_starting") will now return zero.
 	The |v:vim_did_enter| variable is set to 1.
 	The |VimEnter| autocommands are executed.
@@ -581,7 +583,7 @@ setting can affect the entire editor in ways that are not initially obvious.
 To find the cause of a problem in your config, you must "bisect" it:
 1. Remove or disable half of your |config|.
 2. Restart Nvim.
-3. If the problem still occurs, goto 1. 
+3. If the problem still occurs, goto 1.
 4. If the problem is gone, restore half of the removed lines.
 5. Continue narrowing your config in this way, until you find the setting or
    plugin causing the issue.
@@ -698,7 +700,7 @@ vimrc file.
 These commands will write ":map" and ":set" commands to a file, in such a way
 that when these commands are executed, the current key mappings and options
 will be set to the same values.  The options 'columns', 'endofline',
-'fileformat', 'lines', 'modified', and 'scroll' are not included, because 
+'fileformat', 'lines', 'modified', and 'scroll' are not included, because
 these are terminal or file dependent.
 Note that the options 'binary', 'paste' and 'readonly' are included, this
 might not always be what you want.
@@ -715,7 +717,7 @@ with ":map" and ":set" commands and write the modified file.  First read the
 default vimrc in with a command like ":source ~piet/.vimrc.Cprogs", change
 the settings and then save them in the current directory with ":mkvimrc!".  If
 you want to make this file your default |config|, move it to
-$XDG_CONFIG_HOME/nvim.  You could also use autocommands |autocommand| and/or 
+$XDG_CONFIG_HOME/nvim.  You could also use autocommands |autocommand| and/or
 modelines |modeline|.
 
 						*vimrc-option-example*
@@ -797,7 +799,7 @@ resulting file, when executed with a ":source" command:
 After restoring the Session, the full filename of your current Session is
 available in the internal variable |v:this_session|.
 An example mapping: >
-  :nmap <F2> :wa<Bar>exe "mksession! " . v:this_session<CR>:so ~/sessions/
+  :nmap <F2> :wa<Bar>exe "mksession! " .. v:this_session<CR>:so ~/sessions/
 This saves the current Session, and starts off the command to load another.
 
 A session includes all tab pages, unless "tabpages" was removed from
@@ -883,7 +885,7 @@ Shada ("shared data") file			*shada* *shada-file*
 
 If you exit Vim and later start it again, you would normally lose a lot of
 information.  The ShaDa file can be used to remember that information, which
-enables you to continue where you left off.  Its name is the abbreviation of 
+enables you to continue where you left off.  Its name is the abbreviation of
 SHAred DAta because it is used for sharing data between Neovim sessions.
 
 This is introduced in section |21.3| of the user manual.
@@ -914,9 +916,9 @@ The |v:oldfiles| variable is filled.  The marks are not read in at startup
 option upon startup.
 
 							*shada-write*
-When Vim exits and 'shada' is non-empty, the info is stored in the ShaDa file 
-(it's actually merged with the existing one, if one exists |shada-merging|).  
-The 'shada' option is a string containing information about what info should 
+When Vim exits and 'shada' is non-empty, the info is stored in the ShaDa file
+(it's actually merged with the existing one, if one exists |shada-merging|).
+The 'shada' option is a string containing information about what info should
 be stored, and contains limits on how much should be stored (see 'shada').
 
 Notes for Unix:
@@ -974,75 +976,75 @@ remembered.
 
 MERGING							*shada-merging*
 
-When writing ShaDa files with |:wshada| without bang or at regular exit 
-information in the existing ShaDa file is merged with information from current 
-Neovim instance.  For this purpose ShaDa files store timestamps associated 
+When writing ShaDa files with |:wshada| without bang or at regular exit
+information in the existing ShaDa file is merged with information from current
+Neovim instance.  For this purpose ShaDa files store timestamps associated
 with ShaDa entries.  Specifically the following is being done:
 
-1. History lines are merged, ordered by timestamp.  Maximum amount of items in 
-   ShaDa file is defined by 'shada' option (|shada-/|, |shada-:|, |shada-@|, 
-   etc: one suboption for each character that represents history name 
+1. History lines are merged, ordered by timestamp.  Maximum amount of items in
+   ShaDa file is defined by 'shada' option (|shada-/|, |shada-:|, |shada-@|,
+   etc: one suboption for each character that represents history name
    (|:history|)).
-2. Local marks and changes for files that were not opened by Neovim are copied 
-   to new ShaDa file. Marks for files that were opened by Neovim are merged, 
+2. Local marks and changes for files that were not opened by Neovim are copied
+   to new ShaDa file. Marks for files that were opened by Neovim are merged,
    changes to files opened by Neovim are ignored. |shada-'|
-3. Jump list is merged: jumps are ordered by timestamp, identical jumps 
+3. Jump list is merged: jumps are ordered by timestamp, identical jumps
    (identical position AND timestamp) are squashed.
-4. Search patterns and substitute strings are not merged: search pattern or 
-   substitute string which has greatest timestamp will be the only one copied 
+4. Search patterns and substitute strings are not merged: search pattern or
+   substitute string which has greatest timestamp will be the only one copied
    to ShaDa file.
-5. For each register entity with greatest timestamp is the only saved. 
+5. For each register entity with greatest timestamp is the only saved.
    |shada-<|
-6. All saved variables are saved from current Neovim instance. Additionally 
-   existing variable values are copied, meaning that the only way to remove 
-   variable from a ShaDa file is either removing it by hand or disabling 
+6. All saved variables are saved from current Neovim instance. Additionally
+   existing variable values are copied, meaning that the only way to remove
+   variable from a ShaDa file is either removing it by hand or disabling
    writing variables completely. |shada-!|
 7. For each global mark entity with greatest timestamp is the only saved.
-8. Buffer list and header are the only entries which are not merged in any 
-   fashion: the only header and buffer list present are the ones from the 
+8. Buffer list and header are the only entries which are not merged in any
+   fashion: the only header and buffer list present are the ones from the
    Neovim instance which was last writing the file. |shada-%|
 
 COMPATIBILITY						*shada-compatibility*
 
 ShaDa files are forward and backward compatible.  This means that
 
-1. Entries which have unknown type (i.e. that hold unidentified data) are 
+1. Entries which have unknown type (i.e. that hold unidentified data) are
    ignored when reading and blindly copied when writing.
-2. Register entries with unknown register name are ignored when reading and 
-   blindly copied when writing. Limitation: only registers that use name with 
+2. Register entries with unknown register name are ignored when reading and
+   blindly copied when writing. Limitation: only registers that use name with
    code in interval [1, 255] are supported. |registers|
-3. Register entries with unknown register type are ignored when reading and 
+3. Register entries with unknown register type are ignored when reading and
    merged as usual when writing. |getregtype()|
-4. Local and global mark entries with unknown mark names are ignored when 
-   reading. When writing global mark entries are blindly copied and local mark 
-   entries are also blindly copied, but only if file they are attached to fits 
-   in the |shada-'| limit. Unknown local mark entry's timestamp is also taken 
-   into account when calculating which files exactly should fit into this 
-   limit. Limitation: only marks that use name with code in interval [1, 255] 
+4. Local and global mark entries with unknown mark names are ignored when
+   reading. When writing global mark entries are blindly copied and local mark
+   entries are also blindly copied, but only if file they are attached to fits
+   in the |shada-'| limit. Unknown local mark entry's timestamp is also taken
+   into account when calculating which files exactly should fit into this
+   limit. Limitation: only marks that use name with code in interval [1, 255]
    are supported. |mark-motions|
-5. History entries with unknown history type are ignored when reading and 
-   blindly copied when writing. Limitation: there can be only up to 256 
+5. History entries with unknown history type are ignored when reading and
+   blindly copied when writing. Limitation: there can be only up to 256
    history types. |history|
-6. Unknown keys found in register, local mark, global mark, change, jump and 
-   search pattern entries are saved internally and dumped when writing. 
+6. Unknown keys found in register, local mark, global mark, change, jump and
+   search pattern entries are saved internally and dumped when writing.
    Entries created during Neovim session never have such additions.
-7. Additional elements found in replacement string and history entries are 
-   saved internally and dumped. Entries created during Neovim session never 
+7. Additional elements found in replacement string and history entries are
+   saved internally and dumped. Entries created during Neovim session never
    have such additions.
-8. Additional elements found in variable entries are simply ignored when 
-   reading. When writing new variables they will be preserved during merging, 
-   but that's all. Variable values dumped from current Neovim session never 
-   have additional elements, even if variables themselves were obtained by 
+8. Additional elements found in variable entries are simply ignored when
+   reading. When writing new variables they will be preserved during merging,
+   but that's all. Variable values dumped from current Neovim session never
+   have additional elements, even if variables themselves were obtained by
    reading ShaDa files.
 
-"Blindly" here means that there will be no attempts to somehow merge them, 
+"Blindly" here means that there will be no attempts to somehow merge them,
 even if other entries (with known name/type/etc) are merged. |shada-merging|
 
 SHADA FILE NAME						*shada-file-name*
 
 - Default name of the |shada| file is:
-      Unix:     "$XDG_DATA_HOME/nvim/shada/main.shada"
-      Windows:  "$XDG_DATA_HOME/nvim-data/shada/main.shada"
+      Unix:     "$XDG_STATE_HOME/nvim/shada/main.shada"
+      Windows:  "$XDG_STATE_HOME/nvim-data/shada/main.shada"
   See also |base-directories|.
 - To choose a different file name you can use:
     - The "n" flag in the 'shada' option.
@@ -1064,55 +1066,55 @@ however that this means everything will be overwritten with information from
 the first Vim, including the command line history, etc.
 
 The ShaDa file itself can be edited by hand too, although we suggest you
-start with an existing one to get the format right.  You need to understand 
-MessagePack (or, more likely, find software that is able to use it) format to 
-do this.  This can be useful in order to create a second file, say 
-"~/.my.shada" which could contain certain settings that you always want when 
-you first start Neovim.  For example, you can preload registers with 
-particular data, or put certain commands in the command line history.  A line 
+start with an existing one to get the format right.  You need to understand
+MessagePack (or, more likely, find software that is able to use it) format to
+do this.  This can be useful in order to create a second file, say
+"~/.my.shada" which could contain certain settings that you always want when
+you first start Neovim.  For example, you can preload registers with
+particular data, or put certain commands in the command line history.  A line
 in your |config| file like >
 	:rshada! ~/.my.shada
-can be used to load this information.  You could even have different ShaDa 
-files for different types of files (e.g., C code) and load them based on the 
-file name, using the ":autocmd" command (see |:autocmd|).  More information on 
+can be used to load this information.  You could even have different ShaDa
+files for different types of files (e.g., C code) and load them based on the
+file name, using the ":autocmd" command (see |:autocmd|).  More information on
 ShaDa file format is contained in |shada-format| section.
 
 					  *E136* *E929* *shada-error-handling*
-Some errors make Neovim leave temporary file named `{basename}.tmp.X` (X is 
-any free letter from `a` to `z`) while normally it will create this file, 
-write to it and then rename `{basename}.tmp.X` to `{basename}`. Such errors 
+Some errors make Neovim leave temporary file named `{basename}.tmp.X` (X is
+any free letter from `a` to `z`) while normally it will create this file,
+write to it and then rename `{basename}.tmp.X` to `{basename}`. Such errors
 include:
 
-- Errors which make Neovim think that read file is not a ShaDa file at all: 
-  non-ShaDa files are not overwritten for safety reasons to avoid accidentally 
-  destroying an unrelated file.  This could happen e.g. when typing "nvim -i 
-  file" in place of "nvim -R file" (yes, somebody did that at least with Vim).  
+- Errors which make Neovim think that read file is not a ShaDa file at all:
+  non-ShaDa files are not overwritten for safety reasons to avoid accidentally
+  destroying an unrelated file.  This could happen e.g. when typing "nvim -i
+  file" in place of "nvim -R file" (yes, somebody did that at least with Vim).
   Such errors are listed at |shada-critical-contents-errors|.
-- If writing to the temporary file failed: e.g. because of the insufficient 
+- If writing to the temporary file failed: e.g. because of the insufficient
   space left.
 - If renaming file failed: e.g. because of insufficient permissions.
-- If target ShaDa file has different from the Neovim instance's owners (user 
-  and group) and changing them failed.  Unix-specific, applies only when 
+- If target ShaDa file has different from the Neovim instance's owners (user
+  and group) and changing them failed.  Unix-specific, applies only when
   Neovim was launched from root.
 
-Do not forget to remove the temporary file or replace the target file with 
-temporary one after getting one of the above errors or all attempts to create 
-a ShaDa file may fail with |E929|.  If you got one of them when using 
-|:wshada| (and not when exiting Neovim: i.e. when you have Neovim session 
+Do not forget to remove the temporary file or replace the target file with
+temporary one after getting one of the above errors or all attempts to create
+a ShaDa file may fail with |E929|.  If you got one of them when using
+|:wshada| (and not when exiting Neovim: i.e. when you have Neovim session
 running) you have additional options:
 
-- First thing which you should consider if you got any error, except failure 
-  to write to the temporary file: remove existing file and replace it with the 
+- First thing which you should consider if you got any error, except failure
+  to write to the temporary file: remove existing file and replace it with the
   temporary file.  Do it even if you have running Neovim instance.
-- Fix the permissions and/or file ownership, free some space and attempt to 
+- Fix the permissions and/or file ownership, free some space and attempt to
   write again.  Do not remove the existing file.
-- Use |:wshada| with bang.  Does not help in case of permission error.  If 
-  target file was actually the ShaDa file some information may be lost in this 
-  case.  To make the matters slightly better use |:rshada| prior to writing, 
-  but this still will loose buffer-local marks and change list entries for any 
+- Use |:wshada| with bang.  Does not help in case of permission error.  If
+  target file was actually the ShaDa file some information may be lost in this
+  case.  To make the matters slightly better use |:rshada| prior to writing,
+  but this still will loose buffer-local marks and change list entries for any
   file which is not opened in the current Neovim instance.
-- Remove the target file from shell and use |:wshada|.  Consequences are not 
-  different from using |:wshada| with bang, but "rm -f" works in some cases 
+- Remove the target file from shell and use |:wshada|.  Consequences are not
+  different from using |:wshada| with bang, but "rm -f" works in some cases
   when you don't have write permissions.
 
 						    *:rsh* *:rshada* *E886*
@@ -1126,13 +1128,13 @@ running) you have additional options:
 			The information in the file is first read in to make
 			a merge between old and new info.  When [!] is used,
 			the old information is not read first, only the
-			internal info is written (also disables safety checks 
-			described in |shada-error-handling|).  If 'shada' is 
+			internal info is written (also disables safety checks
+			described in |shada-error-handling|).  If 'shada' is
 			empty, marks for up to 100 files will be written.
-			When you get error "E929: All .tmp.X files exist, 
-			cannot write ShaDa file!" check that no old temp files 
-			were left behind (e.g. 
-			~/.local/share/nvim/shada/main.shada.tmp*).
+			When you get error "E929: All .tmp.X files exist,
+			cannot write ShaDa file!" check that no old temp files
+			were left behind (e.g.
+			~/.local/state/nvim/shada/main.shada.tmp*).
 
 			Note: Executing :wshada will reset all |'quote| marks.
 
@@ -1155,82 +1157,82 @@ running) you have additional options:
 
 SHADA FILE FORMAT						*shada-format*
 
-ShaDa files are concats of MessagePack entries.  Each entry is a concat of 
+ShaDa files are concats of MessagePack entries.  Each entry is a concat of
 exactly four MessagePack objects:
 
-1. First goes type of the entry.  Object type must be an unsigned integer.  
+1. First goes type of the entry.  Object type must be an unsigned integer.
    Object type must not be equal to zero.
 2. Second goes entry timestamp.  It must also be an unsigned integer.
-3. Third goes the length of the fourth entry.  Unsigned integer as well, used 
+3. Third goes the length of the fourth entry.  Unsigned integer as well, used
    for fast skipping without parsing.
-4. Fourth is actual entry data.  All currently used ShaDa entries use 
-   containers to hold data: either map or array.  All string values in those 
-   containers are either binary (applies to filenames) or UTF-8, yet parser 
+4. Fourth is actual entry data.  All currently used ShaDa entries use
+   containers to hold data: either map or array.  All string values in those
+   containers are either binary (applies to filenames) or UTF-8, yet parser
    needs to expect that invalid bytes may be present in a UTF-8 string.
 
    Exact format depends on the entry type:
 
    Entry type (name)   Entry data ~
-   1 (Header)          Map containing data that describes the generator 
-                       instance that wrote this ShaDa file.  It is ignored 
+   1 (Header)          Map containing data that describes the generator
+                       instance that wrote this ShaDa file.  It is ignored
                        when reading ShaDa files.  Contains the following data:
                        Key        Data ~
-                       generator  Binary, software used to generate ShaDa 
-                                  file. Is equal to "nvim" when ShaDa file was 
+                       generator  Binary, software used to generate ShaDa
+                                  file. Is equal to "nvim" when ShaDa file was
                                   written by Neovim.
                        version    Binary, generator version.
                        encoding   Binary, effective 'encoding' value.
                        max_kbyte  Integer, effective |shada-s| limit value.
                        pid        Integer, instance process ID.
-                       *          It is allowed to have any number of 
+                       *          It is allowed to have any number of
                                   additional keys with any data.
-   2 (SearchPattern)   Map containing data describing last used search or 
-                       substitute pattern.  Normally ShaDa file contains two 
-                       such entries: one with "ss" key set to true (describes 
-                       substitute pattern, see |:substitute|), and one set to 
-                       false (describes search pattern, see 
-                       |search-commands|). "su" key should be true on one of 
-                       the entries.  If key value is equal to default then it 
+   2 (SearchPattern)   Map containing data describing last used search or
+                       substitute pattern.  Normally ShaDa file contains two
+                       such entries: one with "ss" key set to true (describes
+                       substitute pattern, see |:substitute|), and one set to
+                       false (describes search pattern, see
+                       |search-commands|). "su" key should be true on one of
+                       the entries.  If key value is equal to default then it
                        is normally not present.  Keys:
                        Key  Type     Default  Description ~
                        sm   Boolean  true     Effective 'magic' value.
                        sc   Boolean  false    Effective 'smartcase' value.
-                       sl   Boolean  true     True if search pattern comes 
-                                              with a line offset.  See 
+                       sl   Boolean  true     True if search pattern comes
+                                              with a line offset.  See
                                               |search-offset|.
-                       se   Boolean  false    True if |search-offset| 
-                                              requested to place cursor at 
-                                              (relative to) the end of the 
+                       se   Boolean  false    True if |search-offset|
+                                              requested to place cursor at
+                                              (relative to) the end of the
                                               pattern.
                        so   Integer  0        Offset value. |search-offset|
-                       su   Boolean  false    True if current entry was the 
+                       su   Boolean  false    True if current entry was the
                                               last used search pattern.
-                       ss   Boolean  false    True if current entry describes 
+                       ss   Boolean  false    True if current entry describes
                                               |:substitute| pattern.
                        sh   Boolean  false    True if |v:hlsearch| is on.
-                                              With |shada-h| or 'nohlsearch' 
+                                              With |shada-h| or 'nohlsearch'
                                               this key is always false.
                        sp   Binary   N/A      Actual pattern.  Required.
-                       sb   Boolean  false    True if search direction is 
+                       sb   Boolean  false    True if search direction is
                                               backward.
-                       *    any      none     Other keys are allowed for 
-                                              compatibility reasons, see 
+                       *    any      none     Other keys are allowed for
+                                              compatibility reasons, see
                                               |shada-compatibility|.
-   3 (SubString)       Array containing last |:substitute| replacement string.  
-                       Contains single entry: binary, replacement string used.  
-                       More entries are allowed for compatibility reasons, see 
+   3 (SubString)       Array containing last |:substitute| replacement string.
+                       Contains single entry: binary, replacement string used.
+                       More entries are allowed for compatibility reasons, see
                        |shada-compatibility|.
-   4 (HistoryEntry)    Array containing one entry from history.  Should have 
-                       two or three entries.  First one is history type 
-                       (unsigned integer), second is history line (binary), 
-                       third is the separator character (unsigned integer, 
-                       must be in interval [0, 255]).  Third item is only 
-                       valid for search history.  Possible history types are 
-                       listed in |hist-names|, here are the corresponding 
-                       numbers: 0 - cmd, 1 - search, 2 - expr, 3 - input, 
+   4 (HistoryEntry)    Array containing one entry from history.  Should have
+                       two or three entries.  First one is history type
+                       (unsigned integer), second is history line (binary),
+                       third is the separator character (unsigned integer,
+                       must be in interval [0, 255]).  Third item is only
+                       valid for search history.  Possible history types are
+                       listed in |hist-names|, here are the corresponding
+                       numbers: 0 - cmd, 1 - search, 2 - expr, 3 - input,
                        4 - debug.
-   5 (Register)        Map describing one register (|registers|).  If key 
-                       value is equal to default then it is normally not 
+   5 (Register)        Map describing one register (|registers|).  If key
+                       value is equal to default then it is normally not
                        present.  Keys:
                        Key  Type             Def   Description ~
                        rt   UInteger         0     Register type:
@@ -1258,12 +1260,12 @@ exactly four MessagePack objects:
                        *    any              none  Other keys are allowed
                                                    for compatibility reasons,
                                                    see |shada-compatibility|.
-   6 (Variable)        Array containing two items: variable name (binary) and 
-                       variable value (any object).  Values are converted 
-                       using the same code |msgpackparse()| uses when reading, 
-                       |msgpackdump()| when writing, so there may appear 
-                       |msgpack-special-dict|s.  If there are more then two 
-                       entries then the rest are ignored 
+   6 (Variable)        Array containing two items: variable name (binary) and
+                       variable value (any object).  Values are converted
+                       using the same code |msgpackparse()| uses when reading,
+                       |msgpackdump()| when writing, so there may appear
+                       |msgpack-special-dict|s.  If there are more then two
+                       entries then the rest are ignored
                        (|shada-compatibility|).
    7 (GlobalMark)
    8 (Jump)
@@ -1277,57 +1279,58 @@ exactly four MessagePack objects:
 
                        Data contained in the map:
                        Key  Type      Default  Description ~
-                       l    UInteger  1        Position line number.  Must be 
+                       l    UInteger  1        Position line number.  Must be
                                                greater then zero.
                        c    UInteger  0        Position column number.
-                       n    UInteger  34 ('"') Mark name.  Only valid for 
-                                               GlobalMark and LocalMark 
+                       n    UInteger  34 ('"') Mark name.  Only valid for
+                                               GlobalMark and LocalMark
                                                entries.
                        f    Binary    N/A      File name.  Required.
-                       *    any       none     Other keys are allowed for 
-                                               compatibility reasons, see 
+                       *    any       none     Other keys are allowed for
+                                               compatibility reasons, see
                                                |shada-compatibility|.
-   9 (BufferList)      Array containing maps.  Each map in the array 
+   9 (BufferList)      Array containing maps.  Each map in the array
                        represents one buffer.  Possible keys:
                        Key  Type      Default  Description ~
-                       l    UInteger  1        Position line number.  Must be 
+                       l    UInteger  1        Position line number.  Must be
                                                greater then zero.
                        c    UInteger  0        Position column number.
                        f    Binary    N/A      File name.  Required.
-                       *    any       none     Other keys are allowed for 
-                                               compatibility reasons, see 
+                       *    any       none     Other keys are allowed for
+                                               compatibility reasons, see
                                                |shada-compatibility|.
-   * (Unknown)         Any other entry type is allowed for compatibility 
+   * (Unknown)         Any other entry type is allowed for compatibility
                        reasons, see |shada-compatibility|.
 
 								*E575* *E576*
-Errors in ShaDa file may have two types: E575 used for all “logical” errors 
-and E576 used for all “critical” errors.  Critical errors trigger behaviour 
-described in |shada-error-handling| when writing and skipping the rest of the 
+Errors in ShaDa file may have two types: E575 used for all “logical” errors
+and E576 used for all “critical” errors.  Critical errors trigger behaviour
+described in |shada-error-handling| when writing and skipping the rest of the
 file when reading and include:
 					    *shada-critical-contents-errors*
 - Any of first three MessagePack objects being not an unsigned integer.
-- Third object requesting amount of bytes greater then bytes left in the ShaDa 
+- Third object requesting amount of bytes greater then bytes left in the ShaDa
   file.
 - Entry with zero type.  I.e. first object being equal to zero.
 - MessagePack parser failing to parse the entry data.
-- MessagePack parser consuming less or requesting greater bytes then described 
-  in the third object for parsing fourth object.  I.e. when fourth object 
-  either contains more then one MessagePack object or it does not contain 
+- MessagePack parser consuming less or requesting greater bytes then described
+  in the third object for parsing fourth object.  I.e. when fourth object
+  either contains more then one MessagePack object or it does not contain
   complete MessagePack object.
 
 ==============================================================================
 Standard Paths					*standard-path*
 
-Nvim stores configuration, data, and logs in standard locations. Plugins are 
-strongly encouraged to follow this pattern also. Use |stdpath()| to get the 
+Nvim stores configuration, data, and logs in standard locations. Plugins are
+strongly encouraged to follow this pattern also. Use |stdpath()| to get the
 paths.
 
 						*base-directories* *xdg*
 The "base" (root) directories conform to the XDG Base Directory Specification.
 https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
-The $XDG_CONFIG_HOME and $XDG_DATA_HOME environment variables are used if they
-exist, otherwise default values (listed below) are used.
+The $XDG_CONFIG_HOME, $XDG_DATA_HOME, $XDG_RUNTIME_DIR, and $XDG_STATE_HOME
+environment variables are used if defined, else default values (listed below)
+are used.
 
 CONFIG DIRECTORY (DEFAULT) ~
                   *$XDG_CONFIG_HOME*            Nvim: stdpath("config")
@@ -1339,14 +1342,24 @@ DATA DIRECTORY (DEFAULT) ~
     Unix:         ~/.local/share              ~/.local/share/nvim
     Windows:      ~/AppData/Local             ~/AppData/Local/nvim-data
 
+RUN DIRECTORY (DEFAULT) ~
+                  *$XDG_RUNTIME_DIR*            Nvim: stdpath("run")
+    Unix:         /tmp/nvim.user/xxx          /tmp/nvim.user/xxx
+    Windows:      $TMP/nvim.user/xxx          $TMP/nvim.user/xxx
+
+STATE DIRECTORY (DEFAULT) ~
+                  *$XDG_STATE_HOME*             Nvim: stdpath("state")
+    Unix:         ~/.local/state              ~/.local/state/nvim
+    Windows:      ~/AppData/Local             ~/AppData/Local/nvim-data
+
 Note: Throughout the user manual these defaults are used as placeholders, e.g.
 "~/.config" is understood to mean "$XDG_CONFIG_HOME or ~/.config".
 
-LOG FILE					*$NVIM_LOG_FILE*
+LOG FILE					*$NVIM_LOG_FILE* *E5430*
 Besides 'debug' and 'verbose', Nvim keeps a general log file for internal
 debugging, plugins and RPC clients. >
 	:echo $NVIM_LOG_FILE
-By default, the file is located at stdpath('cache')/log unless that path 
+By default, the file is located at stdpath('log')/log unless that path
 is inaccessible or if $NVIM_LOG_FILE was set before |startup|.
 
 
diff --git a/runtime/doc/syntax.txt b/runtime/doc/syntax.txt
index 2c5531411d..9ed3c37b8c 100644
--- a/runtime/doc/syntax.txt
+++ b/runtime/doc/syntax.txt
@@ -26,7 +26,8 @@ In the User Manual:
 1. Quick start						*:syn-qstart*
 
 				*:syn-enable* *:syntax-enable* *:syn-on* *:syntax-on*
-This command switches on syntax highlighting: >
+Syntax highlighting is enabled by default. If you need to enable it again
+after it was disabled (see below), use: >
 
 	:syntax enable
 
@@ -188,7 +189,8 @@ A syntax group name doesn't specify any color or attributes itself.
 
 The name for a highlight or syntax group must consist of ASCII letters, digits
 and the underscore.  As a regexp: "[a-zA-Z0-9_]*".  However, Vim does not give
-an error when using other characters.
+an error when using other characters.  The maximum length of a group name is
+about 200 bytes.  *E1249*
 
 To be able to allow each user to pick their favorite set of colors, there must
 be preferred names for highlight groups that are common for many languages.
@@ -451,7 +453,7 @@ your own highlight colors for the progress bar. Example: >
 	hi TOhtmlProgress guifg=#c0ffee ctermbg=7
 <
 							 *g:html_number_lines*
-Default: current 'number' setting.
+Default: Current 'number' setting.
 When 0, buffer text is displayed in the generated HTML without line numbering.
 When 1, a column of line numbers is added to the generated HTML with the same
 highlighting as the line number column in Vim (|hl-LineNr|).
@@ -540,7 +542,7 @@ folded text will open the fold as if |g:html_hover_unfold| were set.
    :let g:html_no_foldcolumn = 1
 <
 				*TOhtml-uncopyable-text* *g:html_prevent_copy*
-Default: empty string.
+Default: Empty string.
 This option prevents certain regions of the generated HTML from being copied,
 when you select all text in document rendered in a browser and copy it. Useful
 for allowing users to copy-paste only the source text even if a fold column or
@@ -566,7 +568,7 @@ uncopyable regions. In some browsers, especially older browsers, after
 selecting an entire page and copying the selection, the <input> tags are not
 pasted with the page text. If |g:html_no_invalid| is 0, the <input> tags have
 invalid type; this works in more browsers, but the page will not validate.
-Note: this method does NOT work in recent versions of Chrome and equivalent
+Note: This method does NOT work in recent versions of Chrome and equivalent
 browsers; the <input> tags get pasted with the text.
 
 When "fallback" (default value), the same <input> elements are generated for
@@ -616,18 +618,18 @@ evaluate to get a unique string to append to each ID used in a given document,
 so that the full IDs will be unique even when combined with other content in a
 larger HTML document. Example, to append _ and the buffer number to each ID: >
 
-	:let g:html_id_expr = '"_".bufnr("%")'
+	:let g:html_id_expr = '"_" .. bufnr("%")'
 <
 To append a string "_mystring" to the end of each ID: >
 
 	:let g:html_id_expr = '"_mystring"'
 <
-Note, when converting a diff view to HTML, the expression will only be
+Note: When converting a diff view to HTML, the expression will only be
 evaluated for the first window in the diff, and the result used for all the
 windows.
 
 					  *TOhtml-wrap-text* *g:html_pre_wrap*
-Default: current 'wrap' setting.
+Default: Current 'wrap' setting.
 When 0, if |g:html_no_pre| is 0 or unset, the text in the generated HTML does
 not wrap at the edge of the browser window.
 When 1, if |g:html_use_css| is 1, the CSS 2.0 "white-space:pre-wrap" value is
@@ -687,7 +689,7 @@ wide browser support. However, you can override this to support specific
 encodings that may not be automatically detected by default (see options
 below). See http://www.iana.org/assignments/character-sets for the IANA names.
 
-Note, by default all Unicode encodings are converted to UTF-8 with no BOM in
+Note: By default all Unicode encodings are converted to UTF-8 with no BOM in
 the generated HTML, as recommended by W3C:
 
 	http://www.w3.org/International/questions/qa-choosing-encodings
@@ -920,12 +922,16 @@ in .../after/syntax/baan.vim (see |after-directory|). Eg: >
 
 BASIC			*basic.vim* *vb.vim* *ft-basic-syntax* *ft-vb-syntax*
 
-Both Visual Basic and "normal" basic use the extension ".bas".	To detect
+Both Visual Basic and "normal" BASIC use the extension ".bas".	To detect
 which one should be used, Vim checks for the string "VB_Name" in the first
 five lines of the file.  If it is not found, filetype will be "basic",
 otherwise "vb".  Files with the ".frm" extension will always be seen as Visual
 Basic.
 
+If the automatic detection doesn't work for you or you only edit, for
+example, FreeBASIC files, use this in your startup vimrc: >
+   :let filetype_bas = "freebasic"
+
 
 C							*c.vim* *ft-c-syntax*
 
@@ -1287,8 +1293,8 @@ the global or buffer-local variable load_doxygen_syntax.  This is done by
 adding the following to your vimrc. >
 	:let g:load_doxygen_syntax=1
 
-There are a couple of variables that have an effect on syntax highlighting, and
-are to do with non-standard highlighting options.
+There are a couple of variables that have an effect on syntax highlighting,
+and are to do with non-standard highlighting options.
 
 Variable			Default	Effect ~
 g:doxygen_enhanced_color
@@ -1430,8 +1436,8 @@ To enable highlighting some special atoms, put this in your vimrc: >
 
 ELIXIR						*elixir.vim* *ft-elixir-syntax*
 
-Elixir is a dynamic, functional language for building scalable and maintainable
-applications.
+Elixir is a dynamic, functional language for building scalable and
+maintainable applications.
 
 The following file extensions are auto-detected as Elixir file types:
 
@@ -1447,7 +1453,7 @@ Elixir.
 FLEXWIKI				*flexwiki.vim* *ft-flexwiki-syntax*
 
 FlexWiki is an ASP.NET-based wiki package available at http://www.flexwiki.com
-NOTE: this site currently doesn't work, on Wikipedia is mentioned that
+NOTE: This site currently doesn't work, on Wikipedia is mentioned that
 development stopped in 2009.
 
 Syntax highlighting is available for the most common elements of FlexWiki
@@ -1470,7 +1476,7 @@ modes Conditional, Number, Statement, Comment, PreProc, Type, and String,
 following the language specifications in 'Symbolic Manipulation with FORM' by
 J.A.M. Vermaseren, CAN, Netherlands, 1991.
 
-If you want include your own changes to the default colors, you have to
+If you want to include your own changes to the default colors, you have to
 redefine the following syntax groups:
 
     - formConditional
@@ -1496,6 +1502,14 @@ The enhanced mode also takes advantage of additional color features for a dark
 gvim display.  Here, statements are colored LightYellow instead of Yellow, and
 conditionals are LightBlue for better distinction.
 
+Both Visual Basic and FORM use the extension ".frm".  To detect which one
+should be used, Vim checks for the string "VB_Name" in the first five lines of
+the file.  If it is found, filetype will be "vb", otherwise "form".
+
+If the automatic detection doesn't work for you or you only edit, for
+example, FORM files, use this in your startup vimrc: >
+   :let filetype_frm = "form"
+
 
 FORTH						*forth.vim* *ft-forth-syntax*
 
@@ -1519,8 +1533,8 @@ syntax highlighting will not be correct if the form is incorrectly set.
 When you create a new fortran file, the syntax script assumes fixed source
 form.  If you always use free source form, then >
     :let fortran_free_source=1
-in your vimrc prior to the :syntax on command.  If you always use fixed source
-form, then >
+in your vimrc prior to the :syntax on command.  If you always use fixed
+source form, then >
     :let fortran_fixed_source=1
 in your vimrc prior to the :syntax on command.
 
@@ -1645,6 +1659,21 @@ because Fortran90 has no reserved words.
 For further information related to fortran, see |ft-fortran-indent| and
 |ft-fortran-plugin|.
 
+FREEBASIC				*freebasic.vim* *ft-freebasic-syntax*
+
+FreeBASIC files will be highlighted differently for each of the four available
+dialects, "fb", "qb", "fblite" and "deprecated".  See |ft-freebasic-plugin|
+for how to select the correct dialect.
+
+Highlighting is further configurable via the following variables.
+
+Variable			Highlight ~
+*freebasic_no_comment_fold*	disable multiline comment folding
+*freebasic_operators*		non-alpha operators
+*freebasic_space_errors*	trailing white space and spaces before a <Tab>
+*freebasic_type_suffixes*	QuickBASIC style type suffixes
+
+
 
 FVWM CONFIGURATION FILES			*fvwm.vim* *ft-fvwm-syntax*
 
@@ -1793,8 +1822,8 @@ ends with -->) you can define >
 
 JavaScript and Visual Basic embedded inside HTML documents are highlighted as
 'Special' with statements, comments, strings and so on colored as in standard
-programming languages.  Note that only JavaScript and Visual Basic are currently
-supported, no other scripting language has been added yet.
+programming languages.  Note that only JavaScript and Visual Basic are
+currently supported, no other scripting language has been added yet.
 
 Embedded and inlined cascading style sheets (CSS) are highlighted too.
 
@@ -1898,8 +1927,8 @@ The java.vim syntax highlighting file offers several options:
 
 In Java 1.0.2 it was never possible to have braces inside parens, so this was
 flagged as an error.  Since Java 1.1 this is possible (with anonymous
-classes), and therefore is no longer marked as an error.  If you prefer the old
-way, put the following line into your vim startup file: >
+classes), and therefore is no longer marked as an error.  If you prefer the
+old way, put the following line into your vim startup file: >
 	:let java_mark_braces_in_parens_as_errors=1
 
 All identifiers in java.lang.* are always visible in all classes.  To
@@ -2017,10 +2046,10 @@ LISP						*lisp.vim* *ft-lisp-syntax*
 
 The lisp syntax highlighting provides two options: >
 
-	g:lisp_instring : if it exists, then "(...)" strings are highlighted
+	g:lisp_instring : If it exists, then "(...)" strings are highlighted
 			  as if the contents of the string were lisp.
 			  Useful for AutoLisp.
-	g:lisp_rainbow  : if it exists and is nonzero, then differing levels
+	g:lisp_rainbow  : If it exists and is nonzero, then differing levels
 			  of parenthesization will receive different
 			  highlighting.
 <
@@ -2150,6 +2179,15 @@ $VIMRUNTIME/syntax/syntax.vim).
   mv_finance	 mv_logic	mv_powseries
 
 
+MARKDOWN						*ft-markdown-syntax*
+
+If you have long regions there might be wrong highlighting.  At the cost of
+slowing down displaying, you can have the engine look further back to sync on
+the start of a region, for example 500 lines: >
+
+	:let g:markdown_minlines = 500
+
+
 MATHEMATICA		*mma.vim* *ft-mma-syntax* *ft-mathematica-syntax*
 
 Empty *.m files will automatically be presumed to be Matlab files unless you
@@ -2417,8 +2455,8 @@ If you do not want complex things like '@{${"foo"}}' to be parsed: >
 
 (In Vim 6.x it was the other way around: "perl_extended_vars" enabled it.)
 
-The coloring strings can be changed.  By default strings and qq friends will be
-highlighted like the first line.  If you set the variable
+The coloring strings can be changed.  By default strings and qq friends will
+be highlighted like the first line.  If you set the variable
 perl_string_as_statement, it will be highlighted as in the second line.
 
    "hello world!"; qq|hello world|;
@@ -2430,8 +2468,8 @@ perl_string_as_statement, it will be highlighted as in the second line.
 The syncing has 3 options.  The first two switch off some triggering of
 synchronization and should only be needed in case it fails to work properly.
 If while scrolling all of a sudden the whole screen changes color completely
-then you should try and switch off one of those.  Let me know if you can figure
-out the line that causes the mistake.
+then you should try and switch off one of those.  Let me know if you can
+figure out the line that causes the mistake.
 
 One triggers on "^\s*sub\s*" and the other on "^[$@%]" more or less. >
 
@@ -2468,7 +2506,7 @@ behavior, set 'perl_nofold_packages': >
 
 PHP3 and PHP4		*php.vim* *php3.vim* *ft-php-syntax* *ft-php3-syntax*
 
-[note: previously this was called "php3", but since it now also supports php4
+[Note: Previously this was called "php3", but since it now also supports php4
 it has been renamed to "php"]
 
 There are the following options for the php syntax highlighting.
@@ -2538,15 +2576,15 @@ PPWizard is a preprocessor for HTML and OS/2 INF files
 
 This syntax file has the options:
 
-- ppwiz_highlight_defs : determines highlighting mode for PPWizard's
+- ppwiz_highlight_defs : Determines highlighting mode for PPWizard's
   definitions.  Possible values are
 
   ppwiz_highlight_defs = 1 : PPWizard #define statements retain the
-    colors of their contents (e.g. PPWizard macros and variables)
+    colors of their contents (e.g. PPWizard macros and variables).
 
-  ppwiz_highlight_defs = 2 : preprocessor #define and #evaluate
+  ppwiz_highlight_defs = 2 : Preprocessor #define and #evaluate
     statements are shown in a single color with the exception of line
-    continuation symbols
+    continuation symbols.
 
   The default setting for ppwiz_highlight_defs is 1.
 
@@ -2585,7 +2623,7 @@ highlighted by defining the postscr_level variable as follows: >
 If this variable is not defined it defaults to 2 (level 2) since this is
 the most prevalent version currently.
 
-Note, not all PS interpreters will support all language features for a
+Note: Not all PS interpreters will support all language features for a
 particular language level.  In particular the %!PS-Adobe-3.0 at the start of
 PS files does NOT mean the PostScript present is level 3 PostScript!
 
@@ -2687,7 +2725,7 @@ If you want all possible Python highlighting (the same as setting the
 preceding last option and unsetting all other ones): >
 	:let python_highlight_all = 1
 
-Note: only existence of these options matter, not their value. You can replace
+Note: Only existence of these options matter, not their value. You can replace
       1 above with anything.
 
 QUAKE						*quake.vim* *ft-quake-syntax*
@@ -3127,16 +3165,16 @@ The Speedup syntax file has some options:
   the DECLARE section; if you defined own types, you have to include
   them in the syntax file.
 
-- oneline_comments : this value ranges from 1 to 3 and determines the
+- oneline_comments : This value ranges from 1 to 3 and determines the
   highlighting of # style comments.
 
-  oneline_comments = 1 : allow normal Speedup code after an even
+  oneline_comments = 1 : Allow normal Speedup code after an even
   number of #s.
 
-  oneline_comments = 2 : show code starting with the second # as
+  oneline_comments = 2 : Show code starting with the second # as
   error.  This is the default setting.
 
-  oneline_comments = 3 : show the whole line as error if it contains
+  oneline_comments = 3 : Show the whole line as error if it contains
   more than one #.
 
 Since especially OPERATION sections tend to become very large due to
@@ -3175,8 +3213,8 @@ This covers the shell named "tcsh".  It is a superset of csh.  See |csh.vim|
 for how the filetype is detected.
 
 Tcsh does not allow \" in strings unless the "backslash_quote" shell variable
-is set.  If you want VIM to assume that no backslash quote constructs exist add
-this line to your vimrc: >
+is set.  If you want VIM to assume that no backslash quote constructs exist 
+add this line to your vimrc: >
 
 	:let tcsh_backslash_quote = 0
 
@@ -3529,7 +3567,7 @@ start and end tags.  This can be turned on by >
 	:let g:xml_syntax_folding = 1
 	:set foldmethod=syntax
 
-Note: syntax folding might slow down syntax highlighting significantly,
+Note: Syntax folding might slow down syntax highlighting significantly,
 especially for large files.
 
 
@@ -3546,8 +3584,8 @@ Do you want to draw with the mouse?  Try the following: >
    :function! GetPixel()
    :   let c = getline(".")[col(".") - 1]
    :   echo c
-   :   exe "noremap <LeftMouse> <LeftMouse>r".c
-   :   exe "noremap <LeftDrag>	<LeftMouse>r".c
+   :   exe "noremap <LeftMouse> <LeftMouse>r" .. c
+   :   exe "noremap <LeftDrag>	<LeftMouse>r" .. c
    :endfunction
    :noremap <RightMouse> <LeftMouse>:call GetPixel()<CR>
    :set guicursor=n:hor20	   " to see the color beneath the cursor
@@ -4384,7 +4422,7 @@ Leading context			*:syn-lc* *:syn-leading* *:syn-context*
 
 Note: This is an obsolete feature, only included for backwards compatibility
 with previous Vim versions.  It's now recommended to use the |/\@<=| construct
-in the pattern.
+in the pattern.  You can also often use |/\zs|.
 
 The "lc" offset specifies leading context -- a part of the pattern that must
 be present, but is not considered part of the match.  An offset of "lc=n" will
@@ -4817,6 +4855,7 @@ in their own color.
 :hi[ghlight] {group-name}
 			List one highlight group.
 
+						*highlight-clear* *:hi-clear*
 :hi[ghlight] clear	Reset all highlighting to the defaults.  Removes all
 			highlighting for groups added by the user!
 			Uses the current value of 'background' to decide which
@@ -4872,14 +4911,18 @@ the same syntax file on all UIs.
 1. TUI highlight arguments
 
 					*bold* *underline* *undercurl*
-					*inverse* *italic* *standout*
-					*nocombine* *strikethrough*
+					*underdouble* *underdotted*
+					*underdashed* *inverse* *italic*
+					*standout* *nocombine* *strikethrough*
 cterm={attr-list}			*attr-list* *highlight-cterm* *E418*
-	attr-list is a comma separated list (without spaces) of the
+	attr-list is a comma-separated list (without spaces) of the
 	following items (in any order):
 		bold
 		underline
 		undercurl	curly underline
+		underdouble	double underline
+		underdotted	dotted underline
+		underdashed	dashed underline
 		strikethrough
 		reverse
 		inverse		same as reverse
@@ -4890,8 +4933,9 @@ cterm={attr-list}			*attr-list* *highlight-cterm* *E418*
 
 	Note that "bold" can be used here and by using a bold font.  They
 	have the same effect.
-	"undercurl" falls back to "underline" in a terminal that does not
-	support it.  The color is set using |highlight-guisp|.
+	"undercurl", "underdouble", "underdotted", and "underdashed" fall back
+	to "underline" in a terminal that does not support them. The color is
+	set using |highlight-guisp|.
 
 start={term-list}				*highlight-start* *E422*
 stop={term-list}				*term-list* *highlight-stop*
@@ -4953,8 +4997,8 @@ ctermbg={color-nr}				*highlight-ctermbg*
 	a number instead of a color name.
 
 	Note that for 16 color ansi style terminals (including xterms), the
-	numbers in the NR-8 column is used.  Here '*' means 'add 8' so that Blue
-	is 12, DarkGray is 8 etc.
+	numbers in the NR-8 column is used.  Here '*' means 'add 8' so that 
+	Blue is 12, DarkGray is 8 etc.
 
 	Note that for some color terminals these names may result in the wrong
 	colors!
@@ -5024,8 +5068,8 @@ guifg={color-name}					*highlight-guifg*
 guibg={color-name}					*highlight-guibg*
 guisp={color-name}					*highlight-guisp*
 	These give the foreground (guifg), background (guibg) and special
-	(guisp) color to use in the GUI.  "guisp" is used for undercurl
-	and underline.
+	(guisp) color to use in the GUI.  "guisp" is used for various
+	underlines.
 	There are a few special names:
 		NONE		no color (transparent)
 		bg		use normal background color
@@ -5067,53 +5111,56 @@ These are the builtin highlighting groups.  Note that the highlighting depends
 on the value of 'background'.  You can see the current settings with the
 ":highlight" command.
 							*hl-ColorColumn*
-ColorColumn	used for the columns set with 'colorcolumn'
+ColorColumn	Used for the columns set with 'colorcolumn'.
 							*hl-Conceal*
-Conceal		placeholder characters substituted for concealed
-		text (see 'conceallevel')
+Conceal		Placeholder characters substituted for concealed
+		text (see 'conceallevel').
+							*hl-CurSearch*
+CurSearch	Used for highlighting a search pattern under the cursor
+		(see 'hlsearch').
 							*hl-Cursor*
-Cursor		character under the cursor
-lCursor		the character under the cursor when |language-mapping|
-		is used (see 'guicursor')
+Cursor		Character under the cursor.
+lCursor		Character under the cursor when |language-mapping|
+		is used (see 'guicursor').
 							*hl-CursorIM*
-CursorIM	like Cursor, but used when in IME mode |CursorIM|
+CursorIM	Like Cursor, but used when in IME mode. |CursorIM|
 							*hl-CursorColumn*
 CursorColumn	Screen-column at the cursor, when 'cursorcolumn' is set.
 							*hl-CursorLine*
 CursorLine	Screen-line at the cursor, when 'cursorline' is set.
 		Low-priority if foreground (ctermfg OR guifg) is not set.
 							*hl-Directory*
-Directory	directory names (and other special names in listings)
+Directory	Directory names (and other special names in listings).
 							*hl-DiffAdd*
-DiffAdd		diff mode: Added line |diff.txt|
+DiffAdd		Diff mode: Added line. |diff.txt|
 							*hl-DiffChange*
-DiffChange	diff mode: Changed line |diff.txt|
+DiffChange	Diff mode: Changed line. |diff.txt|
 							*hl-DiffDelete*
-DiffDelete	diff mode: Deleted line |diff.txt|
+DiffDelete	Diff mode: Deleted line. |diff.txt|
 							*hl-DiffText*
-DiffText	diff mode: Changed text within a changed line |diff.txt|
+DiffText	Diff mode: Changed text within a changed line. |diff.txt|
 							*hl-EndOfBuffer*
-EndOfBuffer	filler lines (~) after the end of the buffer.
+EndOfBuffer	Filler lines (~) after the end of the buffer.
 		By default, this is highlighted like |hl-NonText|.
 							*hl-TermCursor*
-TermCursor	cursor in a focused terminal
+TermCursor	Cursor in a focused terminal.
 							*hl-TermCursorNC*
-TermCursorNC	cursor in an unfocused terminal
+TermCursorNC	Cursor in an unfocused terminal.
 							*hl-ErrorMsg*
-ErrorMsg	error messages on the command line
-							*hl-VertSplit*
-VertSplit	the column separating vertically split windows
+ErrorMsg	Error messages on the command line.
+							*hl-WinSeparator*
+WinSeparator	Separators between window splits.
 							*hl-Folded*
-Folded		line used for closed folds
+Folded		Line used for closed folds.
 							*hl-FoldColumn*
 FoldColumn	'foldcolumn'
 							*hl-SignColumn*
-SignColumn	column where |signs| are displayed
+SignColumn	Column where |signs| are displayed.
 							*hl-IncSearch*
 IncSearch	'incsearch' highlighting; also used for the text replaced with
-		":s///c"
+		":s///c".
 							*hl-Substitute*
-Substitute	|:substitute| replacement text highlighting
+Substitute	|:substitute| replacement text highlighting.
 
 							*hl-LineNr*
 LineNr		Line number for ":number" and ":#" commands, and when 'number'
@@ -5132,15 +5179,15 @@ CursorLineSign	Like SignColumn when 'cursorline' is set for the cursor line.
 							*hl-CursorLineFold*
 CursorLineFold	Like FoldColumn when 'cursorline' is set for the cursor line.
 							*hl-MatchParen*
-MatchParen	The character under the cursor or just before it, if it
+MatchParen	Character under the cursor or just before it, if it
 		is a paired bracket, and its match. |pi_paren.txt|
 
 							*hl-ModeMsg*
-ModeMsg		'showmode' message (e.g., "-- INSERT --")
+ModeMsg		'showmode' message (e.g., "-- INSERT --").
 							*hl-MsgArea*
-MsgArea		Area for messages and cmdline
+MsgArea		Area for messages and cmdline.
 							*hl-MsgSeparator*
-MsgSeparator	Separator for scrolled messages, `msgsep` flag of 'display'
+MsgSeparator	Separator for scrolled messages, `msgsep` flag of 'display'.
 							*hl-MoreMsg*
 MoreMsg		|more-prompt|
 							*hl-NonText*
@@ -5149,21 +5196,21 @@ NonText		'@' at the end of the window, characters from 'showbreak'
 		(e.g., ">" displayed when a double-wide character doesn't
 		fit at the end of the line). See also |hl-EndOfBuffer|.
 							*hl-Normal*
-Normal		normal text
+Normal		Normal text.
 							*hl-NormalFloat*
 NormalFloat	Normal text in floating windows.
 							*hl-NormalNC*
-NormalNC	normal text in non-current windows
+NormalNC	Normal text in non-current windows.
 							*hl-Pmenu*
-Pmenu		Popup menu: normal item.
+Pmenu		Popup menu: Normal item.
 							*hl-PmenuSel*
-PmenuSel	Popup menu: selected item.
+PmenuSel	Popup menu: Selected item.
 							*hl-PmenuSbar*
-PmenuSbar	Popup menu: scrollbar.
+PmenuSbar	Popup menu: Scrollbar.
 							*hl-PmenuThumb*
 PmenuThumb	Popup menu: Thumb of the scrollbar.
 							*hl-Question*
-Question	|hit-enter| prompt and yes/no questions
+Question	|hit-enter| prompt and yes/no questions.
 							*hl-QuickFixLine*
 QuickFixLine	Current |quickfix| item in the quickfix window. Combined with
                 |hl-CursorLine| when the cursor is there.
@@ -5171,7 +5218,7 @@ QuickFixLine	Current |quickfix| item in the quickfix window. Combined with
 Search		Last search pattern highlighting (see 'hlsearch').
 		Also used for similar items that need to stand out.
 							*hl-SpecialKey*
-SpecialKey	Unprintable characters: text displayed differently from what
+SpecialKey	Unprintable characters: Text displayed differently from what
 		it really is. But not 'listchars' whitespace. |hl-Whitespace|
 							*hl-SpellBad*
 SpellBad	Word that is not recognized by the spellchecker. |spell|
@@ -5188,29 +5235,34 @@ SpellRare	Word that is recognized by the spellchecker as one that is
 		hardly ever used. |spell|
 		Combined with the highlighting used otherwise.
 							*hl-StatusLine*
-StatusLine	status line of current window
+StatusLine	Status line of current window.
 							*hl-StatusLineNC*
-StatusLineNC	status lines of not-current windows
-		Note: if this is equal to "StatusLine" Vim will use "^^^" in
+StatusLineNC	Status lines of not-current windows.
+		Note: If this is equal to "StatusLine", Vim will use "^^^" in
 		the status line of the current window.
 							*hl-TabLine*
-TabLine		tab pages line, not active tab page label
+TabLine		Tab pages line, not active tab page label.
 							*hl-TabLineFill*
-TabLineFill	tab pages line, where there are no labels
+TabLineFill	Tab pages line, where there are no labels.
 							*hl-TabLineSel*
-TabLineSel	tab pages line, active tab page label
+TabLineSel	Tab pages line, active tab page label.
 							*hl-Title*
-Title		titles for output from ":set all", ":autocmd" etc.
+Title		Titles for output from ":set all", ":autocmd" etc.
 							*hl-Visual*
-Visual		Visual mode selection
+Visual		Visual mode selection.
  							*hl-VisualNOS*
 VisualNOS	Visual mode selection when vim is "Not Owning the Selection".
 							*hl-WarningMsg*
-WarningMsg	warning messages
+WarningMsg	Warning messages.
 							*hl-Whitespace*
-Whitespace	"nbsp", "space", "tab" and "trail" in 'listchars'
+Whitespace	"nbsp", "space", "tab", "multispace", "lead" and "trail"
+		in 'listchars'.
 							*hl-WildMenu*
-WildMenu	current match in 'wildmenu' completion
+WildMenu	Current match in 'wildmenu' completion.
+							*hl-WinBar*
+WinBar		Window bar of current window.
+							*hl-WinBarNC*
+WinBarNC	Window bar of not-current windows.
 
 					*hl-User1* *hl-User1..9* *hl-User9*
 The 'statusline' syntax allows the use of 9 different highlights in the
@@ -5345,11 +5397,12 @@ WARNING: The longer the tags file, the slower this will be, and the more
 memory Vim will consume.
 
 Only highlighting typedefs, unions and structs can be done too.  For this you
-must use Exuberant ctags (found at http://ctags.sf.net).
+must use Universal Ctags (found at https://ctags.io) or Exuberant ctags (found
+at http://ctags.sf.net).
 
 Put these lines in your Makefile:
 
-# Make a highlight file for types.  Requires Exuberant ctags and awk
+# Make a highlight file for types.  Requires Universal/Exuberant ctags and awk
 types: types.vim
 types.vim: *.[ch]
 	ctags --c-kinds=gstu -o- *.[ch] |\
@@ -5359,9 +5412,9 @@ types.vim: *.[ch]
 And put these lines in your vimrc: >
 
    " load the types.vim highlighting file, if it exists
-   autocmd BufRead,BufNewFile *.[ch] let fname = expand('<afile>:p:h') . '/types.vim'
+   autocmd BufRead,BufNewFile *.[ch] let fname = expand('<afile>:p:h') .. '/types.vim'
    autocmd BufRead,BufNewFile *.[ch] if filereadable(fname)
-   autocmd BufRead,BufNewFile *.[ch]   exe 'so ' . fname
+   autocmd BufRead,BufNewFile *.[ch]   exe 'so ' .. fname
    autocmd BufRead,BufNewFile *.[ch] endif
 
 ==============================================================================
@@ -5402,7 +5455,7 @@ To test your color setup, a file has been included in the Vim distribution.
 To use it, execute this command: >
    :runtime syntax/colortest.vim
 
-Nvim uses 256-color and |true-color| terminal capabilities whereever possible.
+Nvim uses 256-color and |true-color| terminal capabilities wherever possible.
 
 ==============================================================================
 18. When syntax is slow						*:syntime*
diff --git a/runtime/doc/tabpage.txt b/runtime/doc/tabpage.txt
index 7f91fda9f4..9197710819 100644
--- a/runtime/doc/tabpage.txt
+++ b/runtime/doc/tabpage.txt
@@ -129,11 +129,14 @@ something else.
 		    :+tabclose	    " close the next tab page
 		    :1tabclose	    " close the first tab page
 		    :$tabclose	    " close the last tab page
-		    :tabclose -2    " close the 2nd previous tab page 
+		    :tabclose -2    " close the 2nd previous tab page
 		    :tabclose +	    " close the next tab page
 		    :tabclose 3	    " close the third tab page
 		    :tabclose $	    " close the last tab page
-<
+		    :tabclose #     " close the last accessed tab page
+
+When a tab is closed the next tab page will become the current one.
+
 							*:tabo* *:tabonly*
 :tabo[nly][!]	Close all other tab pages.
 		When the 'hidden' option is set, all buffers in closed windows
@@ -159,6 +162,8 @@ something else.
 				    " one
 		    :tabonly 1	    " close all tab pages except the first one
 		    :tabonly $	    " close all tab pages except the last one
+		    :tabonly #	    " close all tab pages except the last
+				    " accessed one
 
 
 SWITCHING TO ANOTHER TAB PAGE:
@@ -181,6 +186,7 @@ gt					*i_CTRL-<PageDown>* *i_<C-PageDown>*
 		    :+2tabnext	" go to the two next tab page
 		    :1tabnext	" go to the first tab page
 		    :$tabnext	" go to the last tab page
+		    :tabnext #  " go to the last accessed tab page
 		    :tabnext $	" as above
 		    :tabnext -	" go to the previous tab page
 		    :tabnext -1	" as above
@@ -190,10 +196,6 @@ gt					*i_CTRL-<PageDown>* *i_<C-PageDown>*
 {count}<C-PageDown>
 {count}gt	Go to tab page {count}.  The first tab page has number one.
 
-CTRL-<Tab>					*CTRL-<Tab>*
-CTRL-W g<Tab>					*g<Tab>* *CTRL-W_g<Tab>*
-g<Tab>		Go to previous (last accessed) tab page.
-
 :tabp[revious]				*:tabp* *:tabprevious* *gT* *:tabN*
 :tabN[ext]				*:tabNext* *CTRL-<PageUp>*
 <C-PageUp>			 *<C-PageUp>* *i_CTRL-<PageUp>* *i_<C-PageUp>*
@@ -213,6 +215,9 @@ gT		Go to the previous tab page.  Wraps around from the first one
 							*:tabl* *:tablast*
 :tabl[ast]	Go to the last tab page.
 
+<C-Tab>						*CTRL-<Tab>* *<C-Tab>*
+CTRL-W g<Tab>					*g<Tab>* *CTRL-W_g<Tab>*
+g<Tab>		Go to the last accessed tab page.
 
 Other commands:
 							*:tabs*
@@ -245,6 +250,8 @@ REORDERING TAB PAGES:
 		    :tabmove	" move the tab page to the last
 		    :$tabmove	" as above
 		    :tabmove $	" as above
+		    :tabmove #  " move the tab page after the last accessed
+				" tab page
 
 :tabm[ove] +[N]
 :tabm[ove] -[N]
@@ -366,24 +373,24 @@ pages and define labels for them.  Then get the label for each tab page. >
 	  for i in range(tabpagenr('$'))
 	    " select the highlighting
 	    if i + 1 == tabpagenr()
-	      let s .= '%#TabLineSel#'
+	      let s ..= '%#TabLineSel#'
 	    else
-	      let s .= '%#TabLine#'
+	      let s ..= '%#TabLine#'
 	    endif
 
 	    " set the tab page number (for mouse clicks)
-	    let s .= '%' . (i + 1) . 'T'
+	    let s ..= '%' .. (i + 1) .. 'T'
 
 	    " the label is made by MyTabLabel()
-	    let s .= ' %{MyTabLabel(' . (i + 1) . ')} '
+	    let s ..= ' %{MyTabLabel(' .. (i + 1) .. ')} '
 	  endfor
 
 	  " after the last tab fill with TabLineFill and reset tab page nr
-	  let s .= '%#TabLineFill#%T'
+	  let s ..= '%#TabLineFill#%T'
 
 	  " right-align the label to close the current tab page
 	  if tabpagenr('$') > 1
-	    let s .= '%=%#TabLine#%999Xclose'
+	    let s ..= '%=%#TabLine#%999Xclose'
 	  endif
 
 	  return s
@@ -446,14 +453,14 @@ windows in the tab page and a '+' if there is a modified buffer: >
 	  " Append the number of windows in the tab page if more than one
 	  let wincount = tabpagewinnr(v:lnum, '$')
 	  if wincount > 1
-	    let label .= wincount
+	    let label ..= wincount
 	  endif
 	  if label != ''
-	    let label .= ' '
+	    let label ..= ' '
 	  endif
 
 	  " Append the buffer name
-	  return label . bufname(bufnrlist[tabpagewinnr(v:lnum) - 1])
+	  return label .. bufname(bufnrlist[tabpagewinnr(v:lnum) - 1])
 	endfunction
 
 	set guitablabel=%{GuiTabLabel()}
diff --git a/runtime/doc/tagsrch.txt b/runtime/doc/tagsrch.txt
index 4d938c4a23..2485290667 100644
--- a/runtime/doc/tagsrch.txt
+++ b/runtime/doc/tagsrch.txt
@@ -544,7 +544,8 @@ also works.  The <CR> and <NL> characters can never appear inside a line.
 
 The second format is new.  It includes additional information in optional
 fields at the end of each line.  It is backwards compatible with Vi.  It is
-only supported by new versions of ctags (such as Exuberant ctags).
+only supported by new versions of ctags (such as Universal ctags or Exuberant
+ctags).
 
 {tagname}	The identifier.  Normally the name of a function, but it can
 		be any identifier.  It cannot contain a <Tab>.
@@ -705,7 +706,7 @@ matches the pattern "^# *define" it is not considered to be a comment.
 If you want to list matches, and then select one to jump to, you could use a
 mapping to do that for you.  Here is an example: >
 
-  :map <F4> [I:let nr = input("Which one: ")<Bar>exe "normal " . nr ."[\t"<CR>
+  :map <F4> [I:let nr = input("Which one: ")<Bar>exe "normal " .. nr .. "[\t"<CR>
 <
 							*[i*
 [i			Display the first line that contains the keyword
diff --git a/runtime/doc/term.txt b/runtime/doc/term.txt
index 62e13285f5..cd6798a5de 100644
--- a/runtime/doc/term.txt
+++ b/runtime/doc/term.txt
@@ -108,6 +108,58 @@ and right scroll margins as well.  If Nvim detects that the terminal is Xterm,
 it will make use of this ability to speed up scrolling that is not the full
 width of the terminal.
 
+							*tui-input*
+Nvim uses libtermkey to convert terminal escape sequences to key codes.
+|terminfo| is used first, and CSI sequences not in |terminfo| (including
+extended keys a.k.a. modifyOtherKeys or "CSI u") can also be parsed.
+For example, when running Nvim in tmux, this makes Nvim leave Insert mode and
+go to the window below: >
+	tmux send-keys 'Escape' [ 2 7 u 'C-W' j
+Where `'Escape' [ 2 7 u` is an unambiguous "CSI u" sequence for the <Esc> key.
+
+The kitty keyboard protocol https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+is partially supported, including keypad keys in Unicode Private Use Area.
+For example, this sequence is recognized by Nvim as <C-kEnter>: >
+	CSI 57414 ; 5 u
+and can be used differently from <C-CR> in mappings.
+
+						*tui-modifyOtherKeys* *tui-csiu*
+Historically, terminal emulators could not distinguish between certain control
+key modifiers and other keys. For example, <C-I> and <Tab> are represented the
+same way, as are <Esc> and <C-[>, <CR> and <C-M>, and <NL> and <C-J>. This
+meant that Nvim also could not map these keys separately.
+
+Modern terminal emulators are able to distinguish between these pairs of keys
+by encoding control modifiers differently. There are two common but distinct
+ways of doing this, known as "modifyOtherKeys" and "CSI u". Nvim supports both
+encoding methods and at startup will tell the terminal emulator that it
+understands these key encodings. If your terminal emulator supports it then
+this will allow you to map the key pairs listed above separately.
+
+At startup Nvim will query your terminal to see if it supports the CSI u
+encoding by writing the sequence >
+
+	CSI ? u CSI c
+
+If your terminal emulator responds with >
+
+	CSI ? <flags> u
+
+this means your terminal supports the CSI u encoding and Nvim will tell your
+terminal to enable it by writing the sequence >
+
+	CSI > 1 u
+
+If your terminal does not support CSI u then Nvim will instead enable the
+"modifyOtherKeys" encoding by writing the sequence >
+
+	CSI > 4 ; 2 m
+
+When Nvim exits cleanly it will send the corresponding sequence to disable the
+special key encoding. If Nvim does not exit cleanly then your terminal
+emulator could be in a bad state. If this happens, simply run "reset".
+
+
 							*tui-colors*
 Nvim uses 256 colours by default, ignoring |terminfo| for most terminal types,
 including "linux" (whose virtual terminals have had 256-colour support since
@@ -321,7 +373,7 @@ an #if/#else/#endif block, the selection becomes linewise.
 For MS-Windows and xterm the time for double clicking can be set with the
 'mousetime' option. For the other systems this time is defined outside of Vim.
 An example, for using a double click to jump to the tag under the cursor: >
-	:map <2-LeftMouse> :exe "tag ". expand("<cword>")<CR>
+	:map <2-LeftMouse> :exe "tag " .. expand("<cword>")<CR>
 
 Dragging the mouse with a double click (button-down, button-up, button-down
 and then drag) will result in whole words to be selected.  This continues
diff --git a/runtime/doc/testing.txt b/runtime/doc/testing.txt
index 8ec66d26a4..4e4a908d0f 100644
--- a/runtime/doc/testing.txt
+++ b/runtime/doc/testing.txt
@@ -12,7 +12,7 @@ and for testing plugins.
 
 1. Testing Vim				|testing|
 2. Test functions			|test-functions-details|
-3. Assert funtions			|assert-functions-details|
+3. Assert functions			|assert-functions-details|
 
 ==============================================================================
 1. Testing Vim						*testing*
diff --git a/runtime/doc/tips.txt b/runtime/doc/tips.txt
index b77c7d9a6d..d913b53c6b 100644
--- a/runtime/doc/tips.txt
+++ b/runtime/doc/tips.txt
@@ -84,14 +84,14 @@ What you need:
   create it with the shell command "mkid file1 file2 ..".
 
 Put this in your |init.vim|: >
-	map _u :call ID_search()<Bar>execute "/\\<" . g:word . "\\>"<CR>
-	map _n :n<Bar>execute "/\\<" . g:word . "\\>"<CR>
+	map _u :call ID_search()<Bar>execute "/\\<" .. g:word .. "\\>"<CR>
+	map _n :n<Bar>execute "/\\<" .. g:word .. "\\>"<CR>
 
 	function! ID_search()
 	  let g:word = expand("<cword>")
-	  let x = system("lid --key=none ". g:word)
+	  let x = system("lid --key=none " .. g:word)
 	  let x = substitute(x, "\n", " ", "g")
-	  execute "next " . x
+	  execute "next " .. x
 	endfun
 
 To use it, place the cursor on a word, type "_u" and vim will load the file
@@ -285,13 +285,13 @@ This mapping will format any bullet list.  It requires that there is an empty
 line above and below each list entry.  The expression commands are used to
 be able to give comments to the parts of the mapping. >
 
-	:let m =     ":map _f  :set ai<CR>"    " need 'autoindent' set
-	:let m = m . "{O<Esc>"		      " add empty line above item
-	:let m = m . "}{)^W"		      " move to text after bullet
-	:let m = m . "i     <CR>     <Esc>"    " add space for indent
-	:let m = m . "gq}"		      " format text after the bullet
-	:let m = m . "{dd"		      " remove the empty line
-	:let m = m . "5lDJ"		      " put text after bullet
+	:let m =     ":map _f  :set ai<CR>"   " need 'autoindent' set
+	:let m ..= "{O<Esc>"		      " add empty line above item
+	:let m ..= "}{)^W"		      " move to text after bullet
+	:let m ..= "i     <CR>     <Esc>"     " add space for indent
+	:let m ..= "gq}"		      " format text after the bullet
+	:let m ..= "{dd"		      " remove the empty line
+	:let m ..= "5lDJ"		      " put text after bullet
 	:execute m			      |" define the mapping
 
 (<> notation |<>|.  Note that this is all typed literally.  ^W is "^" "W", not
@@ -429,15 +429,15 @@ A slightly more advanced version is used in the |matchparen| plugin.
 	    let c = '\['
 	    let c2 = '\]'
 	  endif
-	  let s_skip ='synIDattr(synID(line("."), col("."), 0), "name") ' .
+	  let s_skip ='synIDattr(synID(line("."), col("."), 0), "name") ' ..
 		\ '=~?	"string\\|comment"'
 	  execute 'if' s_skip '| let s_skip = 0 | endif'
 
 	  let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip)
 
 	  if m_lnum > 0 && m_lnum >= line('w0') && m_lnum <= line('w$')
-	    exe 'match Search /\(\%' . c_lnum . 'l\%' . c_col .
-		  \ 'c\)\|\(\%' . m_lnum . 'l\%' . m_col . 'c\)/'
+	    exe 'match Search /\(\%' .. c_lnum .. 'l\%' .. c_col ..
+		  \ 'c\)\|\(\%' .. m_lnum .. 'l\%' .. m_col .. 'c\)/'
 	    let s:paren_hl_on = 1
 	  endif
 	endfunction
diff --git a/runtime/doc/treesitter.txt b/runtime/doc/treesitter.txt
index 7de6a0f890..eb19bf5934 100644
--- a/runtime/doc/treesitter.txt
+++ b/runtime/doc/treesitter.txt
@@ -14,10 +14,12 @@ VIM.TREESITTER						*lua-treesitter*
 Nvim integrates the tree-sitter library for incremental parsing of buffers.
 
                                              *vim.treesitter.language_version*
-To check which language version is compiled with neovim, the number is stored
-within `vim.treesitter.language_version`. This number is not too helpful
-unless you are wondering about compatibility between different versions of
-compiled grammars.
+The latest parser ABI version that is supported by the bundled tree-sitter
+library.
+
+                                     *vim.treesitter.minimum_language_version*
+The earliest parser ABI version that is supported by the bundled tree-sitter
+library.
 
 Parser files						*treesitter-parsers*
 
@@ -49,10 +51,10 @@ Whenever you need to access the current syntax tree, parse the buffer: >
 
     tstree = parser:parse()
 
-<This will return a table of immutable trees that represent the current state of the
-buffer. When the plugin wants to access the state after a (possible) edit
-it should call `parse()` again. If the buffer wasn't edited, the same tree will
-be returned again without extra work. If the buffer was parsed before,
+<This will return a table of immutable trees that represent the current state
+of the buffer. When the plugin wants to access the state after a (possible)
+edit it should call `parse()` again. If the buffer wasn't edited, the same tree
+will be returned again without extra work. If the buffer was parsed before,
 incremental parsing will be done of the changed parts.
 
 Note: to use the parser directly inside a |nvim_buf_attach| Lua callback, you
@@ -61,9 +63,10 @@ parsing shouldn't be done directly in the change callback anyway as they will
 be very frequent. Rather a plugin that does any kind of analysis on a tree
 should use a timer to throttle too frequent updates.
 
-tsparser:set_included_regions({region_list})			*tsparser:set_included_regions()*
+tsparser:set_included_regions({region_list})  *tsparser:set_included_regions()*
 	Changes the regions the parser should consider. This is used for
-	language injection.  {region_list} should be of the form (all zero-based): >
+	language injection.  {region_list} should be of the form
+	(all zero-based): >
 	{
 		{node1, node2},
 		...
@@ -92,13 +95,13 @@ tsnode:next_sibling()					*tsnode:next_sibling()*
 tsnode:prev_sibling()					*tsnode:prev_sibling()*
 	Get the node's previous sibling.
 
-tsnode:next_named_sibling()				*tsnode:next_named_sibling()*
+tsnode:next_named_sibling()                       *tsnode:next_named_sibling()*
 	Get the node's next named sibling.
 
-tsnode:prev_named_sibling()				*tsnode:prev_named_sibling()*
+tsnode:prev_named_sibling()			  *tsnode:prev_named_sibling()*
 	Get the node's previous named sibling.
 
-tsnode:iter_children()					*tsnode:iter_children()*
+tsnode:iter_children()				       *tsnode:iter_children()*
 	Iterates over all the direct children of {tsnode}, regardless of
 	whether they are named or not.
 	Returns the child node plus the eventual field name corresponding to
@@ -114,10 +117,10 @@ tsnode:child({index})					*tsnode:child()*
 	Get the node's child at the given {index}, where zero represents the
 	first child.
 
-tsnode:named_child_count()				*tsnode:named_child_count()*
+tsnode:named_child_count()			   *tsnode:named_child_count()*
 	Get the node's number of named children.
 
-tsnode:named_child({index})				*tsnode:named_child()*
+tsnode:named_child({index})			         *tsnode:named_child()*
 	Get the node's named child at the given {index}, where zero represents
 	the first named child.
 
@@ -157,20 +160,20 @@ tsnode:sexpr()						*tsnode:sexpr()*
 tsnode:id()						*tsnode:id()*
 	Get an unique identifier for the node inside its own tree.
 
-	No guarantees are made about this identifier's internal representation,
-	except for being a primitive lua type with value equality (so not a table).
-	Presently it is a (non-printable) string.
+	No guarantees are made about this identifier's internal
+	representation, except for being a primitive lua type with value
+	equality (so not a table). Presently it is a (non-printable) string.
 
 	Note: the id is not guaranteed to be unique for nodes from different
 	trees.
 
+						*tsnode:descendant_for_range()*
 tsnode:descendant_for_range({start_row}, {start_col}, {end_row}, {end_col})
-							*tsnode:descendant_for_range()*
 	Get the smallest node within this node that spans the given range of
 	(row, column) positions
 
+					  *tsnode:named_descendant_for_range()*
 tsnode:named_descendant_for_range({start_row}, {start_col}, {end_row}, {end_col})
-							*tsnode:named_descendant_for_range()*
 	Get the smallest named node within this node that spans the given
 	range of (row, column) positions
 
@@ -192,11 +195,11 @@ and predicates. A `capture` allows you to associate names with a specific
 node in a pattern. A `predicate` adds arbitrary metadata and conditional data
 to a match.
 
-Treesitter Query Predicates				*lua-treesitter-predicates*
+Treesitter Query Predicates			    *lua-treesitter-predicates*
 
 When writing queries for treesitter, one might use `predicates`, that is,
-special scheme nodes that are evaluated to verify things on a captured node for
-example, the |eq?| predicate : >
+special scheme nodes that are evaluated to verify things on a captured node
+for example, the |eq?| predicate : >
 	((identifier) @foo (#eq? @foo "foo"))
 
 This will only match identifier corresponding to the `"foo"` text.
@@ -204,100 +207,102 @@ Here is a list of built-in predicates :
 
 	`eq?`						*ts-predicate-eq?*
 		This predicate will check text correspondence between nodes or
-		strings : >
+		strings: >
 			((identifier) @foo (#eq? @foo "foo"))
 			((node1) @left (node2) @right (#eq? @left @right))
 <
 	`match?`					*ts-predicate-match?*
-	`vim-match?`					*ts-predicate-vim-match?*
+	`vim-match?`				    *ts-predicate-vim-match?*
 		This will match if the provided vim regex matches the text
-		corresponding to a node : >
+		corresponding to a node: >
 			((identifier) @constant (#match? @constant "^[A-Z_]+$"))
 <		Note: the `^` and `$` anchors will respectively match the
 			start and end of the node's text.
 
-	`lua-match?`					*ts-predicate-lua-match?*
+	`lua-match?`				    *ts-predicate-lua-match?*
 		This will match the same way than |match?| but using lua
 		regexes.
 
-	`contains?`					*ts-predicate-contains?*
+	`contains?`				     *ts-predicate-contains?*
 		Will check if any of the following arguments appears in the
-		text corresponding to the node : >
+		text corresponding to the node: >
 			((identifier) @foo (#contains? @foo "foo"))
 			((identifier) @foo-bar (#contains @foo-bar "foo" "bar"))
 <
-	`any-of?`					*ts-predicate-any-of?*
-		Will check if the text is the same as any of the following.
+	`any-of?`				       *ts-predicate-any-of?*
+		Will check if the text is the same as any of the following
+		arguments: >
+			((identifier) @foo (#any-of? @foo "foo" "bar"))
+<
 		This is the recommended way to check if the node matches one
 		of many keywords for example, as it has been optimized for
 		this.
-		arguments : >
-			((identifier) @foo (#any-of? @foo "foo" "bar"))
 <
-							*lua-treesitter-not-predicate*
+						 *lua-treesitter-not-predicate*
 Each predicate has a `not-` prefixed predicate that is just the negation of
 the predicate.
 
-						*vim.treesitter.query.add_predicate()*
+					 *vim.treesitter.query.add_predicate()*
 vim.treesitter.query.add_predicate({name}, {handler})
 
 This adds a predicate with the name {name} to be used in queries.
 {handler} should be a function whose signature will be : >
 	handler(match, pattern, bufnr, predicate)
 <
-						*vim.treesitter.query.list_predicates()*
+				       *vim.treesitter.query.list_predicates()*
 vim.treesitter.query.list_predicates()
 
 This lists the currently available predicates to use in queries.
 
-Treesitter Query Directive				*lua-treesitter-directives*
+Treesitter Query Directive			    *lua-treesitter-directives*
 
-Treesitter queries can also contain `directives`. Directives store metadata for a node
-or match and perform side effects. For example, the |set!| predicate sets metadata on
-the match or node : >
+Treesitter queries can also contain `directives`. Directives store metadata
+for a node or match and perform side effects. For example, the |set!|
+predicate sets metadata on the match or node : >
 	((identifier) @foo (#set! "type" "parameter"))
 
-Here is a list of built-in directives:
+Built-in directives:
+
+        `set!`                                              *ts-directive-set!*
+                Sets key/value metadata for a specific match or capture.
+                Value is accessible as either `metadata[key]` (match
+                specific) or `metadata[capture_id][key]` (capture specific).
 
-	`set!`						*ts-directive-set!*
-		Sets key/value metadata for a specific node or match : >
-			((identifier) @foo (#set! @foo "kind" "parameter"))
-			((node1) @left (node2) @right (#set! "type" "pair"))
+                Parameters: ~
+                    {capture_id} (optional)
+                    {key}
+                    {value}
+
+                Examples: >
+                        ((identifier) @foo (#set! @foo "kind" "parameter"))
+                        ((node1) @left (node2) @right (#set! "type" "pair"))
 <
-	`offset!`					*ts-predicate-offset!*
-		Takes the range of the captured node and applies the offsets
-		to it's range : >
-			((identifier) @constant (#offset! @constant 0 1 0 -1))
-<		This will generate a range object for the captured node with the
-		offsets applied. The arguments are
-		`({capture_id}, {start_row}, {start_col}, {end_row}, {end_col}, {key?})`
-		The default key is "offset".
-
-					*vim.treesitter.query.add_directive()*
-vim.treesitter.query.add_directive({name}, {handler})
-
-This adds a directive with the name {name} to be used in queries.
-{handler} should be a function whose signature will be : >
-	handler(match, pattern, bufnr, predicate, metadata)
-Handlers can set match level data by setting directly on the metadata object `metadata.key = value`
-Handlers can set node level data by using the capture id on the metadata table
-`metadata[capture_id].key = value`
+        `offset!`                                        *ts-directive-offset!*
+                Takes the range of the captured node and applies an offset.
+                This will generate a new range object for the captured node
+                as `metadata[capture_id].range`.
 
-					*vim.treesitter.query.list_directives()*
-vim.treesitter.query.list_directives()
+                Parameters: ~
+                    {capture_id}
+                    {start_row}
+                    {start_col}
+                    {end_row}
+                    {end_col}
 
-This lists the currently available directives to use in queries.
+                Example: >
+                        ((identifier) @constant (#offset! @constant 0 1 0 -1))
+<
 
-Treesitter syntax highlighting (WIP)			*lua-treesitter-highlight*
+Treesitter syntax highlighting (WIP)		     *lua-treesitter-highlight*
 
 NOTE: This is a partially implemented feature, and not usable as a default
 solution yet. What is documented here is a temporary interface intended
 for those who want to experiment with this feature and contribute to
 its development.
 
-Highlights are defined in the same query format as in the tree-sitter highlight
-crate, with some limitations and additions. Set a highlight query for a
-buffer with this code: >
+Highlights are defined in the same query format as in the tree-sitter
+highlight crate, with some limitations and additions. Set a highlight query
+for a buffer with this code: >
 
     local query = [[
       "for" @keyword
@@ -338,7 +343,8 @@ Treesitter Highlighting Priority            *lua-treesitter-highlight-priority*
 Tree-sitter uses |nvim_buf_set_extmark()| to set highlights with a default 
 priority of 100. This enables plugins to set a highlighting priority lower or
 higher than tree-sitter. It is also possible to change the priority of an
-individual query pattern manually by setting its `"priority"` metadata attribute: >
+individual query pattern manually by setting its `"priority"` metadata
+attribute: >
 
     (
       (super_important_node) @ImportantHighlight
@@ -404,10 +410,15 @@ Lua module: vim.treesitter.query                            *treesitter-query*
 add_directive({name}, {handler}, {force})                    *add_directive()*
                 Adds a new directive to be used in queries
 
+                Handlers can set match level data by setting directly on the
+                metadata object `metadata.key = value`, additionally, handlers
+                can set node level data by using the capture id on the
+                metadata table `metadata[capture_id].key = value`
+
                 Parameters: ~
                     {name}     the name of the directive, without leading #
                     {handler}  the handler function to be used signature will
-                               be (match, pattern, bufnr, predicate)
+                               be (match, pattern, bufnr, predicate, metadata)
 
 add_predicate({name}, {handler}, {force})                    *add_predicate()*
                 Adds a new predicate to be used in queries
@@ -446,6 +457,8 @@ get_query_files({lang}, {query_name}, {is_included})
                                    as `nil`
 
 list_directives()                                          *list_directives()*
+                Lists the currently available directives to use in queries.
+
                 Return: ~
                     The list of supported directives.
 
@@ -461,14 +474,15 @@ parse_query({lang}, {query})                                   *parse_query()*
                 can be used to search nodes in the syntax tree for the
                 patterns defined in {query} using `iter_*` methods below.
 
-                Exposes `info` and `captures` with additional information about the {query}.
+                Exposes `info` and `captures` with additional context about {query}.
                 • `captures` contains the list of unique capture names defined
-                  in {query}. - `info.captures` also points to `captures` .
+                  in {query}. -`info.captures` also points to `captures`.
                 • `info.patterns` contains information about predicates.
 
                 Parameters: ~
-                    {lang}   The language
-                    {query}  A string containing the query (s-expr syntax)
+                    {lang}   (string) The language
+                    {query}  (string) A string containing the query (s-expr
+                             syntax)
 
                 Return: ~
                     The query
@@ -522,8 +536,8 @@ Query:iter_matches({self}, {node}, {source}, {start}, {stop})
                 a table mapping capture indices to nodes, and metadata from
                 any directives processing the match. If the query has more
                 than one pattern the capture table might be sparse, and e.g.
-                `pairs()` method should be used over `ipairs` . Here an
-                example iterating over all captures in every match:
+                `pairs()` method should be used over `ipairs`. Here an example
+                iterating over all captures in every match:
 >
 
     for pattern, match, metadata in cquery:iter_matches(tree:root(), bufnr, first, last) do
@@ -608,10 +622,7 @@ LanguageTree:children({self})                        *LanguageTree:children()*
                     {self}
 
 LanguageTree:contains({self}, {range})               *LanguageTree:contains()*
-                Determines whether This goes down the tree to recursively check children.
-
-                Parameters: ~
-                    {range}  is contained in this language tree
+                Determines whether {range} is contained in this language tree
 
                 Parameters: ~
                     {range}  A range, that is a `{ start_line, start_col,
@@ -621,8 +632,9 @@ LanguageTree:contains({self}, {range})               *LanguageTree:contains()*
 LanguageTree:destroy({self})                          *LanguageTree:destroy()*
                 Destroys this language tree and all its children.
 
-                Any cleanup logic should be performed here. Note, this DOES
-                NOT remove this tree from a parent. `remove_child` must be called on the parent to remove it.
+                Any cleanup logic should be performed here.
+
+                Note: This DOES NOT remove this tree from a parent. Instead, `remove_child` must be called on the parent to remove it.
 
                 Parameters: ~
                     {self}
@@ -665,7 +677,8 @@ LanguageTree:invalidate({self}, {reload})          *LanguageTree:invalidate()*
                     {self}
 
 LanguageTree:is_valid({self})                        *LanguageTree:is_valid()*
-                Determines whether this tree is valid. If the tree is invalid, `parse()` must be called to get the an updated tree.
+                Determines whether this tree is valid. If the tree is invalid,
+                call `parse()` . This will return the updated tree.
 
                 Parameters: ~
                     {self}
@@ -678,7 +691,7 @@ LanguageTree:lang({self})                                *LanguageTree:lang()*
 
                                            *LanguageTree:language_for_range()*
 LanguageTree:language_for_range({self}, {range})
-                Gets the appropriate language that contains
+                Gets the appropriate language that contains {range}
 
                 Parameters: ~
                     {range}  A text range, see |LanguageTree:contains|
@@ -694,13 +707,22 @@ LanguageTree:parse({self})                              *LanguageTree:parse()*
                     {self}
 
 LanguageTree:register_cbs({self}, {cbs})         *LanguageTree:register_cbs()*
-                Registers callbacks for the parser
-
-                Parameters: ~
-                    {cbs}   An `nvim_buf_attach` -like table argument with the following keys : `on_bytes` : see `nvim_buf_attach` , but this will be called after the parsers callback. `on_changedtree` : a callback that will be called every time the
-                            tree has syntactical changes. it will only be
-                            passed one argument, that is a table of the ranges
-                            (as node ranges) that changed. `on_child_added` : emitted when a child is added to the tree. `on_child_removed` : emitted when a child is removed from the tree.
+                Registers callbacks for the parser.
+
+                Parameters: ~
+                    {cbs}   (table) An |nvim_buf_attach()|-like table argument
+                            with the following keys :
+                            • `on_bytes` : see |nvim_buf_attach()|, but this will be
+                              called after the parsers callback.
+                            • `on_changedtree` : a callback that will be
+                              called every time the tree has syntactical
+                              changes. It will only be passed one argument,
+                              which is a table of the ranges (as node ranges)
+                              that changed.
+                            • `on_child_added` : emitted when a child is added
+                              to the tree.
+                            • `on_child_removed` : emitted when a child is
+                              removed from the tree.
                     {self}
 
 LanguageTree:remove_child({self}, {lang})        *LanguageTree:remove_child()*
@@ -732,8 +754,8 @@ LanguageTree:set_included_regions({self}, {regions})
                 parsed again.
 
                 Parameters: ~
-                    {regions}  A list of regions this tree should manage and
-                               parse.
+                    {regions}  (table) list of regions this tree should manage
+                               and parse.
                     {self}
 
 LanguageTree:source({self})                            *LanguageTree:source()*
diff --git a/runtime/doc/uganda.txt b/runtime/doc/uganda.txt
index 79519da51e..23dfa082a0 100644
--- a/runtime/doc/uganda.txt
+++ b/runtime/doc/uganda.txt
@@ -129,11 +129,12 @@ Kibaale Children's Centre		*kcc* *Kibaale*  *charity*
 Kibaale Children's Centre (KCC) is located in Kibaale, a small town in the
 south of Uganda, near Tanzania, in East Africa.  The area is known as Rakai
 District.  The population is mostly farmers.  Although people are poor, there
-is enough food.  But this district is suffering from AIDS more than any other
-part of the world.  Some say that it started there.  Estimations are that 10
-to 30% of the Ugandans are infected with HIV.  Because parents die, there are
-many orphans.  In this district about 60,000 children have lost one or both
-parents, out of a population of 350,000.  And this is still continuing.
+usually is enough food.  But this district is suffering from AIDS more than
+any other part of the world.  Some say that it started there.  Estimations are
+that in the past 10 to 30% of the Ugandans are infected with HIV.  Because
+parents die, there are many orphans.  In this district about 60,000 children
+have lost one or both parents, out of a population of 350,000.  Although AIDS
+is now mostly under control, the problems are still continuing.
 
 The children need a lot of help.  The KCC is working hard to provide the needy
 with food, medical care and education.  Food and medical care to keep them
diff --git a/runtime/doc/ui.txt b/runtime/doc/ui.txt
index e7be14e732..3fb9ed1125 100644
--- a/runtime/doc/ui.txt
+++ b/runtime/doc/ui.txt
@@ -49,6 +49,14 @@ with these (optional) keys:
 				'wildmenu'. |ui-popupmenu|
 	`ext_tabline`		Externalize the tabline. |ui-tabline|
 	`ext_termcolors`	Use external default colors.
+	`term_name`		Sets the name of the terminal 'term'.
+	`term_colors`		Sets the number of supported colors 't_Co'.
+	`term_background`	Sets the default value of 'background'.
+	`stdin_fd`		Read buffer from `fd` as if it was a stdin pipe
+				This option can only used by |--embed| ui,
+				see |ui-startup-stdin|.
+
+
 
 Specifying an unknown option is an error; UIs can check the |api-metadata|
 `ui_options` key for supported options.
@@ -137,6 +145,19 @@ procedure:
    Inside this request handler, the UI can safely do any initialization before
    entering normal mode, for example reading variables set by init.vim.
 
+							   *ui-startup-stdin*
+An UI can support the native read from stdin feature as invoked with
+`command | nvim -` for the builtin TUI. |--|
+The embedding process can detect that its stdin is open to a file which
+not is a terminal, just like nvim does. It then needs to forward this fd
+to Nvim. As fd=0 is already is used to send rpc data from the embedder to
+Nvim, it needs to use some other file descriptor, like fd=3 or higher.
+
+Then, `stdin_fd` option should be passed to `nvim_ui_attach` and nvim will
+implicitly read it as a buffer. This option can only be used when Nvim is
+launched with `--embed` option, as described above.
+
+
 ==============================================================================
 Global Events							    *ui-global*
 
@@ -283,19 +304,23 @@ numerical highlight ids to the actual attributes.
 	attributes specified by the `rgb_attr` and `cterm_attr` dicts, with the
 	following (all optional) keys.
 
-	`foreground`:	foreground color.
-	`background`:	background color.
-	`special`:	color to use for underline and undercurl, when present.
-	`reverse`:	reverse video. Foreground and background colors are
-			switched.
-	`italic`:	italic text.
-	`bold`:		bold text.
-	`strikethrough`:  struckthrough text.
-	`underline`:	underlined text. The line has `special` color.
-	`undercurl`:	undercurled text. The curl has `special` color.
-	`blend`:	Blend level (0-100). Could be used by UIs to support
-			blending floating windows to the background or to
-			signal a transparent cursor.
+	`foreground`:		foreground color.
+	`background`:		background color.
+	`special`:		color to use for various underlines, when
+				present.
+	`reverse`:		reverse video. Foreground and background colors
+				are switched.
+	`italic`:		italic text.
+	`bold`:			bold text.
+	`strikethrough`:	struckthrough text.
+	`underline`:		underlined text. The line has `special` color.
+	`undercurl`:		undercurled text. The curl has `special` color.
+	`underdouble`:		double underlined text. The lines have `special` color.
+	`underdotted`:		underdotted text. The dots have `special` color.
+	`underdashed`:		underdashed text. The dashes have `special` color.
+	`blend`:		Blend level (0-100). Could be used by UIs to
+				support blending floating windows to the
+				background or to signal a transparent cursor.
 
 	For absent color keys the default color should be used. Don't store
 	the default value in the table, rather a sentinel value, so that
@@ -444,7 +469,7 @@ is not active. New UIs should implement |ui-linegrid| instead.
 
 	`foreground`:	foreground color.
 	`background`:	background color.
-	`special`:	color to use for underline and undercurl, when present.
+	`special`:	color to use for various underlines, when present.
 	`reverse`:	reverse video. Foreground and background colors are
 			switched.
 	`italic`:	italic text.
@@ -452,6 +477,9 @@ is not active. New UIs should implement |ui-linegrid| instead.
 	`strikethrough`:  struckthrough text.
 	`underline`:	underlined text. The line has `special` color.
 	`undercurl`:	undercurled text. The curl has `special` color.
+	`underdouble`:	double underlined text. The lines have `special` color.
+	`underdotted`:	underdotted text. The dots have `special` color.
+	`underdashed`:	underdashed text. The dashes have `special` color.
 
 ["put", text]
 	The (utf-8 encoded) string `text` is put at the cursor position
@@ -598,6 +626,10 @@ tabs.
 	`botline` is set to one more than the line count of the buffer, if
 	there are filler lines past the end.
 
+["win_extmark", grid, win, ns_id, mark_id, row, col]
+	Updates the position of an extmark which is currently visible in a
+	window. Only emitted if the mark has the `ui_watched` attribute. 
+
 ==============================================================================
 Popupmenu Events						 *ui-popupmenu*
 
diff --git a/runtime/doc/undo.txt b/runtime/doc/undo.txt
index b11d7581ed..67f24103cd 100644
--- a/runtime/doc/undo.txt
+++ b/runtime/doc/undo.txt
@@ -22,6 +22,14 @@ u			Undo [count] changes.
 :u[ndo] {N}		Jump to after change number {N}.  See |undo-branches|
 			for the meaning of {N}.
 
+:u[ndo]!		Undo one change and remove it from undo history.
+								*E5767*
+:u[ndo]! {N}		Like ":u[ndo] {N}", but forget all changes in the
+			current undo branch up until {N}. You may only use
+			":undo! {N}" to move backwards in the same undo
+			branch, not to redo or switch to a different undo
+			branch.
+
 							*CTRL-R*
 CTRL-R			Redo [count] changes which were undone.
 
@@ -100,12 +108,14 @@ change again.  But you can do something like this: >
 
 After this a "u" command will undo the delete command and the previous
 change.
-
+							*undo-break*
 To do the opposite, break a change into two undo blocks, in Insert mode use
 CTRL-G u.  This is useful if you want an insert command to be undoable in
 parts.  E.g., for each sentence.  |i_CTRL-G_u|
+
 Setting the value of 'undolevels' also breaks undo.  Even when the new value
-is equal to the old value.
+is equal to the old value: >
+	let &undolevels = &undolevels
 
 ==============================================================================
 4. Undo branches				*undo-branches* *undo-tree*
@@ -272,12 +282,12 @@ history file.  E.g.: >
 	au BufReadPost * call ReadUndo()
 	au BufWritePost * call WriteUndo()
 	func ReadUndo()
-	  if filereadable(expand('%:h'). '/UNDO/' . expand('%:t'))
+	  if filereadable(expand('%:h') .. '/UNDO/' .. expand('%:t'))
 	    rundo %:h/UNDO/%:t
 	  endif
 	endfunc
 	func WriteUndo()
-	  let dirname = expand('%:h') . '/UNDO'
+	  let dirname = expand('%:h') .. '/UNDO'
 	  if !isdirectory(dirname)
 	    call mkdir(dirname)
 	  endif
diff --git a/runtime/doc/usr_04.txt b/runtime/doc/usr_04.txt
index b2dd617542..c7c900274b 100644
--- a/runtime/doc/usr_04.txt
+++ b/runtime/doc/usr_04.txt
@@ -349,15 +349,17 @@ Notice that "yw" includes the white space after a word.  If you don't want
 this, use "ye".
 
 The "yy" command yanks a whole line, just like "dd" deletes a whole line.
-Unexpectedly, while "D" deletes from the cursor to the end of the line, "Y"
-works like "yy", it yanks the whole line.  Watch out for this inconsistency!
-Use "y$" to yank to the end of the line.
 
 	a text line   yy	a text line	       a text line
 	line 2			line 2		p      line 2
 	last line		last line	       a text line
 						       last line
 
+"Y" was originally equivalent to "yank the entire line", as opposed to "D"
+which is "delete to end of the line".  "Y" has thus been remapped to mean
+"yank to end of the line" to make it consistent with the behavior of "D".
+Mappings will be covered in later chapters.
+
 ==============================================================================
 *04.7*	Using the clipboard
 
diff --git a/runtime/doc/usr_05.txt b/runtime/doc/usr_05.txt
index f93a221e43..0e94d9a1b1 100644
--- a/runtime/doc/usr_05.txt
+++ b/runtime/doc/usr_05.txt
@@ -45,7 +45,7 @@ This file is always used and is recommended:
 
 The vimrc file can contain all the commands that you type after a colon.  The
 simplest ones are for setting options.  For example, if you want Vim to always
-start with the 'incsearch' option on, add this line your vimrc file: >
+start with the 'ignorecase' option on, add this line your vimrc file: >
 
 	set ignorecase
 
@@ -131,7 +131,7 @@ it worked before Vim 5.0.  Otherwise the "Q" command starts Ex mode, but you
 will not need it.
 
 >
-	vnoremap _g y:exe "grep /" . escape(@", '\\/') . "/ *.c *.h"<CR>
+	vnoremap _g y:exe "grep /" .. escape(@", '\\/') .. "/ *.c *.h"<CR>
 
 This mapping yanks the visually selected text and searches for it in C files.
 This is a complicated mapping.  You can see that mappings can be used to do
@@ -139,13 +139,11 @@ quite complicated things.  Still, it is just a sequence of commands that are
 executed like you typed them.
 
 >
-	syntax on
 	set hlsearch
 
-This switches on syntax highlighting.  And the 'hlsearch' option tells Vim to
-highlight matches with the last used search pattern.  The "if" command is very
-useful to set options only when some condition is met.  More about that in
-|usr_41.txt|.
+This option tells Vim to highlight matches with the last used search pattern.
+The "if" command is very useful to set options only when some condition is
+met.  More about that in |usr_41.txt|.
 
 							*vimrc-filetype*  >
 	filetype plugin indent on
diff --git a/runtime/doc/usr_06.txt b/runtime/doc/usr_06.txt
index 360f72ec63..b99e0fb482 100644
--- a/runtime/doc/usr_06.txt
+++ b/runtime/doc/usr_06.txt
@@ -24,28 +24,8 @@ Table of contents: |usr_toc.txt|
 ==============================================================================
 *06.1*	Switching it on
 
-It all starts with one simple command: >
-
-	:syntax enable
-
-That should work in most situations to get color in your files.  Vim will
-automagically detect the type of file and load the right syntax highlighting.
-Suddenly comments are blue, keywords brown and strings red.  This makes it
-easy to overview the file.  After a while you will find that black&white text
-slows you down!
-
-If you always want to use syntax highlighting, put the ":syntax enable"
-command in your |init.vim| file.
-
-If you want syntax highlighting only when the terminal supports colors, you
-can put this in your |init.vim| file: >
-
-	if &t_Co > 1
-	   syntax enable
-	endif
-
-If you want syntax highlighting only in the GUI version, put the ":syntax
-enable" command in your |ginit.vim| file.
+Syntax highlighting is enabled by default.  Nvim will automagically detect the
+type of file and load the right syntax highlighting.
 
 ==============================================================================
 *06.2*	No or wrong colors?
diff --git a/runtime/doc/usr_07.txt b/runtime/doc/usr_07.txt
index 649be8d7ce..ebf5c3d7b8 100644
--- a/runtime/doc/usr_07.txt
+++ b/runtime/doc/usr_07.txt
@@ -336,7 +336,7 @@ there. >
 
 Of course you can use many other commands to yank the text.  For example, to
 select whole lines start Visual mode with "V".  Or use CTRL-V to select a
-rectangular block.  Or use "Y" to yank a single line, "yaw" to yank-a-word,
+rectangular block.  Or use "yy" to yank a single line, "yaw" to yank-a-word,
 etc.
    The "p" command puts the text after the cursor.  Use "P" to put the text
 before the cursor.  Notice that Vim remembers if you yanked a whole line or a
@@ -359,7 +359,7 @@ the text should be placed in the f register.  This must come just before the
 yank command.
    Now yank three whole lines to the l register (l for line): >
 
-	"l3Y
+	"l3yy
 
 The count could be before the "l just as well.  To yank a block of text to the
 b (for block) register: >
diff --git a/runtime/doc/usr_08.txt b/runtime/doc/usr_08.txt
index 8ccaa73006..1d20913a14 100644
--- a/runtime/doc/usr_08.txt
+++ b/runtime/doc/usr_08.txt
@@ -482,6 +482,8 @@ statusline:
 	0	never
 	1	only when there are split windows (the default)
 	2	always
+	3	have a global statusline at the bottom instead of one for each
+		window
 
 Many commands that edit another file have a variant that splits the window.
 For Command-line commands this is done by prepending an "s".  For example:
diff --git a/runtime/doc/usr_10.txt b/runtime/doc/usr_10.txt
index 5365f90314..8844671e01 100644
--- a/runtime/doc/usr_10.txt
+++ b/runtime/doc/usr_10.txt
@@ -132,11 +132,11 @@ This works both with recording and with yank and delete commands.  For
 example, you want to collect a sequence of lines into the a register.  Yank
 the first line with: >
 
-	"aY
+	"ayy
 
 Now move to the second line, and type: >
 
-	"AY
+	"Ayy
 
 Repeat this command for all lines.  The a register now contains all those
 lines, in the order you yanked them.
diff --git a/runtime/doc/usr_21.txt b/runtime/doc/usr_21.txt
index 44d653a1a7..add5d48073 100644
--- a/runtime/doc/usr_21.txt
+++ b/runtime/doc/usr_21.txt
@@ -352,12 +352,12 @@ another session.
 this yourself then.  Example: >
 
 	:mksession! ~/.config/nvim/secret.vim
-	:wshada! ~/.local/share/nvim/shada/secret.shada
+	:wshada! ~/.local/state/nvim/shada/secret.shada
 
 And to restore this again: >
 
 	:source ~/.config/nvim/secret.vim
-	:rshada! ~/.local/share/nvim/shada/secret.shada
+	:rshada! ~/.local/state/nvim/shada/secret.shada
 
 ==============================================================================
 *21.5*	Views
diff --git a/runtime/doc/usr_29.txt b/runtime/doc/usr_29.txt
index 3381d1870c..d8c556c281 100644
--- a/runtime/doc/usr_29.txt
+++ b/runtime/doc/usr_29.txt
@@ -33,10 +33,12 @@ following command: >
 	ctags *.c
 
 "ctags" is a separate program.  Most Unix systems already have it installed.
-If you do not have it yet, you can find Exuberant ctags here:
-
+If you do not have it yet, you can find Universal/Exuberant ctags at:
+	http://ctags.io ~
 	http://ctags.sf.net ~
 
+Universal ctags is preferred, Exuberant ctags is no longer being developed.
+
 Now when you are in Vim and you want to go to a function definition, you can
 jump to it by using the following command: >
 
@@ -142,15 +144,15 @@ ONE TAGS FILE
 When Vim has to search many places for tags files, you can hear the disk
 rattling.  It may get a bit slow.  In that case it's better to spend this
 time while generating one big tags file.  You might do this overnight.
-   This requires the Exuberant ctags program, mentioned above.  It offers an
-argument to search a whole directory tree: >
+   This requires the Universal or Exuberant ctags program, mentioned above.
+It offers an argument to search a whole directory tree: >
 
 	cd ~/proj
 	ctags -R .
 
-The nice thing about this is that Exuberant ctags recognizes various file
-types.  Thus this doesn't work just for C and C++ programs, also for Eiffel
-and even Vim scripts.  See the ctags documentation to tune this.
+The nice thing about this is that Universal/Exuberant ctags recognizes various
+file types.  Thus this doesn't work just for C and C++ programs, also for
+Eiffel and even Vim scripts.  See the ctags documentation to tune this.
    Now you only need to tell Vim where your big tags file is: >
 
 	:set tags=~/proj/tags
@@ -232,7 +234,8 @@ A TAGS BROWSER
 Since CTRL-] takes you to the definition of the identifier under the cursor,
 you can use a list of identifier names as a table of contents.  Here is an
 example.
-   First create a list of identifiers (this requires Exuberant ctags): >
+   First create a list of identifiers (this requires Universal or Exuberant
+ctags): >
 
 	ctags --c-types=f -f functions *.c
 
diff --git a/runtime/doc/usr_40.txt b/runtime/doc/usr_40.txt
index 5b1254e2ae..f47c933124 100644
--- a/runtime/doc/usr_40.txt
+++ b/runtime/doc/usr_40.txt
@@ -463,6 +463,17 @@ separated) that trigger the command.
 The optional [++nested] flag allows for nesting of autocommands (see below),
 and finally, {command} is the command to be executed.
 
+When adding an autocommand the already existing ones remain.  To avoid adding
+the autocommand several times you should use this form: >
+
+	:augroup updateDate
+	:  autocmd!
+	:  autocmd BufWritePre *  call DateInsert()
+	:augroup END
+
+This will delete any previously defined autocommand with `:autocmd!` before
+defining the new one.  Groups are explained later.
+
 
 EVENTS
 
diff --git a/runtime/doc/usr_41.txt b/runtime/doc/usr_41.txt
index 7e611a47f3..5acef2f352 100644
--- a/runtime/doc/usr_41.txt
+++ b/runtime/doc/usr_41.txt
@@ -157,7 +157,7 @@ cannot start with a digit.  Valid variable names are:
 	FuncLength
 	LENGTH
 
-Invalid names are "foo+bar" and "6var".
+Invalid names are "foo.bar" and "6var".
    These variables are global.  To see a list of currently defined variables
 use this command: >
 
@@ -549,7 +549,7 @@ A "&" character is prepended to "path", thus the argument to eval() is
 
 Vim defines many functions and provides a large amount of functionality that
 way.  A few examples will be given in this section.  You can find the whole
-list here: |functions|.
+list below: |function-list|.
 
 A function is called with the ":call" command.  The parameters are passed in
 between parentheses separated by commas.  Example: >
@@ -581,15 +581,15 @@ statements is equal to: >
 
 	:substitute/\a/*/g
 
-Using the functions becomes more interesting when you do more work before and
+Using the functions becomes interesting when you do more work before and
 after the substitute() call.
 
 
 FUNCTIONS						*function-list*
 
 There are many functions.  We will mention them here, grouped by what they are
-used for.  You can find an alphabetical list here: |functions|.  Use CTRL-] on
-the function name to jump to detailed help on it.
+used for.  You can find an alphabetical list here: |builtin-function-list|.
+Use CTRL-] on the function name to jump to detailed help on it.
 
 String manipulation:					*string-functions*
 	nr2char()		get a character by its number value
@@ -608,6 +608,8 @@ String manipulation:					*string-functions*
 	toupper()		turn a string to uppercase
 	match()			position where a pattern matches in a string
 	matchend()		position where a pattern match ends in a string
+	matchfuzzy()		fuzzy matches a string in a list of strings
+	matchfuzzypos()		fuzzy matches a string in a list of strings
 	matchstr()		match of a pattern in a string
 	matchstrpos()		match and positions of a pattern in a string
 	matchlist()		like matchstr() and also return submatches
@@ -746,6 +748,11 @@ Cursor and mark position:		*cursor-functions* *mark-functions*
 	screenchar()		get character code at a screen line/row
 	screenchars()		get character codes at a screen line/row
 	screenstring()		get string of characters at a screen line/row
+	charcol()		character number of the cursor or a mark
+	getcharpos()		get character position of cursor, mark, etc.
+	setcharpos()		set character position of cursor, mark, etc.
+	getcursorcharpos()	get character position of the cursor
+	setcursorcharpos()	set character position of the cursor
 
 Working with text in the current buffer:		*text-functions*
 	getline()		get a line or list of lines from the buffer
@@ -837,6 +844,8 @@ Buffers, windows and the argument list:
 	win_gotoid()		go to window with ID
 	win_id2tabwin()		get tab and window nr from window ID
 	win_id2win()		get window nr from window ID
+	win_move_separator()	move window vertical separator
+	win_move_statusline()	move window status line
 	getbufinfo()		get a list with buffer information
 	gettabinfo()		get a list with tab page information
 	getwininfo()		get a list with window information
@@ -846,8 +855,12 @@ Buffers, windows and the argument list:
 	swapname()		get the swap file path of a buffer
 
 Command line:					*command-line-functions*
+	getcmdcompltype()	get the type of the current command line
+				completion
 	getcmdline()		get the current command line
 	getcmdpos()		get position of the cursor in the command line
+	getcmdscreenpos()	get screen position of the cursor in the
+				command line
 	setcmdpos()		set position of the cursor in the command line
 	getcmdtype()		return the current command-line type
 	getcmdwintype()		return the current command-line window type
@@ -951,6 +964,10 @@ Window size and position:			*window-size-functions*
 	winrestview()		restore saved view of current window
 
 Mappings:				    *mapping-functions*
+	digraph_get()		get |digraph|
+	digraph_getlist()	get all |digraph|s
+	digraph_set()		register |digraph|
+	digraph_setlist()	register multiple |digraph|s
 	hasmapto()		check if a mapping exists
 	mapcheck()		check if a matching mapping exists
 	maparg()		get rhs of a mapping
@@ -1579,7 +1596,7 @@ the same (the text may change, e.g., it may be translated).
 
 When the ":read" command causes another error, the pattern "E484:" will not
 match in it.  Thus this exception will not be caught and result in the usual
-error message.
+error message and execution is aborted.
 
 You might be tempted to do this: >
 
@@ -1619,27 +1636,29 @@ manual: |exception-handling|.
 Here is a summary of items that apply to Vim scripts.  They are also mentioned
 elsewhere, but form a nice checklist.
 
-The end-of-line character depends on the system.  For Unix a single <NL>
-character is used.  For Windows <CR><NL> is used.  This is important when
-using mappings that end in a <CR>.  See |:source_crnl|.
+The end-of-line character depends on the system.  For Vim scripts it is
+recommended to always use the Unix fileformat.  Lines are then separated with
+the Newline character.  This also works on any other system.  That way you can
+copy your Vim scripts from MS-Windows to Unix and they still work.  See
+|:source_crnl|.  To be sure it is set right, do this before writing the file:
+ >
+	:setlocal fileformat=unix
 
+When using "dos" fileformat, lines are separated with CR-NL, two characters.
+The CR character causes various problems, better avoid this.
 
-WHITE SPACE
-
-Blank lines are allowed and ignored.
 
-Leading whitespace characters (blanks and TABs) are always ignored.  The
-whitespaces between parameters (e.g. between the "set" and the "cpoptions" in
-the example below) are reduced to one blank character and plays the role of a
-separator, the whitespaces after the last (visible) character may or may not
-be ignored depending on the situation, see below.
+WHITE SPACE
 
-For a ":set" command involving the "=" (equal) sign, such as in: >
+Blank lines are allowed in a script and ignored.
 
-	:set cpoptions    =aABceFst
+Leading whitespace characters (blanks and TABs) are ignored, except when using
+|:let-heredoc| without "trim".
 
-the whitespace immediately before the "=" sign is ignored.  But there can be
-no whitespace after the "=" sign!
+Trailing whitespace is often ignored, but not always.  One command that
+includes it is `map`.  You have to watch out for that, it can cause hard to
+understand mistakes.  A generic solution is to never use trailing white space,
+unless you really need it.
 
 To include a whitespace character in the value of an option, it must be
 escaped by a "\" (backslash)  as in the following example: >
diff --git a/runtime/doc/usr_42.txt b/runtime/doc/usr_42.txt
index ff3ae7057a..470f4e0fe5 100644
--- a/runtime/doc/usr_42.txt
+++ b/runtime/doc/usr_42.txt
@@ -150,7 +150,8 @@ like the variations on the ":map" command:
 	:menu!		Insert and Command-line mode
 	:imenu		Insert mode
 	:cmenu		Command-line mode
-	:amenu		All modes
+	:tlmenu		Terminal mode
+	:amenu		All modes (except for Terminal mode)
 
 To avoid that the commands of a menu item are being mapped, use the command
 ":noremenu", ":nnoremenu", ":anoremenu", etc.
diff --git a/runtime/doc/various.txt b/runtime/doc/various.txt
index 05bffc3038..9eb6470962 100644
--- a/runtime/doc/various.txt
+++ b/runtime/doc/various.txt
@@ -30,10 +30,10 @@ CTRL-L			Clears and redraws the screen.  The redraw may happen
 			function (or a mapping if 'lazyredraw' set).
 
 						*:redraws* *:redrawstatus*
-:redraws[tatus][!]	Redraws the status line of the current window, or all
-			status lines if "!" is included.
-			Useful if 'statusline' includes an item that doesn't
-			cause automatic updating.
+:redraws[tatus][!]	Redraws the status line and window bar of the current
+			window, or all status lines and window bars if "!" is
+			included. Useful if 'statusline' or 'winbar' includes
+			an item that doesn't cause automatic updating.
 
 						*:redrawt* *:redrawtabline*
 :redrawt[abline]	Redraw the tabline.  Useful to update the tabline when
@@ -208,8 +208,6 @@ g8			Print the hex values of the bytes used in the
 			{commands} cannot start with a space.  Put a count of
 			1 (one) before it, "1 " is one space.
 
-			The 'insertmode' option is ignored for {commands}.
-
 			This command cannot be followed by another command,
 			since any '|' is considered part of the command.
 
@@ -275,7 +273,7 @@ g8			Print the hex values of the bytes used in the
 			Special characters are not escaped, use quotes or
 			|shellescape()|: >
 				:!ls "%"
-				:exe "!ls " . shellescape(expand("%"))
+				:exe "!ls " .. shellescape(expand("%"))
 <
 			Newline character ends {cmd} unless a backslash
 			precedes the newline.  What follows is interpreted as
@@ -348,7 +346,11 @@ g8			Print the hex values of the bytes used in the
 			Only string variables can be used.  After the
 			redirection starts, if the variable is removed or
 			locked or the variable type is changed, then further
-			command output messages will cause errors.
+			command output messages will cause errors.  When using
+			a local variable (l:var in a function or s:var in a
+			script) and another `:redir` causes the current one to
+			end, the scope might be different and the assignment
+			fails.
 			To get the output of one command the |execute()|
 			function can be used instead of redirection.
 
@@ -358,19 +360,19 @@ g8			Print the hex values of the bytes used in the
 :redi[r] END		End redirecting messages.
 
 							*:filt* *:filter*
-:filt[er][!] {pat} {command}
-:filt[er][!] /{pat}/ {command}
+:filt[er][!] {pattern} {command}
+:filt[er][!] /{pattern}/ {command}
 			Restrict the output of {command} to lines matching
-			with {pat}.  For example, to list only xml files: >
+			with {pattern}.  For example, to list only xml files: >
 				:filter /\.xml$/ oldfiles
 <			If the [!] is given, restrict the output of {command}
-			to lines that do NOT match {pat}.
+			to lines that do NOT match {pattern}.
 
-			{pat} is a Vim search pattern.  Instead of enclosing
+			{pattern} is a Vim search pattern.  Instead of enclosing
 			it in / any non-ID character (see |'isident'|) can be
-			used, so long as it does not appear in {pat}.  Without
-			the enclosing character the pattern cannot include the
-			bar character. 'ignorecase' is not used.
+			used, so long as it does not appear in {pattern}.
+			Without the enclosing character the pattern cannot
+			include the bar character. 'ignorecase' is not used.
 
 			The pattern is matched against the relevant part of
 			the output, not necessarily the whole line. Only some
@@ -388,6 +390,8 @@ g8			Print the hex values of the bytes used in the
 			   |:marks|      - filter by text in the current file,
 					   or file name for other files
 			   |:oldfiles|   - filter by file name
+			   |:registers|  - filter by register contents
+					   (does not work multi-line)
 			   |:set|        - filter by option name
 
 			Only normal messages are filtered, error messages are
@@ -430,7 +434,7 @@ g8			Print the hex values of the bytes used in the
 			used.  In this example |:silent| is used to avoid the
 			message about reading the file and |:unsilent| to be
 			able to list the first line of each file. >
-    		:silent argdo unsilent echo expand('%') . ": " . getline(1)
+		:silent argdo unsilent echo expand('%') .. ": " .. getline(1)
 <
 
 						*:verb* *:verbose*
@@ -459,10 +463,11 @@ g8			Print the hex values of the bytes used in the
 							*:verbose-cmd*
 When 'verbose' is non-zero, listing the value of a Vim option or a key map or
 an abbreviation or a user-defined function or a command or a highlight group
-or an autocommand will also display where it was last defined.  If it was
-defined manually then there will be no "Last set" message.  When it was
-defined while executing a function, user command or autocommand, the script in
-which it was defined is reported.
+or an autocommand will also display where it was last defined. If they were
+defined in Lua they will only be located if 'verbose' is set. So Start
+nvim with -V1 arg to see them. If it was defined manually then there
+will be no "Last set" message.  When it was defined while executing a function,
+user command or autocommand, the script in which it was defined is reported.
 
 							*K*
 [count]K       		Runs the program given by 'keywordprg' to lookup the
diff --git a/runtime/doc/vim_diff.txt b/runtime/doc/vim_diff.txt
index 4fcaf15717..a74149d050 100644
--- a/runtime/doc/vim_diff.txt
+++ b/runtime/doc/vim_diff.txt
@@ -17,25 +17,27 @@ centralized reference of the differences.
 
 - Use `$XDG_CONFIG_HOME/nvim/init.vim` instead of `.vimrc` for your |config|.
 - Use `$XDG_CONFIG_HOME/nvim` instead of `.vim` to store configuration files.
-- Use `$XDG_DATA_HOME/nvim/shada/main.shada` instead of `.viminfo` for persistent
+- Use `$XDG_STATE_HOME/nvim/shada/main.shada` instead of `.viminfo` for persistent
   session information.  |shada|
 
 ==============================================================================
 2. Defaults					            *nvim-defaults*
 
-- Syntax highlighting is enabled by default
-- ":filetype plugin indent on" is enabled by default
+- Filetype detection is enabled by default. This can be disabled by adding
+  ":filetype off" to |init.vim|.
+- Syntax highlighting is enabled by default. This can be disabled by adding
+  ":syntax off" to |init.vim|.
 
 - 'autoindent' is enabled
 - 'autoread' is enabled
 - 'background' defaults to "dark" (unless set automatically by the terminal/UI)
 - 'backspace' defaults to "indent,eol,start"
-- 'backupdir' defaults to .,~/.local/share/nvim/backup// (|xdg|), auto-created
+- 'backupdir' defaults to .,~/.local/state/nvim/backup// (|xdg|), auto-created
 - 'belloff' defaults to "all"
 - 'compatible' is always disabled
 - 'complete' excludes "i"
 - 'cscopeverbose' is enabled
-- 'directory' defaults to ~/.local/share/nvim/swap// (|xdg|), auto-created
+- 'directory' defaults to ~/.local/state/nvim/swap// (|xdg|), auto-created
 - 'display' defaults to "lastline,msgsep"
 - 'encoding' is UTF-8 (cf. 'fileencoding' for file-content encoding)
 - 'fillchars' defaults (in effect) to "vert:│,fold:·,sep:│"
@@ -50,6 +52,8 @@ centralized reference of the differences.
 - 'langremap' is disabled
 - 'laststatus' defaults to 2 (statusline is always shown)
 - 'listchars' defaults to "tab:> ,trail:-,nbsp:+"
+- 'mouse' defaults to "nvi"
+- 'mousemodel' defaults to "popup_setpos"
 - 'nrformats' defaults to "bin,hex"
 - 'ruler' is enabled
 - 'sessionoptions' includes "unix,slash", excludes "options"
@@ -63,7 +67,7 @@ centralized reference of the differences.
 - 'tags' defaults to "./tags;,tags"
 - 'ttimeoutlen' defaults to 50
 - 'ttyfast' is always set
-- 'undodir' defaults to ~/.local/share/nvim/undo// (|xdg|), auto-created
+- 'undodir' defaults to ~/.local/state/nvim/undo// (|xdg|), auto-created
 - 'viewoptions' includes "unix,slash", excludes "options"
 - 'viminfo' includes "!"
 - 'wildmenu' is enabled
@@ -76,15 +80,42 @@ centralized reference of the differences.
 - |g:vimsyn_embed| defaults to "l" to enable Lua highlighting
 
 
+Default Mouse ~
+						*default-mouse* *disable-mouse*
+By default the mouse is enabled.  The right button click opens |popup-menu|
+with standard actions, such as "Cut", "Copy" and "Paste".
+
+If you don't like this you can add to your |config| any of the following:
+
+- ignore mouse completely >
+  set mouse=
+<
+- no |popup-menu| but the right button extends selection >
+  set mousemodel=extend
+>
+- pressing ALT+LeftMouse releases mouse until main cursor moves  >
+  nnoremap <M-LeftMouse> <Cmd>
+    \ set mouse=<Bar>
+    \ echo 'mouse OFF until next cursor-move'<Bar>
+    \ autocmd CursorMoved * ++once set mouse&<Bar>
+    \ echo 'mouse ON'<CR>
+<
+Also, mouse is not in use in |command-mode| or at |more-prompt|.  So if you
+need to copy/paste with your terminal then just pressing ':' makes Nvim to
+release the mouse cursor temporarily.
+
 Default Mappings ~
 							*default-mappings*
 Nvim creates the following default mappings at |startup|. You can disable any
 of these in your config by simply removing the mapping, e.g. ":unmap Y".
 >
 	nnoremap Y y$
-	nnoremap <C-L> <Cmd>nohlsearch<Bar>diffupdate<CR><C-L>
+	nnoremap <C-L> <Cmd>nohlsearch<Bar>diffupdate<Bar>normal! <C-L><CR>
 	inoremap <C-U> <C-G>u<C-U>
 	inoremap <C-W> <C-G>u<C-W>
+	xnoremap * y/\V<C-R>"<CR>
+	xnoremap # y?\V<C-R>"<CR>
+	nnoremap & :&&<CR>
 <
 Default Autocommands ~
 							*default-autocmds*
@@ -178,6 +209,8 @@ Commands:
   |:Man| is available by default, with many improvements such as completion
   |:sign-define| accepts a `numhl` argument, to highlight the line number
   |:match| can be invoked before highlight group is defined
+  |:source| works with Lua and anonymous (no file) scripts
+  User commands can support |:command-preview| to show results as you type
 
 Events:
   |RecordingEnter|
@@ -209,6 +242,7 @@ Highlight groups:
   |hl-Substitute|
   |hl-TermCursor|
   |hl-TermCursorNC|
+  |hl-WinSeparator| highlights window separators
   |hl-Whitespace| highlights 'listchars' whitespace
 
 Input/Mappings:
@@ -225,9 +259,13 @@ Options:
   'cpoptions'   flags: |cpo-_|
   'display'     flags: "msgsep" minimizes scrolling when showing messages
   'guicursor'   works in the terminal
-  'fillchars'   flags: "msgsep" (see 'display')
+  'fillchars'   flags: "msgsep" (see 'display'), "horiz", "horizup",
+                "horizdown", "vertleft", "vertright", "verthoriz"
   'foldcolumn'  supports up to 9 dynamic/fixed columns
   'inccommand'  shows interactive results for |:substitute|-like commands
+                and |:command-preview| commands
+  'laststatus'  global statusline support
+  'mousescroll' amount to scroll by when scrolling with a mouse
   'pumblend'    pseudo-transparent popupmenu
   'scrollback'
   'signcolumn'  supports up to 9 dynamic/fixed columns
@@ -320,6 +358,8 @@ coerced to strings. See |id()| for more details, currently it uses
 
 |c_CTRL-R| pasting a non-special register into |cmdline| omits the last <CR>.
 
+|CursorMoved| always triggers when moving between windows.
+
 Lua interface (|lua.txt|):
 
 - `:lua print("a\0b")` will print `a^@b`, like with `:echomsg "a\nb"` . In Vim
@@ -337,13 +377,17 @@ Commands:
 Functions:
   |input()| and |inputdialog()| support for each other’s features (return on
   cancel and completion respectively) via dictionary argument (replaces all
-  other arguments if used).
+  other arguments if used), and "cancelreturn" can have any type if passed in
+  a dictionary.
   |input()| and |inputdialog()| support user-defined cmdline highlighting.
 
 Highlight groups:
   |hl-ColorColumn|, |hl-CursorColumn| are lower priority than most other
   groups
+  |hl-CurSearch| highlights match under cursor instead of last match found
+  using |n| or |N|
   |hl-CursorLine| is low-priority unless foreground color is set
+  |hl-VertSplit| superseded by |hl-WinSeparator|
 
 Macro/|recording| behavior
   Replay of a macro recorded during :lmap produces the same actions as when it
@@ -354,6 +398,10 @@ Macro/|recording| behavior
   macros and 'keymap' at the same time. This also means you can use |:imap| on
   the results of keys from 'keymap'.
 
+Mappings:
+  Creating a mapping for a simplifiable key (e.g. <C-I>) doesn't replace an
+  existing mapping for its simplified form (e.g. <Tab>).
+
 Motion:
   The |jumplist| avoids useless/phantom jumps.
 
@@ -364,6 +412,9 @@ Normal commands:
 Options:
   'ttimeout', 'ttimeoutlen' behavior was simplified
   |jumpoptions| "stack" behavior
+  |jumpoptions| "view" tries to restore the |mark-view| when moving through
+  the |jumplist|, |changelist|, |alternate-file| or using |mark-motions|.
+  'shortmess' the "F" flag does not affect output from autocommands
 
 Shell:
   Shell output (|:!|, |:make|, …) is always routed through the UI, so it
@@ -429,7 +480,8 @@ Vimscript compatibility:
   `this_session` does not alias to |v:this_session|
 
 Working directory (Vim implemented some of these later than Nvim):
-- |DirChanged| can be triggered when switching to another window.
+- |DirChanged| and |DirChangedPre| can be triggered when switching to another
+  window or tab.
 - |getcwd()| and |haslocaldir()| may throw errors if the tab page or window
   cannot be found.  *E5000* *E5001* *E5002*
 - |haslocaldir()| checks for tab-local directory if and only if -1 is passed as
@@ -481,7 +533,6 @@ Commands:
   :tearoff
 
 Compile-time features:
-  EBCDIC
   Emacs tags support
   X11 integration (see |x11-selection|)
 
@@ -490,6 +541,9 @@ Eval:
   *js_encode()*
   *js_decode()*
   *v:none* (used by Vim to represent JavaScript "undefined"); use |v:null| instead.
+  *v:sizeofint*
+  *v:sizeoflong*
+  *v:sizeofpointer*
 
 Events:
   *SigUSR1* Use |Signal| to detect `SIGUSR1` signal instead.
@@ -507,6 +561,9 @@ Highlight groups:
 
 Options:
   'antialias'
+  *'balloondelay'* *'bdlay'*
+  *'ballooneval'* *'beval'* *'noballooneval'* *'nobeval'*
+  *'balloonexpr'* *'bexpr'*
   'bioskey' (MS-DOS)
   'conskey' (MS-DOS)
   *'cp'* *'nocompatible'* *'nocp'* *'compatible'* (Nvim is always "nocompatible".)
@@ -522,25 +579,58 @@ Options:
   *'imactivatefunc'* *'imaf'*
   *'imactivatekey'* *'imak'*
   *'imstatusfunc'* *'imsf'*
+  *'insertmode'* *'im'* Use the following script to emulate 'insertmode':
+>
+    autocmd BufWinEnter * startinsert
+    inoremap <Esc> <C-X><C-Z><C-]>
+    inoremap <C-C> <C-X><C-Z>
+    inoremap <C-L> <C-X><C-Z><C-]><Esc>
+    inoremap <C-Z> <C-X><C-Z><Cmd>suspend<CR>
+    noremap <C-C> <Esc>
+    snoremap <C-C> <Esc>
+    noremap <C-\><C-G> <C-\><C-N><Cmd>startinsert<CR>
+    cnoremap <C-\><C-G> <C-\><C-N><Cmd>startinsert<CR>
+    inoremap <C-\><C-G> <C-X><C-Z>
+    autocmd CmdWinEnter * noremap <buffer> <C-C> <C-C>
+    autocmd CmdWinEnter * inoremap <buffer> <C-C> <C-C>
+
+    lua << EOF
+      vim.on_key(function(c)
+        if c == '\27' then
+          local mode = vim.api.nvim_get_mode().mode
+          if mode:find('^[nvV\22sS\19]') and vim.fn.getcmdtype() == '' then
+            vim.schedule(function()
+              vim.cmd('startinsert')
+            end)
+          end
+        end
+      end)
+    EOF
+<
   *'macatsui'*
+  *'maxcombine'* *'mco'*
+    Nvim always displays up to 6 combining characters.  You can still edit
+    text with more than 6 combining characters, you just can't see them.
+    Use |g8| or |ga|.  See |mbyte-combining|.
   'maxmem' Nvim delegates memory-management to the OS.
   'maxmemtot' Nvim delegates memory-management to the OS.
-  'maxcombine' (6 is always used)
   *'prompt'* *'noprompt'*
+  *'remap'* *'noremap'*
   *'restorescreen'* *'rs'* *'norestorescreen'* *'nors'*
   'shelltype'
   *'shortname'* *'sn'* *'noshortname'* *'nosn'*
   *'swapsync'* *'sws'*
   *'termencoding'* *'tenc'* (Vim 7.4.852 also removed this for Windows)
+  *'terse'* *'noterse'* (Add "s" to 'shortmess' instead)
   'textauto'
   'textmode'
   *'toolbar'* *'tb'*
   *'toolbariconsize'* *'tbis'*
   *'ttybuiltin'* *'tbi'* *'nottybuiltin'* *'notbi'*
+  *'ttyfast'* *'tf'* *'nottyfast'* *'notf'*
   *'ttymouse'* *'ttym'*
   *'ttyscroll'* *'tsl'*
   *'ttytype'* *'tty'*
-  'ttyfast'
   'weirdinvert'
 
 Startup:
@@ -572,6 +662,7 @@ Test functions:
   test_scrollbar()
   test_setmouse()
   test_settime()
+  test_srand_seed()
 
 TUI:
 			  *t_xx* *termcap-options* *t_AB* *t_Sb* *t_vb* *t_SI*
diff --git a/runtime/doc/visual.txt b/runtime/doc/visual.txt
index 4a69fc989b..905ae49887 100644
--- a/runtime/doc/visual.txt
+++ b/runtime/doc/visual.txt
@@ -255,6 +255,7 @@ Additionally the following commands can be used:
 	X	delete (2)					|v_X|
 	Y	yank (2)					|v_Y|
 	p	put						|v_p|
+	P	put without overwriting registers		|v_P|
 	J	join (1)					|v_J|
 	U	make uppercase					|v_U|
 	u	make lowercase					|v_u|
@@ -478,6 +479,10 @@ Commands in Select mode:
 - ESC stops Select mode.
 - CTRL-O switches to Visual mode for the duration of one command. *v_CTRL-O*
 - CTRL-G switches to Visual mode.
+- CTRL-R {register} selects the register to be used for the text that is
+  deleted when typing text.					  *v_CTRL-R*
+  Unless you specify the "_" (black hole) register, the unnamed register is
+  also overwritten.
 
 Otherwise, typed characters are handled as in Visual mode.
 
@@ -494,6 +499,13 @@ work both in Visual mode and in Select mode.  When these are used in Select
 mode Vim automatically switches to Visual mode, so that the same behavior as
 in Visual mode is effective.  If you don't want this use |:xmap| or |:smap|.
 
+One particular edge case: >
+  	:vnoremap <C-K> <Esc>
+This ends Visual mode when in Visual mode, but in Select mode it does not
+work, because Select mode is restored after executing the mapped keys.  You
+need to use: >
+  	:snoremap <C-K> <Esc>
+<
 Users will expect printable characters to replace the selected area.
 Therefore avoid mapping printable characters in Select mode.  Or use
 |:sunmap|  after |:map| and |:vmap| to remove it for Select mode.
diff --git a/runtime/doc/windows.txt b/runtime/doc/windows.txt
index 5b91321c40..8062b9e28f 100644
--- a/runtime/doc/windows.txt
+++ b/runtime/doc/windows.txt
@@ -104,6 +104,8 @@ when the last window also has a status line:
 	'laststatus' = 0	never a status line
 	'laststatus' = 1	status line if there is more than one window
 	'laststatus' = 2	always a status line
+	'laststatus' = 3	have a global statusline at the bottom instead
+				of one for each window
 
 You can change the contents of the status line with the 'statusline' option.
 This option can be local to the window, so that you can have a different
@@ -447,7 +449,7 @@ These commands can also be executed with ":wincmd":
 		the |CursorHold| autocommand event).  Or when a Normal mode
 		command is inconvenient.
 		The count can also be a window number.  Example: >
-			:exe nr . "wincmd w"
+			:exe nr .. "wincmd w"
 <		This goes to window "nr".
 
 ==============================================================================
@@ -909,12 +911,12 @@ CTRL-W g }						*CTRL-W_g}*
 		cursor.  This is less clever than using |:ptag|, but you don't
 		need a tags file and it will also find matches in system
 		include files.  Example: >
-  :au! CursorHold *.[ch] ++nested exe "silent! psearch " . expand("<cword>")
+  :au! CursorHold *.[ch] ++nested exe "silent! psearch " .. expand("<cword>")
 <		Warning: This can be slow.
 
 Example						*CursorHold-example*  >
 
-  :au! CursorHold *.[ch] ++nested exe "silent! ptag " . expand("<cword>")
+  :au! CursorHold *.[ch] ++nested exe "silent! ptag " .. expand("<cword>")
 
 This will cause a ":ptag" to be executed for the keyword under the cursor,
 when the cursor hasn't moved for the time set with 'updatetime'.  "++nested"
@@ -937,14 +939,14 @@ is no word under the cursor, and a few other things: >
   :
   :    " Delete any existing highlight before showing another tag
   :    silent! wincmd P			" jump to preview window
-  :    if &previewwindow			" if we really get there...
+  :    if &previewwindow		" if we really get there...
   :      match none			" delete existing highlight
   :      wincmd p			" back to old window
   :    endif
   :
   :    " Try displaying a matching tag for the word under the cursor
   :    try
-  :       exe "ptag " . w
+  :       exe "ptag " .. w
   :    catch
   :      return
   :    endtry
@@ -956,10 +958,10 @@ is no word under the cursor, and a few other things: >
   :	 endif
   :	 call search("$", "b")		" to end of previous line
   :	 let w = substitute(w, '\\', '\\\\', "")
-  :	 call search('\<\V' . w . '\>')	" position cursor on match
+  :	 call search('\<\V' .. w .. '\>')	" position cursor on match
   :	 " Add a match highlight to the word at this position
   :      hi previewWord term=bold ctermbg=green guibg=green
-  :	 exe 'match previewWord "\%' . line(".") . 'l\%' . col(".") . 'c\k*"'
+  :	 exe 'match previewWord "\%' .. line(".") .. 'l\%' .. col(".") .. 'c\k*"'
   :      wincmd p			" back to old window
   :    endif
   :  endif
@@ -981,7 +983,7 @@ modified, but is forced (with '!') to be removed from a window, and
 'autowrite' is off or the buffer can't be written.
 
 You can make a hidden buffer not hidden by starting to edit it with any
-command.  Or by deleting it with the ":bdelete" command.
+command, or by deleting it with the ":bdelete" command.
 
 The 'hidden' is global, it is used for all buffers.  The 'bufhidden' option
 can be used to make an exception for a specific buffer.  It can take these