diff --git a/src/cmdexpand.c b/src/cmdexpand.c
index 3ef3e1d..e7cf819 100644
--- a/src/cmdexpand.c
+++ b/src/cmdexpand.c
@@ -992,7 +992,7 @@
     }
 
     // 3. Skip over the range to find the command.
-    cmd = skip_range(cmd, &xp->xp_context);
+    cmd = skip_range(cmd, TRUE, &xp->xp_context);
     xp->xp_pattern = cmd;
     if (*cmd == NUL)
 	return NULL;
diff --git a/src/ex_docmd.c b/src/ex_docmd.c
index 6495db6..ed52b46 100644
--- a/src/ex_docmd.c
+++ b/src/ex_docmd.c
@@ -1779,9 +1779,7 @@
     may_have_range = !vim9script || starts_with_colon;
     if (may_have_range)
 #endif
-	ea.cmd = skip_range(ea.cmd, NULL);
-    if (*ea.cmd == '*' && vim_strchr(p_cpo, CPO_STAR) == NULL)
-	ea.cmd = skipwhite(ea.cmd + 1);
+	ea.cmd = skip_range(ea.cmd, TRUE, NULL);
 
 #ifdef FEAT_EVAL
     if (vim9script && !starts_with_colon)
@@ -2683,7 +2681,7 @@
 	    return FAIL;
 	}
 
-	p = skip_range(eap->cmd, NULL);
+	p = skip_range(eap->cmd, TRUE, NULL);
 	switch (*p)
 	{
 	    // When adding an entry, also modify cmd_exists().
@@ -3534,7 +3532,8 @@
     char_u *
 skip_range(
     char_u	*cmd,
-    int		*ctx)	// pointer to xp_context or NULL
+    int		skip_star,	// skip "*" used for Visual range
+    int		*ctx)		// pointer to xp_context or NULL
 {
     unsigned	delim;
 
@@ -3569,6 +3568,10 @@
     while (*cmd == ':')
 	cmd = skipwhite(cmd + 1);
 
+    // Skip "*" used for Visual range.
+    if (skip_star && *cmd == '*' && vim_strchr(p_cpo, CPO_STAR) == NULL)
+	cmd = skipwhite(cmd + 1);
+
     return cmd;
 }
 
diff --git a/src/ex_getln.c b/src/ex_getln.c
index 2c157ee..b46748f 100644
--- a/src/ex_getln.c
+++ b/src/ex_getln.c
@@ -187,8 +187,12 @@
  * May change the last search pattern.
  */
     static int
-do_incsearch_highlighting(int firstc, int *search_delim, incsearch_state_T *is_state,
-						     int *skiplen, int *patlen)
+do_incsearch_highlighting(
+	int		    firstc,
+	int		    *search_delim,
+	incsearch_state_T   *is_state,
+	int		    *skiplen,
+	int		    *patlen)
 {
     char_u	*cmd;
     cmdmod_T	save_cmdmod = cmdmod;
@@ -230,7 +234,7 @@
     parse_command_modifiers(&ea, &dummy, TRUE);
     cmdmod = save_cmdmod;
 
-    cmd = skip_range(ea.cmd, NULL);
+    cmd = skip_range(ea.cmd, TRUE, NULL);
     if (vim_strchr((char_u *)"sgvl", *cmd) == NULL)
 	goto theend;
 
diff --git a/src/proto/ex_docmd.pro b/src/proto/ex_docmd.pro
index 3ed1523..7d46f15 100644
--- a/src/proto/ex_docmd.pro
+++ b/src/proto/ex_docmd.pro
@@ -16,7 +16,7 @@
 int cmd_exists(char_u *name);
 cmdidx_T excmd_get_cmdidx(char_u *cmd, int len);
 long excmd_get_argt(cmdidx_T idx);
-char_u *skip_range(char_u *cmd, int *ctx);
+char_u *skip_range(char_u *cmd, int skip_star, int *ctx);
 void ex_ni(exarg_T *eap);
 int expand_filename(exarg_T *eap, char_u **cmdlinep, char **errormsgp);
 void separate_nextcmd(exarg_T *eap);
diff --git a/src/testdir/test_vim9_cmd.vim b/src/testdir/test_vim9_cmd.vim
index 4b4e58e..6b97372 100644
--- a/src/testdir/test_vim9_cmd.vim
+++ b/src/testdir/test_vim9_cmd.vim
@@ -330,6 +330,17 @@
   bwipe!
 enddef
 
+def Test_command_star_range()
+  new
+  setline(1, ['xxx foo xxx', 'xxx bar xxx', 'xxx foo xx bar'])
+  setpos("'<", [0, 1, 0, 0])
+  setpos("'>", [0, 3, 0, 0])
+  :*s/\(foo\|bar\)/baz/g
+  getline(1, 3)->assert_equal(['xxx baz xxx', 'xxx baz xxx', 'xxx baz xx baz'])
+
+  bwipe!
+enddef
+
 
 
 " vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker
diff --git a/src/userfunc.c b/src/userfunc.c
index d28125f..53514de 100644
--- a/src/userfunc.c
+++ b/src/userfunc.c
@@ -3150,7 +3150,7 @@
 	    }
 
 	    // Check for ":append", ":change", ":insert".  Not for :def.
-	    p = skip_range(p, NULL);
+	    p = skip_range(p, FALSE, NULL);
 	    if (eap->cmdidx != CMD_def
 		&& ((p[0] == 'a' && (!ASCII_ISALPHA(p[1]) || p[1] == 'p'))
 		    || (p[0] == 'c'
diff --git a/src/version.c b/src/version.c
index a59b82d..a04f93c 100644
--- a/src/version.c
+++ b/src/version.c
@@ -751,6 +751,8 @@
 static int included_patches[] =
 {   /* Add new patch number below this line */
 /**/
+    1679,
+/**/
     1678,
 /**/
     1677,
diff --git a/src/vim9compile.c b/src/vim9compile.c
index 4ef3fdc..8a46b2f 100644
--- a/src/vim9compile.c
+++ b/src/vim9compile.c
@@ -4276,7 +4276,7 @@
 	    }
 	    if (need_type(stack_type, cctx->ctx_ufunc->uf_ret_type, -1,
 							  cctx, FALSE) == FAIL)
-	    return NULL;
+		return NULL;
 	}
     }
     else
@@ -6830,7 +6830,7 @@
 	cmd = ea.cmd;
 	if (*cmd != '\'' || starts_with_colon)
 	{
-	    ea.cmd = skip_range(ea.cmd, NULL);
+	    ea.cmd = skip_range(ea.cmd, TRUE, NULL);
 	    if (ea.cmd > cmd)
 	    {
 		if (!starts_with_colon)
