diff --git a/src/change.c b/src/change.c
index 3a823b6..44c2f04 100644
--- a/src/change.c
+++ b/src/change.c
@@ -693,7 +693,7 @@
  * Like changed_bytes() but also adjust text properties for "added" bytes.
  * When "added" is negative text was deleted.
  */
-    static void
+    void
 inserted_bytes(linenr_T lnum, colnr_T col, int added UNUSED)
 {
 #ifdef FEAT_PROP_POPUP
diff --git a/src/ops.c b/src/ops.c
index 2988a18..d572940 100644
--- a/src/ops.c
+++ b/src/ops.c
@@ -481,6 +481,7 @@
     int		count = 0;	// extra spaces to replace a cut TAB
     int		spaces = 0;	// non-zero if cutting a TAB
     colnr_T	offset;		// pointer along new line
+    colnr_T	startcol;	// column where insert starts
     unsigned	s_len;		// STRLEN(s)
     char_u	*newp, *oldp;	// new, old lines
     linenr_T	lnum;		// loop var
@@ -553,9 +554,10 @@
 
 	// insert pre-padding
 	vim_memset(newp + offset, ' ', (size_t)spaces);
+	startcol = offset + spaces;
 
 	// copy the new text
-	mch_memmove(newp + offset + spaces, s, (size_t)s_len);
+	mch_memmove(newp + startcol, s, (size_t)s_len);
 	offset += s_len;
 
 	if (spaces && !bdp->is_short)
@@ -574,6 +576,10 @@
 
 	ml_replace(lnum, newp, FALSE);
 
+	if (b_insert)
+	    // correct any text properties
+	    inserted_bytes(lnum, startcol, s_len);
+
 	if (lnum == oap->end.lnum)
 	{
 	    // Set "']" mark to the end of the block instead of the end of
diff --git a/src/proto/change.pro b/src/proto/change.pro
index badb19d..69ba2a6 100644
--- a/src/proto/change.pro
+++ b/src/proto/change.pro
@@ -9,6 +9,7 @@
 void invoke_listeners(buf_T *buf);
 void remove_listeners(buf_T *buf);
 void changed_bytes(linenr_T lnum, colnr_T col);
+void inserted_bytes(linenr_T lnum, colnr_T col, int added);
 void appended_lines(linenr_T lnum, long count);
 void appended_lines_mark(linenr_T lnum, long count);
 void deleted_lines(linenr_T lnum, long count);
diff --git a/src/testdir/test_textprop.vim b/src/testdir/test_textprop.vim
index ae84cf9..5bd7e95 100644
--- a/src/testdir/test_textprop.vim
+++ b/src/testdir/test_textprop.vim
@@ -1314,4 +1314,35 @@
   call prop_type_delete('test')
 endfunc
 
+func Test_prop_block_insert()
+  new
+  call prop_type_add('test', {'highlight': 'ErrorMsg'})
+  call setline(1, ['one ', 'two '])
+  call prop_add(1, 1, {'length': 3, 'type': 'test'})
+  call prop_add(2, 1, {'length': 3, 'type': 'test'})
+
+  " insert "xx" in the first column of both lines
+  exe "normal! gg0\<C-V>jIxx\<Esc>"
+  eval getline(1, 2)->assert_equal(['xxone ', 'xxtwo '])
+  let expected = [#{id: 0, col: 3, end: 1, type: 'test', length: 3, start: 1}]
+  eval prop_list(1)->assert_equal(expected)
+  eval prop_list(2)->assert_equal(expected)
+
+  " insert "yy" inside the text props to make them longer
+  exe "normal! gg03l\<C-V>jIyy\<Esc>"
+  eval getline(1, 2)->assert_equal(['xxoyyne ', 'xxtyywo '])
+  let expected[0].length = 5
+  eval prop_list(1)->assert_equal(expected)
+  eval prop_list(2)->assert_equal(expected)
+
+  " insert "zz" after the text props, text props don't change
+  exe "normal! gg07l\<C-V>jIzz\<Esc>"
+  eval getline(1, 2)->assert_equal(['xxoyynezz ', 'xxtyywozz '])
+  eval prop_list(1)->assert_equal(expected)
+  eval prop_list(2)->assert_equal(expected)
+
+  bwipe!
+  call prop_type_delete('test')
+endfunc
+
 " vim: shiftwidth=2 sts=2 expandtab
diff --git a/src/version.c b/src/version.c
index f4b0241..6aa02b4 100644
--- a/src/version.c
+++ b/src/version.c
@@ -751,6 +751,8 @@
 static int included_patches[] =
 {   /* Add new patch number below this line */
 /**/
+    1690,
+/**/
     1689,
 /**/
     1688,
