["x]<Leader>k{motion}   Delete any text in the line(s) covered by {motion}
                        except for the text that {motion} moves over itself,
                        and any indent (including a potential comment prefix).
                        Register x contains the deleted text (and the indent,
                        too).
                        When this is repeated (.) on a linewise selection,
                        the text covered by the previous {motion}, starting
                        from the current column, is kept in each line. For
                        characterwise and blockwise selections, it works like
                        a repeat of the following visual mode mapping,
                        deleting any text in the selected lines except the
                        selected text itself.
{Visual}["x]<Leader>k   Delete any text in the selected line(s) except the
                        selected text itself, and any indent / comment prefix.

["x]<Leader>kkn         Within the current line / [N] / selected lines, delete
{Visual}["x]<Leader>kkn any text that does not match the last search pattern,
                        and also keep any indent (including a potential
                        comment prefix).
["x]<Leader>kkN         Same as <Leader>kkn, but query whether to keep each
{Visual}["x]<Leader>kkN match.

["x]<Leader>kk/         Same as <Leader>kkN, but query a search pattern (and
{Visual}["x]<Leader>kk/ also query whether to keep each match).
["x]<Leader>kk?         Same as <Leader>kkN, but reuse the previously queried
{Visual}["x]<Leader>kk? search pattern from <Leader>kk/ (and also query
                        whether to keep each match).

["x]g<Leader>k{motion}  Delete any text in the entire buffer except for the
                        text that {motion} moves over itself.
                        Register x contains the deleted text.
{Visual}["x]g<Leader>k  Delete any text in the entire buffer except the
                        selected text itself.

["x]<Leader>zk{motion}  Delete any text in the last selection except for the
                        text that {motion} moves over itself. {motion} must be
                        (at least partially) inside the selection.
                        Register x contains the deleted text.

:[range]KeepRange [{register}] {range}
                        Delete any lines of the buffer / within [range] except
                        those that are covered by {range} into the unnamed
                        register / [{register}].
:[range]KeepRange! [{register}] {range}
                        Delete any lines of the buffer / within [range] that
                        are covered by {range} into the unnamed register /
                        [{register}].

:[range]KeepMatch [{register}] /{pattern}/[flags]
                        Within the current line / [range], delete any text
                        that does not match {pattern} into the unnamed
                        register / [{register}]. Only match(es) are kept.
                        Pass the special [<] flag to also keep any indent
                        (including a potential comment prefix), both in the
                        line and as part of the deleted text.
:[range]KeepMatch [{register}] /{pattern}/{string}/[flags]
                        Like above, but keep {string} (which can refer to the
                        match via &, \1, etc.)

:[range]KeepMatch! [{register}] /{pattern}/[flags]
                        Within the current line / [range], delete any text
                        that matches {pattern} into the unnamed
                        register / [{register}]. Only text that does not match
                        is kept. This is like
                            :[range]substitute/{pattern}//[flags]
                        but it stores the deleted text in a register.
:[range]KeepMatch! [{register}] /{pattern}/{string}/[flags]
                        Like above, but store {string} (which can refer to the
                        match via &, \1, etc.) in a register.

:[range]KeepMatchAndNewline [{register}] /{pattern}/[flags]
                        Within the current line / [range], delete any text
                        that does not match {pattern} into the unnamed
                        register / [{register}]. Only match(es) and newline
                        characters are kept; i.e. in contrast to :KeepMatch,
                        this variant does not join lines if the newline is not
                        included in {pattern}.
                        Pass the special [<] flag to also keep any indent
                        (including a potential comment prefix), both in the
                        line and as part of the deleted text.
                        This command is similar to
                            :[range]global/^/KeepMatch ...
                        but with correct register contents. Note: When
                        executed on a single line, it's the same as
                        :KeepMatch.
:[range]KeepMatchAndNewline [{register}] /{pattern}/{string}/[flags]
                        Like above, but keep {string} (which can refer to the
                        match via &, \1, etc.)
:[range]KeepMatchAndNewline! [{register}] /{pattern}/[flags]
:[range]KeepMatchAndNewline! [{register}] /{pattern}/{string}/[flags]
                        Within the current line / [range], delete any text
                        that matches {pattern} and newlines into the unnamed
                        register / [{register}]. Only text that does not match
                        and newlines are kept. This is like
                            :[range]substitute/{pattern}//[flags]
                        but it stores the deleted text in a register.

He said: "Hello, world!" and then left.

:substitute/.*"\(.*\)".*/\1/

:KeepMatch/"\zs.*\ze"/

vim KeepText*.vmb.gz
:so %

nmap <Leader>k <Plug>(KeepTextLineOperator)
xmap <Leader>k <Plug>(KeepTextLineVisual)
nmap <Leader>K <Plug>(KeepTextBufferOperator)
xmap <Leader>K <Plug>(KeepTextBufferVisual)
nmap <Leader>z <Plug>(KeepTextSelectionOperator)
nmap <Leader>/ <Plug>(KeepTextQueriedQueriedPatternMatchesLine)
xmap <Leader>/ <Plug>(KeepTextQueriedQueriedPatternMatchesVisual)
nmap <Leader>? <Plug>(KeepTextQueriedRecalledPatternMatchesLine)
xmap <Leader>? <Plug>(KeepTextQueriedRecalledPatternMatchesVisual)