diff --git a/runtime/autoload/dist/ft.vim b/runtime/autoload/dist/ft.vim
index 6a3c5e1..bfc325d 100644
--- a/runtime/autoload/dist/ft.vim
+++ b/runtime/autoload/dist/ft.vim
@@ -3,7 +3,7 @@
 # Vim functions for file type detection
 #
 # Maintainer:	Bram Moolenaar <Bram@vim.org>
-# Last Change:	2022 Nov 24
+# Last Change:	2022 Dec 14
 
 # These functions are moved here from runtime/filetype.vim to make startup
 # faster.
diff --git a/runtime/doc/autocmd.txt b/runtime/doc/autocmd.txt
index 5acf733..73506cc 100644
--- a/runtime/doc/autocmd.txt
+++ b/runtime/doc/autocmd.txt
@@ -1,4 +1,4 @@
-*autocmd.txt*   For Vim version 9.0.  Last change: 2022 Nov 22
+*autocmd.txt*   For Vim version 9.0.  Last change: 2022 Dec 12
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -97,7 +97,7 @@
 and in a `:def` function) then {cmd} will be executed as in Vim9
 script.  Thus this depends on where the autocmd is defined, not where it is
 triggered.
-
+							*:autocmd-block*
 {cmd} can be a block, like with `:command`, see |:command-repl|.  Example: >
 	au BufReadPost *.xml {
 		  setlocal matchpairs+=<:>
diff --git a/runtime/doc/builtin.txt b/runtime/doc/builtin.txt
index 05e8d70..ea3ce61 100644
--- a/runtime/doc/builtin.txt
+++ b/runtime/doc/builtin.txt
@@ -1,4 +1,4 @@
-*builtin.txt*	For Vim version 9.0.  Last change: 2022 Dec 05
+*builtin.txt*	For Vim version 9.0.  Last change: 2022 Dec 23
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -4137,7 +4137,7 @@
 				this script name links to, if any, otherwise
 				zero
 		    variables   A dictionary with the script-local variables.
-				Present only when the a particular script is
+				Present only when a particular script is
 				specified using the "sid" item in {opts}.
 				Note that this is a copy, the value of
 				script-local variables cannot be changed using
@@ -9113,6 +9113,8 @@
 			Blob		0z00112233.44556677.8899
 			List		[item, item]
 			Dictionary	{key: value, key: value}
+			Class		class SomeName
+			Object		object of SomeName {lnum: 1, col: 3}
 
 		When a |List| or |Dictionary| has a recursive reference it is
 		replaced by "[...]" or "{...}".  Using eval() on the result
diff --git a/runtime/doc/diff.txt b/runtime/doc/diff.txt
index 1c93de4..2c1233b 100644
--- a/runtime/doc/diff.txt
+++ b/runtime/doc/diff.txt
@@ -1,4 +1,4 @@
-*diff.txt*      For Vim version 9.0.  Last change: 2022 Oct 01
+*diff.txt*      For Vim version 9.0.  Last change: 2022 Dec 24
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -148,6 +148,10 @@
 	'foldmethod'	"manual"
 	'foldcolumn'	0
 
+'foldenable' will most-likely be reset to off.  That is when 'foldmethod' is
+is restored to "manual".  The folds themselves are not cleared but they should
+not show up, resetting 'foldenable' is the best way to do that.
+
 ==============================================================================
 2. Viewing diffs						*view-diffs*
 
diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt
index 87fd2cf..dc6e16b 100644
--- a/runtime/doc/options.txt
+++ b/runtime/doc/options.txt
@@ -1,4 +1,4 @@
-*options.txt*	For Vim version 9.0.  Last change: 2022 Dec 09
+*options.txt*	For Vim version 9.0.  Last change: 2022 Dec 31
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -34,6 +34,8 @@
 			key codes are not shown, because they are generated
 			internally and can't be changed.  Changing the terminal
 			codes in the GUI is not useful either...
+			The options have the form t_AB, see
+			|terminal-options|.
 
 :se[t]! termcap		Idem, but don't use multiple columns.
 
@@ -1249,7 +1251,7 @@
 		\ ' on word "' .. v:beval_text .. '"'
     endfunction
     set bexpr=MyBalloonExpr()
-    set ballooneval
+    set ballooneval balloonevalterm
 <
 	Also see |balloon_show()|, it can be used if the content of the balloon
 	is to be fetched asynchronously.  In that case evaluating
@@ -4936,6 +4938,12 @@
 			    CSI ?u	request kitty keyboard protocol state
 			    CSI >c	request the termresponse
 
+	If you notice problems, such as characters being displayed that
+	disappear after `CTRL-L`, you might want to try making this option
+	empty.  Then set the 'term' option to have it take effect: >
+		set keyprotocol=
+		let &term = &term
+
 
 					*'keywordprg'* *'kp'*
 'keywordprg' 'kp'	string	(default "man" or "man -s",  DOS: ":help",
@@ -7112,7 +7120,7 @@
 						*'shortmess'* *'shm'*
 'shortmess' 'shm'	string	(Vim default "filnxtToOS", Vi default: "S",
 							POSIX default: "AS")
-			global
+			global					*E1336*
 	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.
 	It is a list of flags:
@@ -7127,30 +7135,30 @@
 		and "[a]" instead of "appended" for ':w >> file' command
 	  x	use "[dos]" instead of "[dos format]", "[unix]"		*shm-x*
 		instead of "[unix format]" and "[mac]" instead of "[mac
-		format]".
+		format]"
 	  a	all of the above abbreviations				*shm-a*
 
 	  o	overwrite message for writing a file with subsequent	*shm-o*
 		message for reading a file (useful for ":wn" or when
 		'autowrite' on)
-	  O	message for reading a file overwrites any previous	*smh-O*
-		message.  Also for quickfix message (e.g., ":cn").
+	  O	message for reading a file overwrites any previous	*shm-O*
+		message;  also for quickfix message (e.g., ":cn")
 	  s	don't give "search hit BOTTOM, continuing at TOP" or	*shm-s*
 		"search hit TOP, continuing at BOTTOM" messages; when using
 		the search count do not show "W" after the count message (see
 		S below)
 	  t	truncate file message at the start if it is too long	*shm-t*
 		to fit on the command-line, "<" will appear in the left most
-		column.  Ignored in Ex mode.
+		column; ignored in Ex mode
 	  T	truncate other messages in the middle if they are too	*shm-T*
-		long to fit on the command line.  "..." will appear in the
-		middle.  Ignored in Ex mode.
+		long to fit on the command line; "..." will appear in the
+		middle; ignored in Ex mode
 	  W	don't give "written" or "[w]" when writing a file	*shm-W*
 	  A	don't give the "ATTENTION" message when an existing	*shm-A*
-		swap file is found.
+		swap file is found
 	  I	don't give the intro message when starting Vim,		*shm-I*
-	  	see |:intro|.
-	  c	don't give |ins-completion-menu| messages.  For		*shm-c*
+	  	see |:intro|
+	  c	don't give |ins-completion-menu| messages; for		*shm-c*
 		example, "-- XXX completion (YYY)", "match 1 of 2", "The only
 		match", "Pattern not found", "Back at original", etc.
 	  C	don't give messages while scanning for ins-completion	*shm-C*
@@ -7227,11 +7235,12 @@
 
 			*'showcmdloc'* *'sloc'*
 'showcmdloc' 'sloc'	string	(default "last")
+			global
 	This option can be used to display the (partially) entered command in
 	another location.  Possible values are:
 	  last		Last line of the screen (default).
 	  statusline	Status line of the current window.
-	  tabline	First line of the screen if 'showtabine' is enabled.
+	  tabline	First line of the screen if 'showtabline' is enabled.
 	Setting this option to "statusline" or "tabline" means that these will
 	be redrawn whenever the command changes, which can be on every key
 	pressed.
diff --git a/runtime/doc/quickref.txt b/runtime/doc/quickref.txt
index ff508b5..ffdfd10 100644
--- a/runtime/doc/quickref.txt
+++ b/runtime/doc/quickref.txt
@@ -1,4 +1,4 @@
-*quickref.txt*  For Vim version 9.0.  Last change: 2022 Nov 23
+*quickref.txt*  For Vim version 9.0.  Last change: 2022 Dec 16
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -902,7 +902,8 @@
 'shortmess'	  'shm'     list of flags, reduce length of messages
 'shortname'	  'sn'	    Filenames assumed to be 8.3 chars
 'showbreak'	  'sbr'     string to use at the start of wrapped lines
-'showcmd'	  'sc'	    show (partial) command in status line
+'showcmd'	  'sc'	    show (partial) command somewhere
+'showcmdloc'	  'sloc'    where to show (partial) command
 'showfulltag'	  'sft'     show full tag pattern when completing tag
 'showmatch'	  'sm'	    briefly jump to matching bracket if insert one
 'showmode'	  'smd'     message on status line to show current mode
diff --git a/runtime/doc/sign.txt b/runtime/doc/sign.txt
index c366ae5..c698499 100644
--- a/runtime/doc/sign.txt
+++ b/runtime/doc/sign.txt
@@ -1,4 +1,4 @@
-*sign.txt*      For Vim version 9.0.  Last change: 2021 Dec 05
+*sign.txt*      For Vim version 9.0.  Last change: 2022 Dec 20
 
 
 		  VIM REFERENCE MANUAL    by Gordon Prieur
@@ -625,9 +625,9 @@
 				then a new unique identifier is allocated.
 				Otherwise the specified number is used. See
 				|sign-identifier| for more information.
-		    lnum	line number in the buffer {expr} where the
-				sign is to be placed. For the accepted values,
-				see |line()|.
+		    lnum	line number in the buffer where the sign is to
+				be placed. For the accepted values, see
+				|line()|.
 		    name	name of the sign to place. See |sign_define()|
 		    		for more information.
 		    priority	priority of the sign. When multiple signs are
diff --git a/runtime/doc/syntax.txt b/runtime/doc/syntax.txt
index cd3dbca..27c65da 100644
--- a/runtime/doc/syntax.txt
+++ b/runtime/doc/syntax.txt
@@ -1,4 +1,4 @@
-*syntax.txt*	For Vim version 9.0.  Last change: 2022 Nov 24
+*syntax.txt*	For Vim version 9.0.  Last change: 2022 Dec 26
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -5003,7 +5003,7 @@
 
 						*highlight-clear* *:hi-clear*
 :hi[ghlight] clear	Reset all highlighting to the defaults.  Removes all
-			highlighting for groups added by the user!
+			highlighting for groups added by the user.
 			Uses the current value of 'background' to decide which
 			default colors to use.
 			If there was a default link, restore it. |:hi-link|
diff --git a/runtime/doc/tags b/runtime/doc/tags
index 9178c77..66dd96a 100644
--- a/runtime/doc/tags
+++ b/runtime/doc/tags
@@ -438,10 +438,8 @@
 'keymap'	options.txt	/*'keymap'*
 'keymodel'	options.txt	/*'keymodel'*
 'keyprotocol'	options.txt	/*'keyprotocol'*
-'keywordprg'	options.txt	/*'keywordprg'*
 'km'	options.txt	/*'km'*
 'kmp'	options.txt	/*'kmp'*
-'kp'	options.txt	/*'kp'*
 'kpc'	options.txt	/*'kpc'*
 'langmap'	options.txt	/*'langmap'*
 'langmenu'	options.txt	/*'langmenu'*
@@ -926,6 +924,7 @@
 'shortname'	options.txt	/*'shortname'*
 'showbreak'	options.txt	/*'showbreak'*
 'showcmd'	options.txt	/*'showcmd'*
+'showcmdloc'	options.txt	/*'showcmdloc'*
 'showfulltag'	options.txt	/*'showfulltag'*
 'showmatch'	options.txt	/*'showmatch'*
 'showmode'	options.txt	/*'showmode'*
@@ -938,6 +937,7 @@
 'siso'	options.txt	/*'siso'*
 'sj'	options.txt	/*'sj'*
 'slm'	options.txt	/*'slm'*
+'sloc'	options.txt	/*'sloc'*
 'slow'	vi_diff.txt	/*'slow'*
 'slowopen'	vi_diff.txt	/*'slowopen'*
 'sm'	options.txt	/*'sm'*
@@ -2201,6 +2201,7 @@
 :aun	gui.txt	/*:aun*
 :aunmenu	gui.txt	/*:aunmenu*
 :autocmd	autocmd.txt	/*:autocmd*
+:autocmd-block	autocmd.txt	/*:autocmd-block*
 :autocmd-verbose	autocmd.txt	/*:autocmd-verbose*
 :b	windows.txt	/*:b*
 :bN	windows.txt	/*:bN*
@@ -3017,6 +3018,7 @@
 :pts	tagsrch.txt	/*:pts*
 :ptselect	tagsrch.txt	/*:ptselect*
 :pu	change.txt	/*:pu*
+:public	vim9class.txt	/*:public*
 :put	change.txt	/*:put*
 :pw	editing.txt	/*:pw*
 :pwd	editing.txt	/*:pwd*
@@ -4383,7 +4385,19 @@
 E1325	vim9class.txt	/*E1325*
 E1326	vim9class.txt	/*E1326*
 E1327	vim9class.txt	/*E1327*
+E1328	vim9class.txt	/*E1328*
+E1329	vim9class.txt	/*E1329*
 E133	userfunc.txt	/*E133*
+E1330	vim9class.txt	/*E1330*
+E1331	vim9class.txt	/*E1331*
+E1332	vim9class.txt	/*E1332*
+E1333	vim9class.txt	/*E1333*
+E1334	vim9class.txt	/*E1334*
+E1335	vim9class.txt	/*E1335*
+E1336	options.txt	/*E1336*
+E1337	vim9class.txt	/*E1337*
+E1338	vim9class.txt	/*E1338*
+E1339	textprop.txt	/*E1339*
 E134	change.txt	/*E134*
 E135	autocmd.txt	/*E135*
 E136	starting.txt	/*E136*
@@ -8200,6 +8214,7 @@
 keys()	builtin.txt	/*keys()*
 keytrans()	builtin.txt	/*keytrans()*
 kitty-keyboard-protocol	map.txt	/*kitty-keyboard-protocol*
+kitty-terminal	term.txt	/*kitty-terminal*
 known-bugs	todo.txt	/*known-bugs*
 l	motion.txt	/*l*
 l:	eval.txt	/*l:*
@@ -9575,6 +9590,7 @@
 shm-C	options.txt	/*shm-C*
 shm-F	options.txt	/*shm-F*
 shm-I	options.txt	/*shm-I*
+shm-O	options.txt	/*shm-O*
 shm-S	options.txt	/*shm-S*
 shm-T	options.txt	/*shm-T*
 shm-W	options.txt	/*shm-W*
@@ -9630,7 +9646,6 @@
 slow-fast-terminal	term.txt	/*slow-fast-terminal*
 slow-start	starting.txt	/*slow-start*
 slow-terminal	term.txt	/*slow-terminal*
-smh-O	options.txt	/*smh-O*
 socket-interface	channel.txt	/*socket-interface*
 sort()	builtin.txt	/*sort()*
 sorting	change.txt	/*sorting*
@@ -10312,6 +10327,7 @@
 test_getvalue()	testing.txt	/*test_getvalue()*
 test_gui_event()	testing.txt	/*test_gui_event()*
 test_ignore_error()	testing.txt	/*test_ignore_error()*
+test_mswin_event()	testing.txt	/*test_mswin_event()*
 test_null_blob()	testing.txt	/*test_null_blob()*
 test_null_channel()	testing.txt	/*test_null_channel()*
 test_null_dict()	testing.txt	/*test_null_dict()*
@@ -11068,6 +11084,7 @@
 xterm-end-home-keys	term.txt	/*xterm-end-home-keys*
 xterm-focus-event	term.txt	/*xterm-focus-event*
 xterm-function-keys	term.txt	/*xterm-function-keys*
+xterm-kitty	term.txt	/*xterm-kitty*
 xterm-modifier-keys	term.txt	/*xterm-modifier-keys*
 xterm-mouse	options.txt	/*xterm-mouse*
 xterm-mouse-wheel	scroll.txt	/*xterm-mouse-wheel*
@@ -11076,6 +11093,7 @@
 xterm-screens	tips.txt	/*xterm-screens*
 xterm-scroll-region	term.txt	/*xterm-scroll-region*
 xterm-shifted-keys	term.txt	/*xterm-shifted-keys*
+xterm-terminfo-entries	term.txt	/*xterm-terminfo-entries*
 xterm-true-color	term.txt	/*xterm-true-color*
 y	change.txt	/*y*
 yaml.vim	syntax.txt	/*yaml.vim*
diff --git a/runtime/doc/term.txt b/runtime/doc/term.txt
index 146ef47..f519bed 100644
--- a/runtime/doc/term.txt
+++ b/runtime/doc/term.txt
@@ -1,4 +1,4 @@
-*term.txt*      For Vim version 9.0.  Last change: 2022 Dec 01
+*term.txt*      For Vim version 9.0.  Last change: 2022 Dec 31
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -88,7 +88,8 @@
 
 Note: When 't_ti' is not empty, Vim assumes that it causes switching to the
 alternate screen.  This may slightly change what happens when executing a
-shell command or exiting Vim.  To avoid this use 't_TI' and 't_TE'.
+shell command or exiting Vim.  To avoid this use 't_TI' and 't_TE' (but make
+sure to add to them, not overwrite).
 
 Vim will try to detect what keyboard protocol the terminal is using with the
 't_RK' termcap entry.  This is sent after 't_TI', but only when there is no
@@ -126,7 +127,11 @@
 	  exec "set t_PS=\e[200~"
 	  exec "set t_PE=\e[201~"
 	endif
-<
+
+The terminfo entries "BE", "BD", "PS" and "PE" were added in ncurses version
+6.4, early 2023, for some terminals.  If you have this version then you may
+not have to manually configure your terminal.
+
 							*tmux-integration*
 If you experience issues when running Vim inside tmux, here are a few hints.
 You can comment-out parts if something doesn't work (it may depend on the
@@ -294,13 +299,32 @@
 starts with CSI, it assumes that the terminal is in 8-bit mode and will
 convert all key sequences to their 8-bit variants.
 
+						*xterm-terminfo-entries*
+For some time the terminfo entries were insufficient to describe all the
+features tht Vim can use.  The builtin xterm termcap entries did have these,
+with the result that several terminals that were similar enough to xterm took
+advantage of these by prefixing "xterm-" to the terminal name in $TERM.
+
+This leads to problems, because quite often these terminals are not 100%
+compatible with xterm.  At the start of 2023 several entries have been added
+to the terminfo database to make it possible to use these features without
+using the "xterm" workaround.  These are the relevant entries (so far):
+
+	name	xterm value	description ~
+	RV	"\033[>c"	Request version |t_RV|
+
+	BE	"\033[?2004h"	enable bracketed paste mode |t_BE|
+	BD	"\033[?2004l"	disable bracketed paste mode |t_BD|
+	PS	"\033[200~"	pasted text start |t_PS|
+	PE	"\033[201~"	pasted text end |t_PE|
+
 						*xterm-kitty* *kitty-terminal*
-The Kitty terminal is a special case.  Mainly because it works different from
-most other terminals, but also because, instead of trying the fit in and make
-it behave like other terminals by default, it dictates how applications need
-to work when using Kitty.  This makes it very difficult for Vim to work in a
-Kitty terminal.  Some exceptions have been hard coded, but it is not at all
-nice to have to make exceptions for one specific terminal.
+The Kitty terminal is a special case.  Mainly because it works differently
+from most other terminals, but also because, instead of trying the fit in and
+make it behave like other terminals by default, it dictates how applications
+need to work when using Kitty.  This makes it very difficult for Vim to work
+in a Kitty terminal.  Some exceptions have been hard coded, but it is not at
+all nice to have to make exceptions for one specific terminal.
 
 One of the problems is that the value for $TERM is set to "xterm-kitty".  For
 Vim this is an indication that the terminal is xterm-compatible and the
@@ -448,10 +472,10 @@
 	t_Si	save icon text to stack				*t_Si* *'t_Si'*
 	t_Ri	restore icon text from stack			*t_Ri* *'t_Ri'*
 	t_TE	end of "raw" mode				*t_TE* *'t_TE'*
-	t_TI	put terminal into "raw" mode 			*t_TI* *'t_TI'*
-	t_fe	enable focus-event tracking 			*t_fe* *'t_fe'*
+	t_TI	put terminal into "raw" mode			*t_TI* *'t_TI'*
+	t_fe	enable focus-event tracking			*t_fe* *'t_fe'*
 		|xterm-focus-event|
-	t_fd	disable focus-event tracking 			*t_fd* *'t_fd'*
+	t_fd	disable focus-event tracking			*t_fd* *'t_fd'*
 		|xterm-focus-event|
 
 Some codes have a start, middle and end part.  The start and end are defined
@@ -461,8 +485,8 @@
 	set cursor color:   t_SC  {color name}  t_EC
 
 t_SH must take one argument:
-	0, 1 or none  	blinking block cursor
-	2	      	block cursor
+	0, 1 or none	blinking block cursor
+	2		block cursor
 	3		blinking underline cursor
 	4		underline cursor
 	5		blinking vertical bar cursor
@@ -531,6 +555,7 @@
 	t_%1	<Help>		help key			*t_%1* *'t_%1'*
 	t_&8	<Undo>		undo key			*t_&8* *'t_&8'*
 	t_kI	<Insert>	insert key			*t_kI* *'t_kI'*
+		<kInsert>	keypad insert key
 	t_kD	<Del>		delete key			*t_kD* *'t_kD'*
 	t_kb	<BS>		backspace key			*t_kb* *'t_kb'*
 	t_kB	<S-Tab>		back-tab (shift-tab)  *<S-Tab>*	*t_kB* *'t_kB'*
@@ -563,9 +588,13 @@
 	t_KK	<k8>		keypad 8		 *<k8>*	*t_KK* *'t_KK'*
 	t_KL	<k9>		keypad 9		 *<k9>*	*t_KL* *'t_KL'*
 		<Mouse>		leader of mouse code		*<Mouse>*
-								*t_PS* *'t_PS'*
-	t_PS	start of bracketed paste |xterm-bracketed-paste|
-	t_PE	end of bracketed paste |xterm-bracketed-paste|  *t_PE* *'t_PE'*
+
+	t_PS	<PasteStart>	start of bracketed paste	*t_PS* *'t_PS'*
+				|xterm-bracketed-paste|
+	t_PE	<PasteEnd>	end of bracketed paste		*t_PE* *'t_PE'*
+				|xterm-bracketed-paste|
+		<FocusGained>	Vim window got focus (internal only)
+		<FocusLost>	Vim window lost focus (internal only)
 
 Note about t_so and t_mr: When the termcap entry "so" is not present the
 entry for "mr" is used.  And vice versa.  The same is done for "se" and "me".
@@ -604,12 +633,15 @@
 See https://github.com/termstandard/colors for a list of terminals that
 support true colors.
 
-Sometimes setting 'termguicolors' is not enough and one has to set the |t_8f|
-and |t_8b| options explicitly. Default values of these options are
-"^[[38;2;%lu;%lu;%lum" and "^[[48;2;%lu;%lu;%lum" respectively, but it is only
-set when `$TERM` is `xterm`. Some terminals accept the same sequences, but
-with all semicolons replaced by colons (this is actually more compatible, but
-less widely supported): >
+For telling the terminal what RGB color to use the |t_8f| and |t_8b| termcap
+entries are used.  These are set by default to values that work for most
+terminals.  If that does not work for your terminal you can set them manually.
+The default values are set like this: >
+	 let &t_8f = "\<Esc>[38;2;%lu;%lu;%lum"
+	 let &t_8b = "\<Esc>[48;2;%lu;%lu;%lum"
+
+Some terminals accept the same sequences, but with all semicolons replaced by
+colons (this is actually more compatible, but less widely supported): >
 	 let &t_8f = "\<Esc>[38:2:%lu:%lu:%lum"
 	 let &t_8b = "\<Esc>[48:2:%lu:%lu:%lum"
 
@@ -627,7 +659,7 @@
 To overrule the default, put this line in your ~/.Xdefaults or
 ~/.Xresources:
 >
-	XTerm*allowWindowOps: 		true
+	XTerm*allowWindowOps:		true
 
 And run "xrdb -merge .Xresources" to make it effective.  You can check the
 value with the context menu (right mouse button while CTRL key is pressed),
diff --git a/runtime/doc/testing.txt b/runtime/doc/testing.txt
index 089e61f..beef79d 100644
--- a/runtime/doc/testing.txt
+++ b/runtime/doc/testing.txt
@@ -1,4 +1,4 @@
-*testing.txt*	For Vim version 9.0.  Last change: 2022 Nov 28
+*testing.txt*	For Vim version 9.0.  Last change: 2022 Dec 30
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
diff --git a/runtime/doc/textprop.txt b/runtime/doc/textprop.txt
index 086742a..c6178c3 100644
--- a/runtime/doc/textprop.txt
+++ b/runtime/doc/textprop.txt
@@ -1,4 +1,4 @@
-*textprop.txt*  For Vim version 9.0.  Last change: 2022 Nov 18
+*textprop.txt*  For Vim version 9.0.  Last change: 2022 Dec 19
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -220,10 +220,16 @@
 		Any Tab and other control character in the text will be
 		changed to a space (Rationale: otherwise the size of the text
 		is difficult to compute).
-		A negative "id" will be chosen and is returned.  Once a
-		property with "text" has been added for a buffer then using a
-		negative "id" for any other property will give an error:
-		*E1293*
+		A negative "id" will be chosen and is returned.
+
+		Before text properties with text were supported it was
+		possible to use a negative "id", even though this was very
+		rare.  Now that negative "id"s are reserved for text
+		properties with text an error is given when using a negative
+		"id".  When a text property with text already exists using a
+		negative "id" results in *E1293* .  If a negative "id" was
+		used and later a text property with text is added results in
+		*E1339* .
 
 		Can also be used as a |method|: >
 			GetLnum()->prop_add(col, props)
diff --git a/runtime/doc/todo.txt b/runtime/doc/todo.txt
index 4474632..c7fefa6 100644
--- a/runtime/doc/todo.txt
+++ b/runtime/doc/todo.txt
@@ -1,4 +1,4 @@
-*todo.txt*      For Vim version 9.0.  Last change: 2022 Dec 11
+*todo.txt*      For Vim version 9.0.  Last change: 2022 Dec 31
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -54,13 +54,19 @@
 
 Further Vim9 improvements, possibly after launch:
 - implement :class and :interface: See |vim9-classes|  #11544
-    make default constructor use "this.member = void"
-    make public / default read access / private work for members.
-    string value of class and object in echo_string_core()
-    object empty(), len() - can class define a method?
+    class members: add test for read/write access
+	Test for E1337
+    Should object members be declared with "var"?  Looks more normal.
+    Don't use "class method" in the help but use "class function", more people
+    are used to that.
+    implement class functions: static def Method()
+    Disallow shadowing class members, e.g. by function arguments.
     tv_equal() should compare values, not identity.
+    import/export of a class
+    using a class name as a type
     garbage collection: set_ref_in_item(): Mark items in class as used ?
     type() should return different type for each class?
+    object empty(), len() - can class define a method to be used for them?
     how about lock/unlock?
 - implement :type
 - implement :enum
@@ -70,6 +76,56 @@
     has(featureName), len(someString)
 - Implement as part of an expression: ++expr, --expr, expr++, expr--.
 
+Information missing in terminfo:
+Priority:
+- t_RV	request terminal version string; xterm:	"\033[>c"
+Codes used for focus gained and lost (currently using use_xterm_like_mouse())
+  termcodes are hard-coded in set_termname(), not named.
+- t_fe	enable focus-event tracking
+- t_fd	disable focus-event tracking
+Underline and similar:
+- t_AU - Set underline color: like "AF" and "AB" entries.
+- t_Ce	undercurl and underline end
+- t_Cs	undercurl (curly underline) mode
+- t_Us	double underline mode
+- t_ds	dotted underline mode
+- t_Ds	dashed underline mode
+- t_Te	strikethrough end
+- t_Ts	strikethrough mode
+Cursor codes: |termcap-cursor-shape|
+- t_RC	request terminal cursor blinking
+- t_RS	request terminal cursor style
+- t_VS	cursor normally visible (no blink)
+- t_SI	start insert mode (bar cursor shape)
+- t_SR	start replace mode (underline cursor shape)
+- t_EI	end insert or replace mode (block cursor shape)
+- t_SC	set cursor color start
+- t_EC	set cursor color end
+- t_SH	set cursor shape
+State requests:
+- t_RF	request terminal foreground color
+- t_RB	request terminal background color
+Less important (not needed for regular editing):
+- t_IS	set icon text start
+- t_IE	set icon text end
+- t_ST	save window title to stack
+- t_RT	restore window title from stack
+- t_Si	save icon text to stack
+- t_Ri	restore icon text from stack
+- t_WP	set window position (Y, X) in pixels
+- t_GP	get window position (Y, X) in pixels
+- t_WS	set window size (height, width in cells)
+Vim internal, but there should be a terminfo entry for these:
+- t_8f	set foreground color (R, G, B) in printf() format
+- t_8b	set background color (R, G, B) in printf() format
+- t_8u	set underline color (R, G, B) in printf() format
+Probably Vim internal, not in terminfo:
+- t_TE	end of "raw" mode
+- t_TI	put terminal into "raw" mode
+- t_RK	request terminal keyboard protocol state; sent after |t_TI|
+Already working, not properly documented:
+- t_u7	request cursor position
+
 Popup windows:
 - Add a function to redraw a specific popup window.  Esp. to be used when
   editing the command line, when screen updating doesn't happen. (Shougo)
@@ -177,6 +233,10 @@
 - When 'encoding' is not utf-8, or the job is using another encoding, setup
   conversions.
 
+Patch adds showcmd() function  #11708  - tests missing StopVimInTerminal()
+
+Some setaf/setab/t_AF/t_AB values support RGB somehow?  Can we use that?
+
 Crash when a variable is removed while listing variables (Issue #11435)
 
 Autoconf: must use autoconf 2.69, later version generates lots of warnings
@@ -212,6 +272,12 @@
 
 PR #11579 to add visualtext(), return Visually selected text.
 
+Stray characters in the shell #11719, caused by requesting a response for:
+- XT key sequences
+- Whether modifyOtherKeys is active
+- Whether kitty keyboard protocol is active
+Can we not request XT key sequences, or reduce them drastically?
+
 Issue #10512: Dynamic loading broken with Perl 5.36
 Damien has a patch (2022 Dec 4)
 
@@ -426,6 +492,10 @@
 Using "au!" after "filetype on" is a bit slow.  Can the matching of
 autocommands be made faster?  (#7056)
 
+Using a search pattern containing "\%V" and 'hlsearch' set keeps old matches
+when the Visual area changes.  #11694.  Do a redraw when starting a Visual
+selection?
+
 Append in Visual block mode inserts the wrong character.
 Test_visual_block_mode() already has the proper check, which is commented out.
 (#8288)
diff --git a/runtime/doc/usr_41.txt b/runtime/doc/usr_41.txt
index c67bd99..5597077 100644
--- a/runtime/doc/usr_41.txt
+++ b/runtime/doc/usr_41.txt
@@ -1,4 +1,4 @@
-*usr_41.txt*	For Vim version 9.0.  Last change: 2022 Dec 05
+*usr_41.txt*	For Vim version 9.0.  Last change: 2022 Dec 20
 
 		     VIM USER MANUAL - by Bram Moolenaar
 
diff --git a/runtime/doc/various.txt b/runtime/doc/various.txt
index a88f318..a11e166 100644
--- a/runtime/doc/various.txt
+++ b/runtime/doc/various.txt
@@ -1,4 +1,4 @@
-*various.txt*   For Vim version 9.0.  Last change: 2022 Nov 04
+*various.txt*   For Vim version 9.0.  Last change: 2022 Dec 13
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -496,7 +496,7 @@
 T  *+vreplace*		|gR| and |gr|
    *+vtp*		on MS-Windows console: support for 'termguicolors'
 T  *+wildignore*	|'wildignore'|  Always enabled since 9.0.0278
-T  *+wildmenu*		|'wildmenu'||  Always enabled since 9.0.0279
+T  *+wildmenu*		|'wildmenu'|  Always enabled since 9.0.0279
 T  *+windows*		more than one window; Always enabled since 8.0.1118.
 m  *+writebackup*	|'writebackup'| is default on
 m  *+xim*		X input method |xim|
diff --git a/runtime/doc/vim9class.txt b/runtime/doc/vim9class.txt
index 4dc84f3..cabe55b 100644
--- a/runtime/doc/vim9class.txt
+++ b/runtime/doc/vim9class.txt
@@ -1,4 +1,4 @@
-*vim9class.txt*	For Vim version 9.0.  Last change: 2022 Dec 11
+*vim9class.txt*	For Vim version 9.0.  Last change: 2022 Dec 20
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -117,7 +117,7 @@
 Now try to change an object member directly: >
 
 	pos.lnum = 9
-
+<								*E1335*
 This will give you an error!  That is because by default object members can be
 read but not set.  That's why the class provides a method for it: >
 
@@ -128,7 +128,7 @@
 have side effects that need to be taken care of.  In this case, the SetLnum()
 method could check if the line number is valid and either give an error or use
 the closest valid value.
-
+						*:public* *E1331*
 If you don't care about side effects and want to allow the object member to be
 changed at any time, you can make it public: >
 
@@ -137,10 +137,14 @@
 
 Now you don't need the SetLnum(), SetCol() and SetPosition() methods, setting
 "pos.lnum" directly above will no longer give an error.
+							*E1334*
+If you try to set an object member that doesn't exist you get an error: >
+	pos.other = 9
+<	E1334: Object member not found: other ~
 
 
 Private members ~
-
+							*E1332* *E1333*
 On the other hand, if you do not want the object members to be read directly,
 you can make them private.  This is done by prefixing an underscore to the
 name: >
@@ -245,7 +249,7 @@
 	   enddef
 	endclass
 <
-						*class-member* *:static*
+					*class-member* *:static* *E1337* *E1338*
 Class members are declared with "static".  They are used by the name without a
 prefix: >
 
@@ -389,6 +393,17 @@
   	def newName(arguments)
 - An object method: >
   	def SomeMethod(arguments)
+<							*E1329*
+For the object member the type must be specified.  The best way is to do this
+explicitly with ": {type}".  For simple types you can also use an initializer,
+such as "= 123", and Vim will see that the type is a number.  Avoid doing this
+for more complex types and when the type will be incomplete.  For example: >
+	this.nameList = []
+This specifies a list, but the item type is unknown.  Better use: >
+	this.nameList: list<string>
+The initialization isn't needed, the list is empty by default.
+							*E1330*
+Some types cannot be used, such as "void", "null" and "v:none".
 
 
 Defining an interface ~
diff --git a/runtime/filetype.vim b/runtime/filetype.vim
index 3ace157..c659de8 100644
--- a/runtime/filetype.vim
+++ b/runtime/filetype.vim
@@ -1,7 +1,7 @@
 " Vim support file to detect file types
 "
 " Maintainer:	Bram Moolenaar <Bram@vim.org>
-" Last Change:	2022 Dec 05
+" Last Change:	2022 Dec 19
 
 " Listen very carefully, I will say this only once
 if exists("did_load_filetypes")
diff --git a/runtime/indent/nginx.vim b/runtime/indent/nginx.vim
index 8cef766..6550609 100644
--- a/runtime/indent/nginx.vim
+++ b/runtime/indent/nginx.vim
@@ -1,19 +1,78 @@
 " Vim indent file
 " Language: nginx.conf
 " Maintainer: Chris Aumann <me@chr4.org>
-" Last Change:  2022 Apr 06
+" Last Change:  2022 Dec 01
 
-if exists("b:did_indent")
-    finish
+" Only load this indent file when no other was loaded.
+if exists('b:did_indent')
+  finish
 endif
 let b:did_indent = 1
 
-setlocal indentexpr=
+setlocal indentexpr=GetNginxIndent()
 
-" cindent actually works for nginx' simple file structure
-setlocal cindent
+setlocal indentkeys=0{,0},0#,!^F,o,O
 
-" Just make sure that the comments are not reset as defs would be.
-setlocal cinkeys-=0#
+let b:undo_indent = 'setl inde< indk<'
 
-let b:undo_indent = "setl inde< cin< cink<"
+" Only define the function once.
+if exists('*GetNginxIndent')
+  finish
+endif
+
+function GetNginxIndent() abort
+  let plnum = s:PrevNotAsBlank(v:lnum - 1)
+
+  " Hit the start of the file, use zero indent.
+  if plnum == 0
+    return 0
+  endif
+
+  let ind = indent(plnum)
+
+  " Add a 'shiftwidth' after '{'
+  if s:AsEndWith(getline(plnum), '{')
+    let ind = ind + shiftwidth()
+  end
+
+  " Subtract a 'shiftwidth' on '}'
+  " This is the part that requires 'indentkeys'.
+  if getline(v:lnum) =~ '^\s*}'
+    let ind = ind - shiftwidth()
+  endif
+
+  let pplnum = s:PrevNotAsBlank(plnum - 1)
+
+  if s:IsLineContinuation(plnum)
+    if !s:IsLineContinuation(pplnum)
+      let ind = ind + shiftwidth()
+    end
+  else
+    if s:IsLineContinuation(pplnum)
+      let ind = ind - shiftwidth()
+    end
+  endif
+
+  return ind
+endfunction
+
+" Find the first line at or above {lnum} that is non-blank and not a comment.
+function s:PrevNotAsBlank(lnum) abort
+  let lnum = prevnonblank(a:lnum)
+  while lnum > 0
+    if getline(lnum) !~ '^\s*#'
+      break
+    endif
+    let lnum = prevnonblank(lnum - 1)
+  endwhile
+  return lnum
+endfunction
+
+" Check whether {line} ends with {pat}, ignoring trailing comments.
+function s:AsEndWith(line, pat) abort
+  return a:line =~ a:pat . '\m\s*\%(#.*\)\?$'
+endfunction
+
+function s:IsLineContinuation(lnum) abort
+  return a:lnum > 0 && !s:AsEndWith(getline(a:lnum), '[;{}]')
+endfunction
diff --git a/runtime/indent/testdir/vb.in b/runtime/indent/testdir/vb.in
new file mode 100644
index 0000000..1653ae6
--- /dev/null
+++ b/runtime/indent/testdir/vb.in
@@ -0,0 +1,134 @@
+' vim: filetype=vb shiftwidth=4 expandtab
+'
+' START_INDENT
+Public Type GEmployeeRecord     ' Create user-defined type. 
+ID As Integer               ' Define elements of data type. 
+Name As String * 20 
+Address As String * 30 
+Phone As Long 
+HireDate As Date 
+End Type 
+
+Public Enum InterfaceColors 
+icMistyRose = &HE1E4FF& 
+icSlateGray = &H908070& 
+icDodgerBlue = &HFF901E& 
+icDeepSkyBlue = &HFFBF00& 
+icSpringGreen = &H7FFF00& 
+icForestGreen = &H228B22& 
+icGoldenrod = &H20A5DA& 
+icFirebrick = &H2222B2& 
+End Enum
+
+Enum SecurityLevel 
+IllegalEntry = -1 
+SecurityLevel1 = 0 
+SecurityLevel2 = 1 
+End Enum 
+
+Public Function TestConditional (number As Integer, ext As String) As Boolean
+Dim inRange As Boolean
+
+Select Case number
+Case <= 0
+inRange = False
+Case > 10
+inRange = False
+Case Else
+inRange = True
+End Select
+
+' This is a special case identified in the indent script.
+Select Case number
+End Select
+
+If ext = ".xlm" Then
+If inRange Then
+TestConditional = True
+Else
+TestConditional = False
+End If
+ElseIf ext = ".xlsx" Then
+If inRange Then
+TestConditional = False
+Else
+TestConditional = True
+End If
+Else
+TestConditional = False
+End If
+End Function
+
+Private Sub TestIterators (lLimit As Integer, uLimit As Integer)
+Dim a() As Variant
+Dim elmt As Variant
+Dim found As Boolean
+Dim indx As Integer
+Const specialValue As Integer = 5
+
+If uLimit < lLimit Then
+Exit Sub
+End If
+
+ReDim a(lLimit To uLimit)
+For indx=lLimit To Ulimit
+a(indx) = 2 * indx
+Next indx
+
+found = False
+For Each elmt in a
+If elmt = specialValue Then
+found = True
+End If
+Next elmt
+
+If found then
+indx = uLimit
+Do While indx >= lLimit
+indx = indx - 1
+Loop
+End If
+
+End Sub
+
+Public Sub TestMultiline (cellAddr As String, rowNbr As Long)
+Dim rng As Range
+
+Set rng = Range(cellAddr)
+With rng
+.Cells(1,1).Value = _
+"Line 1 of multiline string; " & _
+"Line 2 of multiline string; " & _
+"Line 3 of multiline string"
+End With
+
+' The following lines have whitespace after the underscore character
+' and therefore do not form a valid multiline statement.  The indent
+' script correctly treats them as four single line statements contrary
+' to the author's obvious indent.
+rng..Cells(1,1).Value = _ 
+"Line 1 of multiline string; " & _ 
+"Line 2 of multiline string; " & _ 
+"Line 3 of multiline string"
+
+End Sub
+
+Private Sub TestStmtLabel()
+GoTo stmtLabel
+
+' Statement labels are never indented
+stmtLabel:
+
+End Sub
+
+Sub TestTypeKeyword()
+Type EmployeeRecord         ' Create user-defined type. 
+ID As Integer           ' Define elements of data type. 
+Name As String * 20 
+Address As String * 30 
+Phone As Long 
+HireDate As Date 
+End Type 
+Dim varType As EmployeeRecord
+End Sub
+' END_INDENT
diff --git a/runtime/indent/testdir/vb.ok b/runtime/indent/testdir/vb.ok
new file mode 100644
index 0000000..143c688
--- /dev/null
+++ b/runtime/indent/testdir/vb.ok
@@ -0,0 +1,134 @@
+' vim: filetype=vb shiftwidth=4 expandtab
+'
+' START_INDENT
+Public Type GEmployeeRecord     ' Create user-defined type. 
+    ID As Integer               ' Define elements of data type. 
+    Name As String * 20 
+    Address As String * 30 
+    Phone As Long 
+    HireDate As Date 
+End Type 
+
+Public Enum InterfaceColors 
+    icMistyRose = &HE1E4FF& 
+    icSlateGray = &H908070& 
+    icDodgerBlue = &HFF901E& 
+    icDeepSkyBlue = &HFFBF00& 
+    icSpringGreen = &H7FFF00& 
+    icForestGreen = &H228B22& 
+    icGoldenrod = &H20A5DA& 
+    icFirebrick = &H2222B2& 
+End Enum
+
+Enum SecurityLevel 
+    IllegalEntry = -1 
+    SecurityLevel1 = 0 
+    SecurityLevel2 = 1 
+End Enum 
+
+Public Function TestConditional (number As Integer, ext As String) As Boolean
+    Dim inRange As Boolean
+
+    Select Case number
+        Case <= 0
+            inRange = False
+        Case > 10
+            inRange = False
+        Case Else
+            inRange = True
+    End Select
+
+    ' This is a special case identified in the indent script.
+    Select Case number
+    End Select
+
+    If ext = ".xlm" Then
+        If inRange Then
+            TestConditional = True
+        Else
+            TestConditional = False
+        End If
+    ElseIf ext = ".xlsx" Then
+        If inRange Then
+            TestConditional = False
+        Else
+            TestConditional = True
+        End If
+    Else
+        TestConditional = False
+    End If
+End Function
+
+Private Sub TestIterators (lLimit As Integer, uLimit As Integer)
+    Dim a() As Variant
+    Dim elmt As Variant
+    Dim found As Boolean
+    Dim indx As Integer
+    Const specialValue As Integer = 5
+
+    If uLimit < lLimit Then
+        Exit Sub
+    End If
+
+    ReDim a(lLimit To uLimit)
+    For indx=lLimit To Ulimit
+        a(indx) = 2 * indx
+    Next indx
+
+    found = False
+    For Each elmt in a
+        If elmt = specialValue Then
+            found = True
+        End If
+    Next elmt
+
+    If found then
+        indx = uLimit
+        Do While indx >= lLimit
+            indx = indx - 1
+        Loop
+    End If
+
+End Sub
+
+Public Sub TestMultiline (cellAddr As String, rowNbr As Long)
+    Dim rng As Range
+
+    Set rng = Range(cellAddr)
+    With rng
+        .Cells(1,1).Value = _
+            "Line 1 of multiline string; " & _
+            "Line 2 of multiline string; " & _
+            "Line 3 of multiline string"
+    End With
+
+    ' The following lines have whitespace after the underscore character
+    ' and therefore do not form a valid multiline statement.  The indent
+    ' script correctly treats them as four single line statements contrary
+    ' to the author's obvious indent.
+    rng..Cells(1,1).Value = _ 
+    "Line 1 of multiline string; " & _ 
+    "Line 2 of multiline string; " & _ 
+    "Line 3 of multiline string"
+
+End Sub
+
+Private Sub TestStmtLabel()
+    GoTo stmtLabel
+
+    ' Statement labels are never indented
+stmtLabel:
+
+End Sub
+
+Sub TestTypeKeyword()
+    Type EmployeeRecord         ' Create user-defined type. 
+        ID As Integer           ' Define elements of data type. 
+        Name As String * 20 
+        Address As String * 30 
+        Phone As Long 
+        HireDate As Date 
+    End Type 
+    Dim varType As EmployeeRecord
+End Sub
+' END_INDENT
diff --git a/runtime/indent/vb.vim b/runtime/indent/vb.vim
index 4d05345..bc7142f 100644
--- a/runtime/indent/vb.vim
+++ b/runtime/indent/vb.vim
@@ -1,8 +1,12 @@
 " Vim indent file
 " Language:	VisualBasic (ft=vb) / Basic (ft=basic) / SaxBasic (ft=vb)
 " Author:	Johannes Zellner <johannes@zellner.org>
+" Maintainer:	Michael Soyka (mssr953@gmail.com)
 " Last Change:	Fri, 18 Jun 2004 07:22:42 CEST
 "		Small update 2010 Jul 28 by Maxim Kim
+"		2022/12/15: add support for multiline statements.
+"		2022/12/21: move VbGetIndent from global to script-local scope
+"		2022/12/26: recognize "Type" keyword
 
 if exists("b:did_indent")
     finish
@@ -10,28 +14,33 @@
 let b:did_indent = 1
 
 setlocal autoindent
-setlocal indentexpr=VbGetIndent(v:lnum)
+setlocal indentexpr=s:VbGetIndent(v:lnum)
 setlocal indentkeys&
-setlocal indentkeys+==~else,=~elseif,=~end,=~wend,=~case,=~next,=~select,=~loop,<:>
+setlocal indentkeys+==~else,=~elseif,=~end,=~wend,=~case,=~next,=~select,=~loop
 
 let b:undo_indent = "set ai< indentexpr< indentkeys<"
 
 " Only define the function once.
-if exists("*VbGetIndent")
+if exists("*s:VbGetIndent")
     finish
 endif
 
-fun! VbGetIndent(lnum)
+function s:VbGetIndent(lnum)
+    let this_lnum = a:lnum
+    let this_line = getline(this_lnum)
+
     " labels and preprocessor get zero indent immediately
-    let this_line = getline(a:lnum)
     let LABELS_OR_PREPROC = '^\s*\(\<\k\+\>:\s*$\|#.*\)'
     if this_line =~? LABELS_OR_PREPROC
 	return 0
     endif
+    
+    " Get the current value of "shiftwidth"
+    let bShiftwidth = shiftwidth()
 
     " Find a non-blank line above the current line.
     " Skip over labels and preprocessor directives.
-    let lnum = a:lnum
+    let lnum = this_lnum
     while lnum > 0
 	let lnum = prevnonblank(lnum - 1)
 	let previous_line = getline(lnum)
@@ -45,34 +54,102 @@
 	return 0
     endif
 
-    let ind = indent(lnum)
+    " Variable "previous_line" now contains the text in buffer line "lnum".
+
+    " Multi-line statements have the underscore character at end-of-line:
+    "
+    "    object.method(arguments, _
+    "                  arguments, _
+    "                  arguments)
+    "
+    " and require extra logic to determine the correct indentation.
+    "
+    " Case 1: Line "lnum" is the first line of a multiline statement.
+    "         Line "lnum" will have a trailing underscore character
+    "         but the preceding non-blank line does not.
+    "         Line "this_lnum" will be indented relative to "lnum".
+    "
+    " Case 2: Line "lnum" is the last line of a multiline statement.
+    "         Line "lnum" will not have a trailing underscore character
+    "         but the preceding non-blank line will.
+    "         Line "this_lnum" will have the same indentation as the starting
+    "         line of the multiline statement.
+    "
+    " Case 3: Line "lnum" is neither the first nor last line.  
+    "         Lines "lnum" and "lnum-1" will have a trailing underscore
+    "         character.
+    "         Line "this_lnum" will have the same indentation as the preceding
+    "         line.
+    "
+    " No matter which case it is, the starting line of the statement must be
+    " found.  It will be assumed that multiline statements cannot have
+    " intermingled comments, statement labels, preprocessor directives or
+    " blank lines.
+    "
+    let lnum_is_continued = (previous_line =~ '_$')
+    if lnum > 1
+	let before_lnum = prevnonblank(lnum-1)
+	let before_previous_line = getline(before_lnum)
+    else
+	let before_lnum = 0
+	let before_previous_line = ""
+    endif
+
+    if before_previous_line !~ '_$'
+	" Variable "previous_line" contains the start of a statement.
+	"
+	let ind = indent(lnum)
+	if lnum_is_continued
+	    let ind += bShiftwidth
+	endif
+    elseif ! lnum_is_continued
+	" Line "lnum" contains the last line of a multiline statement.
+        " Need to find where this multiline statement begins
+	"
+	while before_lnum > 0
+	    let before_lnum -= 1
+	    if getline(before_lnum) !~ '_$'
+		let before_lnum += 1
+		break
+	    endif
+	endwhile
+	if before_lnum == 0
+	    let before_lnum = 1
+	endif
+	let previous_line = getline(before_lnum)
+	let ind = indent(before_lnum)
+    else
+	" Line "lnum" is not the first or last line of a multiline statement.
+	"
+	let ind = indent(lnum)
+    endif
 
     " Add
-    if previous_line =~? '^\s*\<\(begin\|\%(\%(private\|public\|friend\)\s\+\)\=\%(function\|sub\|property\)\|select\|case\|default\|if\|else\|elseif\|do\|for\|while\|enum\|with\)\>'
-	let ind = ind + shiftwidth()
+    if previous_line =~? '^\s*\<\(begin\|\%(\%(private\|public\|friend\)\s\+\)\=\%(function\|sub\|property\|enum\|type\)\|select\|case\|default\|if\|else\|elseif\|do\|for\|while\|with\)\>'
+	let ind = ind + bShiftwidth
     endif
 
     " Subtract
     if this_line =~? '^\s*\<end\>\s\+\<select\>'
 	if previous_line !~? '^\s*\<select\>'
-	    let ind = ind - 2 * shiftwidth()
+	    let ind = ind - 2 * bShiftwidth
 	else
 	    " this case is for an empty 'select' -- 'end select'
 	    " (w/o any case statements) like:
 	    "
 	    " select case readwrite
 	    " end select
-	    let ind = ind - shiftwidth()
+	    let ind = ind - bShiftwidth
 	endif
     elseif this_line =~? '^\s*\<\(end\|else\|elseif\|until\|loop\|next\|wend\)\>'
-	let ind = ind - shiftwidth()
+	let ind = ind - bShiftwidth
     elseif this_line =~? '^\s*\<\(case\|default\)\>'
 	if previous_line !~? '^\s*\<select\>'
-	    let ind = ind - shiftwidth()
+	    let ind = ind - bShiftwidth
 	endif
     endif
 
     return ind
-endfun
+endfunction
 
 " vim:sw=4
diff --git a/runtime/indent/vue.vim b/runtime/indent/vue.vim
index 7ff623b..f6fe350 100644
--- a/runtime/indent/vue.vim
+++ b/runtime/indent/vue.vim
@@ -1,12 +1,14 @@
 " Vim indent file placeholder
 " Language:	Vue
 " Maintainer:	None, please volunteer if you have a real Vue indent script
+" Last Change:	2022 Dec 24
 
 " Only load this indent file when no other was loaded.
 if exists("b:did_indent")
    finish
 endif
-let b:did_indent = 1
+" don't set b:did_indent, otherwise html indenting won't be activated
+" let b:did_indent = 1
 
 " Html comes closest
 runtime! indent/html.vim
diff --git a/runtime/optwin.vim b/runtime/optwin.vim
index bfef518..ed31b67 100644
--- a/runtime/optwin.vim
+++ b/runtime/optwin.vim
@@ -1,7 +1,7 @@
 " These commands create the option window.
 "
 " Maintainer:	Bram Moolenaar <Bram@vim.org>
-" Last Change:	2022 Nov 23
+" Last Change:	2022 Dec 16
 
 " If there already is an option window, jump to that one.
 let buf = bufnr('option-window')
@@ -743,10 +743,12 @@
 call <SID>BinOptionG("terse", &terse)
 call <SID>AddOption("shortmess", gettext("list of flags to make messages shorter"))
 call <SID>OptionG("shm", &shm)
-call <SID>AddOption("showcmd", gettext("show (partial) command keys in the status line"))
+call <SID>AddOption("showcmd", gettext("show (partial) command keys in location given by 'showcmdloc'"))
 let &sc = s:old_sc
 call <SID>BinOptionG("sc", &sc)
 set nosc
+call <SID>AddOption("showcmdloc", gettext("location where to show the (partial) command keys for 'showcmd'"))
+  call <SID>OptionG("sloc", &sloc)
 call <SID>AddOption("showmode", gettext("display the current mode in the status line"))
 call <SID>BinOptionG("smd", &smd)
 call <SID>AddOption("ruler", gettext("show cursor position below each window"))
diff --git a/runtime/syntax/2html.vim b/runtime/syntax/2html.vim
index 32f7eef..b5ebfbd 100644
--- a/runtime/syntax/2html.vim
+++ b/runtime/syntax/2html.vim
@@ -1,6 +1,6 @@
 " Vim syntax support file
 " Maintainer: Ben Fritz <fritzophrenic@gmail.com>
-" Last Change: 2020 Jan 05
+" Last Change: 2022 Dec 26
 "
 " Additional contributors:
 "
@@ -1881,7 +1881,7 @@
   endif
 endif
 
-if !s:settings.use_css && !s:settings_no_doc
+if !s:settings.use_css && !s:settings.no_doc
   " For Netscape 4, set <body> attributes too, though, strictly speaking, it's
   " incorrect.
   execute '%s:<body\([^>]*\):<body bgcolor="' . s:bgc . '" text="' . s:fgc . '"\1>\r<font face="'. s:htmlfont .'"'
diff --git a/runtime/syntax/fstab.vim b/runtime/syntax/fstab.vim
index 6a3c375..7e18c26 100644
--- a/runtime/syntax/fstab.vim
+++ b/runtime/syntax/fstab.vim
@@ -2,8 +2,8 @@
 " Language: fstab file
 " Maintainer: Radu Dineiu <radu.dineiu@gmail.com>
 " URL: https://raw.github.com/rid9/vim-fstab/master/syntax/fstab.vim
-" Last Change: 2022 Dec 10
-" Version: 1.5
+" Last Change: 2022 Dec 11
+" Version: 1.6.2
 "
 " Credits:
 "   David Necas (Yeti) <yeti@physics.muni.cz>
@@ -56,7 +56,7 @@
 " Type
 syn cluster fsTypeCluster contains=fsTypeKeyword,fsTypeUnknown
 syn match fsTypeUnknown /\s\+\zs\w\+/ contained
-syn keyword fsTypeKeyword contained adfs ados affs anon_inodefs atfs audiofs auto autofs bdev befs bfs btrfs binfmt_misc cd9660 ceph cfs cgroup cifs coda coherent configfs cpuset cramfs debugfs devfs devpts devtmpfs dlmfs e2compr ecryptfs efivarfs efs erofs exfat ext2 ext2fs ext3 ext4 f2fs fdesc ffs filecore fuse fuseblk fusectl gfs2 hfs hfsplus hpfs hugetlbfs iso9660 jffs jffs2 jfs kernfs lfs linprocfs mfs minix mqueue msdos ncpfs nfs nfs4 nfsd nilfs2 none ntfs ntfs3 null nwfs ocfs2 omfs overlay ovlfs pipefs portal proc procfs pstore ptyfs pvfs2 qnx4 qnx6 reiserfs ramfs romfs securityfs shm smbfs spufs squashfs sockfs sshfs std subfs swap sysfs sysv tcfs tmpfs ubifs udf ufs umap umsdos union usbfs userfs v9fs vfat virtiofs vs3fs vxfs wrapfs wvfs xenfs xenix xfs zisofs zonefs
+syn keyword fsTypeKeyword contained adfs ados affs anon_inodefs atfs audiofs auto autofs bdev befs bfs btrfs binfmt_misc cd9660 ceph cfs cgroup cifs coda coherent configfs cpuset cramfs debugfs devfs devpts devtmpfs dlmfs e2compr ecryptfs efivarfs efs erofs exfat ext2 ext2fs ext3 ext4 f2fs fdesc ffs filecore fuse fuseblk fusectl gfs2 hfs hfsplus hpfs hugetlbfs iso9660 jffs jffs2 jfs kernfs lfs linprocfs mfs minix mqueue msdos ncpfs nfs nfs4 nfsd nilfs2 none ntfs ntfs3 null nwfs ocfs2 omfs overlay ovlfs pipefs portal proc procfs pstore ptyfs pvfs2 qnx4 qnx6 reiserfs ramfs romfs rpc_pipefs securityfs shm smbfs spufs squashfs sockfs sshfs std subfs swap sysfs sysv tcfs tmpfs ubifs udf ufs umap umsdos union usbfs userfs v9fs vfat virtiofs vs3fs vxfs wrapfs wvfs xenfs xenix xfs zisofs zonefs
 
 " Options
 " -------
@@ -72,9 +72,13 @@
 syn keyword fsOptions01 0 1
 syn cluster fsOptionsCheckCluster contains=fsOptionsExt2Check,fsOptionsFatCheck
 syn keyword fsOptionsSize 512 1024 2048
-syn keyword fsOptionsGeneral async atime auto bind current defaults dev devgid devmode devmtime devuid dirsync exec force fstab kudzu loop mand move noatime noauto noclusterr noclusterw nodev nodevmtime nodiratime noexec nomand norelatime nosuid nosymfollow nouser owner rbind rdonly relatime remount ro rq rw suid suiddir supermount sw sync union update user users wxallowed xx nofail failok
+syn keyword fsOptionsGeneral async atime auto bind current defaults dev devgid devmode devmtime devuid dirsync exec force fstab kudzu loop managed mand move noatime noauto noclusterr noclusterw nodev nodevmtime nodiratime noexec nomand norelatime nosuid nosymfollow nouser owner pamconsole rbind rdonly relatime remount ro rq rw suid suiddir supermount sw sync union update user users wxallowed xx nofail failok lazytime
 syn match fsOptionsGeneral /_netdev/
 
+syn match fsOptionsKeywords contained /\<x-systemd\.\%(requires\|before\|after\|wanted-by\|required-by\|requires-mounts-for\|idle-timeout\|device-timeout\|mount-timeout\)=/ nextgroup=fsOptionsString
+syn match fsOptionsKeywords contained /\<x-systemd\.\%(device-bound\|automount\|makefs\|growfs\|rw-only\)/
+syn match fsOptionsKeywords contained /\<x-initrd\.mount/
+
 syn match fsOptionsKeywords contained /\<cache=/ nextgroup=fsOptionsCache
 syn keyword fsOptionsCache yes no none strict loose fscache mmap
 
diff --git a/runtime/syntax/hgcommit.vim b/runtime/syntax/hgcommit.vim
index 37fe9db..e9f31be 100644
--- a/runtime/syntax/hgcommit.vim
+++ b/runtime/syntax/hgcommit.vim
@@ -1,8 +1,8 @@
 " Vim syntax file
-" Language:	hg (Mercurial) commit file
+" Language:	hg/sl (Mercurial / Sapling) commit file
 " Maintainer:	Ken Takata <kentkt at csc dot jp>
-" Last Change:	2012 Aug 23
-" Filenames:	hg-editor-*.txt
+"  		Max Coplan <mchcopl@gmail.com>
+" Last Change:	2022-12-08
 " License:	VIM License
 " URL:		https://github.com/k-takata/hg-vim
 
@@ -10,12 +10,15 @@
   finish
 endif
 
-syn match hgcommitComment "^HG:.*$"             contains=@NoSpell
-syn match hgcommitUser    "^HG: user: \zs.*$"   contains=@NoSpell contained containedin=hgcommitComment
-syn match hgcommitBranch  "^HG: branch \zs.*$"  contains=@NoSpell contained containedin=hgcommitComment
-syn match hgcommitAdded   "^HG: \zsadded .*$"   contains=@NoSpell contained containedin=hgcommitComment
-syn match hgcommitChanged "^HG: \zschanged .*$" contains=@NoSpell contained containedin=hgcommitComment
-syn match hgcommitRemoved "^HG: \zsremoved .*$" contains=@NoSpell contained containedin=hgcommitComment
+syn match hgcommitComment "^\%(SL\|HG\): .*$"            contains=@NoSpell
+syn match hgcommitUser    "^\%(SL\|HG\): user: \zs.*$"   contains=@NoSpell contained containedin=hgcommitComment
+syn match hgcommitBranch  "^\%(SL\|HG\): branch \zs.*$"  contains=@NoSpell contained containedin=hgcommitComment
+syn match hgcommitAdded   "^\%(SL\|HG\): \zsadded .*$"   contains=@NoSpell contained containedin=hgcommitComment
+syn match hgcommitChanged "^\%(SL\|HG\): \zschanged .*$" contains=@NoSpell contained containedin=hgcommitComment
+syn match hgcommitRemoved "^\%(SL\|HG\): \zsremoved .*$" contains=@NoSpell contained containedin=hgcommitComment
+
+syn region hgcommitDiff start=/\%(^\(SL\|HG\): diff --\%(git\|cc\|combined\) \)\@=/ end=/^\%(diff --\|$\|@@\@!\|[^[:alnum:]\ +-]\S\@!\)\@=/ fold contains=@hgcommitDiff
+syn include @hgcommitDiff syntax/shared/hgcommitDiff.vim
 
 hi def link hgcommitComment Comment
 hi def link hgcommitUser    String
diff --git a/runtime/syntax/shared/hgcommitDiff.vim b/runtime/syntax/shared/hgcommitDiff.vim
new file mode 100644
index 0000000..949cdf0
--- /dev/null
+++ b/runtime/syntax/shared/hgcommitDiff.vim
@@ -0,0 +1,390 @@
+" Vim syntax file
+" Language:	Sapling / Mecurial Diff (context or unified)
+" Maintainer:	Max Coplan <mchcopl@gmail.com>
+"               Translations by Jakson Alves de Aquino.
+" Last Change:	2022-12-08
+" Copied from:	runtime/syntax/diff.vim
+
+" Quit when a (custom) syntax file was already loaded
+if exists("b:current_syntax")
+  finish
+endif
+scriptencoding utf-8
+
+syn match hgDiffOnly		"^\%(SL\|HG\): Only in .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Files .* and .* are identical$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Files .* and .* differ$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Binary files .* and .* differ$"
+syn match hgDiffIsA		"^\%(SL\|HG\): File .* is a .* while file .* is a .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ No newline at end of file .*"
+syn match hgDiffCommon		"^\%(SL\|HG\): Common subdirectories: .*"
+
+" Disable the translations by setting diff_translations to zero.
+if !exists("diff_translations") || diff_translations
+
+" ca
+syn match hgDiffOnly		"^\%(SL\|HG\): Només a .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Els fitxers .* i .* són idèntics$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Els fitxers .* i .* difereixen$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Els fitxers .* i .* difereixen$"
+syn match hgDiffIsA		"^\%(SL\|HG\): El fitxer .* és un .* mentre que el fitxer .* és un .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ No hi ha cap caràcter de salt de línia al final del fitxer"
+syn match hgDiffCommon		"^\%(SL\|HG\): Subdirectoris comuns: .* i .*"
+
+" cs
+syn match hgDiffOnly		"^\%(SL\|HG\): Pouze v .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Soubory .* a .* jsou identické$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Soubory .* a .* jsou různé$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Binární soubory .* a .* jsou rozdílné$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Soubory .* a .* jsou různé$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Soubor .* je .* pokud soubor .* je .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Chybí znak konce řádku na konci souboru"
+syn match hgDiffCommon		"^\%(SL\|HG\): Společné podadresáře: .* a .*"
+
+" da
+syn match hgDiffOnly		"^\%(SL\|HG\): Kun i .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Filerne .* og .* er identiske$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Filerne .* og .* er forskellige$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Binære filer .* og .* er forskellige$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Filen .* er en .* mens filen .* er en .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Intet linjeskift ved filafslutning"
+syn match hgDiffCommon		"^\%(SL\|HG\): Identiske underkataloger: .* og .*"
+
+" de
+syn match hgDiffOnly		"^\%(SL\|HG\): Nur in .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Dateien .* und .* sind identisch.$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Dateien .* und .* sind verschieden.$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Binärdateien .* and .* sind verschieden.$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Binärdateien .* und .* sind verschieden.$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Datei .* ist ein .* während Datei .* ein .* ist.$"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Kein Zeilenumbruch am Dateiende."
+syn match hgDiffCommon		"^\%(SL\|HG\): Gemeinsame Unterverzeichnisse: .* und .*.$"
+
+" el
+syn match hgDiffOnly		"^\%(SL\|HG\): Μόνο στο .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Τα αρχεία .* καί .* είναι πανομοιότυπα$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Τα αρχεία .* και .* διαφέρουν$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Τα αρχεία .* και .* διαφέρουν$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Το αρχείο .* είναι .* ενώ το αρχείο .* είναι .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Δεν υπάρχει χαρακτήρας νέας γραμμής στο τέλος του αρχείου"
+syn match hgDiffCommon		"^\%(SL\|HG\): Οι υποκατάλογοι .* και .* είναι ταυτόσημοι$"
+
+" eo
+syn match hgDiffOnly		"^\%(SL\|HG\): Nur en .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Dosieroj .* kaj .* estas samaj$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Dosieroj .* kaj .* estas malsamaj$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Dosieroj .* kaj .* estas malsamaj$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Dosiero .* estas .*, dum dosiero .* estas .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Mankas linifino ĉe fino de dosiero"
+syn match hgDiffCommon		"^\%(SL\|HG\): Komunaj subdosierujoj: .* kaj .*"
+
+" es
+syn match hgDiffOnly		"^\%(SL\|HG\): Sólo en .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Los ficheros .* y .* son idénticos$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Los ficheros .* y .* son distintos$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Los ficheros binarios .* y .* son distintos$"
+syn match hgDiffIsA		"^\%(SL\|HG\): El fichero .* es un .* mientras que el .* es un .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ No hay ningún carácter de nueva línea al final del fichero"
+syn match hgDiffCommon		"^\%(SL\|HG\): Subdirectorios comunes: .* y .*"
+
+" fi
+syn match hgDiffOnly		"^\%(SL\|HG\): Vain hakemistossa .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Tiedostot .* ja .* ovat identtiset$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Tiedostot .* ja .* eroavat$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Binääritiedostot .* ja .* eroavat$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Tiedosto .* on .*, kun taas tiedosto .* on .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Ei rivinvaihtoa tiedoston lopussa"
+syn match hgDiffCommon		"^\%(SL\|HG\): Yhteiset alihakemistot: .* ja .*"
+
+" fr
+syn match hgDiffOnly		"^\%(SL\|HG\): Seulement dans .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Les fichiers .* et .* sont identiques.*"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Les fichiers .* et .* sont différents.*"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Les fichiers binaires .* et .* sont différents.*"
+syn match hgDiffIsA		"^\%(SL\|HG\): Le fichier .* est un .* alors que le fichier .* est un .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Pas de fin de ligne à la fin du fichier.*"
+syn match hgDiffCommon		"^\%(SL\|HG\): Les sous-répertoires .* et .* sont identiques.*"
+
+" ga
+syn match hgDiffOnly		"^\%(SL\|HG\): I .* amháin: .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Is comhionann iad na comhaid .* agus .*"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Tá difríocht idir na comhaid .* agus .*"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Tá difríocht idir na comhaid .* agus .*"
+syn match hgDiffIsA		"^\%(SL\|HG\): Tá comhad .* ina .* ach tá comhad .* ina .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Gan líne nua ag an chomhadchríoch"
+syn match hgDiffCommon		"^\%(SL\|HG\): Fochomhadlanna i gcoitianta: .* agus .*"
+
+" gl
+syn match hgDiffOnly		"^\%(SL\|HG\): Só en .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Os ficheiros .* e .* son idénticos$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Os ficheiros .* e .* son diferentes$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Os ficheiros binarios .* e .* son diferentes$"
+syn match hgDiffIsA		"^\%(SL\|HG\): O ficheiro .* é un .* mentres que o ficheiro .* é un .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Non hai un salto de liña na fin da liña"
+syn match hgDiffCommon		"^\%(SL\|HG\): Subdirectorios comúns: .* e .*"
+
+" he
+" ^\%(SL\|HG\): .* are expansive patterns for long lines, so disabled unless we can match
+" some specific hebrew chars
+if search('\%u05d5\|\%u05d1', 'nw', '', 100)
+  syn match hgDiffOnly		"^\%(SL\|HG\): .*-ב קר אצמנ .*"
+  syn match hgDiffIdentical	"^\%(SL\|HG\): םיהז םניה .*-ו .* םיצבקה$"
+  syn match hgDiffDiffer	"^\%(SL\|HG\): הזמ הז םינוש `.*'-ו `.*' םיצבקה$"
+  syn match hgDiffBDiffer	"^\%(SL\|HG\): הזמ הז םינוש `.*'-ו `.*' םיירניב םיצבק$"
+  syn match hgDiffIsA		"^\%(SL\|HG\): .* .*-ל .* .* תוושהל ןתינ אל$"
+  syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ ץבוקה ףוסב השד.-הרוש ות רס."
+  syn match hgDiffCommon	"^\%(SL\|HG\): .*-ו .* :תוהז תויקית-תת$"
+endif
+
+" hr
+syn match hgDiffOnly		"^\%(SL\|HG\): Samo u .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Datoteke .* i .* su identične$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Datoteke .* i .* se razlikuju$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Binarne datoteke .* i .* se razlikuju$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Datoteka .* je .*, a datoteka .* je .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Nema novog retka na kraju datoteke"
+syn match hgDiffCommon		"^\%(SL\|HG\): Uobičajeni poddirektoriji: .* i .*"
+
+" hu
+syn match hgDiffOnly		"^\%(SL\|HG\): Csak .* -ben: .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): .* és .* fájlok azonosak$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): A(z) .* és a(z) .* fájlok különböznek$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): A(z) .* és a(z) .* fájlok különböznek$"
+syn match hgDiffIsA		"^\%(SL\|HG\): A(z) .* fájl egy .*, viszont a(z) .* fájl egy .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Nincs újsor a fájl végén"
+syn match hgDiffCommon		"^\%(SL\|HG\): Közös alkönyvtárak: .* és .*"
+
+" id
+syn match hgDiffOnly		"^\%(SL\|HG\): Hanya dalam .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): File .* dan .* identik$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Berkas .* dan .* berbeda$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): File biner .* dan .* berbeda$"
+syn match hgDiffIsA		"^\%(SL\|HG\): File .* adalah .* sementara file .* adalah .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Tidak ada baris-baru di akhir dari berkas"
+syn match hgDiffCommon		"^\%(SL\|HG\): Subdirektori sama: .* dan .*"
+
+" it
+syn match hgDiffOnly		"^\%(SL\|HG\): Solo in .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): I file .* e .* sono identici$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): I file .* e .* sono diversi$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): I file .* e .* sono diversi$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): I file binari .* e .* sono diversi$"
+syn match hgDiffIsA		"^\%(SL\|HG\): File .* è un .* mentre file .* è un .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Manca newline alla fine del file"
+syn match hgDiffCommon		"^\%(SL\|HG\): Sottodirectory in comune: .* e .*"
+
+" ja
+syn match hgDiffOnly		"^\%(SL\|HG\): .*だけに発見: .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): ファイル.*と.*は同一$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): ファイル.*と.*は違います$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): バイナリー・ファイル.*と.*は違います$"
+syn match hgDiffIsA		"^\%(SL\|HG\): ファイル.*は.*、ファイル.*は.*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ ファイル末尾に改行がありません"
+syn match hgDiffCommon		"^\%(SL\|HG\): 共通の下位ディレクトリー: .*と.*"
+
+" ja DiffUtils 3.3
+syn match hgDiffOnly		"^\%(SL\|HG\): .* のみに存在: .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): ファイル .* と .* は同一です$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): ファイル .* と .* は異なります$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): バイナリーファイル .* と.* は異なります$"
+syn match hgDiffIsA		"^\%(SL\|HG\): ファイル .* は .* です。一方、ファイル .* は .* です$"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ ファイル末尾に改行がありません"
+syn match hgDiffCommon		"^\%(SL\|HG\): 共通のサブディレクトリー: .* と .*"
+
+" lv
+syn match hgDiffOnly		"^\%(SL\|HG\): Tikai iekš .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Fails .* un .* ir identiski$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Faili .* un .* atšķiras$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Faili .* un .* atšķiras$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Binārie faili .* un .* atšķiras$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Fails .* ir .* kamēr fails .* ir .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Nav jaunu rindu faila beigās"
+syn match hgDiffCommon		"^\%(SL\|HG\): Kopējās apakšdirektorijas: .* un .*"
+
+" ms
+syn match hgDiffOnly		"^\%(SL\|HG\): Hanya dalam .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Fail .* dan .* adalah serupa$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Fail .* dan .* berbeza$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Fail .* dan .* berbeza$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Fail .* adalah .* manakala fail .* adalah .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Tiada baris baru pada penghujung fail"
+syn match hgDiffCommon		"^\%(SL\|HG\): Subdirektori umum: .* dan .*"
+
+" nl
+syn match hgDiffOnly		"^\%(SL\|HG\): Alleen in .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Bestanden .* en .* zijn identiek$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Bestanden .* en .* zijn verschillend$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Bestanden .* en .* zijn verschillend$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Binaire bestanden .* en .* zijn verschillend$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Bestand .* is een .* terwijl bestand .* een .* is$"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Geen regeleindeteken (LF) aan einde van bestand"
+syn match hgDiffCommon		"^\%(SL\|HG\): Gemeenschappelijke submappen: .* en .*"
+
+" pl
+syn match hgDiffOnly		"^\%(SL\|HG\): Tylko w .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Pliki .* i .* są identyczne$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Pliki .* i .* różnią się$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Pliki .* i .* różnią się$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Binarne pliki .* i .* różnią się$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Plik .* jest .*, podczas gdy plik .* jest .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Brak znaku nowej linii na końcu pliku"
+syn match hgDiffCommon		"^\%(SL\|HG\): Wspólne podkatalogi: .* i .*"
+
+" pt_BR
+syn match hgDiffOnly		"^\%(SL\|HG\): Somente em .*"
+syn match hgDiffOnly		"^\%(SL\|HG\): Apenas em .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Os aquivos .* e .* são idênticos$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Os arquivos .* e .* são diferentes$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Os arquivos binários .* e .* são diferentes$"
+syn match hgDiffIsA		"^\%(SL\|HG\): O arquivo .* é .* enquanto o arquivo .* é .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Falta o caracter nova linha no final do arquivo"
+syn match hgDiffCommon		"^\%(SL\|HG\): Subdiretórios idênticos: .* e .*"
+
+" ro
+syn match hgDiffOnly		"^\%(SL\|HG\): Doar în .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Fişierele .* şi .* sunt identice$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Fişierele .* şi .* diferă$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Fişierele binare .* şi .* diferă$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Fişierul .* este un .* pe când fişierul .* este un .*.$"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Nici un element de linie nouă la sfârşitul fişierului"
+syn match hgDiffCommon		"^\%(SL\|HG\): Subdirectoare comune: .* şi .*.$"
+
+" ru
+syn match hgDiffOnly		"^\%(SL\|HG\): Только в .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Файлы .* и .* идентичны$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Файлы .* и .* различаются$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Файлы .* и .* различаются$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Файл .* это .*, тогда как файл .* -- .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ В конце файла нет новой строки"
+syn match hgDiffCommon		"^\%(SL\|HG\): Общие подкаталоги: .* и .*"
+
+" sr
+syn match hgDiffOnly		"^\%(SL\|HG\): Само у .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Датотеке „.*“ и „.*“ се подударају$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Датотеке .* и .* различите$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Бинарне датотеке .* и .* различите$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Датотека „.*“ је „.*“ док је датотека „.*“ „.*“$"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Без новог реда на крају датотеке"
+syn match hgDiffCommon		"^\%(SL\|HG\): Заједнички поддиректоријуми: .* и .*"
+
+" sv
+syn match hgDiffOnly		"^\%(SL\|HG\): Endast i .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Filerna .* och .* är lika$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Filerna .* och .* skiljer$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Filerna .* och .* skiljer$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Fil .* är en .* medan fil .* är en .*"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): De binära filerna .* och .* skiljer$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Filen .* är .* medan filen .* är .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Ingen nyrad vid filslut"
+syn match hgDiffCommon		"^\%(SL\|HG\): Lika underkataloger: .* och .*"
+
+" tr
+syn match hgDiffOnly		"^\%(SL\|HG\): Yalnızca .*'da: .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): .* ve .* dosyaları birbirinin aynı$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): .* ve .* dosyaları birbirinden farklı$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): .* ve .* dosyaları birbirinden farklı$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): İkili .* ve .* birbirinden farklı$"
+syn match hgDiffIsA		"^\%(SL\|HG\): .* dosyası, bir .*, halbuki .* dosyası bir .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Dosya sonunda yenisatır yok."
+syn match hgDiffCommon		"^\%(SL\|HG\): Ortak alt dizinler: .* ve .*"
+
+" uk
+syn match hgDiffOnly		"^\%(SL\|HG\): Лише у .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Файли .* та .* ідентичні$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Файли .* та .* відрізняються$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Файли .* та .* відрізняються$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Двійкові файли .* та .* відрізняються$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Файл .* це .*, тоді як файл .* -- .*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Наприкінці файлу немає нового рядка"
+syn match hgDiffCommon		"^\%(SL\|HG\): Спільні підкаталоги: .* та .*"
+
+" vi
+syn match hgDiffOnly		"^\%(SL\|HG\): Chỉ trong .*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Hai tập tin .* và .* là bằng nhau.$"
+syn match hgDiffIdentical	"^\%(SL\|HG\): Cả .* và .* là cùng một tập tin$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): Hai tập tin .* và .* là khác nhau.$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Hai tập tin nhị phân .* và .* khác nhau$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Tập tin .* là một .* trong khi tập tin .* là một .*.$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): Hai tập tin .* và .* là khác nhau.$"
+syn match hgDiffIsA		"^\%(SL\|HG\): Tập tin .* là một .* còn tập tin .* là một .*.$"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ Không có ký tự dòng mới tại kêt thức tập tin."
+syn match hgDiffCommon		"^\%(SL\|HG\): Thư mục con chung: .* và .*"
+
+" zh_CN
+syn match hgDiffOnly		"^\%(SL\|HG\): 只在 .* 存在：.*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): 檔案 .* 和 .* 相同$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): 文件 .* 和 .* 不同$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): 文件 .* 和 .* 不同$"
+syn match hgDiffIsA		"^\%(SL\|HG\): 文件 .* 是.*而文件 .* 是.*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ 文件尾没有 newline 字符"
+syn match hgDiffCommon		"^\%(SL\|HG\): .* 和 .* 有共同的子目录$"
+
+" zh_TW
+syn match hgDiffOnly		"^\%(SL\|HG\): 只在 .* 存在：.*"
+syn match hgDiffIdentical	"^\%(SL\|HG\): 檔案 .* 和 .* 相同$"
+syn match hgDiffDiffer		"^\%(SL\|HG\): 檔案 .* 與 .* 不同$"
+syn match hgDiffBDiffer		"^\%(SL\|HG\): 二元碼檔 .* 與 .* 不同$"
+syn match hgDiffIsA		"^\%(SL\|HG\): 檔案 .* 是.*而檔案 .* 是.*"
+syn match hgDiffNoEOL		"^\%(SL\|HG\): \\ 檔案末沒有 newline 字元"
+syn match hgDiffCommon		"^\%(SL\|HG\): .* 和 .* 有共同的副目錄$"
+
+endif
+
+
+syn match hgDiffRemoved		"^\%(SL\|HG\): -.*"
+syn match hgDiffRemoved		"^\%(SL\|HG\): <.*"
+syn match hgDiffAdded		"^\%(SL\|HG\): +.*"
+syn match hgDiffAdded		"^\%(SL\|HG\): >.*"
+syn match hgDiffChanged		"^\%(SL\|HG\): ! .*"
+
+syn match hgDiffSubname		" @@..*"ms=s+3 contained
+syn match hgDiffLine		"^\%(SL\|HG\): @.*" contains=hgDiffSubname
+syn match hgDiffLine		"^\%(SL\|HG\): \<\d\+\>.*"
+syn match hgDiffLine		"^\%(SL\|HG\): \*\*\*\*.*"
+syn match hgDiffLine		"^\%(SL\|HG\): ---$"
+
+" Some versions of diff have lines like "#c#" and "#d#" (where # is a number)
+syn match hgDiffLine		"^\%(SL\|HG\): \d\+\(,\d\+\)\=[cda]\d\+\>.*"
+
+syn match hgDiffFile		"^\%(SL\|HG\): diff\>.*"
+syn match hgDiffFile		"^\%(SL\|HG\): Index: .*"
+syn match hgDiffFile		"^\%(SL\|HG\): ==== .*"
+
+if search('^\%(SL\|HG\): @@ -\S\+ +\S\+ @@', 'nw', '', 100)
+  " unified
+  syn match hgDiffOldFile	"^\%(SL\|HG\): --- .*"
+  syn match hgDiffNewFile	"^\%(SL\|HG\): +++ .*"
+else
+  " context / old style
+  syn match hgDiffOldFile	"^\%(SL\|HG\): \*\*\* .*"
+  syn match hgDiffNewFile	"^\%(SL\|HG\): --- .*"
+endif
+
+" Used by git
+syn match hgDiffIndexLine	"^\%(SL\|HG\): index \x\x\x\x.*"
+
+syn match hgDiffComment		"^\%(SL\|HG\): #.*"
+
+" Define the default highlighting.
+" Only used when an item doesn't have highlighting yet
+hi def link hgDiffOldFile	hgDiffFile
+hi def link hgDiffNewFile	hgDiffFile
+hi def link hgDiffIndexLine	PreProc
+hi def link hgDiffFile		Type
+hi def link hgDiffOnly		Constant
+hi def link hgDiffIdentical	Constant
+hi def link hgDiffDiffer	Constant
+hi def link hgDiffBDiffer	Constant
+hi def link hgDiffIsA		Constant
+hi def link hgDiffNoEOL		Constant
+hi def link hgDiffCommon	Constant
+hi def link hgDiffRemoved	Special
+hi def link hgDiffChanged	PreProc
+hi def link hgDiffAdded		Identifier
+hi def link hgDiffLine		Statement
+hi def link hgDiffSubname	PreProc
+hi def link hgDiffComment	Comment
+
+let b:current_syntax = "hgcommitDiff"
+
+" vim: ts=8 sw=2
diff --git a/runtime/syntax/vim.vim b/runtime/syntax/vim.vim
index d662d20..e6651b8 100644
--- a/runtime/syntax/vim.vim
+++ b/runtime/syntax/vim.vim
@@ -1,8 +1,8 @@
 " Vim syntax file
 " Language:	Vim 9.0 script
 " Maintainer:	Charles E. Campbell <NcampObell@SdrPchip.AorgM-NOSPAM>
-" Last Change:	December 06, 2022
-" Version:	9.0-14
+" Last Change:	December 20, 2022
+" Version:	9.0-17
 " URL:	http://www.drchip.org/astronaut/vim/index.html#SYNTAX_VIM
 " Automatically generated keyword lists: {{{1
 
@@ -19,24 +19,24 @@
 syn cluster vimCommentGroup	contains=vimTodo,@Spell
 
 " regular vim commands {{{2
-syn keyword vimCommand contained	a ar[gs] argg[lobal] b[uffer] bf[irst] br[ewind] bufdo c[hange] caddf[ile] cbel[ow] ce[nter] cgetb[uffer] chi[story] cmapc[lear] col[der] conf[irm] cr[ewind] cw[indow] delc[ommand] deletp di[splay] diffs[plit] dl dr[op] ec el[se] endfun eval f[ile] fina[lly] foldd[oopen] function h[elp] hi iabc[lear] import isp[lit] keepa l[ist] laf[ter] lbel[ow] lcscope lf[ile] lgr[ep] lli[st] lnf[ile] lol[der] lt[ag] lw[indow] menut[ranslate] mkvie[w] nbc[lose] noh[lsearch] ol[dfiles] pa[ckadd] po[p] prof[ile] pta[g] ptr[ewind] py3f[ile] pythonx quita[ll] redraws[tatus] rew[ind] rubyf[ile] sIg sa[rgument] sba[ll] sbr[ewind] scl scscope sfir[st] sgl sic sin sm[ap] snoreme spelld[ump] spellw[rong] srg sta[g] sts[elect] sus[pend] syncbind tabN[ext] tabl[ast] tabr[ewind] tcld[o] tj[ump] tlu tno[remap] tu[nmenu] undol[ist] v vie[w] vne[w] win[size] wq xmapc[lear] xr[estore]
-syn keyword vimCommand contained	ab arga[dd] argl[ocal] ba[ll] bl[ast] brea[k] buffers ca caf[ter] cbo[ttom] cex[pr] cgete[xpr] cl[ist] cn[ext] colo[rscheme] cons[t] cs d[elete] delel delfunction dif[fupdate] difft[his] dli[st] ds[earch] echoc[onsole] elsei[f] endfunc ex files fini[sh] folddoc[losed] go[to] ha[rdcopy] hid[e] if in iuna[bbrev] keepalt la[st] lan[guage] lbo[ttom] ld[o] lfdo lgrepa[dd] lma lo[adview] lop[en] lua m[ove] mes[sages] mod[e] nbs[tart] nor omapc[lear] packl[oadall] popu[p] profd[el] ptf[irst] pts[elect] py3f[ile] pyx r[ead] redrawt[abline] ri[ght] rundo sIl sal[l] sbf[irst] sc scp se[t] sg sgn sie sip sme snoremenu spelli[nfo] spr[evious] sri star[tinsert] substitutepattern sv[iew] syntime tabc[lose] tabm[ove] tabs tclf[ile] tl[ast] tlunmenu to[pleft] tunma[p] unh[ide] var vim9[cmd] vs[plit] winc[md] wqa[ll] xme xunme
-syn keyword vimCommand contained	abc[lear] argd[elete] argu[ment] bad[d] bm[odified] breaka[dd] bun[load] cabc[lear] call cc cf[ile] changes cla[st] cnew[er] com cope[n] cscope debug delep dell diffg[et] dig[raphs] do dsp[lit] echoe[rr] em[enu] endfunction exi[t] filet fir[st] foldo[pen] gr[ep] helpc[lose] his[tory] ij[ump] inor j[oin] keepj[umps] lab[ove] lat lc[d] le[ft] lfir[st] lh[elpgrep] lmak[e] loadk lp[revious] luado ma[rk] mk[exrc] mz[scheme] new nore on[ly] pc[lose] pp[op] promptf[ind] ptj[ump] pu[t] py[thon] pyxdo rec[over] reg[isters] rightb[elow] rv[iminfo] sIn san[dbox] sbl[ast] scI scr[iptnames] setf[iletype] sgI sgp sig sir smenu so[urce] spellr[are] sr srl startg[replace] substituterepeat sw[apname] t tabd[o] tabn[ext] tags te[aroff] tlm tm[enu] tp[revious] type unl ve[rsion] vim9s[cript] wN[ext] windo wundo xmenu xunmenu
-syn keyword vimCommand contained	abo[veleft] argded[upe] as[cii] balt bn[ext] breakd[el] bw[ipeout] cabo[ve] cat[ch] ccl[ose] cfdo chd[ir] class cnf[ile] comc[lear] cp[revious] cstag debugg[reedy] deletel delm[arks] diffo[ff] dir doau e[dit] echom[sg] en[dif] endt[ry] exp filetype fix[del] for grepa[dd] helpf[ind] hor[izontal] il[ist] interface ju[mps] keepp[atterns] lad[dexpr] later lch[dir] lefta[bove] lg[etfile] lhi[story] lmapc[lear] loadkeymap lpf[ile] luafile mak[e] mks[ession] mzf[ile] nmapc[lear] nos[wapfile] opt[ions] pe[rl] pre[serve] promptr[epl] ptl[ast] pw[d] pydo pyxfile red[o] res[ize] ru[ntime] sI sIp sav[eas] sbm[odified] sce scripte[ncoding] setg[lobal] sgc sgr sign sl[eep] smile sor[t] spellr[epall] srI srn startr[eplace] sun[hide] sy tN[ext] tabe[dit] tabnew tc[d] ter[minal] tlmenu tma[p] tr[ewind] u[ndo] unlo[ckvar] verb[ose] vim[grep] w[rite] winp[os] wv[iminfo] xnoreme xwininfo
-syn keyword vimCommand contained	addd argdo au bd[elete] bo[tright] breakl[ist] cN[ext] cad[dbuffer] cb[uffer] cd cfir[st] che[ckpath] cle[arjumps] cnor comp[iler] cpf[ile] cun def deletep delp diffp[atch] disa[ssemble] doaut ea echon enddef endw[hile] export filt[er] fo[ld] fun gui helpg[rep] i imapc[lear] intro k lN[ext] laddb[uffer] lb[uffer] lcl[ose] leg[acy] lgetb[uffer] ll lne[xt] loc[kmarks] lr[ewind] lv[imgrep] marks mksp[ell] n[ext] noa nu[mber] ownsyntax ped[it] prev[ious] ps[earch] ptn[ext] py3 pyf[ile] q[uit] redi[r] ret[ab] rub[y] sIc sIr sbN[ext] sbn[ext] scg scriptv[ersion] setl[ocal] sge sh[ell] sil[ent] sla[st] sn[ext] sp[lit] spellr[rare] src srp stj[ump] sunme syn ta[g] tabf[ind] tabo[nly] tch[dir] tf[irst] tln tmapc[lear] try una[bbreviate] uns[ilent] vert[ical] vimgrepa[dd] wa[ll] wn[ext] x[it] xnoremenu y[ank]
-syn keyword vimCommand contained	al[l] arge[dit] bN[ext] bel[owright] bp[revious] bro[wse] cNf[ile] cadde[xpr] cbe[fore] cdo cg[etfile] checkt[ime] clo[se] co[py] con[tinue] cq[uit] cuna[bbrev] defc[ompile] deletl dep diffpu[t] dj[ump] dp earlier echow[indow] endfo[r] ene[w] exu[sage] fin[d] foldc[lose] func gvim helpt[ags] ia imp is[earch] kee[pmarks] lNf[ile] laddf[ile] lbe[fore] lcs lex[pr] lgete[xpr] lla[st] lnew[er] lockv[ar] ls lvimgrepa[dd] mat[ch] mkv[imrc] nb[key] noautocmd o[pen] p[rint] perld[o] pro ptN[ext] ptp[revious] py3do python3 qa[ll] redr[aw] return rubyd[o] sIe sN[ext] sb[uffer] sbp[revious] sci scs sf[ind] sgi si sim[alt] sm[agic] sno[magic] spe[llgood] spellu[ndo] sre[wind] st[op] stopi[nsert] sunmenu sync tab tabfir[st] tabp[revious] tcl th[row] tlnoremenu tn[ext] ts[elect] undoj[oin] up[date] vi[sual] viu[sage] wh[ile] wp[revious] xa[ll] xprop z[^.=]
+syn keyword vimCommand contained	a ar[gs] argg[lobal] b[uffer] bf[irst] br[ewind] bufdo c[hange] caddf[ile] cbel[ow] ce[nter] cgetb[uffer] chi[story] cmapc[lear] col[der] conf[irm] cr[ewind] cw[indow] defer deletl dep diffpu[t] dj[ump] dp earlier echow[indow] endf[unction] ex files fini[sh] folddoc[losed] grepa[dd] helpf[ind] hor[izontal] il[ist] interface ju[mps] keepp[atterns] lad[dexpr] later lch[dir] lefta[bove] lg[etfile] lhi[story] lmapc[lear] loadkeymap lpf[ile] luafile mak[e] mks[ession] mzf[ile] nmapc[lear] nos[wapfile] opt[ions] pe[rl] pre[serve] promptr[epl] ptl[ast] pw[d] pydo pyxfile red[o] res[ize] ru[ntime] sI sIp sav[eas] sbm[odified] sce scripte[ncoding] setg[lobal] sgc sgr sign sl[eep] smile sor[t] spellr[epall] srI srn startr[eplace] sun[hide] sy tN[ext] tabe[dit] tabnew tc[d] ter[minal] tlmenu tma[p] tr[ewind] u[ndo] unlo[ckvar] verb[ose] vim[grep] w[rite] winp[os] wv[iminfo] xmenu xunme
+syn keyword vimCommand contained	ab arga[dd] argl[ocal] ba[ll] bl[ast] brea[k] buffers ca caf[ter] cbo[ttom] cex[pr] cgete[xpr] cl[ist] cn[ext] colo[rscheme] cons[t] cs d[elete] delc[ommand] deletp di[splay] diffs[plit] dl dr[op] ec el[se] endfo[r] exi[t] filet fir[st] foldo[pen] gui helpg[rep] i imapc[lear] intro k lN[ext] laddb[uffer] lb[uffer] lcl[ose] leg[acy] lgetb[uffer] ll lne[xt] loc[kmarks] lr[ewind] lv[imgrep] marks mksp[ell] n[ext] noa nu[mber] ownsyntax ped[it] prev[ious] ps[earch] ptn[ext] py3 pyf[ile] q[uit] redi[r] ret[ab] rub[y] sIc sIr sbN[ext] sbn[ext] scg scriptv[ersion] setl[ocal] sge sh[ell] sil[ent] sla[st] sn[ext] sp[lit] spellr[rare] src srp stj[ump] sunme syn ta[g] tabf[ind] tabo[nly] tch[dir] tf[irst] tln tmapc[lear] try una[bbreviate] uns[ilent] vert[ical] vimgrepa[dd] wa[ll] wn[ext] x[it] xnoreme xunmenu
+syn keyword vimCommand contained	abc[lear] argd[elete] argu[ment] bad[d] bm[odified] breaka[dd] bun[load] cabc[lear] cal[l] cc cf[ile] changes cla[st] cnew[er] com cope[n] cscope debug delel delf[unction] dif[fupdate] difft[his] dli[st] ds[earch] echoc[onsole] elsei[f] endt[ry] exp filetype fix[del] for gvim helpt[ags] ia imp is[earch] kee[pmarks] lNf[ile] laddf[ile] lbe[fore] lcs lex[pr] lgete[xpr] lla[st] lnew[er] lockv[ar] ls lvimgrepa[dd] mat[ch] mkv[imrc] nb[key] noautocmd o[pen] p[rint] perld[o] pro ptN[ext] ptp[revious] py3do python3 qa[ll] redr[aw] retu[rn] rubyd[o] sIe sN[ext] sb[uffer] sbp[revious] sci scs sf[ind] sgi si sim[alt] sm[agic] sno[magic] spe[llgood] spellu[ndo] sre[wind] st[op] stopi[nsert] sunmenu sync tab tabfir[st] tabp[revious] tcl th[row] tlnoremenu tn[ext] ts[elect] undoj[oin] up[date] vi[sual] viu[sage] wh[ile] wp[revious] xa[ll] xnoremenu xwininfo
+syn keyword vimCommand contained	abo[veleft] argded[upe] as[cii] balt bn[ext] breakd[el] bw[ipeout] cabo[ve] cat[ch] ccl[ose] cfdo chd[ir] class cnf[ile] comc[lear] cp[revious] cstag debugg[reedy] delep dell diffg[et] dig[raphs] do dsp[lit] echoe[rr] em[enu] endw[hile] export filt[er] fo[ld] fu[nction] h[elp] hi iabc[lear] import isp[lit] keepa l[ist] laf[ter] lbel[ow] lcscope lf[ile] lgr[ep] lli[st] lnf[ile] lol[der] lt[ag] lw[indow] menut[ranslate] mkvie[w] nbc[lose] noh[lsearch] ol[dfiles] pa[ckadd] po[p] prof[ile] pta[g] ptr[ewind] py3f[ile] pythonx quita[ll] redraws[tatus] rew[ind] rubyf[ile] sIg sa[rgument] sba[ll] sbr[ewind] scl scscope sfir[st] sgl sic sin sm[ap] snoreme spelld[ump] spellw[rong] srg sta[g] sts[elect] sus[pend] syncbind tabN[ext] tabl[ast] tabr[ewind] tcld[o] tj[ump] tlu tno[remap] tu[nmenu] undol[ist] v vie[w] vne[w] win[size] wq xmapc[lear] xprop y[ank]
+syn keyword vimCommand contained	addd argdo au bd[elete] bo[tright] breakl[ist] cN[ext] cad[dbuffer] cb[uffer] cd cfir[st] che[ckpath] cle[arjumps] cnor comp[iler] cpf[ile] cun def deletel delm[arks] diffo[ff] dir doau e[dit] echom[sg] en[dif] ene[w] exu[sage] fin[d] foldc[lose] go[to] ha[rdcopy] hid[e] if in iuna[bbrev] keepalt la[st] lan[guage] lbo[ttom] ld[o] lfdo lgrepa[dd] lma lo[adview] lop[en] lua m[ove] mes[sages] mod[e] nbs[tart] nor omapc[lear] packl[oadall] popu[p] profd[el] ptf[irst] pts[elect] py3f[ile] pyx r[ead] redrawt[abline] ri[ght] rundo sIl sal[l] sbf[irst] sc scp se[t] sg sgn sie sip sme snoremenu spelli[nfo] spr[evious] sri star[tinsert] substitutepattern sv[iew] syntime tabc[lose] tabm[ove] tabs tclf[ile] tl[ast] tlunmenu to[pleft] tunma[p] unh[ide] var vim9[cmd] vs[plit] winc[md] wqa[ll] xme xr[estore] z[^.=]
+syn keyword vimCommand contained	al[l] arge[dit] bN[ext] bel[owright] bp[revious] bro[wse] cNf[ile] cadde[xpr] cbe[fore] cdo cg[etfile] checkt[ime] clo[se] co[py] con[tinue] cq[uit] cuna[bbrev] defc[ompile] deletep delp diffp[atch] disa[ssemble] doaut ea echon enddef eval f[ile] fina[lly] foldd[oopen] gr[ep] helpc[lose] his[tory] ij[ump] inor j[oin] keepj[umps] lab[ove] lat lc[d] le[ft] lfir[st] lh[elpgrep] lmak[e] loadk lp[revious] luado ma[rk] mk[exrc] mz[scheme] new nore on[ly] pc[lose] pp[op] promptf[ind] ptj[ump] pu[t] py[thon] pyxdo rec[over] reg[isters] rightb[elow] rv[iminfo] sIn san[dbox] sbl[ast] scI scr[iptnames] setf[iletype] sgI sgp sig sir smenu so[urce] spellr[are] sr srl startg[replace] substituterepeat sw[apname] t tabd[o] tabn[ext] tags te[aroff] tlm tm[enu] tp[revious] type unl ve[rsion] vim9s[cript] wN[ext] windo wundo
 syn match   vimCommand contained	"\<z[-+^.=]\=\>"
 syn keyword vimStdPlugin contained	Arguments Asm Break Cfilter Clear Continue DiffOrig Evaluate Finish Gdb Lfilter Man N[ext] Over P[rint] Program Run S Source Step Stop Termdebug TermdebugCommand TOhtml Until Winbar XMLent XMLns
 
 " vimOptions are caught only when contained in a vimSet {{{2
-syn keyword vimOption contained	acd ambw arshape aw backupskip beval bk bri bufhidden cdh ci cinsd cms commentstring conceallevel cpt cscopetagorder csto cursorlineopt dg dir ed enc equalprg expandtab fdls fex fileignorecase fml foldlevel formatexpr gcr gli guifont guitabtooltip hidden hlg imactivatefunc imi inc inex isident keymap langmap linebreak lm lsp makeencoding maxmem mh mmp more mousemoveevent mzq numberwidth opfunc patchexpr pfn pp printfont pumwidth pythonthreehome re restorescreen ro rulerformat scl scs sft shellslash shortmess shq sm sn spellfile splitkeep ssl stmp swapsync synmaxcol tagcase tbi termbidi textauto thesaurusfunc tl ts ttybuiltin tws undodir varsofttabstop vfile virtualedit warn wfh wildchar wim winminheight wmh write
-syn keyword vimOption contained	ai anti asd awa balloondelay bevalterm bkc briopt buflisted cdhome cin cinw co compatible confirm crb cscopeverbose csverb cwh dict directory edcompatible encoding errorbells exrc fdm ff filetype fmr foldlevelstart formatlistpat gd go guifontset helpfile highlight hls imactivatekey iminsert include inf isk keymodel langmenu lines lmap luadll makeprg maxmempattern mis mmt mouse mouses mzquantum nuw osfiletype patchmode ph preserveindent printheader pvh pyx readonly revins rop runtimepath scr sect sh shelltemp shortname si smartcase so spelllang splitright ssop sts swb syntax tagfunc tbidi termencoding textmode tildeop tm tsl ttyfast twsl undofile vartabstop vi visualbell wb wfw wildcharm winaltkeys winminwidth wmnu writeany
-syn keyword vimOption contained	akm antialias autochdir background ballooneval bex bl brk buftype cdpath cindent cinwords cocu complete copyindent cryptmethod csl cuc debug dictionary display ef endoffile errorfile fcl fdn ffs fillchars fo foldmarker formatoptions gdefault gp guifontwide helpheight history hlsearch imaf ims includeexpr infercase iskeyword keyprotocol langnoremap linespace lnr lw mat maxmemtot mkspellmem mod mousef mouseshape mzschemedll odev pa path pheader previewheight printmbcharset pvp pyxversion redrawtime ri rs sb scroll sections shcf shelltype showbreak sidescroll smartindent softtabstop spelloptions spo st su swf ta taglength tbis termguicolors textwidth timeout to tsr ttym twt undolevels vb viewdir vop wc wh wildignore wincolor winptydll wmw writebackup
-syn keyword vimOption contained	al ar autoindent backspace balloonevalterm bexpr bo browsedir casemap cedit cink clipboard cole completefunc cot cscopepathcomp cspc cul deco diff dy efm endofline errorformat fcs fdo fic fixendofline foldclose foldmethod formatprg gfm grepformat guiheadroom helplang hk ic imak imsearch incsearch insertmode isp keywordprg langremap lisp loadplugins lz matchpairs mco ml modeline mousefocus mouset mzschemegcdll oft packpath pdev pi previewpopup printmbfont pvw qe regexpengine rightleft rtp sbo scrollbind secure shell shellxescape showcmd sidescrolloff smarttab sol spellsuggest spr sta sua switchbuf tabline tagrelative tbs termwinkey tf timeoutlen toolbar tsrfu ttymouse tx undoreload vbs viewoptions vsts wcm whichwrap wildignorecase window winwidth wop writedelay
-syn keyword vimOption contained	aleph arab autoread backup balloonexpr bg bomb bs cb cf cinkeys cm colorcolumn completeopt cp cscopeprg csprg culopt def diffexpr ea ei eof esckeys fdc fdt fileencoding fixeol foldcolumn foldminlines fp gfn grepprg guiligatures hf hkmap icon imc imsf inde is isprint km laststatus lispoptions lop ma matchtime mef mle modelineexpr mousehide mousetime nf ofu para penc pm previewwindow printoptions pw qftf relativenumber rightleftcmd ru sbr scrollfocus sel shellcmdflag shellxquote showfulltag signcolumn smc sp spf sps stal suffixes sws tabpagemax tags tc termwinscroll tfu title toolbariconsize ttimeout ttyscroll uc updatecount vdir vif vts wcr wi wildmenu winfixheight wiv wrap ws
-syn keyword vimOption contained	allowrevins arabic autoshelldir backupcopy bdir bh breakat bsdir cc cfu cino cmdheight columns completepopup cpo cscopequickfix csqf cursorbind define diffopt ead ek eol et fde fen fileencodings fk foldenable foldnestmax fs gfs gtl guioptions hh hkmapp iconstring imcmdline imst indentexpr isf joinspaces kmp lazyredraw lispwords lpl macatsui maxcombine menc mls modelines mousem mp nrformats omnifunc paragraphs perldll pmbcs printdevice prompt pythondll quickfixtextfunc remap rl rubydll sc scrolljump selection shellpipe shiftround showmatch siso smd spc spk sr startofline suffixesadd sxe tabstop tagstack tcldll termwinsize tgc titlelen top ttimeoutlen ttytype udf updatetime ve viminfo wa wd wic wildmode winfixwidth wiw wrapmargin ww
-syn keyword vimOption contained	altkeymap arabicshape autowrite backupdir bdlay bin breakindent bsk ccv ch cinoptions cmdwinheight com completeslash cpoptions cscoperelative csre cursorcolumn delcombine digraph eadirection emo ep eventignore fdi fenc fileformat fkmap foldexpr foldopen fsync gfw gtt guipty hi hkp ignorecase imd imstatusfunc indentkeys isfname js kp lbr list lrm magic maxfuncdepth menuitems mm modifiable mousemev mps nu opendevice paste pex pmbfn printencoding pt pythonhome quoteescape renderoptions rlc ruf scb scrolloff selectmode shellquote shiftwidth showmode sj smoothscroll spell spl srr statusline sw sxq tag tal tenc termwintype tgst titleold tpm ttm tw udir ur verbose viminfofile wak weirdinvert wig wildoptions winheight wm wrapscan xtermcodes
-syn keyword vimOption contained	ambiwidth ari autowriteall backupext belloff binary breakindentopt bt cd charconvert cinscopedecls cmp comments concealcursor cpp cscopetag cst cursorline dex dip eb emoji equalalways ex fdl fencs fileformats flp foldignore foldtext ft ghr guicursor guitablabel hid hl im imdisable imstyle indk isi key kpc lcs listchars ls makeef maxmapdepth mfd mmd modified mousemodel msm number operatorfunc pastetoggle pexpr popt printexpr pumheight pythonthreedll rdt report rnu ruler scf scrollopt sessionoptions shellredir shm showtabline slm sms spellcapcheck splitbelow ss stl swapfile syn tagbsearch tb term terse thesaurus titlestring tr tty twk ul ut verbosefile
+syn keyword vimOption contained	acd ambw arshape aw backupskip beval bk bri bufhidden cdh ci cinsd cms commentstring conceallevel cpt cscopetagorder csto cursorlineopt dg dir ed enc equalprg expandtab fdls fex fileignorecase fml foldlevel formatexpr gcr gli guifont guitabtooltip hidden hlg imactivatefunc imi inc inex isident keymap langmap linebreak lm lsp makeencoding maxmem mh mmp more mousemoveevent mzq numberwidth opfunc patchexpr pfn pp printfont pumwidth pythonthreehome re restorescreen ro rulerformat scl scs sft shellslash shortmess showtabline slm smoothscroll spell spl srr statusline sw sxq tag tal tenc termwintype tgst titleold tpm ttm tw udir ur verbose viminfofile warn wfh wildchar wim winminheight wmh write
+syn keyword vimOption contained	ai anti asd awa balloondelay bevalterm bkc briopt buflisted cdhome cin cinw co compatible confirm crb cscopeverbose csverb cwh dict directory edcompatible encoding errorbells exrc fdm ff filetype fmr foldlevelstart formatlistpat gd go guifontset helpfile highlight hls imactivatekey iminsert include inf isk keymodel langmenu lines lmap luadll makeprg maxmempattern mis mmt mouse mouses mzquantum nuw osfiletype patchmode ph preserveindent printheader pvh pyx readonly revins rop runtimepath scr sect sh shelltemp shortname shq sloc sms spellcapcheck splitbelow ss stl swapfile syn tagbsearch tb term terse thesaurus titlestring tr tty twk ul ut verbosefile virtualedit wb wfw wildcharm winaltkeys winminwidth wmnu writeany
+syn keyword vimOption contained	akm antialias autochdir background ballooneval bex bl brk buftype cdpath cindent cinwords cocu complete copyindent cryptmethod csl cuc debug dictionary display ef endoffile errorfile fcl fdn ffs fillchars fo foldmarker formatoptions gdefault gp guifontwide helpheight history hlsearch imaf ims includeexpr infercase iskeyword keyprotocol langnoremap linespace lnr lw mat maxmemtot mkspellmem mod mousef mouseshape mzschemedll odev pa path pheader previewheight printmbcharset pvp pyxversion redrawtime ri rs sb scroll sections shcf shelltype showbreak si sm sn spellfile splitkeep ssl stmp swapsync synmaxcol tagcase tbi termbidi textauto thesaurusfunc tl ts ttybuiltin tws undodir varsofttabstop vfile visualbell wc wh wildignore wincolor winptydll wmw writebackup
+syn keyword vimOption contained	al ar autoindent backspace balloonevalterm bexpr bo browsedir casemap cedit cink clipboard cole completefunc cot cscopepathcomp cspc cul deco diff dy efm endofline errorformat fcs fdo fic fixendofline foldclose foldmethod formatprg gfm grepformat guiheadroom helplang hk ic imak imsearch incsearch insertmode isp keywordprg langremap lisp loadplugins lz matchpairs mco ml modeline mousefocus mouset mzschemegcdll oft packpath pdev pi previewpopup printmbfont pvw qe regexpengine rightleft rtp sbo scrollbind secure shell shellxescape showcmd sidescroll smartcase so spelllang splitright ssop sts swb syntax tagfunc tbidi termencoding textmode tildeop tm tsl ttyfast twsl undofile vartabstop vi vop wcm whichwrap wildignorecase window winwidth wop writedelay
+syn keyword vimOption contained	aleph arab autoread backup balloonexpr bg bomb bs cb cf cinkeys cm colorcolumn completeopt cp cscopeprg csprg culopt def diffexpr ea ei eof esckeys fdc fdt fileencoding fixeol foldcolumn foldminlines fp gfn grepprg guiligatures hf hkmap icon imc imsf inde is isprint km laststatus lispoptions lop ma matchtime mef mle modelineexpr mousehide mousetime nf ofu para penc pm previewwindow printoptions pw qftf relativenumber rightleftcmd ru sbr scrollfocus sel shellcmdflag shellxquote showcmdloc sidescrolloff smartindent softtabstop spelloptions spo st su swf ta taglength tbis termguicolors textwidth timeout to tsr ttym twt undolevels vb viewdir vsts wcr wi wildmenu winfixheight wiv wrap ws
+syn keyword vimOption contained	allowrevins arabic autoshelldir backupcopy bdir bh breakat bsdir cc cfu cino cmdheight columns completepopup cpo cscopequickfix csqf cursorbind define diffopt ead ek eol et fde fen fileencodings fk foldenable foldnestmax fs gfs gtl guioptions hh hkmapp iconstring imcmdline imst indentexpr isf joinspaces kmp lazyredraw lispwords lpl macatsui maxcombine menc mls modelines mousem mp nrformats omnifunc paragraphs perldll pmbcs printdevice prompt pythondll quickfixtextfunc remap rl rubydll sc scrolljump selection shellpipe shiftround showfulltag signcolumn smarttab sol spellsuggest spr sta sua switchbuf tabline tagrelative tbs termwinkey tf timeoutlen toolbar tsrfu ttymouse tx undoreload vbs viewoptions vts wd wic wildmode winfixwidth wiw wrapmargin ww
+syn keyword vimOption contained	altkeymap arabicshape autowrite backupdir bdlay bin breakindent bsk ccv ch cinoptions cmdwinheight com completeslash cpoptions cscoperelative csre cursorcolumn delcombine digraph eadirection emo ep eventignore fdi fenc fileformat fkmap foldexpr foldopen fsync gfw gtt guipty hi hkp ignorecase imd imstatusfunc indentkeys isfname js kp lbr list lrm magic maxfuncdepth menuitems mm modifiable mousemev mps nu opendevice paste pex pmbfn printencoding pt pythonhome quoteescape renderoptions rlc ruf scb scrolloff selectmode shellquote shiftwidth showmatch siso smc sp spf sps stal suffixes sws tabpagemax tags tc termwinscroll tfu title toolbariconsize ttimeout ttyscroll uc updatecount vdir vif wa weirdinvert wig wildoptions winheight wm wrapscan xtermcodes
+syn keyword vimOption contained	ambiwidth ari autowriteall backupext belloff binary breakindentopt bt cd charconvert cinscopedecls cmp comments concealcursor cpp cscopetag cst cursorline dex dip eb emoji equalalways ex fdl fencs fileformats flp foldignore foldtext ft ghr guicursor guitablabel hid hl im imdisable imstyle indk isi key kpc lcs listchars ls makeef maxmapdepth mfd mmd modified mousemodel msm number operatorfunc pastetoggle pexpr popt printexpr pumheight pythonthreedll rdt report rnu ruler scf scrollopt sessionoptions shellredir shm showmode sj smd spc spk sr startofline suffixesadd sxe tabstop tagstack tcldll termwinsize tgc titlelen top ttimeoutlen ttytype udf updatetime ve viminfo wak
 
 " vimOptions: These are the turn-off setting variants {{{2
 syn keyword vimOption contained	noacd noallowrevins noantialias noarabic noarshape noautoindent noautowrite noawa noballoonevalterm nobin nobl nobri noci nocompatible nocp nocscopetag nocst nocul nocursorline nodg noea noedcompatible noemoji noeof noerrorbells noex nofen nofixendofline nofkmap nofsync noguipty nohk nohkp noic noim noimd noinf nois nolangnoremap nolbr nolist nolpl noma nomh nomod nomodifiable nomousef nonu noopendevice nopreserveindent noprompt noreadonly noremap norevins norightleft nornu nors noruler nosc noscf noscrollfocus nosecure noshellslash noshiftround noshowcmd noshowmatch nosi nosmartcase nosmarttab nosmoothscroll nosn nospell nosplitright nosr nosta nostmp noswf notagbsearch notagstack notbidi notermbidi notextauto notf notildeop notitle notop nottimeout nottyfast noudf novb nowa nowb nowfh nowic nowildmenu nowinfixwidth nowmnu nowrapscan nowriteany nows
@@ -78,12 +78,12 @@
 syn case match
 
 " Function Names {{{2
-syn keyword vimFuncName contained	abs argc assert_equal assert_match atan balloon_show bufexists bufwinid ceil ch_canread ch_getbufnr ch_read ch_status complete_check count deletebufline digraph_set eval exists_compiled extendnew findfile fnameescape foldtextresult get getchar getcmdline getcurpos getfsize getloclist getpos gettabinfo getwinpos globpath histdel hlset input insert islocked job_start json_decode libcallnr listener_add luaeval mapset matchend max mzeval perleval popup_create popup_findinfo popup_list popup_setoptions printf prop_add prop_remove prop_type_list pyxeval readdirex reltime remote_peek rename rubyeval screenpos searchdecl serverlist setcharsearch setfperm setqflist setwinvar sign_getdefined sign_undefine sinh sound_playevent split str2list strdisplaywidth strlen strwidth swapname synstack tabpagewinnr tempname term_getansicolors term_getscrolled terminalprops term_setapi term_wait test_garbagecollect_soon test_null_channel test_null_partial test_setmouse timer_info tolower type values winbufnr win_getid win_id2win winnr win_splitmove
-syn keyword vimFuncName contained	acos argidx assert_equalfile assert_nobeep atan2 balloon_split buflisted bufwinnr changenr ch_close ch_getjob ch_readblob cindent complete_info cscope_connection did_filetype digraph_setlist eventhandler exp feedkeys flatten fnamemodify foreground getbufinfo getcharmod getcmdpos getcursorcharpos getftime getmarklist getqflist gettabvar getwinposx has histget hostname inputdialog interrupt isnan job_status json_encode line listener_flush map match matchfuzzy menu_info nextnonblank popup_atcursor popup_dialog popup_findpreview popup_locate popup_settext prompt_getprompt prop_add_list prop_type_add pum_getpos rand readfile reltimefloat remote_read repeat screenattr screenrow searchpair setbufline setcmdline setline setreg sha256 sign_getplaced sign_unplace slice sound_playfile sqrt str2nr strftime strpart submatch synconcealed system tagfiles term_dumpdiff term_getattr term_getsize term_list term_setkill test_alloc_fail test_getvalue test_null_dict test_null_string test_settime timer_pause toupper typename virtcol wincol win_gettype winlayout winrestcmd winwidth
-syn keyword vimFuncName contained	add arglistid assert_exception assert_notequal autocmd_add blob2list bufload byte2line char2nr ch_close_in ch_info ch_readraw clearmatches confirm cursor diff_filler echoraw executable expand filereadable flattennew foldclosed fullcommand getbufline getcharpos getcmdscreenpos getcwd getftype getmatches getreg gettabwinvar getwinposy has_key histnr iconv inputlist invert items job_stop keys line2byte listener_remove maparg matchadd matchfuzzypos min nr2char popup_beval popup_filter_menu popup_getoptions popup_menu popup_show prompt_setcallback prop_clear prop_type_change pumvisible range reduce reltimestr remote_send resolve screenchar screenstring searchpairpos setbufvar setcmdpos setloclist settabvar shellescape sign_jump sign_unplacelist sort sound_stop srand strcharlen strgetchar strptime substitute synID systemlist taglist term_dumpload term_getcursor term_getstatus term_scrape term_setrestore test_autochdir test_gui_event test_null_function test_option_not_set test_srand_seed timer_start tr undofile virtcol2col windowsversion win_gotoid winline winrestview wordcount
-syn keyword vimFuncName contained	and argv assert_fails assert_notmatch autocmd_delete browse bufloaded byteidx charclass chdir ch_log ch_sendexpr col copy debugbreak diff_hlID empty execute expandcmd filewritable float2nr foldclosedend funcref getbufoneline getcharsearch getcmdtype getenv getimstatus getmousepos getreginfo gettagstack getwinvar haslocaldir hlexists indent inputrestore isabsolutepath job_getchannel join keytrans lispindent localtime mapcheck matchaddpos matchlist mkdir or popup_clear popup_filter_yesno popup_getpos popup_move pow prompt_setinterrupt prop_find prop_type_delete py3eval readblob reg_executing remote_expr remote_startserver reverse screenchars search searchpos setcellwidths setcursorcharpos setmatches settabwinvar shiftwidth sign_place simplify sound_clear spellbadword state strcharpart stridx strridx swapfilelist synIDattr tabpagebuflist tan term_dumpwrite term_getjob term_gettitle term_sendkeys term_setsize test_feedinput test_ignore_error test_null_job test_override test_unknown timer_stop trim undotree visualmode win_execute winheight win_move_separator winsaveview writefile
-syn keyword vimFuncName contained	append asin assert_false assert_report autocmd_get browsedir bufname byteidxcomp charcol ch_evalexpr ch_logfile ch_sendraw complete cos deepcopy digraph_get environ exepath expr10 filter floor foldlevel function getbufvar getcharstr getcmdwintype getfontname getjumplist getmouseshape getregtype gettext glob hasmapto hlget index inputsave isdirectory job_info js_decode len list2blob log maplist matcharg matchstr mode pathshorten popup_close popup_findecho popup_hide popup_notification prevnonblank prompt_setprompt prop_list prop_type_get pyeval readdir reg_recording remote_foreground remove round screencol searchcount server2client setcharpos setenv setpos settagstack sign_define sign_placelist sin soundfold spellsuggest str2float strchars string strtrans swapinfo synIDtrans tabpagenr tanh term_getaltscreen term_getline term_gettty term_setansicolors term_start test_garbagecollect_now test_null_blob test_null_list test_refcount test_void timer_stopall trunc uniq wildmenumode win_findbuf win_id2tabwin win_move_statusline win_screenpos xor
-syn keyword vimFuncName contained	appendbufline assert_beeps assert_inrange assert_true balloon_gettext bufadd bufnr call charidx ch_evalraw ch_open ch_setoptions complete_add cosh delete digraph_getlist escape exists extend finddir fmod foldtext garbagecollect getchangelist getcmdcompltype getcompletion getfperm getline getpid getscriptinfo getwininfo glob2regpat histadd hlID indexof inputsecret isinf job_setoptions js_encode libcall list2str log10 mapnew matchdelete matchstrpos
+syn keyword vimFuncName contained	abs argc assert_equal assert_match atan balloon_show bufexists bufwinid ceil ch_canread ch_getbufnr ch_read ch_status complete_check count deletebufline digraph_set eval exists_compiled extendnew findfile fnameescape foldtextresult get getchar getcmdline getcurpos getfsize getloclist getpos gettabinfo getwinpos globpath histdel hlset input insert islocked job_start json_decode libcallnr listener_add luaeval mapset matchend max nextnonblank popup_atcursor popup_dialog popup_findpreview popup_locate popup_settext prompt_getprompt prop_add_list prop_type_add pum_getpos rand readfile reltimefloat remote_read repeat screenattr screenrow searchpair setbufline setcmdline setline setreg sha256 sign_getplaced sign_unplace slice sound_playfile sqrt str2nr strftime strpart submatch synconcealed system tagfiles term_dumpdiff term_getattr term_getsize term_list term_setkill test_alloc_fail test_getvalue test_null_channel test_null_partial test_setmouse timer_info tolower type values winbufnr win_getid win_id2win winnr win_splitmove
+syn keyword vimFuncName contained	acos argidx assert_equalfile assert_nobeep atan2 balloon_split buflisted bufwinnr changenr ch_close ch_getjob ch_readblob cindent complete_info cscope_connection did_filetype digraph_setlist eventhandler exp feedkeys flatten fnamemodify foreground getbufinfo getcharmod getcmdpos getcursorcharpos getftime getmarklist getqflist gettabvar getwinposx has histget hostname inputdialog interrupt isnan job_status json_encode line listener_flush map match matchfuzzy menu_info nr2char popup_beval popup_filter_menu popup_getoptions popup_menu popup_show prompt_setcallback prop_clear prop_type_change pumvisible range reduce reltimestr remote_send resolve screenchar screenstring searchpairpos setbufvar setcmdpos setloclist settabvar shellescape sign_jump sign_unplacelist sort sound_stop srand strcharlen strgetchar strptime substitute synID systemlist taglist term_dumpload term_getcursor term_getstatus term_scrape term_setrestore test_autochdir test_gui_event test_null_dict test_null_string test_settime timer_pause toupper typename virtcol wincol win_gettype winlayout winrestcmd winwidth
+syn keyword vimFuncName contained	add arglistid assert_exception assert_notequal autocmd_add blob2list bufload byte2line char2nr ch_close_in ch_info ch_readraw clearmatches confirm cursor diff_filler echoraw executable expand filereadable flattennew foldclosed fullcommand getbufline getcharpos getcmdscreenpos getcwd getftype getmatches getreg gettabwinvar getwinposy has_key histnr iconv inputlist invert items job_stop keys line2byte listener_remove maparg matchadd matchfuzzypos min or popup_clear popup_filter_yesno popup_getpos popup_move pow prompt_setinterrupt prop_find prop_type_delete py3eval readblob reg_executing remote_expr remote_startserver reverse screenchars search searchpos setcellwidths setcursorcharpos setmatches settabwinvar shiftwidth sign_place simplify sound_clear spellbadword state strcharpart stridx strridx swapfilelist synIDattr tabpagebuflist tan term_dumpwrite term_getjob term_gettitle term_sendkeys term_setsize test_feedinput test_ignore_error test_null_function test_option_not_set test_srand_seed timer_start tr undofile virtcol2col windowsversion win_gotoid winline winrestview wordcount
+syn keyword vimFuncName contained	and argv assert_fails assert_notmatch autocmd_delete browse bufloaded byteidx charclass chdir ch_log ch_sendexpr col copy debugbreak diff_hlID empty execute expandcmd filewritable float2nr foldclosedend funcref getbufoneline getcharsearch getcmdtype getenv getimstatus getmousepos getreginfo gettagstack getwinvar haslocaldir hlexists indent inputrestore isabsolutepath job_getchannel join keytrans lispindent localtime mapcheck matchaddpos matchlist mkdir pathshorten popup_close popup_findecho popup_hide popup_notification prevnonblank prompt_setprompt prop_list prop_type_get pyeval readdir reg_recording remote_foreground remove round screencol searchcount server2client setcharpos setenv setpos settagstack sign_define sign_placelist sin soundfold spellsuggest str2float strchars string strtrans swapinfo synIDtrans tabpagenr tanh term_getaltscreen term_getline term_gettty term_setansicolors term_start test_garbagecollect_now test_mswin_event test_null_job test_override test_unknown timer_stop trim undotree visualmode win_execute winheight win_move_separator winsaveview writefile
+syn keyword vimFuncName contained	append asin assert_false assert_report autocmd_get browsedir bufname byteidxcomp charcol ch_evalexpr ch_logfile ch_sendraw complete cos deepcopy digraph_get environ exepath expr10 filter floor foldlevel function getbufvar getcharstr getcmdwintype getfontname getjumplist getmouseshape getregtype gettext glob hasmapto hlget index inputsave isdirectory job_info js_decode len list2blob log maplist matcharg matchstr mode perleval popup_create popup_findinfo popup_list popup_setoptions printf prop_add prop_remove prop_type_list pyxeval readdirex reltime remote_peek rename rubyeval screenpos searchdecl serverlist setcharsearch setfperm setqflist setwinvar sign_getdefined sign_undefine sinh sound_playevent split str2list strdisplaywidth strlen strwidth swapname synstack tabpagewinnr tempname term_getansicolors term_getscrolled terminalprops term_setapi term_wait test_garbagecollect_soon test_null_blob test_null_list test_refcount test_void timer_stopall trunc uniq wildmenumode win_findbuf win_id2tabwin win_move_statusline win_screenpos xor
+syn keyword vimFuncName contained	appendbufline assert_beeps assert_inrange assert_true balloon_gettext bufadd bufnr call charidx ch_evalraw ch_open ch_setoptions complete_add cosh delete digraph_getlist escape exists extend finddir fmod foldtext garbagecollect getchangelist getcmdcompltype getcompletion getfperm getline getpid getscriptinfo getwininfo glob2regpat histadd hlID indexof inputsecret isinf job_setoptions js_encode libcall list2str log10 mapnew matchdelete matchstrpos mzeval
 
 "--- syntax here and above generated by mkvimvim ---
 " Special Vim Highlighting (not automatic) {{{1
@@ -353,7 +353,7 @@
 syn region	vimSubstRep4    contained	matchgroup=vimSubstDelim start="\z(.\)" skip="\\\\\|\\\z1" end="\z1" matchgroup=vimNotation end="<[cC][rR]>" contains=@vimSubstRepList	nextgroup=vimSubstFlagErr	oneline
 syn region	vimCollection   contained transparent	start="\\\@<!\[" skip="\\\[" end="\]"	contains=vimCollClass
 syn match	vimCollClassErr contained	"\[:.\{-\}:\]"
-syn match	vimCollClass    contained transparent	"\%#=1\[:\(alnum\|alpha\|blank\|cntrl\|digit\|graph\|lower\|print\|punct\|space\|upper\|xdigit\|return\|tab\|escape\|backspace\):\]"
+syn match	vimCollClass    contained transparent	"\%#=1\[:\(alnum\|alpha\|blank\|cntrl\|digit\|graph\|lower\|print\|punct\|space\|upper\|xdigit\|retu\%[rn]\|tab\|escape\|backspace\):\]"
 syn match	vimSubstSubstr  contained	"\\z\=\d"
 syn match	vimSubstTwoBS   contained	"\\\\"
 syn match	vimSubstFlagErr contained	"[^< \t\r|]\+" contains=vimSubstFlags
@@ -453,7 +453,7 @@
 " Angle-Bracket Notation: (tnx to Michael Geddes) {{{2
 " ======================
 syn case ignore
-syn match	vimNotation	"\%#=1\(\\\|<lt>\)\=<\([scamd]-\)\{0,4}x\=\(f\d\{1,2}\|[^ \t:]\|cmd\|cr\|lf\|linefeed\|return\|k\=del\%[ete]\|bs\|backspace\|tab\|esc\|right\|left\|help\|undo\|insert\|ins\|mouse\|k\=home\|k\=end\|kplus\|kminus\|kdivide\|kmultiply\|kenter\|kpoint\|space\|k\=\(page\)\=\(\|down\|up\|k\d\>\)\)>" contains=vimBracket
+syn match	vimNotation	"\%#=1\(\\\|<lt>\)\=<\([scamd]-\)\{0,4}x\=\(f\d\{1,2}\|[^ \t:]\|cmd\|cr\|lf\|linefeed\|retu\%[rn]\|k\=del\%[ete]\|bs\|backspace\|tab\|esc\|right\|left\|help\|undo\|insert\|ins\|mouse\|k\=home\|k\=end\|kplus\|kminus\|kdivide\|kmultiply\|kenter\|kpoint\|space\|k\=\(page\)\=\(\|down\|up\|k\d\>\)\)>" contains=vimBracket
 syn match	vimNotation	"\%#=1\(\\\|<lt>\)\=<\([scam2-4]-\)\{0,4}\(right\|left\|middle\)\(mouse\)\=\(drag\|release\)\=>"	contains=vimBracket
 syn match	vimNotation	"\%#=1\(\\\|<lt>\)\=<\(bslash\|plug\|sid\|space\|bar\|nop\|nul\|lt\)>"			contains=vimBracket
 syn match	vimNotation	'\(\\\|<lt>\)\=<C-R>[0-9a-z"%#:.\-=]'he=e-1				contains=vimBracket
@@ -481,7 +481,7 @@
  syn match	vimBufnrWarn	/\<bufnr\s*(\s*["']\.['"]\s*)/
 endif
 
-syn match vimNotFunc	"\<if\>\|\<el\%[seif]\>\|\<return\>\|\<while\>"	skipwhite nextgroup=vimOper,vimOperParen,vimVar,vimFunc,vimNotation
+syn match vimNotFunc	"\<if\>\|\<el\%[seif]\>\|\<retu\%[rn]\>\|\<while\>"	skipwhite nextgroup=vimOper,vimOperParen,vimVar,vimFunc,vimNotation
 
 " Norm: {{{2
 " ====
