diff --git a/README.md b/README.md
index 6da46dc..3230b45 100644
--- a/README.md
+++ b/README.md
@@ -15,6 +15,7 @@ Multi-line text editor can be easily put as part of your TUI application.
 - Line number
 - Cursor line highlight
 - Search with regular expressions
+- Text selection
 - Mouse scrolling
 - Yank support. Paste text deleted with `C-k`, `C-j`, ...
 - Backend agnostic. [crossterm][], [termion][], [termwiz][], and your own backend are all supported
@@ -250,6 +251,8 @@ Default key mappings are as follows:
 | `Alt+D`, `Alt+Delete`                        | Delete one word next to cursor            |
 | `Ctrl+U`                                     | Undo                                      |
 | `Ctrl+R`                                     | Redo                                      |
+| `Ctrl+C`                                     | Copy selected text                        |
+| `Ctrl+X`                                     | Cut selected text                         |
 | `Ctrl+Y`                                     | Paste yanked text                         |
 | `Ctrl+F`, `→`                                | Move cursor forward by one character      |
 | `Ctrl+B`, `←`                                | Move cursor backward by one character     |
@@ -480,7 +483,11 @@ notify how to move the cursor.
 | `textarea.delete_next_word()`                        | Delete one word next to cursor                  |
 | `textarea.undo()`                                    | Undo                                            |
 | `textarea.redo()`                                    | Redo                                            |
+| `textarea.copy()`                                    | Copy selected text                              |
+| `textarea.cut()`                                     | Cut selected text                               |
 | `textarea.paste()`                                   | Paste yanked text                               |
+| `textarea.start_selection()`                         | Start text selection                            |
+| `textarea.cancel_selection()`                        | Cancel text selection                           |
 | `textarea.move_cursor(CursorMove::Forward)`          | Move cursor forward by one character            |
 | `textarea.move_cursor(CursorMove::Back)`             | Move cursor backward by one character           |
 | `textarea.move_cursor(CursorMove::Up)`               | Move cursor up by one line                      |
diff --git a/examples/editor.rs b/examples/editor.rs
index 5d03c43..3680348 100644
--- a/examples/editor.rs
+++ b/examples/editor.rs
@@ -248,7 +248,7 @@ impl<'a> Editor<'a> {
                         Span::raw(" to save, "),
                         Span::styled("^G", Style::default().add_modifier(Modifier::BOLD)),
                         Span::raw(" to search, "),
-                        Span::styled("^X", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::styled("^T", Style::default().add_modifier(Modifier::BOLD)),
                         Span::raw(" to switch buffer"),
                     ])
                 };
@@ -314,7 +314,7 @@ impl<'a> Editor<'a> {
                         ..
                     } => break,
                     Input {
-                        key: Key::Char('x'),
+                        key: Key::Char('t'),
                         ctrl: true,
                         ..
                     } => {
diff --git a/examples/modal.rs b/examples/modal.rs
index 6ee70e2..633ff5a 100644
--- a/examples/modal.rs
+++ b/examples/modal.rs
@@ -60,7 +60,7 @@ fn main() -> io::Result<()> {
     } else {
         TextArea::default()
     };
-    textarea.set_selection_style(Style::default().bg(Color::Red));
+
     let mut mode = Mode::Normal;
     loop {
         // Show help message and current mode in title of the block
@@ -75,41 +75,32 @@ fn main() -> io::Result<()> {
 
         term.draw(|f| f.render_widget(textarea.widget(), f.size()))?;
 
-        let input: Input = crossterm::event::read()?.into();
-
-        // since this sample doesnt use input a lot of the time
-        // it must call should_select
-
-        textarea.should_select(&input);
+        let input = crossterm::event::read()?.into();
         match mode {
             Mode::Normal => match input {
                 // Mappings in normal mode
-
-                // note that the navigation keys can be pressed with or without shift
-                // if the user is selecting text
-                // so we have to look for 'h' and 'H' etc.
                 Input {
-                    key: Key::Char('h' | 'H'),
+                    key: Key::Char('h'),
                     ..
                 } => textarea.move_cursor(CursorMove::Back),
                 Input {
-                    key: Key::Char('j' | 'J'),
+                    key: Key::Char('j'),
                     ..
                 } => textarea.move_cursor(CursorMove::Down),
                 Input {
-                    key: Key::Char('k' | 'K'),
+                    key: Key::Char('k'),
                     ..
                 } => textarea.move_cursor(CursorMove::Up),
                 Input {
-                    key: Key::Char('l' | 'L'),
+                    key: Key::Char('l'),
                     ..
                 } => textarea.move_cursor(CursorMove::Forward),
                 Input {
-                    key: Key::Char('w' | 'W'),
+                    key: Key::Char('w'),
                     ..
                 } => textarea.move_cursor(CursorMove::WordForward),
                 Input {
-                    key: Key::Char('b' | 'B'),
+                    key: Key::Char('b'),
                     ctrl: false,
                     ..
                 } => textarea.move_cursor(CursorMove::WordBack),
@@ -140,13 +131,6 @@ fn main() -> io::Result<()> {
                 } => {
                     textarea.paste();
                 }
-                Input {
-                    key: Key::Char('y'),
-                    ctrl: false,
-                    ..
-                } => {
-                    textarea.copy();
-                }
                 Input {
                     key: Key::Char('u'),
                     ctrl: false,
@@ -182,8 +166,6 @@ fn main() -> io::Result<()> {
                     key: Key::Char('A'),
                     ..
                 } => {
-                    // stop selection is called to prevent 'A' being interpreted as selecting
-                    textarea.stop_selection();
                     textarea.move_cursor(CursorMove::End);
                     mode = Mode::Insert;
                 }
@@ -199,8 +181,6 @@ fn main() -> io::Result<()> {
                     key: Key::Char('O'),
                     ..
                 } => {
-                    // stop selection is called to prevent 'O' being interpreted as selecting
-                    textarea.stop_selection();
                     textarea.move_cursor(CursorMove::Head);
                     textarea.insert_newline();
                     textarea.move_cursor(CursorMove::Up);
@@ -210,7 +190,6 @@ fn main() -> io::Result<()> {
                     key: Key::Char('I'),
                     ..
                 } => {
-                    textarea.stop_selection();
                     textarea.move_cursor(CursorMove::Head);
                     mode = Mode::Insert;
                 }
@@ -248,6 +227,33 @@ fn main() -> io::Result<()> {
                     ctrl: true,
                     ..
                 } => textarea.scroll(Scrolling::PageUp),
+                Input {
+                    key: Key::Char('v'),
+                    ctrl: false,
+                    ..
+                } => textarea.start_selection(),
+                Input {
+                    key: Key::Char('V'),
+                    ctrl: false,
+                    ..
+                } => {
+                    textarea.move_cursor(CursorMove::Head);
+                    textarea.start_selection();
+                    textarea.move_cursor(CursorMove::End);
+                }
+                Input { key: Key::Esc, .. } => textarea.cancel_selection(),
+                Input {
+                    key: Key::Char('y'),
+                    ctrl: false,
+                    ..
+                } if textarea.is_selecting() => textarea.copy(),
+                Input {
+                    key: Key::Char('d'),
+                    ctrl: false,
+                    ..
+                } if textarea.is_selecting() => {
+                    textarea.cut();
+                }
                 _ => {}
             },
             Mode::Insert => match input {
diff --git a/examples/tuirs_editor.rs b/examples/tuirs_editor.rs
index c5afb69..c40a74e 100644
--- a/examples/tuirs_editor.rs
+++ b/examples/tuirs_editor.rs
@@ -250,7 +250,7 @@ impl<'a> Editor<'a> {
                         Span::raw(" to save, "),
                         Span::styled("^G", Style::default().add_modifier(Modifier::BOLD)),
                         Span::raw(" to search, "),
-                        Span::styled("^X", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::styled("^T", Style::default().add_modifier(Modifier::BOLD)),
                         Span::raw(" to switch buffer"),
                     ])
                 };
@@ -316,7 +316,7 @@ impl<'a> Editor<'a> {
                         ..
                     } => break,
                     Input {
-                        key: Key::Char('x'),
+                        key: Key::Char('t'),
                         ctrl: true,
                         ..
                     } => {
diff --git a/src/highlight.rs b/src/highlight.rs
index 82f2ac0..d834bfa 100644
--- a/src/highlight.rs
+++ b/src/highlight.rs
@@ -10,12 +10,11 @@ use std::iter;
 use tui::text::Spans as Line;
 use unicode_width::UnicodeWidthChar as _;
 
-#[derive(Debug)]
 enum Boundary {
     Cursor(Style),
+    Select(Style),
     #[cfg(feature = "search")]
     Search(Style),
-    Select(Style),
     End,
 }
 
@@ -25,8 +24,8 @@ impl Boundary {
             match b {
                 Boundary::Cursor(_) => 3,
                 #[cfg(feature = "search")]
-                Boundary::Search(_) => 1,
-                Boundary::Select(_) => 2,
+                Boundary::Search(_) => 2,
+                Boundary::Select(_) => 1,
                 Boundary::End => 0,
             }
         }
@@ -36,10 +35,10 @@ impl Boundary {
     fn style(&self) -> Option<Style> {
         match self {
             Boundary::Cursor(s) => Some(*s),
+            Boundary::Select(s) => Some(*s),
             #[cfg(feature = "search")]
             Boundary::Search(s) => Some(*s),
             Boundary::End => None,
-            Boundary::Select(s) => Some(*s),
         }
     }
 }
@@ -98,13 +97,13 @@ impl DisplayTextBuilder {
 pub struct LineHighlighter<'a> {
     line: &'a str,
     spans: Vec<Span<'a>>,
-    // reminder - the usize is the start of a section, in BYTES, not chars
     boundaries: Vec<(Boundary, usize)>, // TODO: Consider smallvec
     style_begin: Style,
     cursor_at_end: bool,
     cursor_style: Style,
     tab_len: u8,
     mask: Option<char>,
+    select_at_end: bool,
     select_style: Style,
 }
 
@@ -125,6 +124,7 @@ impl<'a> LineHighlighter<'a> {
             cursor_style,
             tab_len,
             mask,
+            select_at_end: false,
             select_style,
         }
     }
@@ -135,11 +135,6 @@ impl<'a> LineHighlighter<'a> {
             .push(Span::styled(format!("{}{} ", pad, row + 1), style));
     }
 
-    pub fn select(&mut self, start: usize, end: usize, style: Style) {
-        self.boundaries.push((Boundary::Select(style), start));
-        self.boundaries.push((Boundary::End, end));
-    }
-
     pub fn cursor_line(&mut self, cursor_col: usize, style: Style) {
         if let Some((start, c)) = self.line.char_indices().nth(cursor_col) {
             self.boundaries
@@ -151,60 +146,6 @@ impl<'a> LineHighlighter<'a> {
         self.style_begin = style;
     }
 
-    pub(crate) fn select_line(
-        &mut self,
-        row: usize,
-        line: &str,
-        start: (usize, usize),
-        end: (usize, usize),
-    ) {
-        // is this row selected?
-
-        // note that the input coordinates here are in char offsets not bytes
-        // so a lot of this code is converting from char offsets to byte offsets
-        if start.0 <= row && end.0 >= row {
-            let mut indices = line.char_indices();
-            let llen = line.len();
-            match (start.0 == row, end.0 == row) {
-                (true, true) => {
-                    // only line
-                    self.select(
-                        indices.nth(start.1).unwrap_or((llen, 'x')).0,
-                        indices.nth(end.1 - start.1).unwrap_or((llen, 'x')).0,
-                        self.select_style,
-                    );
-                }
-                (true, false) => {
-                    // a line in the start of selection
-
-                    // the +1 extends the highlight one beyond end, to show
-                    // that the newline is included
-                    // same done for middle rows below
-
-                    self.select(
-                        indices.nth(start.1).unwrap_or((llen, 'x')).0,
-                        llen + 1,
-                        self.select_style,
-                    );
-                }
-                (false, true) => {
-                    // last line
-                    if end.1 > 0 {
-                        self.select(
-                            0,
-                            indices.nth(end.1).unwrap_or((llen, 'x')).0,
-                            self.select_style,
-                        );
-                    }
-                }
-                (false, false) => {
-                    // in the middle of selection
-                    self.select(0, llen + 1, self.select_style);
-                }
-            }
-        }
-    }
-
     #[cfg(feature = "search")]
     pub fn search(&mut self, matches: impl Iterator<Item = (usize, usize)>, style: Style) {
         for (start, end) in matches {
@@ -215,6 +156,36 @@ impl<'a> LineHighlighter<'a> {
         }
     }
 
+    pub fn selection(
+        &mut self,
+        row: usize,
+        start_row: usize,
+        start_off: usize,
+        end_row: usize,
+        end_off: usize,
+    ) {
+        let (start, end) = if row == start_row {
+            if start_row == end_row {
+                (start_off, end_off)
+            } else {
+                self.select_at_end = true;
+                (start_off, self.line.len())
+            }
+        } else if row == end_row {
+            (0, end_off)
+        } else if start_row < row && row < end_row {
+            self.select_at_end = true;
+            (0, self.line.len())
+        } else {
+            return;
+        };
+        if start != end {
+            self.boundaries
+                .push((Boundary::Select(self.select_style), start));
+            self.boundaries.push((Boundary::End, end));
+        }
+    }
+
     pub fn into_spans(self) -> Line<'a> {
         let Self {
             line,
@@ -225,14 +196,20 @@ impl<'a> LineHighlighter<'a> {
             cursor_style,
             cursor_at_end,
             mask,
+            select_at_end,
             select_style,
         } = self;
         let mut builder = DisplayTextBuilder::new(tab_len, mask);
 
         if boundaries.is_empty() {
-            spans.push(Span::styled(builder.build(line), style_begin));
+            let built = builder.build(line);
+            if !built.is_empty() {
+                spans.push(Span::styled(built, style_begin));
+            }
             if cursor_at_end {
                 spans.push(Span::styled(" ", cursor_style));
+            } else if select_at_end {
+                spans.push(Span::styled(" ", select_style));
             }
             return Line::from(spans);
         }
@@ -245,18 +222,10 @@ impl<'a> LineHighlighter<'a> {
         let mut style = style_begin;
         let mut start = 0;
         let mut stack = vec![];
-        let mut dont_add_cursor = false;
+
         for (next_boundary, end) in boundaries {
             if start < end {
-                // add extra select space at line end to indicate
-                // that the \n will be deleted / included
-                if end > line.len() && style == select_style {
-                    spans.push(Span::styled(builder.build(&line[start..end - 1]), style));
-                    spans.push(Span::styled(" ", style));
-                    dont_add_cursor = true;
-                } else {
-                    spans.push(Span::styled(builder.build(&line[start..end]), style));
-                }
+                spans.push(Span::styled(builder.build(&line[start..end]), style));
             }
 
             style = if let Some(s) = next_boundary.style() {
@@ -267,20 +236,27 @@ impl<'a> LineHighlighter<'a> {
             };
             start = end;
         }
-        if start < line.len() {
+
+        if start != line.len() {
             spans.push(Span::styled(builder.build(&line[start..]), style));
         }
-        if cursor_at_end && !dont_add_cursor {
+
+        if cursor_at_end {
             spans.push(Span::styled(" ", cursor_style));
+        } else if select_at_end {
+            spans.push(Span::styled(" ", select_style));
         }
 
         Line::from(spans)
     }
 }
 
-#[cfg(test)]
+// Tests for spans don't work with tui-rs
+#[cfg(all(test, feature = "ratatui"))]
 mod tests {
     use super::*;
+    use crate::ratatui::style::Color;
+    use std::fmt::Debug;
     use unicode_width::UnicodeWidthStr as _;
 
     fn build(text: &'static str, tab: u8, mask: Option<char>) -> Cow<'static, str> {
@@ -374,5 +350,255 @@ mod tests {
         assert_eq!(&build_with_offset(2, "あ\tあ\t", 4), "あ    あ  ");
     }
 
-    // TODO: Add tests for LineHighlighter
+    fn assert_spans<T: Debug>(lh: LineHighlighter, want: &[(&str, Style)], context: T) {
+        let line = lh.into_spans();
+        let have = line
+            .spans
+            .iter()
+            .map(|s| (s.content.as_ref(), s.style))
+            .collect::<Vec<_>>();
+        assert_eq!(&have, want, "Test case: {context:?}");
+    }
+
+    const DEFAULT: Style = Style::new();
+    const CUR: Style = Style::new().bg(Color::Red); // Cursor
+    #[allow(unused)]
+    const SEARCH: Style = Style::new().bg(Color::Green);
+    const SEL: Style = Style::new().bg(Color::Blue);
+    const LINE: Style = Style::new().bg(Color::Gray);
+    const LNUM: Style = Style::new().bg(Color::Yellow);
+
+    #[test]
+    fn into_spans_normal_line() {
+        let tests = [
+            ("", &[][..]),
+            ("abc", &[("abc", DEFAULT)][..]),
+            ("a\tb\tc", &[("a   b   c", DEFAULT)][..]),
+        ];
+        for test in tests {
+            let (line, want) = test;
+            let lh = LineHighlighter::new(line, CUR, 4, None, SEL);
+            assert_spans(lh, want, test);
+        }
+    }
+
+    #[test]
+    fn into_spans_cursor_line() {
+        let tests = [
+            ("", 0, &[(" ", CUR)][..]),
+            ("a", 0, &[("a", CUR)][..]),
+            ("a", 1, &[("a", LINE), (" ", CUR)][..]),
+            ("あいう", 0, &[("あ", CUR), ("いう", LINE)][..]),
+            ("あいう", 1, &[("あ", LINE), ("い", CUR), ("う", LINE)][..]),
+            ("あいう", 2, &[("あい", LINE), ("う", CUR)][..]),
+            ("a\tb", 1, &[("a", LINE), ("   ", CUR), ("b", LINE)][..]),
+        ];
+
+        for test in tests {
+            let (line, col, want) = test;
+            let mut lh = LineHighlighter::new(line, CUR, 4, None, SEL);
+            lh.cursor_line(col, LINE);
+            assert_spans(lh, want, test);
+        }
+    }
+
+    #[test]
+    fn into_spans_line_number() {
+        let tests = [
+            (0, 1, &[(" 1 ", LNUM)][..]),
+            (123, 3, &[(" 124 ", LNUM)][..]),
+            (123, 5, &[("   124 ", LNUM)][..]),
+        ];
+        for test in tests {
+            let (row, len, want) = test;
+            let mut lh = LineHighlighter::new("", CUR, 4, None, SEL);
+            lh.line_number(row, len, LNUM);
+            assert_spans(lh, want, test);
+        }
+    }
+
+    #[cfg(feature = "search")]
+    #[test]
+    fn into_spans_search() {
+        let tests = [
+            ("abcde", &[(0, 5)][..], &[("abcde", SEARCH)][..]),
+            (
+                "abcde",
+                &[(0, 1), (2, 3), (4, 5)][..],
+                &[
+                    ("a", SEARCH),
+                    ("b", DEFAULT),
+                    ("c", SEARCH),
+                    ("d", DEFAULT),
+                    ("e", SEARCH),
+                ][..],
+            ),
+            (
+                "abcde",
+                &[(1, 2), (3, 4)][..],
+                &[
+                    ("a", DEFAULT),
+                    ("b", SEARCH),
+                    ("c", DEFAULT),
+                    ("d", SEARCH),
+                    ("e", DEFAULT),
+                ][..],
+            ),
+            (
+                "abcde",
+                &[(0, 2), (2, 4), (4, 5)][..],
+                &[("ab", SEARCH), ("cd", SEARCH), ("e", SEARCH)][..],
+            ),
+            ("abcde", &[(1, 1)][..], &[("abcde", DEFAULT)][..]),
+            (
+                "あいうえお",
+                &[(0, 3), (6, 9), (12, 15)][..],
+                &[
+                    ("あ", SEARCH),
+                    ("い", DEFAULT),
+                    ("う", SEARCH),
+                    ("え", DEFAULT),
+                    ("お", SEARCH),
+                ][..],
+            ),
+            (
+                "\ta\tb\t",
+                &[(0, 1), (2, 3), (3, 4)][..],
+                &[
+                    ("    ", SEARCH),
+                    ("a", DEFAULT),
+                    ("   ", SEARCH),
+                    ("b", SEARCH),
+                    ("   ", DEFAULT),
+                ][..],
+            ),
+        ];
+
+        for test in tests {
+            let (line, matches, want) = test;
+            let mut lh = LineHighlighter::new(line, CUR, 4, None, SEL);
+            lh.search(matches.iter().copied(), SEARCH);
+            assert_spans(lh, want, test);
+        }
+    }
+
+    #[test]
+    fn into_spans_selection() {
+        let tests = [
+            // (line, (row, start_row, start_off, end_row, end_off), want)
+            ("abc", (0, 1, 0, 2, 0), &[("abc", DEFAULT)][..]),
+            ("abc", (1, 1, 0, 1, 1), &[("a", SEL), ("bc", DEFAULT)][..]),
+            ("abc", (1, 1, 2, 1, 3), &[("ab", DEFAULT), ("c", SEL)][..]),
+            ("abc", (1, 1, 0, 1, 3), &[("abc", SEL)][..]),
+            ("abc", (1, 1, 0, 2, 0), &[("abc", SEL), (" ", SEL)][..]),
+            (
+                "abc",
+                (1, 1, 2, 2, 0),
+                &[("ab", DEFAULT), ("c", SEL), (" ", SEL)][..],
+            ),
+            ("abc", (1, 1, 3, 2, 0), &[("abc", DEFAULT), (" ", SEL)][..]),
+            ("abc", (2, 1, 0, 3, 0), &[("abc", SEL), (" ", SEL)][..]),
+            ("abc", (2, 1, 0, 2, 0), &[("abc", DEFAULT)][..]),
+            ("abc", (2, 1, 0, 2, 2), &[("ab", SEL), ("c", DEFAULT)][..]),
+            ("abc", (2, 1, 0, 2, 3), &[("abc", SEL)][..]),
+            (
+                "ab\t",
+                (1, 1, 2, 2, 0),
+                &[("ab", DEFAULT), ("  ", SEL), (" ", SEL)][..],
+            ),
+            ("a\tb", (2, 1, 0, 3, 0), &[("a   b", SEL), (" ", SEL)][..]),
+            (
+                "a\tb",
+                (2, 1, 0, 2, 2),
+                &[("a   ", SEL), ("b", DEFAULT)][..],
+            ),
+        ];
+
+        for test in tests {
+            let (line, (row, start_row, start_off, end_row, end_off), want) = test;
+            let mut lh = LineHighlighter::new(line, CUR, 4, None, SEL);
+            lh.selection(row, start_row, start_off, end_row, end_off);
+            assert_spans(lh, want, test);
+        }
+    }
+
+    #[test]
+    fn into_spans_mixed_highlights() {
+        let tests = [
+            (
+                "cursor on selection",
+                {
+                    let mut lh = LineHighlighter::new("abcde", CUR, 4, None, SEL);
+                    lh.cursor_line(2, LINE);
+                    lh.selection(0, 0, 1, 0, 4);
+                    lh
+                },
+                &[("a", LINE), ("b", SEL), ("c", CUR), ("d", SEL), ("e", LINE)][..],
+            ),
+            #[cfg(feature = "search")]
+            (
+                "cursor + selection + search",
+                {
+                    let mut lh = LineHighlighter::new("abcdefg", CUR, 4, None, SEL);
+                    lh.cursor_line(3, LINE);
+                    lh.selection(0, 0, 2, 0, 5);
+                    lh.search([(1, 2), (5, 6)].into_iter(), SEARCH);
+                    lh
+                },
+                &[
+                    ("a", LINE),
+                    ("b", SEARCH),
+                    ("c", SEL),
+                    ("d", CUR),
+                    ("e", SEL),
+                    ("f", SEARCH),
+                    ("g", LINE),
+                ][..],
+            ),
+            (
+                "selection + cursor at end",
+                {
+                    let mut lh = LineHighlighter::new("ab", CUR, 4, None, SEL);
+                    lh.cursor_line(2, LINE);
+                    lh.selection(0, 0, 1, 2, 0);
+                    lh
+                },
+                &[("a", LINE), ("b", SEL), (" ", CUR)][..],
+            ),
+            (
+                "cursor at start of selection",
+                {
+                    let mut lh = LineHighlighter::new("abcd", CUR, 4, None, SEL);
+                    lh.cursor_line(1, LINE);
+                    lh.selection(0, 0, 1, 0, 3);
+                    lh
+                },
+                &[("a", LINE), ("b", CUR), ("c", SEL), ("d", LINE)][..],
+            ),
+            (
+                "cursor at end of selection",
+                {
+                    let mut lh = LineHighlighter::new("abcd", CUR, 4, None, SEL);
+                    lh.cursor_line(2, LINE);
+                    lh.selection(0, 0, 1, 0, 3);
+                    lh
+                },
+                &[("a", LINE), ("b", SEL), ("c", CUR), ("d", LINE)][..],
+            ),
+            (
+                "cursor covers selection",
+                {
+                    let mut lh = LineHighlighter::new("abc", CUR, 4, None, SEL);
+                    lh.cursor_line(1, LINE);
+                    lh.selection(0, 0, 1, 0, 2);
+                    lh
+                },
+                &[("a", LINE), ("b", CUR), ("c", LINE)][..],
+            ),
+        ];
+
+        for (what, lh, want) in tests {
+            assert_spans(lh, want, what);
+        }
+    }
 }
diff --git a/src/input/crossterm.rs b/src/input/crossterm.rs
index 35987c8..e327ccc 100644
--- a/src/input/crossterm.rs
+++ b/src/input/crossterm.rs
@@ -79,7 +79,6 @@ impl From<MouseEvent> for Input {
         let ctrl = mouse.modifiers.contains(KeyModifiers::CONTROL);
         let alt = mouse.modifiers.contains(KeyModifiers::ALT);
         let shift = mouse.modifiers.contains(KeyModifiers::SHIFT);
-
         Self {
             key,
             ctrl,
@@ -118,27 +117,34 @@ mod tests {
         for (from, to) in [
             (
                 key_event(KeyCode::Char('a'), KeyModifiers::empty()),
-                input(Key::Char('a'), false, false),
+                input(Key::Char('a'), false, false, false),
             ),
             (
                 key_event(KeyCode::Enter, KeyModifiers::empty()),
-                input(Key::Enter, false, false),
+                input(Key::Enter, false, false, false),
             ),
             (
                 key_event(KeyCode::Left, KeyModifiers::CONTROL),
-                input(Key::Left, true, false),
+                input(Key::Left, true, false, false),
+            ),
+            (
+                key_event(KeyCode::Right, KeyModifiers::SHIFT),
+                input(Key::Right, false, false, true),
             ),
             (
                 key_event(KeyCode::Home, KeyModifiers::ALT),
-                input(Key::Home, false, true),
+                input(Key::Home, false, true, false),
             ),
             (
-                key_event(KeyCode::F(1), KeyModifiers::ALT | KeyModifiers::CONTROL),
-                input(Key::F(1), true, true),
+                key_event(
+                    KeyCode::F(1),
+                    KeyModifiers::ALT | KeyModifiers::CONTROL | KeyModifiers::SHIFT,
+                ),
+                input(Key::F(1), true, true, true),
             ),
             (
                 key_event(KeyCode::NumLock, KeyModifiers::CONTROL),
-                input(Key::Null, true, false),
+                input(Key::Null, true, false, false),
             ),
         ] {
             assert_eq!(Input::from(from), to, "{:?} -> {:?}", from, to);
@@ -150,26 +156,30 @@ mod tests {
         for (from, to) in [
             (
                 mouse_event(MouseEventKind::ScrollDown, KeyModifiers::empty()),
-                input(Key::MouseScrollDown, false, false),
+                input(Key::MouseScrollDown, false, false, false),
             ),
             (
                 mouse_event(MouseEventKind::ScrollUp, KeyModifiers::CONTROL),
-                input(Key::MouseScrollUp, true, false),
+                input(Key::MouseScrollUp, true, false, false),
+            ),
+            (
+                mouse_event(MouseEventKind::ScrollUp, KeyModifiers::SHIFT),
+                input(Key::MouseScrollUp, false, false, true),
             ),
             (
                 mouse_event(MouseEventKind::ScrollDown, KeyModifiers::ALT),
-                input(Key::MouseScrollDown, false, true),
+                input(Key::MouseScrollDown, false, true, false),
             ),
             (
                 mouse_event(
                     MouseEventKind::ScrollUp,
                     KeyModifiers::CONTROL | KeyModifiers::ALT,
                 ),
-                input(Key::MouseScrollUp, true, true),
+                input(Key::MouseScrollUp, true, true, false),
             ),
             (
                 mouse_event(MouseEventKind::Moved, KeyModifiers::CONTROL),
-                input(Key::Null, true, false),
+                input(Key::Null, true, false, false),
             ),
         ] {
             assert_eq!(Input::from(from), to, "{:?} -> {:?}", from, to);
@@ -181,16 +191,16 @@ mod tests {
         for (from, to) in [
             (
                 Event::Key(key_event(KeyCode::Char('a'), KeyModifiers::empty())),
-                input(Key::Char('a'), false, false),
+                input(Key::Char('a'), false, false, false),
             ),
             (
                 Event::Mouse(mouse_event(
                     MouseEventKind::ScrollDown,
                     KeyModifiers::empty(),
                 )),
-                input(Key::MouseScrollDown, false, false),
+                input(Key::MouseScrollDown, false, false, false),
             ),
-            (Event::FocusGained, input(Key::Null, false, false)),
+            (Event::FocusGained, input(Key::Null, false, false, false)),
         ] {
             assert_eq!(Input::from(from.clone()), to, "{:?} -> {:?}", from, to);
         }
@@ -201,7 +211,7 @@ mod tests {
     fn ignore_key_release_event() {
         let mut from = key_event(KeyCode::Char('a'), KeyModifiers::empty());
         from.kind = KeyEventKind::Release;
-        let to = input(Key::Null, false, false);
+        let to = input(Key::Null, false, false, false);
         assert_eq!(Input::from(from), to, "{:?} -> {:?}", from, to);
     }
 }
diff --git a/src/input/mod.rs b/src/input/mod.rs
index 1a344cc..1eb224e 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -90,7 +90,8 @@ impl Default for Key {
 /// textarea.input(Input {
 ///     key: Key::Char('a'),
 ///     ctrl: true,
-///     alt: false,shift:false
+///     alt: false,
+///     shift: false,
 /// });
 /// ```
 #[derive(Debug, Clone, Default, PartialEq, Hash)]
@@ -102,7 +103,7 @@ pub struct Input {
     pub ctrl: bool,
     /// Alt modifier key. `true` means Alt key was pressed.
     pub alt: bool,
-    // Shift key.  `true` means Shift key was pressed.
+    /// Shift modifier key. `true` means Alt key was pressed.
     pub shift: bool,
 }
 
@@ -111,12 +112,12 @@ mod tests {
     use super::*;
 
     #[allow(dead_code)]
-    pub(crate) fn input(key: Key, ctrl: bool, alt: bool) -> Input {
+    pub(crate) fn input(key: Key, ctrl: bool, alt: bool, shift: bool) -> Input {
         Input {
             key,
             ctrl,
             alt,
-            shift: false,
+            shift,
         }
     }
 
diff --git a/src/input/termion.rs b/src/input/termion.rs
index 8aef36d..545c4b3 100644
--- a/src/input/termion.rs
+++ b/src/input/termion.rs
@@ -17,7 +17,6 @@ impl From<KeyEvent> for Input {
     fn from(key: KeyEvent) -> Self {
         let mut ctrl = false;
         let mut alt = false;
-        let shift = false;
         let key = match key {
             KeyEvent::Char('\n' | '\r') => Key::Enter,
             KeyEvent::Char(c) => Key::Char(c),
@@ -49,7 +48,7 @@ impl From<KeyEvent> for Input {
             key,
             ctrl,
             alt,
-            shift,
+            shift: false,
         }
     }
 }
@@ -90,14 +89,23 @@ mod tests {
     #[test]
     fn key_to_input() {
         for (from, to) in [
-            (KeyEvent::Char('a'), input(Key::Char('a'), false, false)),
-            (KeyEvent::Ctrl('a'), input(Key::Char('a'), true, false)),
-            (KeyEvent::Alt('a'), input(Key::Char('a'), false, true)),
-            (KeyEvent::Char('\n'), input(Key::Enter, false, false)),
-            (KeyEvent::Char('\r'), input(Key::Enter, false, false)),
-            (KeyEvent::F(1), input(Key::F(1), false, false)),
-            (KeyEvent::BackTab, input(Key::Tab, false, false)),
-            (KeyEvent::Null, input(Key::Null, false, false)),
+            (
+                KeyEvent::Char('a'),
+                input(Key::Char('a'), false, false, false),
+            ),
+            (
+                KeyEvent::Ctrl('a'),
+                input(Key::Char('a'), true, false, false),
+            ),
+            (
+                KeyEvent::Alt('a'),
+                input(Key::Char('a'), false, true, false),
+            ),
+            (KeyEvent::Char('\n'), input(Key::Enter, false, false, false)),
+            (KeyEvent::Char('\r'), input(Key::Enter, false, false, false)),
+            (KeyEvent::F(1), input(Key::F(1), false, false, false)),
+            (KeyEvent::BackTab, input(Key::Tab, false, false, false)),
+            (KeyEvent::Null, input(Key::Null, false, false, false)),
         ] {
             assert_eq!(Input::from(from), to, "{:?} -> {:?}", from, to);
         }
@@ -108,18 +116,24 @@ mod tests {
         for (from, to) in [
             (
                 MouseEvent::Press(MouseButton::WheelDown, 1, 1),
-                input(Key::MouseScrollDown, false, false),
+                input(Key::MouseScrollDown, false, false, false),
             ),
             (
                 MouseEvent::Press(MouseButton::WheelUp, 1, 1),
-                input(Key::MouseScrollUp, false, false),
+                input(Key::MouseScrollUp, false, false, false),
             ),
             (
                 MouseEvent::Press(MouseButton::Left, 1, 1),
-                input(Key::Null, false, false),
+                input(Key::Null, false, false, false),
+            ),
+            (
+                MouseEvent::Release(1, 1),
+                input(Key::Null, false, false, false),
+            ),
+            (
+                MouseEvent::Hold(1, 1),
+                input(Key::Null, false, false, false),
             ),
-            (MouseEvent::Release(1, 1), input(Key::Null, false, false)),
-            (MouseEvent::Hold(1, 1), input(Key::Null, false, false)),
         ] {
             assert_eq!(Input::from(from), to, "{:?} -> {:?}", from, to);
         }
@@ -130,13 +144,16 @@ mod tests {
         for (from, to) in [
             (
                 Event::Key(KeyEvent::Char('a')),
-                input(Key::Char('a'), false, false),
+                input(Key::Char('a'), false, false, false),
             ),
             (
                 Event::Mouse(MouseEvent::Press(MouseButton::WheelDown, 1, 1)),
-                input(Key::MouseScrollDown, false, false),
+                input(Key::MouseScrollDown, false, false, false),
+            ),
+            (
+                Event::Unsupported(vec![]),
+                input(Key::Null, false, false, false),
             ),
-            (Event::Unsupported(vec![]), input(Key::Null, false, false)),
         ] {
             assert_eq!(Input::from(from.clone()), to, "{:?} -> {:?}", from, to);
         }
diff --git a/src/input/termwiz.rs b/src/input/termwiz.rs
index 6f01d61..562bd90 100644
--- a/src/input/termwiz.rs
+++ b/src/input/termwiz.rs
@@ -47,6 +47,7 @@ impl From<KeyEvent> for Input {
         let ctrl = modifiers.contains(Modifiers::CTRL);
         let alt = modifiers.contains(Modifiers::ALT);
         let shift = modifiers.contains(Modifiers::SHIFT);
+
         Self {
             key,
             ctrl,
@@ -83,6 +84,7 @@ impl From<MouseEvent> for Input {
         let ctrl = modifiers.contains(Modifiers::CTRL);
         let alt = modifiers.contains(Modifiers::ALT);
         let shift = modifiers.contains(Modifiers::SHIFT);
+
         Self {
             key,
             ctrl,
@@ -105,6 +107,7 @@ impl From<PixelMouseEvent> for Input {
         let ctrl = modifiers.contains(Modifiers::CTRL);
         let alt = modifiers.contains(Modifiers::ALT);
         let shift = modifiers.contains(Modifiers::SHIFT);
+
         Self {
             key,
             ctrl,
@@ -146,27 +149,34 @@ mod tests {
         for (from, to) in [
             (
                 key_event(KeyCode::Char('a'), Modifiers::empty()),
-                input(Key::Char('a'), false, false),
+                input(Key::Char('a'), false, false, false),
             ),
             (
                 key_event(KeyCode::Enter, Modifiers::empty()),
-                input(Key::Enter, false, false),
+                input(Key::Enter, false, false, false),
             ),
             (
                 key_event(KeyCode::LeftArrow, Modifiers::CTRL),
-                input(Key::Left, true, false),
+                input(Key::Left, true, false, false),
+            ),
+            (
+                key_event(KeyCode::RightArrow, Modifiers::SHIFT),
+                input(Key::Right, false, false, true),
             ),
             (
                 key_event(KeyCode::Home, Modifiers::ALT),
-                input(Key::Home, false, true),
+                input(Key::Home, false, true, false),
             ),
             (
-                key_event(KeyCode::Function(1), Modifiers::ALT | Modifiers::CTRL),
-                input(Key::F(1), true, true),
+                key_event(
+                    KeyCode::Function(1),
+                    Modifiers::ALT | Modifiers::CTRL | Modifiers::SHIFT,
+                ),
+                input(Key::F(1), true, true, true),
             ),
             (
                 key_event(KeyCode::NumLock, Modifiers::CTRL),
-                input(Key::Null, true, false),
+                input(Key::Null, true, false, false),
             ),
         ] {
             assert_eq!(Input::from(from.clone()), to, "{:?} -> {:?}", from, to);
@@ -178,30 +188,37 @@ mod tests {
         for (from, to) in [
             (
                 mouse_event(MouseButtons::VERT_WHEEL, Modifiers::empty()),
-                input(Key::MouseScrollDown, false, false),
+                input(Key::MouseScrollDown, false, false, false),
             ),
             (
                 mouse_event(
                     MouseButtons::VERT_WHEEL | MouseButtons::WHEEL_POSITIVE,
                     Modifiers::empty(),
                 ),
-                input(Key::MouseScrollUp, false, false),
+                input(Key::MouseScrollUp, false, false, false),
             ),
             (
                 mouse_event(MouseButtons::VERT_WHEEL, Modifiers::CTRL),
-                input(Key::MouseScrollDown, true, false),
+                input(Key::MouseScrollDown, true, false, false),
+            ),
+            (
+                mouse_event(MouseButtons::VERT_WHEEL, Modifiers::SHIFT),
+                input(Key::MouseScrollDown, false, false, true),
             ),
             (
                 mouse_event(MouseButtons::VERT_WHEEL, Modifiers::ALT),
-                input(Key::MouseScrollDown, false, true),
+                input(Key::MouseScrollDown, false, true, false),
             ),
             (
-                mouse_event(MouseButtons::VERT_WHEEL, Modifiers::CTRL | Modifiers::ALT),
-                input(Key::MouseScrollDown, true, true),
+                mouse_event(
+                    MouseButtons::VERT_WHEEL,
+                    Modifiers::CTRL | Modifiers::ALT | Modifiers::SHIFT,
+                ),
+                input(Key::MouseScrollDown, true, true, true),
             ),
             (
                 mouse_event(MouseButtons::LEFT, Modifiers::empty()),
-                input(Key::Null, false, false),
+                input(Key::Null, false, false, false),
             ),
         ] {
             assert_eq!(Input::from(from.clone()), to, "{:?} -> {:?}", from, to);
@@ -216,22 +233,22 @@ mod tests {
         for (from, to) in [
             (
                 InputEvent::Key(key_event(KeyCode::Char('a'), Modifiers::empty())),
-                input(Key::Char('a'), false, false),
+                input(Key::Char('a'), false, false, false),
             ),
             (
                 InputEvent::Mouse(mouse_event(MouseButtons::VERT_WHEEL, Modifiers::empty())),
-                input(Key::MouseScrollDown, false, false),
+                input(Key::MouseScrollDown, false, false, false),
             ),
             (
                 InputEvent::PixelMouse(pixel_mouse_event(
                     MouseButtons::VERT_WHEEL,
                     Modifiers::empty(),
                 )),
-                input(Key::MouseScrollDown, false, false),
+                input(Key::MouseScrollDown, false, false, false),
             ),
             (
                 InputEvent::Paste("x".into()),
-                input(Key::Null, false, false),
+                input(Key::Null, false, false, false),
             ),
         ] {
             assert_eq!(Input::from(from.clone()), to, "{:?} -> {:?}", from, to);
diff --git a/src/textarea.rs b/src/textarea.rs
index 31fa1fb..f31f334 100644
--- a/src/textarea.rs
+++ b/src/textarea.rs
@@ -1,5 +1,3 @@
-use std::cell::Cell;
-
 use crate::cursor::CursorMove;
 use crate::highlight::LineHighlighter;
 use crate::history::{Edit, EditKind, History};
@@ -15,6 +13,7 @@ use crate::widget::{Renderer, Viewport};
 use crate::word::{find_word_end_forward, find_word_start_backward};
 #[cfg(feature = "ratatui")]
 use ratatui::text::Line;
+use std::cmp::Ordering;
 #[cfg(feature = "tuirs")]
 use tui::text::Spans as Line;
 use unicode_width::UnicodeWidthChar as _;
@@ -46,6 +45,18 @@ impl ToString for YankText {
     }
 }
 
+struct Pos {
+    row: usize,
+    col: usize,
+    offset: usize,
+}
+
+impl Pos {
+    fn new(row: usize, col: usize, offset: usize) -> Self {
+        Self { row, col, offset }
+    }
+}
+
 /// A type to manage state of textarea.
 ///
 /// [`TextArea::default`] creates an empty textarea. [`TextArea::new`] creates a textarea with given text lines.
@@ -57,7 +68,7 @@ impl ToString for YankText {
 /// let mut textarea = TextArea::default();
 ///
 /// // Input 'a'
-/// let input = Input { key: Key::Char('a'), ctrl: false, alt: false , shift:false};
+/// let input = Input { key: Key::Char('a'), ctrl: false, alt: false, shift: false };
 /// textarea.input(input);
 ///
 /// // Get widget to render.
@@ -86,10 +97,7 @@ pub struct TextArea<'a> {
     pub(crate) placeholder: String,
     pub(crate) placeholder_style: Style,
     mask: Option<char>,
-    // these are Cells so that should_end_selection can be called
-    // in a non mutable function call - ie self.widget()
-    select_start: Cell<Option<(usize, usize)>>,
-    pending_end_selection: Cell<bool>,
+    selection_start: Option<(usize, usize)>,
     select_style: Style,
 }
 
@@ -191,9 +199,8 @@ impl<'a> TextArea<'a> {
             placeholder: String::new(),
             placeholder_style: Style::default().fg(Color::DarkGray),
             mask: None,
-            select_start: Default::default(),
+            selection_start: None,
             select_style: Style::default().bg(Color::LightBlue),
-            pending_end_selection: Cell::new(false),
         }
     }
 
@@ -229,13 +236,12 @@ impl<'a> TextArea<'a> {
     /// }
     ///
     /// // Handle backend-agnostic key input
-    /// let input = Input { key: Key::Char('a'), ctrl: false, alt: false };
+    /// let input = Input { key: Key::Char('a'), ctrl: false, alt: false, shift: false };
     /// let modified = textarea.input(input);
     /// assert!(modified);
     /// ```
     pub fn input(&mut self, input: impl Into<Input>) -> bool {
         let input = input.into();
-        self.should_select(&input);
         let modified = match input {
             Input {
                 key: Key::Char('m'),
@@ -337,197 +343,205 @@ impl<'a> TextArea<'a> {
                 ..
             } => self.delete_next_word(),
             Input {
-                key: Key::Char('n' | 'N'),
+                key: Key::Char('n'),
                 ctrl: true,
                 alt: false,
-                ..
+                shift,
             }
             | Input {
                 key: Key::Down,
                 ctrl: false,
                 alt: false,
-                ..
+                shift,
             } => {
-                self.move_cursor(CursorMove::Down);
+                self.move_cursor_with_shift(CursorMove::Down, shift);
                 false
             }
             Input {
-                key: Key::Char('p' | 'P'),
+                key: Key::Char('p'),
                 ctrl: true,
                 alt: false,
-                ..
+                shift,
             }
             | Input {
                 key: Key::Up,
                 ctrl: false,
                 alt: false,
-                ..
+                shift,
             } => {
-                self.move_cursor(CursorMove::Up);
+                self.move_cursor_with_shift(CursorMove::Up, shift);
                 false
             }
             Input {
-                key: Key::Char('f' | 'F'),
+                key: Key::Char('f'),
                 ctrl: true,
                 alt: false,
-                ..
+                shift,
             }
             | Input {
                 key: Key::Right,
                 ctrl: false,
                 alt: false,
-                ..
+                shift,
             } => {
-                self.move_cursor(CursorMove::Forward);
+                self.move_cursor_with_shift(CursorMove::Forward, shift);
                 false
             }
             Input {
-                key: Key::Char('b' | 'B'),
+                key: Key::Char('b'),
                 ctrl: true,
                 alt: false,
-                ..
+                shift,
             }
             | Input {
                 key: Key::Left,
                 ctrl: false,
                 alt: false,
-                ..
+                shift,
             } => {
-                self.move_cursor(CursorMove::Back);
+                self.move_cursor_with_shift(CursorMove::Back, shift);
                 false
             }
             Input {
-                key: Key::Char('a' | 'A'),
+                key: Key::Char('a'),
                 ctrl: true,
                 alt: false,
+                shift,
+            }
+            | Input {
+                key: Key::Home,
+                shift,
                 ..
             }
-            | Input { key: Key::Home, .. }
             | Input {
-                key: Key::Left | Key::Char('b' | 'B'),
+                key: Key::Left | Key::Char('b'),
                 ctrl: true,
                 alt: true,
-                ..
+                shift,
             } => {
-                self.move_cursor(CursorMove::Head);
+                self.move_cursor_with_shift(CursorMove::Head, shift);
                 false
             }
             Input {
                 key: Key::Char('e'),
                 ctrl: true,
                 alt: false,
+                shift,
+            }
+            | Input {
+                key: Key::End,
+                shift,
                 ..
             }
-            | Input { key: Key::End, .. }
             | Input {
-                key: Key::Right | Key::Char('f' | 'F'),
+                key: Key::Right | Key::Char('f'),
                 ctrl: true,
                 alt: true,
-                ..
+                shift,
             } => {
-                self.move_cursor(CursorMove::End);
+                self.move_cursor_with_shift(CursorMove::End, shift);
                 false
             }
             Input {
                 key: Key::Char('<'),
                 ctrl: false,
                 alt: true,
-                ..
+                shift,
             }
             | Input {
-                key: Key::Up | Key::Char('p' | 'P'),
+                key: Key::Up | Key::Char('p'),
                 ctrl: true,
                 alt: true,
-                ..
+                shift,
             } => {
-                self.move_cursor(CursorMove::Top);
+                self.move_cursor_with_shift(CursorMove::Top, shift);
                 false
             }
             Input {
                 key: Key::Char('>'),
                 ctrl: false,
                 alt: true,
-                ..
+                shift,
             }
             | Input {
-                key: Key::Down | Key::Char('n' | 'N'),
+                key: Key::Down | Key::Char('n'),
                 ctrl: true,
                 alt: true,
-                ..
+                shift,
             } => {
-                self.move_cursor(CursorMove::Bottom);
+                self.move_cursor_with_shift(CursorMove::Bottom, shift);
                 false
             }
             Input {
-                key: Key::Char('f' | 'F'),
+                key: Key::Char('f'),
                 ctrl: false,
                 alt: true,
-                ..
+                shift,
             }
             | Input {
                 key: Key::Right,
                 ctrl: true,
                 alt: false,
-                ..
+                shift,
             } => {
-                self.move_cursor(CursorMove::WordForward);
+                self.move_cursor_with_shift(CursorMove::WordForward, shift);
                 false
             }
             Input {
-                key: Key::Char('b' | 'B'),
+                key: Key::Char('b'),
                 ctrl: false,
                 alt: true,
-                ..
+                shift,
             }
             | Input {
                 key: Key::Left,
                 ctrl: true,
                 alt: false,
-                ..
+                shift,
             } => {
-                self.move_cursor(CursorMove::WordBack);
+                self.move_cursor_with_shift(CursorMove::WordBack, shift);
                 false
             }
             Input {
                 key: Key::Char(']'),
                 ctrl: false,
                 alt: true,
-                ..
+                shift,
             }
             | Input {
-                key: Key::Char('n' | 'N'),
+                key: Key::Char('n'),
                 ctrl: false,
                 alt: true,
-                ..
+                shift,
             }
             | Input {
                 key: Key::Down,
                 ctrl: true,
                 alt: false,
-                ..
+                shift,
             } => {
-                self.move_cursor(CursorMove::ParagraphForward);
+                self.move_cursor_with_shift(CursorMove::ParagraphForward, shift);
                 false
             }
             Input {
                 key: Key::Char('['),
                 ctrl: false,
                 alt: true,
-                ..
+                shift,
             }
             | Input {
-                key: Key::Char('p' | 'P'),
+                key: Key::Char('p'),
                 ctrl: false,
                 alt: true,
-                ..
+                shift,
             }
             | Input {
                 key: Key::Up,
                 ctrl: true,
                 alt: false,
-                ..
+                shift,
             } => {
-                self.move_cursor(CursorMove::ParagraphBack);
+                self.move_cursor_with_shift(CursorMove::ParagraphBack, shift);
                 false
             }
             Input {
@@ -548,6 +562,12 @@ impl<'a> TextArea<'a> {
                 alt: false,
                 ..
             } => self.paste(),
+            Input {
+                key: Key::Char('x'),
+                ctrl: true,
+                alt: false,
+                ..
+            } => self.cut(),
             Input {
                 key: Key::Char('c'),
                 ctrl: true,
@@ -558,54 +578,52 @@ impl<'a> TextArea<'a> {
                 false
             }
             Input {
-                key: Key::Char('x'),
+                key: Key::Char('v'),
                 ctrl: true,
                 alt: false,
-                ..
-            } => {
-                self.cut();
-                false
-            }
-            Input {
-                key: Key::Char('v' | 'V'),
-                ctrl: true,
-                alt: false,
-                ..
+                shift,
             }
             | Input {
-                key: Key::PageDown, ..
+                key: Key::PageDown,
+                shift,
+                ..
             } => {
-                self.scroll(Scrolling::PageDown);
+                self.scroll_with_shift(Scrolling::PageDown, shift);
                 false
             }
             Input {
-                key: Key::Char('v' | 'V'),
+                key: Key::Char('v'),
                 ctrl: false,
                 alt: true,
-                ..
+                shift,
             }
             | Input {
-                key: Key::PageUp, ..
+                key: Key::PageUp,
+                shift,
+                ..
             } => {
-                self.scroll(Scrolling::PageUp);
+                self.scroll_with_shift(Scrolling::PageUp, shift);
                 false
             }
             Input {
                 key: Key::MouseScrollDown,
+                shift,
                 ..
             } => {
-                self.scroll((1, 0));
+                self.scroll_with_shift((1, 0).into(), shift);
                 false
             }
             Input {
                 key: Key::MouseScrollUp,
+                shift,
                 ..
             } => {
-                self.scroll((-1, 0));
+                self.scroll_with_shift((-1, 0).into(), shift);
                 false
             }
             _ => false,
         };
+
         // Check invariants
         debug_assert!(!self.lines.is_empty(), "no line after {:?}", input);
         let (r, c) = self.cursor;
@@ -624,7 +642,7 @@ impl<'a> TextArea<'a> {
             self.lines[r],
             input,
         );
-        self.should_end_selection();
+
         modified
     }
 
@@ -641,9 +659,7 @@ impl<'a> TextArea<'a> {
     /// This method is useful when you want to define your own key mappings and don't want default key mappings.
     /// See 'Define your own key mappings' section in [the module document](./index.html).
     pub fn input_without_shortcuts(&mut self, input: impl Into<Input>) -> bool {
-        let input = input.into();
-        self.should_select(&input);
-        let modified = match input {
+        match input.into() {
             Input {
                 key: Key::Char(c),
                 ctrl: false,
@@ -687,9 +703,7 @@ impl<'a> TextArea<'a> {
                 false
             }
             _ => false,
-        };
-        self.should_end_selection();
-        modified
+        }
     }
 
     fn push_history(&mut self, kind: EditKind, cursor_before: (usize, usize)) {
@@ -708,7 +722,6 @@ impl<'a> TextArea<'a> {
     /// ```
     pub fn insert_char(&mut self, c: char) {
         self.delete_selection(false);
-
         let (row, col) = self.cursor;
         let line = &mut self.lines[row];
         let i = line
@@ -734,10 +747,10 @@ impl<'a> TextArea<'a> {
     /// assert_eq!(textarea.lines(), ["hello, world", "goodbye, world"]);
     /// ```
     pub fn insert_str<S: AsRef<str>>(&mut self, s: S) -> bool {
-        self.end_selection();
+        let modified = self.delete_selection(false);
         let mut lines: Vec<_> = s.as_ref().lines().map(ToString::to_string).collect();
         match lines.len() {
-            0 => false,
+            0 => modified,
             1 => self.insert_piece(lines.remove(0)),
             _ => self.insert_chunk(lines),
         }
@@ -791,6 +804,54 @@ impl<'a> TextArea<'a> {
         true
     }
 
+    fn delete_offset_range(
+        &mut self,
+        start_row: usize,
+        start_col: usize,
+        start_offset: usize,
+        end_row: usize,
+        end_offset: usize,
+        should_yank: bool,
+    ) {
+        let cursor_before = self.cursor;
+        self.cursor = (start_row, start_col);
+
+        if start_row == end_row {
+            let removed = self.lines[start_row]
+                .drain(start_offset..end_offset)
+                .as_str()
+                .to_string();
+            if should_yank {
+                self.yank = removed.clone().into();
+            }
+            self.push_history(EditKind::DeleteStr(removed, start_offset), cursor_before);
+            return;
+        }
+
+        let mut deleted = vec![self.lines[start_row]
+            .drain(start_offset..)
+            .as_str()
+            .to_string()];
+        deleted.extend(self.lines.drain(start_row + 1..end_row));
+        if start_row + 1 < self.lines.len() {
+            let mut last_line = self.lines.remove(start_row + 1);
+            self.lines[start_row].push_str(&last_line[end_offset..]);
+            last_line.truncate(end_offset);
+            deleted.push(last_line);
+        }
+
+        if should_yank {
+            self.yank = YankText::Chunk(deleted.clone());
+        }
+
+        let edit = if deleted.len() == 1 {
+            EditKind::DeleteStr(deleted.remove(0), start_offset)
+        } else {
+            EditKind::DeleteChunk(deleted, start_row, start_offset)
+        };
+        self.push_history(edit, cursor_before);
+    }
+
     /// Delete a string from the current cursor position. The `chars` parameter means number of characters, not a byte
     /// length of the string. Newlines at the end of lines are counted in the number. This method returns if some text
     /// was deleted or not.
@@ -810,19 +871,14 @@ impl<'a> TextArea<'a> {
     /// assert_eq!(textarea.lines(), ["🐱", "🐮"]);
     /// ```
     pub fn delete_str(&mut self, chars: usize) -> bool {
-        self.delete_str_internal(chars, true, true)
-    }
-
-    // grabs the specified (maybe multi line string)
-    // sometimes yanked
-    // sometimes deleted from lines array and placed in history
-
-    fn delete_str_internal(&mut self, chars: usize, yank: bool, delete: bool) -> bool {
+        if self.delete_selection(false) {
+            return true;
+        }
         if chars == 0 {
             return false;
         }
 
-        let (row, col) = self.cursor;
+        let (start_row, start_col) = self.cursor;
 
         let mut remaining = chars;
         let mut find_end = move |line: &str| {
@@ -840,34 +896,26 @@ impl<'a> TextArea<'a> {
             }
         };
 
-        let line = &self.lines[row];
-        let first_start = {
+        let line = &self.lines[start_row];
+        let start_offset = {
             line.char_indices()
-                .nth(col)
+                .nth(start_col)
                 .map(|(i, _)| i)
                 .unwrap_or(line.len())
         };
 
         // First line
-        if let Some(offset) = find_end(&line[first_start..]) {
-            let removed = if delete {
-                self.lines[row]
-                    .drain(first_start..first_start + offset)
-                    .as_str()
-                    .to_string()
-            } else {
-                self.lines[row][first_start..first_start + offset].to_string()
-            };
-            if yank {
-                self.yank = removed.clone().into();
-            };
-            if delete {
-                self.push_history(EditKind::DeleteStr(removed, first_start), self.cursor);
-            }
+        if let Some(offset) = find_end(&line[start_offset..]) {
+            let removed = self.lines[start_row]
+                .drain(start_offset..start_offset + offset)
+                .as_str()
+                .to_string();
+            self.yank = removed.clone().into();
+            self.push_history(EditKind::DeleteStr(removed, start_offset), self.cursor);
             return true;
-        };
+        }
 
-        let mut r = row + 1;
+        let mut r = start_row + 1;
         let mut i = 0;
 
         while r < self.lines.len() {
@@ -879,42 +927,7 @@ impl<'a> TextArea<'a> {
             r += 1;
         }
 
-        let mut deleted = if delete {
-            vec![self.lines[row].drain(first_start..).as_str().to_string()]
-        } else {
-            vec![self.lines[row][first_start..].to_string()]
-        };
-
-        if delete {
-            deleted.extend(self.lines.drain(row + 1..r));
-        } else {
-            deleted.extend(self.lines[row + 1..r].iter().map(|s| s.to_string()));
-        }
-
-        if row + 1 < self.lines.len() {
-            let mut last_line = if delete {
-                let ll = self.lines.remove(row + 1);
-                self.lines[row].push_str(&ll[i..]);
-                ll
-            } else {
-                self.lines[row + 1].clone()
-            };
-            last_line.truncate(i);
-            deleted.push(last_line);
-        }
-
-        if yank {
-            self.yank = YankText::Chunk(deleted.clone());
-        };
-        if delete {
-            let edit = if deleted.len() == 1 {
-                EditKind::DeleteStr(deleted.remove(0), first_start)
-            } else {
-                EditKind::DeleteChunk(deleted, row, first_start)
-            };
-            self.push_history(edit, self.cursor);
-        }
-
+        self.delete_offset_range(start_row, start_col, start_offset, r, i, true);
         true
     }
 
@@ -959,8 +972,9 @@ impl<'a> TextArea<'a> {
     /// assert_eq!(textarea.lines(), ["hi      "]);
     /// ```
     pub fn insert_tab(&mut self) -> bool {
+        let modified = self.delete_selection(false);
         if self.tab_len == 0 {
-            return false;
+            return modified;
         }
 
         if self.hard_tab_indent {
@@ -989,6 +1003,7 @@ impl<'a> TextArea<'a> {
     /// ```
     pub fn insert_newline(&mut self) {
         self.delete_selection(false);
+
         let (row, col) = self.cursor;
         let line = &mut self.lines[row];
         let idx = line
@@ -1005,7 +1020,7 @@ impl<'a> TextArea<'a> {
     }
 
     /// Delete a newline from **head** of current cursor line. This method returns if a newline was deleted or not in
-    /// the textarea.
+    /// the textarea. When some text is selected, it is deleted instead.
     /// ```
     /// use tui_textarea::{TextArea, CursorMove};
     ///
@@ -1016,6 +1031,10 @@ impl<'a> TextArea<'a> {
     /// assert_eq!(textarea.lines(), ["helloworld"]);
     /// ```
     pub fn delete_newline(&mut self) -> bool {
+        if self.delete_selection(false) {
+            return true;
+        }
+
         let (row, col) = self.cursor;
         if row == 0 {
             return false;
@@ -1032,7 +1051,8 @@ impl<'a> TextArea<'a> {
     }
 
     /// Delete one character before cursor. When the cursor is at head of line, the newline before the cursor will be
-    /// removed. This method returns if some text was deleted or not in the textarea.
+    /// removed. This method returns if some text was deleted or not in the textarea. When some text is selected, it is
+    /// deleted instead.
     /// ```
     /// use tui_textarea::{TextArea, CursorMove};
     ///
@@ -1043,9 +1063,10 @@ impl<'a> TextArea<'a> {
     /// assert_eq!(textarea.lines(), ["bc"]);
     /// ```
     pub fn delete_char(&mut self) -> bool {
-        if self.select_start.get().is_some() {
-            return self.delete_selection(false);
+        if self.delete_selection(false) {
+            return true;
         }
+
         let (row, col) = self.cursor;
         if col == 0 {
             return self.delete_newline();
@@ -1074,14 +1095,16 @@ impl<'a> TextArea<'a> {
     /// assert_eq!(textarea.lines(), ["ac"]);
     /// ```
     pub fn delete_next_char(&mut self) -> bool {
-        if self.select_start.get().is_some() {
-            return self.delete_selection(false);
+        if self.delete_selection(false) {
+            return true;
         }
+
         let before = self.cursor;
-        self.move_cursor(CursorMove::Forward);
+        self.move_cursor_with_shift(CursorMove::Forward, false);
         if before == self.cursor {
             return false; // Cursor didn't move, meant no character at next of cursor.
         }
+
         self.delete_char()
     }
 
@@ -1100,6 +1123,9 @@ impl<'a> TextArea<'a> {
     /// assert_eq!(textarea.lines(), ["ab"]);
     /// ```
     pub fn delete_line_by_end(&mut self) -> bool {
+        if self.delete_selection(false) {
+            return true;
+        }
         if self.delete_piece(self.cursor.1, usize::MAX) {
             return true;
         }
@@ -1121,6 +1147,9 @@ impl<'a> TextArea<'a> {
     /// assert_eq!(textarea.lines(), ["cde"]);
     /// ```
     pub fn delete_line_by_head(&mut self) -> bool {
+        if self.delete_selection(false) {
+            return true;
+        }
         if self.delete_piece(0, self.cursor.1) {
             return true;
         }
@@ -1146,6 +1175,9 @@ impl<'a> TextArea<'a> {
     /// assert_eq!(textarea.lines(), ["aaa "]);
     /// ```
     pub fn delete_word(&mut self) -> bool {
+        if self.delete_selection(false) {
+            return true;
+        }
         let (r, c) = self.cursor;
         if let Some(col) = find_word_start_backward(&self.lines[r], c) {
             self.delete_piece(col, c - col)
@@ -1173,6 +1205,9 @@ impl<'a> TextArea<'a> {
     /// assert_eq!(textarea.lines(), [" ccc"]);
     /// ```
     pub fn delete_next_word(&mut self) -> bool {
+        if self.delete_selection(false) {
+            return true;
+        }
         let (r, c) = self.cursor;
         let line = &self.lines[r];
         if let Some(col) = find_word_end_forward(line, c) {
@@ -1204,13 +1239,185 @@ impl<'a> TextArea<'a> {
     /// assert_eq!(textarea.lines(), [" bbb cccaaa"]);
     /// ```
     pub fn paste(&mut self) -> bool {
-        self.delete_selection(false);
         match self.yank.clone() {
             YankText::Piece(s) => self.insert_piece(s),
             YankText::Chunk(c) => self.insert_chunk(c),
         }
     }
 
+    /// Start text selection at the cursor position. If text selection is already ongoing, the start position is reset.
+    /// ```
+    /// use tui_textarea::{TextArea, CursorMove};
+    ///
+    /// let mut textarea = TextArea::from(["aaa bbb ccc"]);
+    ///
+    /// textarea.start_selection();
+    /// textarea.move_cursor(CursorMove::WordForward);
+    /// textarea.copy();
+    /// assert_eq!(textarea.yank_text(), "aaa ");
+    /// ```
+    pub fn start_selection(&mut self) {
+        self.selection_start = Some(self.cursor);
+    }
+
+    /// Stop the current text selection. This method does nothing if text selection is not ongoing.
+    /// ```
+    /// use tui_textarea::{TextArea, CursorMove};
+    ///
+    /// let mut textarea = TextArea::from(["aaa bbb ccc"]);
+    ///
+    /// textarea.start_selection();
+    /// textarea.move_cursor(CursorMove::WordForward);
+    ///
+    /// // Cancel the ongoing text selection
+    /// textarea.cancel_selection();
+    ///
+    /// // As the result, this `copy` call does nothing
+    /// textarea.copy();
+    /// assert_eq!(textarea.yank_text(), "");
+    /// ```
+    pub fn cancel_selection(&mut self) {
+        self.selection_start = None;
+    }
+
+    /// Return if text selection is ongoing or not.
+    /// ```
+    /// use tui_textarea::{TextArea};
+    ///
+    /// let mut textarea = TextArea::default();
+    ///
+    /// assert!(!textarea.is_selecting());
+    /// textarea.start_selection();
+    /// assert!(textarea.is_selecting());
+    /// textarea.cancel_selection();
+    /// assert!(!textarea.is_selecting());
+    /// ```
+    pub fn is_selecting(&self) -> bool {
+        self.selection_start.is_some()
+    }
+
+    fn line_offset(&self, row: usize, col: usize) -> usize {
+        let line = self
+            .lines
+            .get(row)
+            .unwrap_or(&self.lines[self.lines.len() - 1]);
+        line.char_indices()
+            .nth(col)
+            .map(|(i, _)| i)
+            .unwrap_or(line.len())
+    }
+
+    /// Set the style used for text selection. The default style is light blue.
+    /// ```
+    /// use tui_textarea::TextArea;
+    /// use ratatui::style::{Style, Color};
+    ///
+    /// let mut textarea = TextArea::default();
+    ///
+    /// // Change the selection color from the default to Red
+    /// textarea.set_selection_style(Style::default().bg(Color::Red));
+    /// assert_eq!(textarea.selection_style(), Style::default().bg(Color::Red));
+    /// ```
+    pub fn set_selection_style(&mut self, style: Style) {
+        self.select_style = style;
+    }
+
+    /// Get the style used for text selection.
+    /// ```
+    /// use tui_textarea::TextArea;
+    /// use ratatui::style::{Style, Color};
+    ///
+    /// let mut textarea = TextArea::default();
+    ///
+    /// assert_eq!(textarea.selection_style(), Style::default().bg(Color::LightBlue));
+    /// ```
+    pub fn selection_style(&mut self) -> Style {
+        self.select_style
+    }
+
+    fn selection_range(&self) -> Option<(Pos, Pos)> {
+        let (sr, sc) = self.selection_start?;
+        let (er, ec) = self.cursor;
+        let (so, eo) = (self.line_offset(sr, sc), self.line_offset(er, ec));
+        let s = Pos::new(sr, sc, so);
+        let e = Pos::new(er, ec, eo);
+        match (sr, so).cmp(&(er, eo)) {
+            Ordering::Less => Some((s, e)),
+            Ordering::Equal => None,
+            Ordering::Greater => Some((e, s)),
+        }
+    }
+
+    fn take_selection_range(&mut self) -> Option<(Pos, Pos)> {
+        let range = self.selection_range();
+        self.cancel_selection();
+        range
+    }
+
+    /// Copy the selection text to the yank buffer. When nothing is selected, this method does nothing.
+    /// To get the yanked text, use [`TextArea::yank_text`].
+    /// ```
+    /// use tui_textarea::{TextArea, Key, Input, CursorMove};
+    ///
+    /// let mut textarea = TextArea::from(["Hello World"]);
+    ///
+    /// // Start text selection at 'W'
+    /// textarea.move_cursor(CursorMove::WordForward);
+    /// textarea.start_selection();
+    ///
+    /// // Select the word "World" and copy the selected text
+    /// textarea.move_cursor(CursorMove::End);
+    /// textarea.copy();
+    ///
+    /// assert_eq!(textarea.yank_text(), "World");
+    /// assert_eq!(textarea.lines(), ["Hello World"]); // Text does not change
+    /// ```
+    pub fn copy(&mut self) {
+        if let Some((start, end)) = self.take_selection_range() {
+            if start.row == end.row {
+                self.yank = self.lines[start.row][start.offset..end.offset]
+                    .to_string()
+                    .into();
+                return;
+            }
+            let mut chunk = vec![self.lines[start.row][start.offset..].to_string()];
+            chunk.extend(self.lines[start.row + 1..end.row].iter().cloned());
+            chunk.push(self.lines[end.row][..end.offset].to_string());
+            self.yank = YankText::Chunk(chunk);
+        }
+    }
+
+    /// Cut the selected text and place it in the yank buffer. This method returns whether the text was modified.
+    /// The cursor will move to the start position of the text selection.
+    /// To get the yanked text, use [`TextArea::yank_text`].
+    /// ```
+    /// use tui_textarea::{TextArea, Key, Input, CursorMove};
+    ///
+    /// let mut textarea = TextArea::from(["Hello World"]);
+    ///
+    /// // Start text selection at 'W'
+    /// textarea.move_cursor(CursorMove::WordForward);
+    /// textarea.start_selection();
+    ///
+    /// // Select the word "World" and copy the selected text
+    /// textarea.move_cursor(CursorMove::End);
+    /// textarea.cut();
+    ///
+    /// assert_eq!(textarea.yank_text(), "World");
+    /// assert_eq!(textarea.lines(), ["Hello "]);
+    /// ```
+    pub fn cut(&mut self) -> bool {
+        self.delete_selection(true)
+    }
+
+    fn delete_selection(&mut self, should_yank: bool) -> bool {
+        if let Some((s, e)) = self.take_selection_range() {
+            self.delete_offset_range(s.row, s.col, s.offset, e.row, e.offset, should_yank);
+            return true;
+        }
+        false
+    }
+
     /// Move the cursor to the position specified by the [`CursorMove`] parameter. For each kind of cursor moves, see
     /// the document of [`CursorMove`].
     /// ```
@@ -1222,9 +1429,20 @@ impl<'a> TextArea<'a> {
     /// assert_eq!(textarea.cursor(), (0, 1));
     /// textarea.move_cursor(CursorMove::Down);
     /// assert_eq!(textarea.cursor(), (1, 1));
-
+    /// ```
     pub fn move_cursor(&mut self, m: CursorMove) {
+        self.move_cursor_with_shift(m, self.selection_start.is_some());
+    }
+
+    fn move_cursor_with_shift(&mut self, m: CursorMove, shift: bool) {
         if let Some(cursor) = m.next_cursor(self.cursor, &self.lines, &self.viewport) {
+            if shift {
+                if self.selection_start.is_none() {
+                    self.start_selection();
+                }
+            } else {
+                self.cancel_selection();
+            }
             self.cursor = cursor;
         }
     }
@@ -1242,6 +1460,7 @@ impl<'a> TextArea<'a> {
     /// ```
     pub fn undo(&mut self) -> bool {
         if let Some(cursor) = self.history.undo(&mut self.lines) {
+            self.cancel_selection();
             self.cursor = cursor;
             true
         } else {
@@ -1264,6 +1483,7 @@ impl<'a> TextArea<'a> {
     /// ```
     pub fn redo(&mut self) -> bool {
         if let Some(cursor) = self.history.redo(&mut self.lines) {
+            self.cancel_selection();
             self.cursor = cursor;
             true
         } else {
@@ -1293,10 +1513,8 @@ impl<'a> TextArea<'a> {
             hl.search(matches, self.search.style);
         }
 
-        // any selected text to highlight?
-        if self.select_start.get().is_some() {
-            let (start, end, _) = self.normalize_selection();
-            hl.select_line(row, line, start, end);
+        if let Some((start, end)) = self.selection_range() {
+            hl.selection(row, start.row, start.offset, end.row, end.offset);
         }
 
         hl.into_spans()
@@ -1329,7 +1547,6 @@ impl<'a> TextArea<'a> {
     /// }
     /// ```
     pub fn widget(&'a self) -> impl Widget + 'a {
-        self.should_end_selection();
         Renderer::new(self)
     }
 
@@ -1391,7 +1608,7 @@ impl<'a> TextArea<'a> {
     /// use tui_textarea::{TextArea, Input, Key};
     ///
     /// let mut textarea = TextArea::default();
-    /// let tab_input = Input { key: Key::Tab, ctrl: false, alt:false,  shift: false };
+    /// let tab_input = Input { key: Key::Tab, ctrl: false, alt: false, shift: false };
     ///
     /// textarea.set_tab_length(8);
     /// textarea.input(tab_input.clone());
@@ -1766,14 +1983,19 @@ impl<'a> TextArea<'a> {
 
     /// Get the yanked text. Text is automatically yanked when deleting strings by [`TextArea::delete_line_by_head`],
     /// [`TextArea::delete_line_by_end`], [`TextArea::delete_word`], [`TextArea::delete_next_word`],
-    /// [`TextArea::delete_str`].
+    /// [`TextArea::delete_str`], [`TextArea::copy`], and [`TextArea::cut`]. When multiple lines were yanked, they are
+    /// joined with `\n`.
     /// ```
     /// use tui_textarea::TextArea;
     ///
     /// let mut textarea = TextArea::from(["abc"]);
-    ///
     /// textarea.delete_next_word();
     /// assert_eq!(textarea.yank_text(), "abc");
+    ///
+    /// // Multiple lines are joined with \n
+    /// let mut textarea = TextArea::from(["abc", "def"]);
+    /// textarea.delete_str(5);
+    /// assert_eq!(textarea.yank_text(), "abc\nd");
     /// ```
     pub fn yank_text(&self) -> String {
         self.yank.to_string()
@@ -2014,229 +2236,20 @@ impl<'a> TextArea<'a> {
     /// assert_eq!(textarea.cursor(), (12, 0));
     /// ```
     pub fn scroll(&mut self, scrolling: impl Into<Scrolling>) {
-        scrolling.into().scroll(&mut self.viewport);
-        self.move_cursor(CursorMove::InViewport);
+        self.scroll_with_shift(scrolling.into(), self.selection_start.is_some());
     }
 
-    // public functions for select
-
-    /// Sets the style used for selected text
-    /// the default is LightBlue
-    ///```
-    /// use tui_textarea::TextArea;
-    /// use ratatui::style::{Style, Color};
-    /// let mut textarea = TextArea::default();
-    /// // change the selection color from the default to Red
-    /// textarea.set_selection_style(Style::default().bg(Color::Red));
-    /// assert_eq!(textarea.get_selection_style(), Style::default().bg(Color::Red));
-    /// ```
-    pub fn set_selection_style(&mut self, style: Style) {
-        self.select_style = style;
-    }
-    /// Gets the style used for selected text
-    ///
-    ///```
-    /// use tui_textarea::TextArea;
-    /// use ratatui::style::{Style, Color};
-    /// let mut textarea = TextArea::default();
-    ///
-    ///
-    /// assert_eq!(textarea.get_selection_style(), Style::default().bg(Color::LightBlue));
-    /// ```
-    pub fn get_selection_style(&mut self) -> Style {
-        self.select_style
-    }
-    /// Copies the current selection to the yank buffer
-    ///
-    ///```
-    /// use tui_textarea::{TextArea, Key, Input};
-    ///
-    ///
-    /// let mut textarea = TextArea::default();
-    /// // load some text
-    /// textarea.insert_str("Hello World");
-    /// // select the word "World" by doing a ctrl-left with the shift key down
-    /// textarea.input(Input{key:Key::Left, ctrl:true, alt:false, shift:true});
-    ///  
-    /// textarea.copy();
-    /// assert_eq!(textarea.yank_text(), "World");
-    /// assert_eq!(textarea.lines(), ["Hello World"]);
-    ///```
-    pub fn copy(&mut self) {
-        if self.select_start.get().is_some() {
-            let (start, end, swapped) = self.normalize_selection();
-
-            self.cursor = start;
-            self.delete_range(start, end, true, false);
-            self.cursor = if swapped { start } else { end };
+    fn scroll_with_shift(&mut self, scrolling: Scrolling, shift: bool) {
+        if shift && self.selection_start.is_none() {
+            self.selection_start = Some(self.cursor);
         }
-    }
-
-    /// Deletes the current selection and places it in the yank buffer
-    ///```
-    /// use tui_textarea::{TextArea, Key, Input};
-    ///
-    ///
-    /// let mut textarea = TextArea::default();
-    /// // load some text
-    /// textarea.insert_str("Hello World");
-    /// // select the word "World" by doing a ctrl-left with the shift key down
-    /// textarea.input(Input{key:Key::Left, ctrl:true, alt:false, shift:true});
-    ///
-    /// textarea.cut();
-    /// assert_eq!(textarea.yank_text(), "World");
-    /// assert_eq!(textarea.lines(), ["Hello "]);
-    ///```
-
-    ///
-    pub fn cut(&mut self) {
-        self.delete_selection(true);
-    }
-
-    /// Must be called before calling textarea functions if you are
-    /// not calling [`TextArea::input`]  or [`TextArea::input_without_shortcuts`] to dispatch the keys.
-    /// It is used to detect whether or not a selection should be started, continued or ended
-    ///
-    /// Handled automatically when inputs are passed to [`TextArea::input`] or  [`TextArea::input_without_shortcuts`]
-    ///
-    /// Note: it is harmless to call this function even if you have some logic paths that call [`TextArea::input`]
-    /// The state of the shift key (or whatever you want to signal start selection) should be passed in.
-    /// If you need to stop an upper case letter being treated as a selection character
-    /// then call this function with false
-    ///
-    /// Look at the modal example for a demonstration of its use
-
-    pub fn should_select(&mut self, input: &Input) {
-        if input.key == Key::Null {
-            return;
-        }
-        // Should we start selecting text, stop the current selection, or do nothing?
-        // the end is handled after the ending keystroke
-        self.pending_end_selection =
-            Cell::new(match (self.select_start.get().is_some(), input.shift) {
-                (true, true) => {
-                    // continue select
-                    false
-                }
-                (true, false) => {
-                    // end select
-                    true
-                }
-                (false, true) => {
-                    // start select
-                    self.start_selection();
-                    false
-                }
-                (false, false) => {
-                    // ignore
-                    false
-                }
-            });
-    }
-
-    /// used in conjunction with code that needs to use [`TextArea::should_select`]
-    /// Used to force the end selection mode
-    ///
-    /// Needed if a simple keystroke is upper case and you want to stop it being treated as a selection
-    /// Look at the modal example for a demonstration of its use - look at the 'a' and 'A' keys
-    ///
-
-    pub fn stop_selection(&mut self) {
-        self.end_selection();
-    }
-    // functions for select
-
-    fn should_end_selection(&self) {
-        // Should we end the current selection?
-        if self.pending_end_selection.take() {
-            self.end_selection();
-        }
-    }
-
-    fn start_selection(&mut self) {
-        self.select_start = Cell::new(Some(self.cursor));
-    }
-
-    fn end_selection(&self) {
-        self.select_start.set(Default::default());
-    }
-
-    fn normalize_selection(&self) -> ((usize, usize), (usize, usize), bool) {
-        // selection can be from right to left or left to right
-        // rest of the code always wants the leftmost part first
-        // bool indicates if swap was done
-        let start = self.select_start.get().unwrap();
-        let end = self.cursor;
-        if start.0 > end.0 || (start.0 == end.0 && start.1 > end.1) {
-            (end, start, true)
-        } else {
-            (start, end, false)
-        }
-    }
-
-    // delete the currect selection, sometimes yank it
-
-    fn delete_selection(&mut self, yank: bool) -> bool {
-        let deleted = match self.select_start.get() {
-            Some(_) => {
-                let (start, end, _) = self.normalize_selection();
-                if start != end {
-                    self.delete_range(start, end, yank, true);
-                    true
-                } else {
-                    false
-                }
-            }
-            None => false,
-        };
-
-        self.select_start = Default::default();
-        deleted
-    }
-
-    fn line_length(&self, row: usize) -> usize {
-        self.lines[row].chars().count()
-    }
-
-    // erase a range of text, start and end must be normalized
-    // erased text may be put in history and yank buffer (by delete_str)
-    // the end range column is not included
-
-    fn delete_range(
-        &mut self,
-        start: (usize, usize),
-        end: (usize, usize),
-        yank: bool,
-        delete: bool,
-    ) {
-        // calculate length of range
-        let (start_row, start_col) = start;
-        let (end_row, end_col) = end;
-        let mut col = start_col;
-        let mut len = 0;
-
-        // need +1 because the row range is inclusive
-        for r in start_row..end_row + 1 {
-            // we only take some of the first line
-            len += self.line_length(r) - col;
-            // but maybe all of subsequent lines
-            col = 0;
-        }
-
-        // we didnt take the whole last line
-        // so subtract the bit we didnt take
-        len -= self.line_length(end_row) - end_col;
-        // plus add the number of linefeeds
-        len += end_row - start_row;
-
-        self.cursor = start;
-
-        self.delete_str_internal(len, yank, delete);
+        scrolling.scroll(&mut self.viewport);
+        self.move_cursor_with_shift(CursorMove::InViewport, shift);
     }
 }
+
 #[cfg(test)]
 mod tests {
-
     use super::*;
 
     // Seaparate tests for tui-rs support
diff --git a/tests/textarea.rs b/tests/textarea.rs
index 773e918..f35885f 100644
--- a/tests/textarea.rs
+++ b/tests/textarea.rs
@@ -1,3 +1,4 @@
+use std::cmp;
 use tui_textarea::{CursorMove, TextArea};
 
 #[test]
@@ -799,385 +800,507 @@ fn test_delete_str_multiple_lines() {
     }
 }
 
-//
-// selection tests
-//
-
-use tui_textarea::{Input, Key};
-
-/*
-
-    each test block is a tuple of
-    - text to be loaded into textarea
-    - vec of key strokes to be sent
-    - expected value in yank
-    - expected text left in textarea
-
-    the text is inserted into a new textarea
-    cursor is moved to (0,0)
-    strokes are sent
-    yank and remainder are checked
-
-
-*/
 #[test]
-fn select_copy() {
-    for test in [
-        // plain ascii
-        (
-            "hello world",
-            vec![
-                (Key::Home, false, false, false),
-                (Key::Right, false, false, true),
-                (Key::Right, false, false, true),
-                (Key::Char('c'), true, false, false),
-            ],
-            "he",
-            "hello world",
-        ),
-        // plain ascii backwards
-        (
-            "hello world",
-            vec![
-                (Key::End, false, false, false),
-                (Key::Left, false, false, true),
-                (Key::Left, false, false, true),
-                (Key::Char('c'), true, false, false),
-            ],
-            "ld",
-            "hello world",
-        ),
-        // utf8
-        (
-            "あい",
-            vec![
-                (Key::Home, false, false, false),
-                (Key::Right, false, false, true),
-                (Key::Char('c'), true, false, false),
-            ],
-            "あ",
-            "あい",
-        ),
-        // multi line - all
-        (
-            "hello\nworld",
-            vec![
-                (Key::Char('P'), true, true, false),
-                (Key::Home, false, false, false),
-                (Key::Char('N'), true, true, true),
-                (Key::End, false, false, true),
-                (Key::Char('c'), true, false, false),
-            ],
-            "hello\nworld",
-            "hello\nworld",
-        ),
-        // multi line - some
-        (
-            "hello\nworld",
-            vec![
-                (Key::Char('P'), true, true, false),
-                (Key::Home, false, false, false),
-                (Key::Right, false, false, false),
-                (Key::Char('N'), true, true, true),
-                (Key::End, false, false, true),
-                (Key::Left, false, false, true),
-                (Key::Char('c'), true, false, false),
-            ],
-            "ello\nworl",
-            "hello\nworld",
-        ),
-        // multi - line utf8
-        (
-            "あい\nうえ",
-            vec![
-                (Key::Char('P'), true, true, false),
-                (Key::Home, false, false, false),
-                (Key::Char('N'), true, true, true),
-                (Key::End, false, false, true),
-                (Key::Char('c'), true, false, false),
-            ],
-            "あい\nうえ",
-            "あい\nうえ",
-        ),
-        // multi-line utf8 - some
-        (
-            "あい\nうえ",
-            vec![
-                (Key::Char('P'), true, true, false),
-                (Key::Home, false, false, false),
-                (Key::Right, false, false, false),
-                (Key::Char('N'), true, true, true),
-                (Key::End, false, false, true),
-                (Key::Left, false, false, true),
-                (Key::Char('c'), true, false, false),
-            ],
-            "い\nう",
-            "あい\nうえ",
-        ),
-    ] {
-        let (text, strokes, yank, remaining) = test;
-        one_select_test(text, &strokes, yank, remaining);
-    }
-}
-#[test]
-fn select_cut() {
-    for test in [
-        // plain ascii
-        (
-            "hello world",
-            vec![
-                (Key::Home, false, false, false),
-                (Key::Right, false, false, true),
-                (Key::Right, false, false, true),
-                (Key::Char('x'), true, false, false),
-            ],
-            "he",
-            "llo world",
-        ),
-        // plain ascii backwards
-        (
-            "hello world",
-            vec![
-                (Key::End, false, false, false),
-                (Key::Left, false, false, true),
-                (Key::Left, false, false, true),
-                (Key::Char('x'), true, false, false),
-            ],
-            "ld",
-            "hello wor",
-        ),
-        // utf8
-        (
-            "あい",
-            vec![
-                (Key::Home, false, false, false),
-                (Key::Right, false, false, true),
-                (Key::Char('x'), true, false, false),
-            ],
-            "あ",
-            "い",
-        ),
-        // multi line - all
-        (
-            "hello\nworld",
-            vec![
-                (Key::Char('P'), true, true, false),
-                (Key::Home, false, false, false),
-                (Key::Char('N'), true, true, true),
-                (Key::End, false, false, true),
-                (Key::Char('x'), true, false, false),
-            ],
-            "hello\nworld",
-            "",
-        ),
-        // multi line - some
-        (
-            "hello\nworld",
-            vec![
-                (Key::Char('P'), true, true, false),
-                (Key::Home, false, false, false),
-                (Key::Right, false, false, false),
-                (Key::Char('N'), true, true, true),
-                (Key::End, false, false, true),
-                (Key::Left, false, false, true),
-                (Key::Char('x'), true, false, false),
-            ],
-            "ello\nworl",
-            "hd",
-        ),
-        // multi - line utf8
-        (
-            "あい\nうえ",
-            vec![
-                (Key::Char('P'), true, true, false),
-                (Key::Home, false, false, false),
-                (Key::Char('N'), true, true, true),
-                (Key::End, false, false, true),
-                (Key::Char('x'), true, false, false),
-            ],
-            "あい\nうえ",
-            "",
-        ),
-        // multi-line utf8 - some
-        (
-            "あい\nうえ",
-            vec![
-                (Key::Char('P'), true, true, false),
-                (Key::Home, false, false, false),
-                (Key::Right, false, false, false),
-                (Key::Char('N'), true, true, true),
-                (Key::End, false, false, true),
-                (Key::Left, false, false, true),
-                (Key::Char('x'), true, false, false),
-            ],
-            "い\nう",
-            "あえ",
-        ),
-    ] {
-        let (text, strokes, yank, remaining) = test;
-        one_select_test(text, &strokes, yank, remaining);
+fn test_copy_single_line() {
+    for i in 0..="abc".len() {
+        for j in i.."abc".len() {
+            let mut t = TextArea::from(["abc"]);
+
+            t.move_cursor(CursorMove::Jump(0, i as u16));
+            t.start_selection();
+            t.move_cursor(CursorMove::Jump(0, j as u16));
+            t.copy();
+
+            assert_eq!(t.yank_text(), &"abc"[i..j], "from {i} to {j}");
+            assert_eq!(t.lines(), ["abc"], "from {i} to {j}");
+        }
     }
 }
 
 #[test]
-fn select_paste() {
-    for test in [
-        // plain ascii
-        (
-            "hello world",
-            vec![
-                (Key::Home, false, false, false),
-                (Key::Right, false, false, true),
-                (Key::Right, false, false, true),
-                (Key::Char('c'), true, false, false),
-                (Key::End, false, false, false),
-                (Key::Char('y'), true, false, false),
-            ],
-            "he",
-            "hello worldhe",
-        ),
-        (
-            "hello world",
-            vec![
-                (Key::Home, false, false, false),
-                (Key::Right, false, false, true),
-                (Key::Right, false, false, true),
-                (Key::Char('c'), true, false, false),
-                (Key::End, false, false, false),
-                (Key::Left, false, false, true),
-                (Key::Left, false, false, true),
-                (Key::Char('y'), true, false, false),
-            ],
-            "he",
-            "hello worhe",
-        ),
-        (
-            "hello\nworld",
-            vec![
-                (Key::Home, false, false, false),
-                (Key::Right, false, false, false),
-                (Key::Right, false, false, false),
-                (Key::Down, false, false, true),
-                (Key::Char('c'), true, false, false),
-                (Key::End, false, false, false),
-                (Key::Enter, false, false, false),
-                (Key::Char('y'), true, false, false),
-            ],
-            "llo\nwo",
-            "hello\nworld\nllo\nwo",
-        ),
-    ] {
-        let (text, strokes, yank, remaining) = test;
-        one_select_test(text, &strokes, yank, remaining);
+fn test_cut_single_line() {
+    for i in 0.."abc".len() {
+        for j in i + 1.."abc".len() {
+            let mut t = TextArea::from(["abc"]);
+
+            t.move_cursor(CursorMove::Jump(0, i as u16));
+            t.start_selection();
+            t.move_cursor(CursorMove::Jump(0, j as u16));
+            t.cut();
+
+            assert_eq!(t.yank_text(), &"abc"[i..j], "from {i} to {j}");
+
+            let mut after = "abc".to_string();
+            after.replace_range(i..j, "");
+            assert_eq!(t.lines(), [after], "from {i} to {j}");
+            assert_eq!(t.cursor(), (0, i));
+
+            t.paste();
+            assert_eq!(t.lines(), ["abc"], "from {i} to {j}");
+        }
     }
 }
+
 #[test]
-fn select_all_keys() {
-    for test in [
+fn test_copy_cut_empty() {
+    for row in 0..=2 {
+        for col in 0..=2 {
+            let check = |f: fn(&mut TextArea<'_>)| {
+                let mut t = TextArea::from(["ab", "cd", "ef"]);
+                t.move_cursor(CursorMove::Jump(row, col));
+                t.start_selection();
+                t.move_cursor(CursorMove::Jump(row, col));
+                f(&mut t);
+                assert!(!t.is_selecting());
+                assert_eq!(t.cursor(), (row as _, col as _));
+                assert_eq!(t.lines(), ["ab", "cd", "ef"]);
+            };
+
+            check(|t| {
+                assert!(!t.cut());
+            });
+            check(|t| t.copy());
+        }
+    }
+}
+
+#[test]
+fn test_copy_cut_paste_multi_lines() {
+    #[rustfmt::skip]
+    let tests = [
         (
-            // enter key erases selection
-            "hello world",
-            vec![
-                (Key::End, false, false, true),
-                (Key::Enter, false, false, true),
-            ],
-            "",
+            // Initial text
+            &[
+                "ab",
+                "cd",
+                "ef",
+            ][..],
+            // Start position of selection
+            (0, 0),
+            // End position of selection
+            (1, 0),
+            // Expected yanked text
+            "ab\n",
+            // Text buffer after cut
+            &[
+                "cd",
+                "ef",
+            ][..]
+        ),
+        (
+            &[
+                "ab",
+                "cd",
+                "ef",
+            ][..],
+            (0, 0),
+            (1, 1),
+            "ab\nc",
+            &[
+                "d",
+                "ef",
+            ][..]
+        ),
+        (
+            &[
+                "ab",
+                "cd",
+                "ef",
+            ][..],
+            (0, 0),
+            (1, 2),
+            "ab\ncd",
+            &[
+                "",
+                "ef",
+            ][..]
+        ),
+        (
+            &[
+                "ab",
+                "cd",
+                "ef",
+            ][..],
+            (0, 0),
+            (2, 0),
+            "ab\ncd\n",
+            &[
+                "ef",
+            ][..]
+        ),
+        (
+            &[
+                "ab",
+                "cd",
+                "ef",
+            ][..],
+            (0, 0),
+            (2, 1),
+            "ab\ncd\ne",
+            &[
+                "f",
+            ][..]
+        ),
+        (
+            &[
+                "ab",
+                "cd",
+                "ef",
+            ][..],
+            (0, 0),
+            (2, 2),
+            "ab\ncd\nef",
+            &[
+                "",
+            ][..]
+        ),
+        (
+            &[
+                "ab",
+                "cd",
+                "ef",
+            ][..],
+            (0, 1),
+            (1, 1),
+            "b\nc",
+            &[
+                "ad",
+                "ef",
+            ][..]
+        ),
+        (
+            &[
+                "ab",
+                "cd",
+                "ef",
+            ][..],
+            (0, 2),
+            (1, 1),
+            "\nc",
+            &[
+                "abd",
+                "ef",
+            ][..]
+        ),
+        (
+            &[
+                "ab",
+                "cd",
+                "ef",
+            ][..],
+            (1, 0),
+            (2, 1),
+            "cd\ne",
+            &[
+                "ab",
+                "f",
+            ][..]
+        ),
+        (
+            &[
+                "ab",
+                "cd",
+                "ef",
+            ][..],
+            (0, 2),
+            (1, 0),
             "\n",
+            &[
+                "abcd",
+                "ef",
+            ][..]
         ),
         (
-            // word forward select
-            "hello world",
-            vec![
-                (Key::Char('f'), false, true, true),
-                (Key::Char('c'), true, false, false),
-            ],
-            "hello ",
-            "hello world",
+            &[
+                "ab",
+                "cd",
+                "ef",
+            ][..],
+            (0, 2),
+            (2, 0),
+            "\ncd\n",
+            &[
+                "abef",
+            ][..]
+        ),
+        // Multi-byte characters
+        (
+            &[
+                "あい",
+                "うえ",
+                "おか",
+            ][..],
+            (0, 0),
+            (2, 2),
+            "あい\nうえ\nおか",
+            &[
+                "",
+            ][..]
         ),
         (
-            // word back select
-            "hello world",
-            vec![
-                (Key::End, false, false, false),
-                (Key::Char('b'), false, true, true),
-                (Key::Char('c'), true, false, false),
-            ],
-            "world",
-            "hello world",
+            &[
+                "あい",
+                "うえ",
+                "おか",
+            ][..],
+            (0, 1),
+            (2, 1),
+            "い\nうえ\nお",
+            &[
+                "あか",
+            ][..]
         ),
         (
-            // para forward select
-            "hello\nworld\n\nhow\nare\nyou",
-            vec![
-                (Key::Char('n'), false, true, true),
-                (Key::Char('x'), true, false, true),
-            ],
-            "hello\nworld\n\n",
-            "how\nare\nyou",
+            &[
+                "あい",
+                "うえ",
+                "おか",
+            ][..],
+            (0, 2),
+            (2, 0),
+            "\nうえ\n",
+            &[
+                "あいおか",
+            ][..]
         ),
         (
-            // para back select
-            "hello\nworld\n\nhow\nare\nyou",
-            vec![
-                // goto end
-                (Key::Char('n'), true, true, false),
-                (Key::End, false, false, false),
-                (Key::Char('p'), false, true, true),
-                (Key::Char('x'), true, false, true),
-            ],
-            "\nare\nyou",
-            "hello\nworld\n\nhow",
+            &[
+                "あい",
+                "うえ",
+                "おか",
+            ][..],
+            (0, 2),
+            (1, 2),
+            "\nうえ",
+            &[
+                "あい",
+                "おか",
+            ][..]
         ),
         (
-            // undo
-            "hello\nworld\n\nhow\nare\nyou",
-            vec![
-                // goto end
-                (Key::Char('n'), true, true, false),
-                (Key::End, false, false, false),
-                (Key::Char('p'), false, true, true),
-                (Key::Char('x'), true, false, false),
-                (Key::Char('u'), true, false, false),
-            ],
-            "\nare\nyou",
-            "hello\nworld\n\nhow\nare\nyou",
+            &[
+                "あい",
+                "うえ",
+                "おか",
+            ][..],
+            (0, 2),
+            (1, 1),
+            "\nう",
+            &[
+                "あいえ",
+                "おか",
+            ][..]
         ),
-    ] {
-        let (text, strokes, yank, remaining) = test;
-        one_select_test(text, &strokes, yank, remaining);
-    }
-}
-fn one_select_test(
-    text: &str,
-    strokes: &Vec<(Key, bool, bool, bool)>,
-    yank: &str,
-    remaining: &str,
-) {
-    let mut ta = TextArea::default();
-    ta.insert_str(text);
+        (
+            &[
+                "あい",
+                "うえ",
+                "おか",
+            ][..],
+            (0, 2),
+            (1, 0),
+            "\n",
+            &[
+                "あいうえ",
+                "おか",
+            ][..]
+        ),
+    ];
 
-    // cursor home
-    ta.input(Input {
-        key: Key::Up,
-        ctrl: true,
-        alt: true,
-        shift: false,
-    });
-    ta.input(Input {
-        key: Key::Home,
-        ctrl: true,
-        alt: true,
-        shift: false,
-    });
-    for k in strokes {
-        let input = Input {
-            key: k.0,
-            ctrl: k.1,
-            alt: k.2,
-            shift: k.3,
-        };
-        ta.input(input);
+    for test in tests {
+        let (init_text, (srow, scol), (erow, ecol), yanked, after_cut) = test;
+
+        {
+            let mut t = TextArea::from(init_text.iter().map(|s| s.to_string()));
+            t.move_cursor(CursorMove::Jump(srow as _, scol as _));
+            t.start_selection();
+            t.move_cursor(CursorMove::Jump(erow as _, ecol as _));
+            t.copy();
+
+            assert_eq!(t.cursor(), (erow, ecol), "{test:?}");
+            assert_eq!(t.yank_text(), yanked, "{test:?}");
+            assert_eq!(t.lines(), init_text, "{test:?}");
+        }
+
+        {
+            let mut t = TextArea::from(init_text.iter().map(|s| s.to_string()));
+            t.move_cursor(CursorMove::Jump(srow as _, scol as _));
+            t.start_selection();
+            t.move_cursor(CursorMove::Jump(erow as _, ecol as _));
+            t.cut();
+
+            assert_eq!(t.cursor(), (srow, scol), "{test:?}");
+            assert_eq!(t.yank_text(), yanked, "{test:?}");
+            assert_eq!(t.lines(), after_cut, "{test:?}");
+
+            t.paste();
+            assert_eq!(t.lines(), init_text, "{test:?}");
+        }
+
+        // Reverse positions
+        {
+            let mut t = TextArea::from(init_text.iter().map(|s| s.to_string()));
+            t.move_cursor(CursorMove::Jump(erow as _, ecol as _));
+            t.start_selection();
+            t.move_cursor(CursorMove::Jump(srow as _, scol as _));
+            t.copy();
+
+            assert_eq!(t.cursor(), (srow, scol), "{test:?}");
+            assert_eq!(t.yank_text(), yanked, "{test:?}");
+            assert_eq!(t.lines(), init_text, "{test:?}");
+        }
+
+        {
+            let mut t = TextArea::from(init_text.iter().map(|s| s.to_string()));
+            t.move_cursor(CursorMove::Jump(erow as _, ecol as _));
+            t.start_selection();
+            t.move_cursor(CursorMove::Jump(srow as _, scol as _));
+            t.cut();
+
+            assert_eq!(t.cursor(), (srow, scol), "{test:?}");
+            assert_eq!(t.yank_text(), yanked, "{test:?}");
+            assert_eq!(t.lines(), after_cut, "{test:?}");
+
+            t.paste();
+            assert_eq!(t.lines(), init_text, "{test:?}");
+        }
     }
-    assert_eq!(ta.yank_text(), yank);
-    assert_eq!(ta.lines().join("\n"), remaining);
+}
+
+#[test]
+fn test_delete_selection_on_delete_operations() {
+    macro_rules! test_case {
+        ($name:ident($($args:expr),*)) => {
+            (
+                stringify!($name),
+                (|t| t.$name($($args),*)) as fn(&mut TextArea) -> bool,
+            )
+        };
+    }
+
+    let tests = [
+        test_case!(delete_char()),
+        test_case!(delete_next_char()),
+        test_case!(delete_line_by_end()),
+        test_case!(delete_line_by_head()),
+        test_case!(delete_word()),
+        test_case!(delete_next_word()),
+        test_case!(delete_str(3)),
+    ];
+
+    for (n, f) in tests {
+        let mut t = TextArea::from(["ab", "cd", "ef"]);
+        t.move_cursor(CursorMove::Jump(0, 1));
+        t.start_selection();
+        t.move_cursor(CursorMove::Jump(2, 1));
+
+        let modified = f(&mut t);
+        assert!(modified, "{n}");
+        assert_eq!(t.lines(), ["af"], "{n}");
+        assert_eq!(t.cursor(), (0, 1), "{n}");
+
+        t.undo();
+        assert_eq!(t.lines(), ["ab", "cd", "ef"], "{n}");
+    }
+}
+
+#[test]
+fn test_delete_selection_on_delete_edge_cases() {
+    macro_rules! test_case {
+        ($name:ident($($args:expr),*), $pos:expr) => {
+            (
+                stringify!($name),
+                (|t| t.$name($($args),*)) as fn(&mut TextArea) -> bool,
+                $pos,
+            )
+        };
+    }
+
+    // When deleting nothing and deleting newline
+    let tests = [
+        test_case!(delete_char(), (0, 0)),
+        test_case!(delete_char(), (1, 0)),
+        test_case!(delete_next_char(), (2, 2)),
+        test_case!(delete_next_char(), (1, 2)),
+        test_case!(delete_line_by_end(), (0, 2)),
+        test_case!(delete_line_by_end(), (2, 2)),
+        test_case!(delete_line_by_head(), (0, 0)),
+        test_case!(delete_line_by_head(), (1, 0)),
+        test_case!(delete_word(), (0, 0)),
+        test_case!(delete_word(), (1, 0)),
+        test_case!(delete_next_word(), (2, 2)),
+        test_case!(delete_next_word(), (1, 2)),
+        test_case!(delete_str(0), (0, 0)),
+        test_case!(delete_str(100), (2, 2)),
+    ];
+
+    for (n, f, pos) in tests {
+        let mut t = TextArea::from(["ab", "cd", "ef"]);
+        t.move_cursor(CursorMove::Jump(1, 1));
+        t.start_selection();
+        t.move_cursor(CursorMove::Jump(pos.0 as _, pos.1 as _));
+
+        assert!(f(&mut t), "{n}, {pos:?}");
+        assert_eq!(t.cursor(), cmp::min(pos, (1, 1)), "{n}, {pos:?}");
+
+        t.undo();
+        assert_eq!(t.lines(), ["ab", "cd", "ef"], "{n}, {pos:?}");
+    }
+}
+
+#[test]
+fn test_delete_selection_before_insert() {
+    macro_rules! test_case {
+        ($name:ident($($args:expr),*), $want:expr) => {
+            (
+                stringify!($name),
+                (|t| {
+                    t.$name($($args),*);
+                }) as fn(&mut TextArea),
+                &$want as &[_],
+            )
+        };
+    }
+
+    let tests = [
+        test_case!(insert_newline(), ["a", "f"]),
+        test_case!(insert_char('x'), ["axf"]),
+        test_case!(insert_tab(), ["a   f"]), // Default tab is 4 spaces
+        test_case!(insert_str("xyz"), ["axyzf"]),
+    ];
+
+    for (n, f, after) in tests {
+        let mut t = TextArea::from(["ab", "cd", "ef"]);
+        t.move_cursor(CursorMove::Jump(0, 1));
+        t.start_selection();
+        t.move_cursor(CursorMove::Jump(2, 1));
+
+        f(&mut t);
+        assert_eq!(t.lines(), after, "{n}");
+
+        // XXX: Deleting selection and inserting text are separate undo units for now
+        t.undo();
+        t.undo();
+        assert_eq!(t.lines(), ["ab", "cd", "ef"], "{n}");
+    }
+}
+
+#[test]
+fn test_undo_redo_stop_selection() {
+    fn check(t: &mut TextArea, f: fn(&mut TextArea) -> bool) {
+        t.move_cursor(CursorMove::Jump(0, 0));
+        t.start_selection();
+        t.move_cursor(CursorMove::Jump(0, 1));
+        assert!(t.is_selecting());
+        assert!(f(t));
+        assert!(!t.is_selecting());
+    }
+
+    let mut t = TextArea::default();
+    t.insert_char('a');
+
+    check(&mut t, |t| t.undo());
+    assert_eq!(t.lines(), [""]);
+    check(&mut t, |t| t.redo());
+    assert_eq!(t.lines(), ["a"]);
 }