docs(builtin): right align tags (#24522)

2 files changed, 461 insertions, 450 deletions

diff --git a/runtime/doc/builtin.txt b/runtime/doc/builtin.txt
index 3033435ee6..6a89eb0524 100644
--- a/runtime/doc/builtin.txt
+++ b/runtime/doc/builtin.txt
@@ -12,7 +12,7 @@ For functions grouped by what they are used for see |function-list|.
 ==============================================================================
 1. Details					*builtin-function-details*
 
-abs({expr})							*abs()*
+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
@@ -29,7 +29,7 @@ abs({expr})							*abs()*
 			Compute()->abs()
 <
 
-acos({expr})							*acos()*
+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
@@ -46,7 +46,7 @@ acos({expr})							*acos()*
 			Compute()->acos()
 <
 
-add({object}, {expr})						*add()*
+add({object}, {expr})                                                    *add()*
 		Append the item {expr} to |List| or |Blob| {object}.  Returns
 		the resulting |List| or |Blob|.  Examples: >vim
 			let alist = add([1, 2, 3], item)
@@ -61,7 +61,7 @@ add({object}, {expr})						*add()*
 			mylist->add(val1)->add(val2)
 <
 
-and({expr}, {expr})						*and()*
+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.
 		Also see `or()` and `xor()`.
@@ -71,14 +71,14 @@ and({expr}, {expr})						*and()*
 			let flag = bits->and(0x80)
 <
 
-api_info()						*api_info()*
+api_info()                                                          *api_info()*
 		Returns Dictionary of |api-metadata|.
 
 		View it in a nice human-readable format: >vim
 		       lua vim.print(vim.fn.api_info())
 <
 
-append({lnum}, {text})					*append()*
+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
@@ -95,7 +95,7 @@ append({lnum}, {text})					*append()*
 			mylist->append(lnum)
 <
 
-appendbufline({buf}, {lnum}, {text})		*appendbufline()*
+appendbufline({buf}, {lnum}, {text})                           *appendbufline()*
 		Like |append()| but append the text in buffer {expr}.
 
 		This function works only for loaded buffers. First call
@@ -118,7 +118,7 @@ appendbufline({buf}, {lnum}, {text})		*appendbufline()*
 			mylist->appendbufline(buf, lnum)
 <
 
-argc([{winid}])						*argc()*
+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
@@ -128,11 +128,11 @@ argc([{winid}])						*argc()*
 		list is used: either the window number or the window ID.
 		Returns -1 if the {winid} argument is invalid.
 
-argidx()							*argidx()*
+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([{winnr} [, {tabnr}]])			*arglistid()*
+arglistid([{winnr} [, {tabnr}]])                                   *arglistid()*
 		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|.
@@ -144,7 +144,7 @@ arglistid([{winnr} [, {tabnr}]])			*arglistid()*
 		page.
 		{winnr} can be the window number or the |window-ID|.
 
-argv([{nr} [, {winid}]])					*argv()*
+argv([{nr} [, {winid}]])                                                *argv()*
 		The result is the {nr}th file in the argument list.  See
 		|arglist|.  "argv(0)" is the first one.  Example: >vim
 			let i = 0
@@ -163,7 +163,7 @@ argv([{nr} [, {winid}]])					*argv()*
 		the argument list.  Returns an empty List if the {winid}
 		argument is invalid.
 
-asin({expr})							*asin()*
+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
@@ -180,7 +180,7 @@ asin({expr})							*asin()*
 			Compute()->asin()
 <
 
-assert_beeps({cmd})					*assert_beeps()*
+assert_beeps({cmd})                                             *assert_beeps()*
 		Run {cmd} and add an error message to |v:errors| if it does
 		NOT produce a beep or visual bell.
 		Also see |assert_fails()|, |assert_nobeep()| and
@@ -190,7 +190,7 @@ assert_beeps({cmd})					*assert_beeps()*
 			GetCmd()->assert_beeps()
 <
 
-assert_equal({expected}, {actual} [, {msg}])		*assert_equal()*
+assert_equal({expected}, {actual} [, {msg}])                    *assert_equal()*
 		When {expected} and {actual} are not equal an error message is
 		added to |v:errors| and 1 is returned.  Otherwise zero is
 		returned. |assert-return|
@@ -210,7 +210,7 @@ assert_equal({expected}, {actual} [, {msg}])		*assert_equal()*
 			mylist->assert_equal([1, 2, 3])
 <
 
-assert_equalfile({fname-one}, {fname-two})	*assert_equalfile()*
+assert_equalfile({fname-one}, {fname-two})                  *assert_equalfile()*
 		When the files {fname-one} and {fname-two} do not contain
 		exactly the same text an error message is added to |v:errors|.
 		Also see |assert-return|.
@@ -221,7 +221,7 @@ assert_equalfile({fname-one}, {fname-two})	*assert_equalfile()*
 			GetLog()->assert_equalfile('expected.log')
 <
 
-assert_exception({error} [, {msg}])		*assert_exception()*
+assert_exception({error} [, {msg}])                         *assert_exception()*
 		When v:exception does not contain the string {error} an error
 		message is added to |v:errors|.  Also see |assert-return|.
 		This can be used to assert that a command throws an exception.
@@ -235,7 +235,7 @@ assert_exception({error} [, {msg}])		*assert_exception()*
 			endtry
 <
 
-						*assert_fails()*
+                                                                *assert_fails()*
 assert_fails({cmd} [, {error} [, {msg} [, {lnum} [, {context}]]]])
 		Run {cmd} and add an error message to |v:errors| if it does
 		NOT produce an error or when {error} is not found in the
@@ -274,7 +274,7 @@ assert_fails({cmd} [, {error} [, {msg} [, {lnum} [, {context}]]]])
 			GetCmd()->assert_fails('E99:')
 <
 
-assert_false({actual} [, {msg}])			*assert_false()*
+assert_false({actual} [, {msg}])                                *assert_false()*
 		When {actual} is not false an error message is added to
 		|v:errors|, like with |assert_equal()|.
 		The error is in the form "Expected False but got {actual}".
@@ -288,7 +288,7 @@ assert_false({actual} [, {msg}])			*assert_false()*
 			GetResult()->assert_false()
 <
 
-assert_inrange({lower}, {upper}, {actual} [, {msg}])	*assert_inrange()*
+assert_inrange({lower}, {upper}, {actual} [, {msg}])          *assert_inrange()*
 		This asserts number and |Float| values.  When {actual}  is lower
 		than {lower} or higher than {upper} an error message is added
 		to |v:errors|.  Also see |assert-return|.
@@ -296,7 +296,7 @@ assert_inrange({lower}, {upper}, {actual} [, {msg}])	*assert_inrange()*
 		but got {actual}".  When {msg} is present it is prefixed to
 		that.
 
-assert_match({pattern}, {actual} [, {msg}])		*assert_match()*
+assert_match({pattern}, {actual} [, {msg}])                     *assert_match()*
 		When {pattern} does not match {actual} an error message is
 		added to |v:errors|.  Also see |assert-return|.
 		The error is in the form "Pattern {pattern} does not match
@@ -319,7 +319,7 @@ assert_match({pattern}, {actual} [, {msg}])		*assert_match()*
 			getFile()->assert_match('foo.*')
 <
 
-assert_nobeep({cmd})				*assert_nobeep()*
+assert_nobeep({cmd})                                           *assert_nobeep()*
 		Run {cmd} and add an error message to |v:errors| if it
 		produces a beep or visual bell.
 		Also see |assert_beeps()|.
@@ -328,7 +328,7 @@ assert_nobeep({cmd})				*assert_nobeep()*
 			GetCmd()->assert_nobeep()
 <
 
-assert_notequal({expected}, {actual} [, {msg}])	*assert_notequal()*
+assert_notequal({expected}, {actual} [, {msg}])              *assert_notequal()*
 		The opposite of `assert_equal()`: add an error message to
 		|v:errors| when {expected} and {actual} are equal.
 		Also see |assert-return|.
@@ -337,7 +337,7 @@ assert_notequal({expected}, {actual} [, {msg}])	*assert_notequal()*
 			mylist->assert_notequal([1, 2, 3])
 <
 
-assert_notmatch({pattern}, {actual} [, {msg}])	*assert_notmatch()*
+assert_notmatch({pattern}, {actual} [, {msg}])               *assert_notmatch()*
 		The opposite of `assert_match()`: add an error message to
 		|v:errors| when {pattern} matches {actual}.
 		Also see |assert-return|.
@@ -346,7 +346,7 @@ assert_notmatch({pattern}, {actual} [, {msg}])	*assert_notmatch()*
 			getFile()->assert_notmatch('bar.*')
 <
 
-assert_report({msg})				*assert_report()*
+assert_report({msg})                                           *assert_report()*
 		Report a test failure directly, using String {msg}.
 		Always returns one.
 
@@ -354,7 +354,7 @@ assert_report({msg})				*assert_report()*
 			GetMessage()->assert_report()
 <
 
-assert_true({actual} [, {msg}])			*assert_true()*
+assert_true({actual} [, {msg}])                                  *assert_true()*
 		When {actual} is not true an error message is added to
 		|v:errors|, like with |assert_equal()|.
 		Also see |assert-return|.
@@ -366,7 +366,7 @@ assert_true({actual} [, {msg}])			*assert_true()*
 			GetResult()->assert_true()
 <
 
-atan({expr})							*atan()*
+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|.
@@ -381,7 +381,7 @@ atan({expr})							*atan()*
 			Compute()->atan()
 <
 
-atan2({expr1}, {expr2})					*atan2()*
+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|.
@@ -397,7 +397,7 @@ atan2({expr1}, {expr2})					*atan2()*
 			Compute()->atan2(1)
 <
 
-blob2list({blob})					*blob2list()*
+blob2list({blob})                                                  *blob2list()*
 		Return a List containing the number value of each byte in Blob
 		{blob}.  Examples: >vim
 			blob2list(0z0102.0304)	" returns [1, 2, 3, 4]
@@ -409,7 +409,7 @@ blob2list({blob})					*blob2list()*
 			GetBlob()->blob2list()
 <
 
-browse({save}, {title}, {initdir}, {default})		*browse()*
+browse({save}, {title}, {initdir}, {default})                         *browse()*
 		Put up a file requester.  This only works when "has("browse")"
 		returns |TRUE| (only in some GUI versions).
 		The input fields are:
@@ -420,7 +420,7 @@ browse({save}, {title}, {initdir}, {default})		*browse()*
 		An empty string is returned when the "Cancel" button is hit,
 		something went wrong, or browsing is not possible.
 
-browsedir({title}, {initdir})				*browsedir()*
+browsedir({title}, {initdir})                                      *browsedir()*
 		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
@@ -432,7 +432,7 @@ browsedir({title}, {initdir})				*browsedir()*
 		When the "Cancel" button is hit, something went wrong, or
 		browsing is not possible, an empty string is returned.
 
-bufadd({name})						*bufadd()*
+bufadd({name})                                                        *bufadd()*
 		Add a buffer to the buffer list with name {name} (must be a
 		String).
 		If a buffer for file {name} already exists, return that buffer
@@ -449,7 +449,7 @@ bufadd({name})						*bufadd()*
 			let bufnr = 'somename'->bufadd()
 <
 
-bufexists({buf})					*bufexists()*
+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.
@@ -475,7 +475,7 @@ bufexists({buf})					*bufexists()*
 			let exists = 'somename'->bufexists()
 <
 
-buflisted({buf})					*buflisted()*
+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()|.
@@ -484,7 +484,7 @@ buflisted({buf})					*buflisted()*
 			let listed = 'somename'->buflisted()
 <
 
-bufload({buf})						*bufload()*
+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
@@ -498,7 +498,7 @@ bufload({buf})						*bufload()*
 			eval 'somename'->bufload()
 <
 
-bufloaded({buf})					*bufloaded()*
+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()|.
@@ -507,7 +507,7 @@ bufloaded({buf})					*bufloaded()*
 			let loaded = 'somename'->bufloaded()
 <
 
-bufname([{buf}])						*bufname()*
+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]".
@@ -541,7 +541,7 @@ bufname([{buf}])						*bufname()*
 			echo bufname("file2")	" name of buffer where "file2" matches.
 <
 
-bufnr([{buf} [, {create}]])					*bufnr()*
+bufnr([{buf} [, {create}]])                                            *bufnr()*
 		The result is the number of a buffer, as it is displayed by
 		the `:ls` command.  For the use of {buf}, see |bufname()|
 		above.
@@ -559,7 +559,7 @@ bufnr([{buf} [, {create}]])					*bufnr()*
 			echo bufref->bufnr()
 <
 
-bufwinid({buf})						*bufwinid()*
+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
@@ -574,7 +574,7 @@ bufwinid({buf})						*bufwinid()*
 			FindBuffer()->bufwinid()
 <
 
-bufwinnr({buf})						*bufwinnr()*
+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
@@ -589,7 +589,7 @@ bufwinnr({buf})						*bufwinnr()*
 			FindBuffer()->bufwinnr()
 <
 
-byte2line({byte})					*byte2line()*
+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
@@ -603,7 +603,7 @@ byte2line({byte})					*byte2line()*
 			GetOffset()->byte2line()
 <
 
-byteidx({expr}, {nr} [, {utf16}])				*byteidx()*
+byteidx({expr}, {nr} [, {utf16}])                                    *byteidx()*
 		Return byte index of the {nr}th character in the String
 		{expr}.  Use zero for the first character, it then returns
 		zero.
@@ -642,7 +642,7 @@ byteidx({expr}, {nr} [, {utf16}])				*byteidx()*
 			GetName()->byteidx(idx)
 <
 
-byteidxcomp({expr}, {nr} [, {utf16}])			*byteidxcomp()*
+byteidxcomp({expr}, {nr} [, {utf16}])                            *byteidxcomp()*
 		Like byteidx(), except that a composing character is counted
 		as a separate character.  Example: >vim
 			let s = 'e' .. nr2char(0x301)
@@ -657,7 +657,7 @@ byteidxcomp({expr}, {nr} [, {utf16}])			*byteidxcomp()*
 			GetName()->byteidxcomp(idx)
 <
 
-call({func}, {arglist} [, {dict}])			*call()* *E699*
+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.
@@ -670,7 +670,7 @@ call({func}, {arglist} [, {dict}])			*call()* *E699*
 			GetFunc()->call([arg, arg], dict)
 <
 
-ceil({expr})							*ceil()*
+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|.
@@ -688,7 +688,7 @@ ceil({expr})							*ceil()*
 			Compute()->ceil()
 <
 
-chanclose({id} [, {stream}])				*chanclose()*
+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
@@ -698,7 +698,7 @@ chanclose({id} [, {stream}])				*chanclose()*
 		For a socket, there is only one stream, and {stream} should be
 		omitted.
 
-changenr()						*changenr()*
+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.
@@ -707,7 +707,7 @@ changenr()						*changenr()*
 		one less than the number of the undone change.
 		Returns 0 if the undo list is empty.
 
-chansend({id}, {data})					*chansend()*
+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
@@ -725,7 +725,7 @@ chansend({id}, {data})					*chansend()*
 		was created with `"rpc":v:true` then the channel expects RPC
 		messages, use |rpcnotify()| and |rpcrequest()| instead.
 
-char2nr({string} [, {utf8}])				*char2nr()*
+char2nr({string} [, {utf8}])                                         *char2nr()*
 		Return Number value of the first char in {string}.
 		Examples: >vim
 			echo char2nr(" ")		" returns 32
@@ -744,7 +744,7 @@ char2nr({string} [, {utf8}])				*char2nr()*
 			GetChar()->char2nr()
 <
 
-charclass({string})					*charclass()*
+charclass({string})                                                *charclass()*
 		Return the character class of the first character in {string}.
 		The character class is one of:
 			0	blank
@@ -755,7 +755,7 @@ charclass({string})					*charclass()*
 		The class is used in patterns and word motions.
 		Returns 0 if {string} is not a |String|.
 
-charcol({expr} [, {winid}])				*charcol()*
+charcol({expr} [, {winid}])                                          *charcol()*
 		Same as |col()| but returns the character index of the column
 		position given with {expr} instead of the byte position.
 
@@ -768,7 +768,7 @@ charcol({expr} [, {winid}])				*charcol()*
 			GetPos()->col()
 <
 
-charidx({string}, {idx} [, {countcc} [, {utf16}]])	*charidx()*
+charidx({string}, {idx} [, {countcc} [, {utf16}]])                   *charidx()*
 		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
@@ -805,7 +805,7 @@ charidx({string}, {idx} [, {countcc} [, {utf16}]])	*charidx()*
 			GetName()->charidx(idx)
 <
 
-chdir({dir})						*chdir()*
+chdir({dir})                                                           *chdir()*
 		Change the current working directory to {dir}.  The scope of
 		the directory change depends on the directory of the current
 		window:
@@ -831,7 +831,7 @@ chdir({dir})						*chdir()*
 			GetDir()->chdir()
 <
 
-cindent({lnum})						*cindent()*
+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
@@ -843,7 +843,7 @@ cindent({lnum})						*cindent()*
 			GetLnum()->cindent()
 <
 
-clearmatches([{win}])				*clearmatches()*
+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
@@ -853,7 +853,7 @@ clearmatches([{win}])				*clearmatches()*
 			GetWin()->clearmatches()
 <
 
-col({expr} [, {winid}])					*col()*
+col({expr} [, {winid}])                                                  *col()*
 		The result is a Number, which is the byte index of the column
 		position given with {expr}.  The accepted positions are:
 		    .	    the cursor position
@@ -895,7 +895,7 @@ col({expr} [, {winid}])					*col()*
 			GetPos()->col()
 <
 
-complete({startcol}, {matches})			*complete()* *E785*
+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
@@ -930,7 +930,7 @@ complete({startcol}, {matches})			*complete()* *E785*
 			GetMatches()->complete(col('.'))
 <
 
-complete_add({expr})					*complete_add()*
+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),
@@ -943,7 +943,7 @@ complete_add({expr})					*complete_add()*
 			GetMoreMatches()->complete_add()
 <
 
-complete_check()					*complete_check()*
+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,
@@ -951,7 +951,7 @@ complete_check()					*complete_check()*
 		Only to be used by the function specified with the
 		'completefunc' option.
 
-complete_info([{what}])				*complete_info()*
+complete_info([{what}])                                        *complete_info()*
 		Returns a |Dictionary| with information about Insert mode
 		completion.  See |ins-completion|.
 		The items are:
@@ -1013,7 +1013,7 @@ complete_info([{what}])				*complete_info()*
 			GetItems()->complete_info()
 <
 
-confirm({msg} [, {choices} [, {default} [, {type}]]])	*confirm()*
+confirm({msg} [, {choices} [, {default} [, {type}]]])                *confirm()*
 		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.
@@ -1069,7 +1069,7 @@ confirm({msg} [, {choices} [, {default} [, {type}]]])	*confirm()*
 			BuildMessage()->confirm("&Yes\n&No")
 <
 
-copy({expr})							*copy()*
+copy({expr})                                                            *copy()*
 		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
@@ -1082,7 +1082,7 @@ copy({expr})							*copy()*
 			mylist->copy()
 <
 
-cos({expr})							*cos()*
+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|.
@@ -1096,7 +1096,7 @@ cos({expr})							*cos()*
 			Compute()->cos()
 <
 
-cosh({expr})							*cosh()*
+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|.
@@ -1111,7 +1111,7 @@ cosh({expr})							*cosh()*
 			Compute()->cosh()
 <
 
-count({comp}, {expr} [, {ic} [, {start}]])			*count()*
+count({comp}, {expr} [, {ic} [, {start}]])                             *count()*
 		Return the number of times an item with value {expr} appears
 		in |String|, |List| or |Dictionary| {comp}.
 
@@ -1128,33 +1128,33 @@ count({comp}, {expr} [, {ic} [, {start}]])			*count()*
 			mylist->count(val)
 <
 
-ctxget([{index}])						*ctxget()*
+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()*
+ctxpop()                                                              *ctxpop()*
 		Pops and restores the |context| at the top of the
 		|context-stack|.
 
-ctxpush([{types}])					*ctxpush()*
+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()*
+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()*
+ctxsize()                                                            *ctxsize()*
 		Returns the size of the |context-stack|.
 
 cursor({lnum}, {col} [, {off}])
-cursor({list})						*cursor()*
+cursor({list})                                                        *cursor()*
 		Positions the cursor at the column (byte count) {col} in the
 		line {lnum}.  The first column is one.
 
@@ -1190,7 +1190,7 @@ cursor({list})						*cursor()*
 			GetCursorPos()->cursor()
 <
 
-debugbreak({pid})					*debugbreak()*
+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-debug|.
@@ -1203,7 +1203,7 @@ debugbreak({pid})					*debugbreak()*
 			GetPid()->debugbreak()
 <
 
-deepcopy({expr} [, {noref}])			*deepcopy()* *E698*
+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
@@ -1227,7 +1227,7 @@ deepcopy({expr} [, {noref}])			*deepcopy()* *E698*
 			GetObject()->deepcopy()
 <
 
-delete({fname} [, {flags}])				*delete()*
+delete({fname} [, {flags}])                                           *delete()*
 		Without {flags} or with {flags} empty: Deletes the file by the
 		name {fname}.
 
@@ -1250,7 +1250,7 @@ delete({fname} [, {flags}])				*delete()*
 			GetName()->delete()
 <
 
-deletebufline({buf}, {first} [, {last}])		*deletebufline()*
+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.
@@ -1268,7 +1268,7 @@ deletebufline({buf}, {first} [, {last}])		*deletebufline()*
 			GetBuffer()->deletebufline(1)
 <
 
-dictwatcheradd({dict}, {pattern}, {callback})	*dictwatcheradd()*
+dictwatcheradd({dict}, {pattern}, {callback})                 *dictwatcheradd()*
 		Adds a watcher to a dictionary. A dictionary watcher is
 		identified by three components:
 
@@ -1308,12 +1308,12 @@ dictwatcheradd({dict}, {pattern}, {callback})	*dictwatcheradd()*
 		This function can be used by plugins to implement options with
 		validation and parsing logic.
 
-dictwatcherdel({dict}, {pattern}, {callback})	*dictwatcherdel()*
+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()*
+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
@@ -1325,7 +1325,7 @@ did_filetype()					*did_filetype()*
 		editing another buffer to set 'filetype' and load a syntax
 		file.
 
-diff_filler({lnum})					*diff_filler()*
+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
@@ -1338,7 +1338,7 @@ diff_filler({lnum})					*diff_filler()*
 			GetLnum()->diff_filler()
 <
 
-diff_hlID({lnum}, {col})				*diff_hlID()*
+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.
@@ -1353,7 +1353,7 @@ diff_hlID({lnum}, {col})				*diff_hlID()*
 			GetLnum()->diff_hlID(col)
 <
 
-digraph_get({chars})				*digraph_get()* *E1214*
+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
@@ -1373,7 +1373,7 @@ digraph_get({chars})				*digraph_get()* *E1214*
 			GetChars()->digraph_get()
 <
 
-digraph_getlist([{listall}])			*digraph_getlist()*
+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.
@@ -1391,7 +1391,7 @@ digraph_getlist([{listall}])			*digraph_getlist()*
 			GetNumber()->digraph_getlist()
 <
 
-digraph_set({chars}, {digraph})			*digraph_set()*
+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*
@@ -1412,7 +1412,7 @@ digraph_set({chars}, {digraph})			*digraph_set()*
 			GetString()->digraph_set('あ')
 <
 
-digraph_setlist({digraphlist})			*digraph_setlist()*
+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
@@ -1431,7 +1431,7 @@ digraph_setlist({digraphlist})			*digraph_setlist()*
 		    GetList()->digraph_setlist()
 <
 
-empty({expr})						*empty()*
+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.
@@ -1444,7 +1444,7 @@ empty({expr})						*empty()*
 			mylist->empty()
 <
 
-environ()							*environ()*
+environ()                                                            *environ()*
 		Return all of environment variables as dictionary. You can
 		check if an environment variable exists like this: >vim
 			echo has_key(environ(), 'HOME')
@@ -1453,7 +1453,7 @@ environ()							*environ()*
 			echo index(keys(environ()), 'HOME', 0, 1) != -1
 <
 
-escape({string}, {chars})					*escape()*
+escape({string}, {chars})                                             *escape()*
 		Escape the characters in {chars} that occur in {string} with a
 		backslash.  Example: >vim
 			echo escape('c:\program files\vim', ' \')
@@ -1465,7 +1465,7 @@ escape({string}, {chars})					*escape()*
 			GetText()->escape(' \')
 <
 
-eval({string})						*eval()*
+eval({string})                                                          *eval()*
 		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
@@ -1476,13 +1476,13 @@ eval({string})						*eval()*
 			argv->join()->eval()
 <
 
-eventhandler()					*eventhandler()*
+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()*
+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.
@@ -1509,7 +1509,7 @@ executable({expr})					*executable()*
 			GetCommand()->executable()
 <
 
-execute({command} [, {silent}])				*execute()*
+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.
@@ -1541,7 +1541,7 @@ execute({command} [, {silent}])				*execute()*
 			GetCommand()->execute()
 <
 
-exepath({expr})						*exepath()*
+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.
@@ -1551,7 +1551,7 @@ exepath({expr})						*exepath()*
 			GetCommand()->exepath()
 <
 
-exists({expr})						*exists()*
+exists({expr})                                                        *exists()*
 		The result is a Number, which is |TRUE| if {expr} is
 		defined, zero otherwise.
 
@@ -1643,7 +1643,7 @@ exists({expr})						*exists()*
 			Varname()->exists()
 <
 
-exp({expr})							*exp()*
+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|.
@@ -1658,7 +1658,7 @@ exp({expr})							*exp()*
 			Compute()->exp()
 <
 
-expand({string} [, {nosuf} [, {list}]])			*expand()*
+expand({string} [, {nosuf} [, {list}]])                               *expand()*
 		Expand wildcards and the following special keywords in
 		{string}.  'wildignorecase' applies.
 
@@ -1753,7 +1753,7 @@ expand({string} [, {nosuf} [, {list}]])			*expand()*
 			Getpattern()->expand()
 <
 
-expandcmd({string} [, {options}])			*expandcmd()*
+expandcmd({string} [, {options}])                                  *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
@@ -1780,7 +1780,7 @@ expandcmd({string} [, {options}])			*expandcmd()*
 			GetCommand()->expandcmd()
 <
 
-extend({expr1}, {expr2} [, {expr3}])			*extend()*
+extend({expr1}, {expr2} [, {expr3}])                                  *extend()*
 		{expr1} and {expr2} must be both |Lists| or both
 		|Dictionaries|.
 
@@ -1820,12 +1820,12 @@ extend({expr1}, {expr2} [, {expr3}])			*extend()*
 			mylist->extend(otherlist)
 <
 
-extendnew({expr1}, {expr2} [, {expr3}])			*extendnew()*
+extendnew({expr1}, {expr2} [, {expr3}])                            *extendnew()*
 		Like |extend()| but instead of adding items to {expr1} a new
 		List or Dictionary is created and returned.  {expr1} remains
 		unchanged.
 
-feedkeys({string} [, {mode}])				*feedkeys()*
+feedkeys({string} [, {mode}])                                       *feedkeys()*
 		Characters in {string} are queued for processing as if they
 		come from a mapping or were typed by the user.
 
@@ -1874,7 +1874,7 @@ feedkeys({string} [, {mode}])				*feedkeys()*
 			GetInput()->feedkeys()
 <
 
-filereadable({file})					*filereadable()*
+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
@@ -1895,7 +1895,7 @@ filereadable({file})					*filereadable()*
 			GetName()->filereadable()</