Add lexical binding cookies (#389 )

* Add lexical binding cookies * multiple-cursors-core.el: Pacify lexical-binding frenzy in master * multiple-cursors-core.el: when saving mc/list-file, prepend a lexical binding flag to avoid emacs master from screaming. When inserting strings, use `\\n' instead of (newline).
Release 1.5.0
2025-10-13 05:03:03 +00:00 · 2025-10-06 13:38:27 -07:00 · 2025-02-10 19:13:49 +01:00 · 2025-02-10 19:12:54 +01:00 · 2024-12-26 17:55:18 +01:00 · 2024-12-02 17:31:03 +01:00
25 changed files with 1611 additions and 540 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -0,0 +1,36 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    paths-ignore:
+    - '**.md'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        emacs_version:
+          - 25.1
+          - 25.2
+          - 25.3
+          - 26.1
+          - 26.2
+          - 26.3
+          - 27.2
+          - 28.1
+          - snapshot
+    steps:
+    - uses: purcell/setup-emacs@master
+      with:
+        version: ${{ matrix.emacs_version }}
+    - name: Install Cask
+      run: git clone https://github.com/cask/cask ~/.cask
+    - name: Add Cask to PATH
+      run: echo "$HOME/.cask/bin" >> $GITHUB_PATH
+    - uses: actions/checkout@v3
+    - name: Install dependencies with Cask
+      run: cask
+    - name: Run tests
+      run: script -e -c /bin/bash -c 'TERM=xterm ./run-tests.sh'
--- a/.gitignore
+++ b/.gitignore
@ -1 +1,3 @@
-elpa
+elpa
+*.elc
+/.ecukes-failing-scenarios
--- a/.travis.yml
+++ b/.travis.yml
@ -1,21 +0,0 @@
-language: emacs-lisp
-before_install:
-  - if [ "$EMACS" = 'emacs-snapshot' ]; then
-      sudo add-apt-repository -y ppa:cassou/emacs &&
-      sudo apt-get update -qq &&
-      sudo apt-get install -qq
-          emacs-snapshot-el emacs-snapshot-gtk emacs-snapshot;
-    fi
-  - if [ "$EMACS" = 'emacs24' ]; then
-      sudo add-apt-repository -y ppa:cassou/emacs &&
-      sudo apt-get update -qq &&
-      sudo apt-get install -qq
-          emacs24 emacs24-el emacs24-common-non-dfsg;
-    fi
-  - curl -fsSkL https://raw.github.com/rejeep/cask.el/master/go | sh
-  - export PATH="/home/travis/.cask/bin:$PATH"
-  - cask
-env:
-  - EMACS=emacs24 TAGS=""
-script:
-  ./run-travis-ci.sh
--- a/README.md
+++ b/README.md
@ -1,9 +1,45 @@
-# multiple-cursors.el [![Build Status](https://secure.travis-ci.org/magnars/multiple-cursors.el.png)](http://travis-ci.org/magnars/multiple-cursors.el)
+[![Build Status](https://github.com/magnars/multiple-cursors.el/workflows/CI/badge.svg)](https://github.com/magnars/multiple-cursors.el/actions)
+[![MELPA](https://melpa.org/packages/multiple-cursors-badge.svg)](https://melpa.org/#/multiple-cursors)
+[![MELPA Stable](https://stable.melpa.org/packages/multiple-cursors-badge.svg)](https://stable.melpa.org/#/multiple-cursors)
+[![NonGNU ELPA](https://elpa.nongnu.org/nongnu/multiple-cursors.svg)](https://elpa.nongnu.org/nongnu/multiple-cursors.html)
+
+# multiple-cursors.el

 Multiple cursors for Emacs. This is some pretty crazy functionality, so yes,
-there are kinks. Don't be afraid tho, I've been using it since 2011 with
+there are kinks. Don't be afraid though, I've been using it since 2011 with
 great success and much merriment.

+## Maintenance warning
+
+I use this package every day, and have been doing so for years. It just works.
+At least, it works for all my use cases. And if it breaks somehow, I fix it.
+
+However, it has become painfully clear to me that I don't have time to fix
+problems I don't have. It's been years since I could keep pace with the issues
+and pull requests. Whenever I try, I keep getting feedback that my fix isn't
+good enough by some standard I don't particularly care about.
+
+So, I have closed the issue tracker and the pull requests. I hope you can
+happily use this package, just like I do. If it doesn't work for you, then I'm
+sorry. Thankfully Emacs is infinitely malleable, you can probably fix it
+yourself.
+
+TLDR: *I am still maintaining this package*, but I am no longer crowdsourcing a list of issues.
+
+## Installation
+
+I highly recommend installing multiple-cursors through `package.el`.
+
+It's available on [MELPA](http://melpa.org/), [MELPA Stable](http://stable.melpa.org) and 
+[NonGNU ELPA](https://elpa.nongnu.org/nongnu/multiple-cursors.html) (enabled by default
+from Emacs 28 onwards):
+
+    M-x package-install multiple-cursors
+
+The package depends on the `cl-lib` package, so if you do not use
+`package.el` or have a recent Emacs, you would need to install that
+too: see [GNU ELPA](http://elpa.gnu.org/packages/cl-lib.html).
+
 ## Basic usage

 Start out with:
@ -39,45 +75,59 @@ You can [watch an intro to multiple-cursors at Emacs Rocks](http://emacsrocks.co

 ### Mark one more occurrence

- - `mc/mark-next-like-this`: Adds a cursor and region at the next part of the buffer forwards that matches the current region.
- - `mc/mark-next-word-like-this`: Like `mc/mark-next-like-this` but only for whole words.
- - `mc/mark-next-symbol-like-this`: Like `mc/mark-next-like-this` but only for whole symbols.
- - `mc/mark-previous-like-this`: Adds a cursor and region at the next part of the buffer backwards that matches the current region.
- - `mc/mark-previous-word-like-this`: Like `mc/mark-previous-like-this` but only for whole words.
- - `mc/mark-previous-symbol-like-this`: Like `mc/mark-previous-like-this` but only for whole symbols.
- - `mc/mark-more-like-this-extended`: Use arrow keys to quickly mark/skip next/previous occurances.
- - `mc/add-cursor-on-click`: Bind to a mouse event to add cursors by clicking. See tips-section.
- - `mc/pop-mark`: Set a cursor at the current point and move to the next (different) position on the mark stack.  This allows for fine grained control over the placement of cursors.
+| Command                             | Description                                                                                                                                                         |
+|-------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `mc/mark-next-like-this`            | Adds a cursor and region at the next part of the buffer forwards that matches the current region.                                                                   |
+| `mc/mark-next-like-this-word`       | Adds a cursor and region at the next part of the buffer forwards that matches the current region, if  no region is selected it selects the word at the point.       |
+| `mc/mark-next-like-this-symbol`     | Adds a cursor and region at the next part of the buffer forwards that matches the current region, if  no region is selected it selects the symbol at the point.     |
+| `mc/mark-next-word-like-this`       | Like `mc/mark-next-like-this` but only for whole words.                                                                                                             |
+| `mc/mark-next-symbol-like-this`     | Like `mc/mark-next-like-this` but only for whole symbols.                                                                                                           |
+| `mc/mark-previous-like-this`        | Adds a cursor and region at the next part of the buffer backwards that matches the current region.                                                                  |
+| `mc/mark-previous-like-this-word`   | Adds a cursor and region at the next part of the buffer backwards that matches the current region, if  no region is selected it selects the word at the point.      |
+| `mc/mark-previous-like-this-symbol` | Adds a cursor and region at the next part of the buffer backwards that matches the current region, if  no region is selected it selects the symbol at the point.    |
+| `mc/mark-previous-word-like-this`   | Like `mc/mark-previous-like-this` but only for whole words.                                                                                                         |
+| `mc/mark-previous-symbol-like-this` | Like `mc/mark-previous-like-this` but only for whole symbols.                                                                                                       |
+| `mc/mark-more-like-this-extended`   | Use arrow keys to quickly mark/skip next/previous occurrences.                                                                                                      |
+| `mc/add-cursor-on-click`            | Bind to a mouse event to add cursors by clicking. See tips-section.                                                                                                 |
+| `mc/mark-pop`                       | Set a cursor at the current point and move to the next (different) position on the mark stack.  This allows for fine grained control over the placement of cursors. |

 ### Juggle around with the current cursors

- - `mc/unmark-next-like-this`: Remove the cursor furthest down in the buffer.
- - `mc/unmark-previous-like-this`: Remove the cursor furthest up in the buffer.
- - `mc/skip-to-next-like-this`: Remove the cursor furthest down, marking the next occurance down.
- - `mc/skip-to-previous-like-this`: Remove the cursor furthest up, marking the next occurance up.
- - `mc/mark-next-like-this-extended`: Temporarily bind the arrow keys to mark/unmark/skip cursors.
+| Command                         | Description                                                        |
+|---------------------------------|--------------------------------------------------------------------|
+| `mc/unmark-next-like-this`      | Remove the cursor furthest down in the buffer.                     |
+| `mc/unmark-previous-like-this`  | Remove the cursor furthest up in the buffer.                       |
+| `mc/skip-to-next-like-this`     | Remove the cursor furthest down, marking the next occurrence down. |
+| `mc/skip-to-previous-like-this` | Remove the cursor furthest up, marking the next occurrence up.     |

 ### Mark many occurrences

- - `mc/edit-lines`: Adds one cursor to each line in the current region.
- - `mc/edit-beginnings-of-lines`: Adds a cursor at the start of each line in the current region.
- - `mc/edit-ends-of-lines`: Adds a cursor at the end of each line in the current region.
- - `mc/mark-all-like-this`: Marks all parts of the buffer that matches the current region.
- - `mc/mark-all-words-like-this`: Like `mc/mark-all-like-this` but only for whole words.
- - `mc/mark-all-symbols-like-this`: Like `mc/mark-all-like-this` but only for whole symbols.
- - `mc/mark-all-in-region`: Prompts for a string to match in the region, adding cursors to all of them.
- - `mc/mark-all-like-this-in-defun`: Marks all parts of the current defun that matches the current region.
- - `mc/mark-all-words-like-this-in-defun`: Like `mc/mark-all-like-this-in-defun` but only for whole words.
- - `mc/mark-all-symbols-like-this-in-defun`: Like `mc/mark-all-like-this-in-defun` but only for whole symbols.
- - `mc/mark-all-dwim`: Tries to be smart about marking everything you want. Can be pressed multiple times.
+| Command                                  | Description                                                                         |
+|------------------------------------------|-------------------------------------------------------------------------------------|
+| `mc/edit-lines`                          | Adds one cursor to each line in the current region.                                 |
+| `mc/edit-beginnings-of-lines`            | Adds a cursor at the start of each line in the current region.                      |
+| `mc/edit-ends-of-lines`                  | Adds a cursor at the end of each line in the current region.                        |
+| `mc/mark-all-like-this`                  | Marks all parts of the buffer that matches the current region.                      |
+| `mc/mark-all-words-like-this`            | Like `mc/mark-all-like-this` but only for whole words.                              |
+| `mc/mark-all-symbols-like-this`          | Like `mc/mark-all-like-this` but only for whole symbols.                            |
+| `mc/mark-all-in-region`                  | Prompts for a string to match in the region, adding cursors to all of them.         |
+| `mc/mark-all-like-this-in-defun`         | Marks all parts of the current defun that matches the current region.               |
+| `mc/mark-all-words-like-this-in-defun`   | Like `mc/mark-all-like-this-in-defun` but only for whole words.                     |
+| `mc/mark-all-symbols-like-this-in-defun` | Like `mc/mark-all-like-this-in-defun` but only for whole symbols.                   |
+| `mc/mark-all-dwim`                       | Tries to be smart about marking everything you want. Can be pressed multiple times. |

 ### Special

- - `set-rectangular-region-anchor`: Think of this one as `set-mark` except you're marking a rectangular region.
- - `mc/mark-sgml-tag-pair`: Mark the current opening and closing tag.
- - `mc/insert-numbers`: Insert increasing numbers for each cursor, top to bottom.
- - `mc/sort-regions`: Sort the marked regions alphabetically.
- - `mc/reverse-regions`: Reverse the order of the marked regions.
+| Command                         | Description                                                                                                                                                                                  |
+|---------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `set-rectangular-region-anchor` | Think of this one as `set-mark` except you're marking a rectangular region.                                                                                                                  |
+| `mc/mark-sgml-tag-pair`         | Mark the current opening and closing tag.                                                                                                                                                    |
+| `mc/insert-numbers`             | Insert increasing numbers for each cursor, top to bottom.                                                                                                                                    |
+| `mc/insert-letters`             | Insert increasing letters for each cursor, top to bottom.                                                                                                                                    |
+| `mc/sort-regions`               | Sort the marked regions alphabetically.                                                                                                                                                      |
+| `mc/reverse-regions`            | Reverse the order of the marked regions.                                                                                                                                                     |
+| `mc/vertical-align`             | Aligns all cursors vertically with a given CHARACTER to the one with the highest column number (the rightest). (Might not behave as intended if more than one cursors are on the same line.) |
+| `mc/vertical-align-with-space`  | Aligns all cursors with whitespace like `mc/vertical-align` does.                                                                                                                            |

 ## Tips and tricks

@ -85,12 +135,20 @@ You can [watch an intro to multiple-cursors at Emacs Rocks](http://emacsrocks.co
  first disable multiple regions before disabling multiple cursors. If you want to
  insert a newline in multiple-cursors-mode, use `C-j`.

+- `(define-key mc/keymap (kbd "<return>") nil)` will make `<return>` insert a
+  newline; multiple-cursors-mode can still be disabled with `C-g`.
+
 - Sometimes you end up with cursors outside of your view. You can
-  scroll the screen to center on each cursor with `C-v` and `M-v`.
+  scroll the screen to center on each cursor with `C-v` and `M-v` or you can
+  press `C-'` to hide all lines without a cursor, press `C-'` again to unhide.

 - Try pressing `mc/mark-next-like-this` with no region selected. It
  will just add a cursor on the next line.

+- Try pressing `mc/mark-next-like-this-word` or
+  `mc/mark-next-like-this-symbol` with no region selected. It will
+  mark the word or symbol and add a cursor at the next occurrence
+
 - Try pressing `mc/mark-all-like-this-dwim` on a tagname in html-mode.

 - Notice that the number of cursors active can be seen in the modeline.
@ -102,9 +160,16 @@ You can [watch an intro to multiple-cursors at Emacs Rocks](http://emacsrocks.co
 - You can use `mc/reverse-regions` with nothing selected and just one cursor.
  It will then flip the sexp at point and the one below it.

+- When you use `mc/edit-lines`, you can give it a positive or negative
+  prefix to change how it behaves on too short lines.
+
 - If you would like to keep the global bindings clean, and get custom keybindings
  when the region is active, you can try [region-bindings-mode](https://github.com/fgallina/region-bindings-mode).

+- There is a special hook that is run when the mode is diabled
+  (which is equivalent to the number of cursors going back to 1):
+  `multiple-cursors-mode-disabled-hook`
+
 BTW, I highly recommend adding `mc/mark-next-like-this` to a key binding that's
 right next to the key for `er/expand-region`.

@ -132,12 +197,17 @@ the location with:

    (setq mc/list-file "/my/preferred/file")

+NB! Make sure to do so before requiring multiple-cursors.
+
+It is possible to set multiple-cursors to "run-for-all" for every
+command except for those that are listed in `mc/cmds-to-run-once`. To
+enable this set `mc/always-run-for-all` to non-nil. Add commands to be
+run once to `mc/cmds-to-run-once` in ".mc-lists.el".

 ## Known limitations

 * isearch-forward and isearch-backward aren't supported with multiple cursors.
  If you want this functionality, you can use [phi-search](https://github.com/zk-phi/phi-search).
-* Commands run with `M-x` won't be repeated for all cursors.
 * All key bindings that refer to lambdas are always run for all cursors. If you
  need to limit it, you will have to give it a name.
 * Redo might screw with your cursors. Undo works very well.
@ -166,17 +236,21 @@ Run the tests with:
 ## Contributors

 * [Takafumi Arakaki](https://github.com/tkf) has contributed several small improvements
-* [Marco Baringer](https://github.com/segv) contributed looping to mc/cycle and adding cursors without region for mark-more.
-* [Ivan Andrus](https://github.com/gvol) added showing number of cursors in mode-line
+* [Marco Baringer](https://github.com/segv) contributed looping to `mc/cycle` and adding cursors without region for mark-more.
+* [Ivan Andrus](https://github.com/gvol) added showing number of cursors in mode-line, and different options for how to handle short lines in `mc/edit-lines`.
 * [Fuco](https://github.com/Fuco1) added the first version of `mc/mark-all-like-this-dwim`
 * [Zach Kost-Smith](https://github.com/smithzvk) added `mc/mark-pop`
 * [Maciej Katafiasz](https://github.com/mathrick) added `mc/mark-all-dwim`
+* [Aleksey Fedotov](https://github.com/lexa) added `mc-hide-unmatched-lines-mode`
+* [Jules Tamagnan](https://github.com/jtamagnan) added `mc/mark-next-like-this-word` and `mc/mark-next-like-this-symbol`
+* [Ingo Lohmar](https://github.com/ilohmar) extended `mc/add-cursor-on-click` to toggle cursors.
+* [Andrea Orru](https://github.com/AndreaOrru) added `mc/mark-previous-like-this-word`/`-symbol`

 Thanks!

 ## License

-Copyright (C) 2012 Magnar Sveen
+Copyright (C) 2012-2016 Magnar Sveen

 Author: Magnar Sveen <magnars@gmail.com>
 Keywords: editing cursors
--- a/features/edit-lines.feature
+++ b/features/edit-lines.feature
@ -55,3 +55,86 @@ Feature: Switching from a multiline region to multiple cursors
    And I go to the front of the word "there"
    And I press "C-S-c C-S-c"
    Then I should have 2 cursors
+
+  Scenario: Edit default short lines
+    When I insert:
+    """
+    hello
+
+    there
+    """
+    And I go to the end of the word "hello"
+    And I set the mark
+    And I go to the end of the word "there"
+    And I press "C-S-c C-S-c"
+    And I press "you"
+    Then I should see:
+    """
+    helloyou
+    you
+    thereyou
+    """
+
+  Scenario: Pad short lines
+    When I insert:
+    """
+    hello
+
+    there
+    """
+    And I go to the end of the word "hello"
+    And I set the mark
+    And I go to the end of the word "there"
+    And I press "M-1 C-S-c C-S-c"
+    Then I should have 3 cursors
+
+  Scenario: Edit padding short lines
+    When I insert:
+    """
+    hello
+
+    there
+    """
+    And I go to the end of the word "hello"
+    And I set the mark
+    And I go to the end of the word "there"
+    And I press "M-1 C-S-c C-S-c"
+    And I press "you"
+    Then I should see:
+    """
+    helloyou
+         you
+    thereyou
+    """
+
+  Scenario: Skip short lines
+    When I insert:
+    """
+    hello
+
+    there
+    """
+    And I go to the end of the word "hello"
+    And I set the mark
+    And I go to the end of the word "there"
+    And I press "M-- M-1 C-S-c C-S-c"
+    Then I should have 2 cursors
+
+  Scenario: Edit skipping short lines
+    When I insert:
+    """
+    hello
+
+    there
+    """
+    And I go to the end of the word "hello"
+    And I set the mark
+    And I go to the end of the word "there"
+    And I press "M-- M-1 C-S-c C-S-c"
+    And I press "you"
+    Then I should see:
+    """
+    helloyou
+
+    thereyou
+    """
--- a/features/hide-unmatched-lines.feature
+++ b/features/hide-unmatched-lines.feature
@ -0,0 +1,73 @@
+Feature: Hiding lines without cursor
+
+  Scenario: Hiding lines when three cursor active
+    Given I have cursors at "line" in :
+    """
+    0
+    line
+    2
+    3
+    line
+    5
+    6
+    7
+    8
+    9
+    10
+    11
+    line
+    13
+    14
+    15
+    """
+    And I press "C-'"
+    Then I should have 3 cursors
+    Then I should see exactly:
+    """
+    0
+    line
+    2
+    3
+    line
+    5
+    6
+
+    10
+    11
+    line
+    13
+    14
+
+   """
+
+
+  Scenario: Hiding lines when only two cursor active
+    When I insert:
+    """
+      1
+      2
+      3
+      4
+      5
+      text
+      6
+      7
+      8
+      9
+      10
+    """
+    And I go to the front of the word "text"
+    And I press "C->"
+    And I press "C-'"
+    Then I should have 2 cursors
+    Then I should see exactly:
+    """
+
+      4
+      5
+      text
+      6
+      7
+      8
+
+    """
--- a/features/insert-letters.feature
+++ b/features/insert-letters.feature
@ -0,0 +1,25 @@
+Feature: Insert increasing letters
+
+  Scenario: Three cursors, a-b-c
+    Given I have cursors at "text" in "This text contains the word text thrice (text)"
+    When I press "H-3"
+    And I press "SPC"
+    Then I should see "This a text contains the word b text thrice (c text)"
+
+  Scenario: Three cursors, j-k-l
+    Given I have cursors at "text" in "This text contains the word text thrice (text)"
+    When I press "C-9 H-3"
+    And I press "SPC"
+    Then I should see "This j text contains the word k text thrice (l text)"
+
+  Scenario: Three cursors, z-aa-ab
+    Given I have cursors at "text" in "This text contains the word text thrice (text)"
+    When I press "C-u 2 5 H-3"
+    And I press "SPC"
+    Then I should see "This z text contains the word aa text thrice (ab text)"
+
+  Scenario: Three cursors, a-b-c
+    Given I have cursors at "text" in "This text contains the word text thrice (text)"
+    When I press "C-u H-3"
+    And I press "SPC"
+    Then I should see "This e text contains the word f text thrice (g text)"
--- a/features/insert-numbers.feature
+++ b/features/insert-numbers.feature
@ -11,3 +11,30 @@ Feature: Insert increasing numbers
    When I press "C-9 H-0"
    And I press "SPC"
    Then I should see "This 9 text contains the word 10 text thrice (11 text)"
+
+  Scenario: Three cursors, 9-10-11
+    Given I have cursors at "text" in "This text contains the word text thrice (text)"
+    When I press "C-u H-0"
+    And I press "SPC"
+    Then I should see "This 4 text contains the word 5 text thrice (6 text)"
+
+  Scenario: Three cursors, 0-1-2, default
+    Given I have cursors at "text" in "This text contains the word text thrice (text)"
+    When I set mc/insert-numbers-default to 1
+    And I press "H-0"
+    And I press "SPC"
+    Then I should see "This 1 text contains the word 2 text thrice (3 text)"
+
+  Scenario: Three cursors, 9-10-11, default
+    Given I have cursors at "text" in "This text contains the word text thrice (text)"
+    When I set mc/insert-numbers-default to 1
+    And I press "C-9 H-0"
+    And I press "SPC"
+    Then I should see "This 9 text contains the word 10 text thrice (11 text)"
+
+  Scenario: Three cursors, 9-10-11, default
+    Given I have cursors at "text" in "This text contains the word text thrice (text)"
+    When I set mc/insert-numbers-default to 1
+    And I press "C-u H-0"
+    And I press "SPC"
+    Then I should see "This 4 text contains the word 5 text thrice (6 text)"
--- a/features/mark-more.feature
+++ b/features/mark-more.feature
@ -14,6 +14,14 @@ Feature: Marking multiple parts of the buffer
    And I type "sentence"
    Then I should see "This sentence has the word sentence in it"

+  Scenario: Marking next like this, word
+    Given I turn on delete-selection-mode
+    When I insert "This text has the word text in it"
+    And I go to word "text"
+    And I press "C-S-c C->"
+    And I type "sentence"
+    Then I should see "This sentence has the word sentence in it"
+
  Scenario: Skipping a mark
    Given I turn on delete-selection-mode
    When I insert "Here's text, text and text"
@ -54,6 +62,14 @@ Feature: Marking multiple parts of the buffer
    And I type "sentence"
    Then I should see "This sentence has the word sentence in it"

+  Scenario: Marking prev like this, word
+    Given I turn on delete-selection-mode
+    When I insert "This text has the word text in it"
+    And I go to last word "text"
+    And I press "C-S-c C-<"
+    And I type "sentence"
+    Then I should see "This sentence has the word sentence in it"
+
  Scenario: Skipping a prev mark
    Given I turn on delete-selection-mode
    When I insert "Here's text, text and text"
--- a/features/multiple-cursors-core.feature
+++ b/features/multiple-cursors-core.feature
@ -50,6 +50,13 @@ Feature: Multiple cursors core
    And I press "C-!"
    Then I should see "This aatext contains the word aatext twice"

+Scenario: Unknown command with multiple read: yes, do for all
+    Given I have bound C-! to a new command that inserts two read-chars
+    And I have cursors at "text" in "This text contains the word text twice"
+    When I press "C-! b c y"
+    And I press "C-! d e"
+    Then I should see "This bcdetext contains the word bcdetext twice"
+
  Scenario: Unknown command: no, don't do for all
    Given I have bound C-! to another new command that inserts "a"
    And I have cursors at "text" in "This text contains the word text twice"
@ -57,6 +64,28 @@ Feature: Multiple cursors core
    And I press "C-!"
    Then I should see "This aatext contains the word text twice"

+  Scenario: Multiple supported M-x command (forward-word in this case)
+    Given I have cursors at "text" in "This text contains the word text twice"
+    And I type "("
+    And I press "M-x forward-word"
+    And I press "M-x forward-word"
+    And I type ")"
+    Then I should see "This (text contains) the word (text twice)"
+
+  Scenario: Unknown M-x command: yes, do for all
+    Given I have cursors at "text" in "This text contains the word text twice"
+    And I press "C-SPC"
+    And I press "M-f"
+    And I press "M-x upcase-dwim RET y"
+    Then I should see "This TEXT contains the word TEXT twice"
+
+  Scenario: Unknown M-x command: no, don't do for all
+    Given I have cursors at "text" in "This text contains the word text twice"
+    And I press "C-SPC"
+    And I press "M-f"
+    And I press "M-x upcase-dwim RET n"
+    Then I should see "This TEXT contains the word text twice"
+
  Scenario: Undo
    Given I have cursors at "text" in "This text contains the word text twice"
    When I press "M-f"
@ -166,9 +195,23 @@ Feature: Multiple cursors core
    And I press "C-v"
    Then the cursor should be at point "8"

+  Scenario: Looping forwards around cursors including one at point-max
+    Given I have cursors at "_" in "1_34_67_"
+    And I press "C-f"
+    And I press "C-v"
+    And I press "C-v"
+    And I press "C-v"
+    Then the cursor should be at point "3"
+
  Scenario: Looping backwards around cursors
    Given I have cursors at "_" in "1_34567_9"
    And I press "M-v"
    And I press "M-v"
    Then the cursor should be at point "2"

+  Scenario: Looping backwards around cursors including one at point-min
+    Given I have cursors at "_" in "_234_67_9"
+    And I press "M-v"
+    And I press "M-v"
+    And I press "M-v"
+    Then the cursor should be at point "1"
--- a/features/repeat-command.feature
+++ b/features/repeat-command.feature
@ -0,0 +1,39 @@
+Feature: Repeat last interactive command for fake cursors (mc/repeat-command)
+
+  Scenario: Clone insert-char from M-x
+    Given I have cursors at "text" in "This text contains the word text thrice (text)"
+    When I start an action chain
+    When I press "M-x"
+    And I type "insert-char"
+    And I press "RET"
+    And I type "21"
+    And I press "RET"
+    And I type "n"
+    And I press "C-:"
+    And I press "y"
+    And I execute the action chain
+    Then I should see "This !text contains the word !text thrice (!text)"
+
+  Scenario: Clone insert-char from M-:
+    Given I have cursors at "text" in "This text contains the word text thrice (text)"
+    When I start an action chain
+    When I press "M-:"
+    And I type "(insert-char (+ 40 2))"
+    And I press "RET"
+    And I press "C-:"
+    And I press "y"
+    And I execute the action chain
+    Then I should see "This *text contains the word *text thrice (*text)"
+
+  Scenario: Disable prompt
+    Given I have cursors at "text" in "This text/0000 contains the word text/1111 thrice (text/2222)"
+    When I set mc/always-repeat-command to t
+    When I set mc/always-run-for-all to t
+    When I start an action chain
+    And I press "M-x"
+    And I type "zap-to-char"
+    And I press "RET"
+    And I press "/"
+    And I press "C-:"
+    And I execute the action chain
+    Then I should see "This 0000 contains the word 1111 thrice (2222)"
--- a/features/step-definitions/multiple-cursors-steps.el
+++ b/features/step-definitions/multiple-cursors-steps.el
@ -1,9 +1,23 @@
+(require 'cl) ;; For lexical-let
+
 (When "^I mark next like this$"
      (lambda () (call-interactively 'mc/mark-next-like-this)))

+(When "^I mark next like this word$"
+      (lambda () (call-interactively 'mc/mark-next-like-this-word)))
+
+(When "^I mark next like this symbol$"
+      (lambda () (call-interactively 'mc/mark-next-like-this-symbol)))
+
 (When "^I mark previous like this$"
      (lambda () (call-interactively 'mc/mark-previous-like-this)))

+(When "^I mark previous like this word$"
+      (lambda () (call-interactively 'mc/mark-previous-like-this-word)))
+
+(When "^I mark previous like this symbol$"
+      (lambda () (call-interactively 'mc/mark-previous-like-this-symbol)))
+
 (When "^I mark all like this$"
      (lambda () (call-interactively 'mc/mark-all-like-this)))

@ -16,6 +30,9 @@
 (When "^I insert numbers$"
      (lambda () (call-interactively 'mc/insert-numbers)))

+(When "^I insert letters$"
+      (lambda () (call-interactively 'mc/insert-letters)))
+
 (When "^I reverse regions$"
      (lambda () (call-interactively 'mc/reverse-regions)))

@ -39,25 +56,25 @@
 (Then "^I should have \\([0-9]+\\) cursors$"
      (lambda (num)
        (let ((actual (mc/num-cursors)))
-          (assert (eq (string-to-number num) actual) nil
-                  "Expected to have %s cursors, but was %d." num actual))))
+          (cl-assert (eq (string-to-number num) actual) nil
+                     "Expected to have %s cursors, but was %d." num actual))))

 (Then "^I should have one cursor$"
      (lambda ()
-        (assert (not multiple-cursors-mode) nil
-                "Expected to have one cursor, but multiple-cursors-mode is still active.")
-        (assert (eq 1 (mc/num-cursors)) nil
-                "Expected to have one cursor, but there are still fake cursor overlays.")))
+        (cl-assert (not multiple-cursors-mode) nil
+                   "Expected to have one cursor, but multiple-cursors-mode is still active.")
+        (cl-assert (eq 1 (mc/num-cursors)) nil
+                   "Expected to have one cursor, but there are still fake cursor overlays.")))

 (Then "^rectangular-region-mode should be off$"
-       (lambda ()
-         (assert (not rectangular-region-mode) nil
-                 "Expected rectangular-region-mode mode to be off, but wasn't.")))
+      (lambda ()
+        (cl-assert (not rectangular-region-mode) nil
+                   "Expected rectangular-region-mode mode to be off, but wasn't.")))

 (Then "^rectangular-region-mode should be on$"
-       (lambda ()
-         (assert rectangular-region-mode nil
-                 "Expected rectangular-region-mode mode to be on, but wasn't.")))
+      (lambda ()
+        (cl-assert rectangular-region-mode nil
+                   "Expected rectangular-region-mode mode to be on, but wasn't.")))

 (When "^I press \"\\(.+\\)\"$"
      (lambda (keybinding)
@ -79,6 +96,17 @@
         (mc/mark-all-like-this)
         (mc/keyboard-quit)))

+(Given "^I have cursors at \"\\(.+\\)\" in \\(?: \"\\(.+\\)\"\\|:\\)$"
+       (lambda (needle haystack)
+         (insert haystack)
+         (goto-char (point-min))
+         (search-forward needle)
+         (set-mark (point))
+         (goto-char (match-beginning 0))
+         (mc/mark-all-like-this)
+         (mc/keyboard-quit)))
+
+
 (When "^I copy \"\\(.+\\)\" in another program$"
       (lambda (text)
         (lexical-let ((text text))
@ -102,6 +130,11 @@
           (defun mc-test-temp-command-2 () (interactive) (insert ins))
           (global-set-key (kbd "C-!") 'mc-test-temp-command-2))))

+(Given "^I have bound C-! to a new command that inserts two read-chars$"
+       (lambda ()
+         (defun mc-test-temp-command-3 () (interactive) (insert (read-char "first: ")) (insert (read-char "second: ")))
+         (global-set-key (kbd "C-!") 'mc-test-temp-command-3)))
+
 (Given "^I have bound C-! to a keyboard macro that insert \"_\"$"
       (lambda ()
         (fset 'mc-test-temp-kmacro "\C-q_")
@ -112,21 +145,27 @@
        (goto-char (point-min))
        (let ((search (re-search-forward (format "%s" char) nil t))
              (message "Can not go to character '%s' since it does not exist in the current buffer: %s"))
-          (assert search nil message char (espuds-buffer-contents)))))
+          (cl-assert search nil message char (espuds-buffer-contents)))))

 (When "^I go to the \\(front\\|end\\) of the word \"\\(.+\\)\"$"
      (lambda (pos word)
        (goto-char (point-min))
        (let ((search (re-search-forward (format "%s" word) nil t))
              (message "Can not go to character '%s' since it does not exist in the current buffer: %s"))
-          (assert search nil message word (espuds-buffer-contents))
+          (cl-assert search nil message word (espuds-buffer-contents))
          (if (string-equal "front" pos) (backward-word)))))

+(When "^I go to last word \"\\(.+\\)\"$"
+      (lambda (text)
+        (goto-char (point-max))
+        (let ((search (re-search-backward text nil t)))
+          (cl-assert search nil "The text '%s' was not found in the current buffer." text))))
+
 (When "^I select the last \"\\(.+\\)\"$"
      (lambda (text)
        (goto-char (point-max))
        (let ((search (re-search-backward text nil t)))
-          (assert search nil "The text '%s' was not found in the current buffer." text))
+          (cl-assert search nil "The text '%s' was not found in the current buffer." text))
        (set-mark (point))
        (re-search-forward text)))

@ -137,3 +176,24 @@
                                              (split-string rest))
                                       "-"))))
          (call-interactively func))))
+
+(Then "^I should see exactly\\(?: \"\\(.+\\)\"\\|:\\)$"
+      "Asserts that the current buffer does not include some text with
+       respect of text hidden by overlays"
+      (lambda (expected)
+        (let ((p (point-min))
+              (visible-text "")
+              (message "Expected '%s' to be part of '%s', but was not found in current buffer.")
+              )
+          (while (not (= p (point-max)))
+            (if (not (invisible-p p))
+                (setq visible-text (concat visible-text  (buffer-substring p (1+ p))))
+              )
+            (setq p (1+ p))
+            )
+          (cl-assert (s-equals? expected visible-text) nil message expected visible-text))))
+
+
+;; Local Variables:
+;; byte-compile-warnings: (not cl-functions)
+;; End:
--- a/features/support/env.el
+++ b/features/support/env.el
@ -21,12 +21,17 @@
 (multiple-cursors-mode 0)
 (rectangular-region-mode 0)
 (global-set-key (kbd "C->") 'mc/mark-next-like-this)
+ (global-set-key (kbd "C-S-c C->") 'mc/mark-next-like-this-word)
+ (global-set-key (kbd "C-S-c M->") 'mc/mark-next-like-this-symbol)
 (global-set-key (kbd "C-<") 'mc/mark-previous-like-this)
+ (global-set-key (kbd "C-S-c C-<") 'mc/mark-previous-like-this-word)
+ (global-set-key (kbd "C-S-c M-<") 'mc/mark-previous-like-this-symbol)
 (global-set-key (kbd "M-!") 'mc/mark-all-like-this)
 (global-set-key (kbd "M-$") 'mc/mark-all-like-this-dwim)
 (global-set-key (kbd "C-$") 'mc/mark-all-dwim)
 (global-set-key (kbd "M-#") 'mc/mark-all-in-region)
 (global-set-key (kbd "H-0") 'mc/insert-numbers)
+ (global-set-key (kbd "H-3") 'mc/insert-letters)
 (global-set-key (kbd "H-1") 'mc/reverse-regions)
 (global-set-key (kbd "H-2") 'mc/sort-regions)
 (global-set-key (kbd "C-S-c C-S-c") 'mc/edit-lines)
@ -40,6 +45,8 @@
 (subword-mode 0)
 (wrap-region-mode 0)
 (setq set-mark-default-inactive nil)
- (deactivate-mark))
+ (deactivate-mark)
+ (setq mc/cmds-to-run-for-all nil)
+ (setq mc/cmds-to-run-once nil))

 (After)
--- a/features/vertical-align.feature
+++ b/features/vertical-align.feature
@ -0,0 +1,27 @@
+Feature: Align cursors with whitespaces
+    
+  Scenario: Vertical aligning with `x'
+    Given I have cursors at "word" in :
+    """
+    One word
+    Another word
+    """
+    And I press "<<mc/vertical-align>> \170"
+    Then I should see:
+    """
+    One xxxxword
+    Another word
+    """
+
+  Scenario: Vertical aligning with space
+    Given I have cursors at "word" in :
+    """
+    One word
+    Another word
+    """
+    And I press "<<mc/vertical-align-with-space>>"
+    Then I should see:
+    """
+    One     word
+    Another word
+    """
--- a/mc-cycle-cursors.el
+++ b/mc-cycle-cursors.el
@ -1,6 +1,6 @@
-;;; mc-cycle-cursors.el
+;;; mc-cycle-cursors.el  -*- lexical-binding: t; -*-

-;; Copyright (C) 2012 Magnar Sveen
+;; Copyright (C) 2012-2016 Magnar Sveen

 ;; Author: Magnar Sveen <magnars@gmail.com>
 ;; Keywords: editing cursors
@ -28,11 +28,9 @@

 (require 'multiple-cursors-core)

-(eval-when-compile (require 'cl))
-
 (defun mc/next-fake-cursor-after-point ()
  (let ((pos (point))
-        (next-pos (point-max))
+        (next-pos (1+ (point-max)))
        next)
    (mc/for-each-fake-cursor
     (let ((cursor-pos (overlay-get cursor 'point)))
@ -44,7 +42,7 @@

 (defun mc/prev-fake-cursor-before-point ()
  (let ((pos (point))
-        (prev-pos (point-min))
+        (prev-pos (1- (point-min)))
        prev)
    (mc/for-each-fake-cursor
     (let ((cursor-pos (overlay-get cursor 'point)))
@ -63,7 +61,7 @@
  :group 'multiple-cursors)

 (defun mc/handle-loop-condition (error-message)
-  (ecase mc/cycle-looping-behaviour
+  (cl-ecase mc/cycle-looping-behaviour
    (error (error error-message))
    (warn  (message error-message))
    (continue 'continue)
@ -72,25 +70,29 @@
 (defun mc/first-fake-cursor-after (point)
  "Very similar to mc/furthest-cursor-before-point, but ignores (mark) and (point)."
  (let* ((cursors (mc/all-fake-cursors))
-         (cursors-after-point (remove-if (lambda (cursor)
-                                           (< (mc/cursor-beg cursor) point))
-                                         cursors))
-         (cursors-in-order (sort* cursors-after-point '< :key 'mc/cursor-beg)))
-    (first cursors-in-order)))
+         (cursors-after-point (cl-remove-if (lambda (cursor)
+                                              (< (mc/cursor-beg cursor) point))
+                                            cursors))
+         (cursors-in-order (cl-sort cursors-after-point '< :key 'mc/cursor-beg)))
+    (car cursors-in-order)))

 (defun mc/last-fake-cursor-before (point)
  "Very similar to mc/furthest-cursor-before-point, but ignores (mark) and (point)."
  (let* ((cursors (mc/all-fake-cursors))
-         (cursors-before-point (remove-if (lambda (cursor)
-                                            (> (mc/cursor-end cursor) point))
-                                          cursors))
-         (cursors-in-order (sort* cursors-before-point '> :key 'mc/cursor-end)))
-    (first cursors-in-order)))
+         (cursors-before-point (cl-remove-if (lambda (cursor)
+                                               (> (mc/cursor-end cursor) point))
+                                             cursors))
+         (cursors-in-order (cl-sort cursors-before-point '> :key 'mc/cursor-end)))
+    (car cursors-in-order)))

-(defun* mc/cycle (next-cursor fallback-cursor loop-message)
+(cl-defun mc/cycle (next-cursor fallback-cursor loop-message)
  (when (null next-cursor)
    (when (eql 'stop (mc/handle-loop-condition loop-message))
-      (return-from mc/cycle nil))
+      (cond
+       ((fboundp 'cl-return-from)
+        (cl-return-from mc/cycle nil))
+       ((fboundp 'return-from)
+        (cl-return-from mc/cycle nil))))
    (setf next-cursor fallback-cursor))
  (mc/create-fake-cursor-at-point)
  (mc/pop-state-from-overlay next-cursor)
@ -116,7 +118,6 @@

 ;; Local Variables:
 ;; coding: utf-8
-;; byte-compile-warnings: (not cl-functions)
 ;; End:

 ;;; mc-cycle-cursors.el ends here
--- a/mc-edit-lines.el
+++ b/mc-edit-lines.el
@ -1,6 +1,6 @@
-;;; mc-edit-lines.el
+;;; mc-edit-lines.el  -*- lexical-binding: t; -*-

-;; Copyright (C) 2012 Magnar Sveen
+;; Copyright (C) 2012-2016 Magnar Sveen

 ;; Author: Magnar Sveen <magnars@gmail.com>
 ;; Keywords: editing cursors
@ -29,26 +29,65 @@

 (require 'multiple-cursors-core)

+(defcustom mc/edit-lines-empty-lines nil
+  "What should be done by `mc/edit-lines' when a line is not long enough."
+  :type '(radio (const :tag "Pad the line with spaces." pad)
+                (const :tag "Ignore the line." ignore)
+                (const :tag "Signal an error." error)
+                (const :tag "Nothing.  Cursor is at end of line." nil))
+  :group 'multiple-cursors)
+
 ;;;###autoload
-(defun mc/edit-lines ()
+(defun mc/edit-lines (&optional arg)
  "Add one cursor to each line of the active region.
 Starts from mark and moves in straight down or up towards the
-line point is on."
-  (interactive)
-  (when (not (and mark-active (/= (point) (mark))))
-    (error "Mark a set of lines first."))
+line point is on.
+
+What is done with lines which are not long enough is governed by
+`mc/edit-lines-empty-lines'.  The prefix argument ARG can be used
+to override this.  If ARG is a symbol (when called from Lisp),
+that symbol is used instead of `mc/edit-lines-empty-lines'.
+Otherwise, if ARG negative, short lines will be ignored.  Any
+other non-nil value will cause short lines to be padded."
+  (interactive "P")
+  (unless mark-active
+    (error "Mark a set of lines first"))
  (mc/remove-fake-cursors)
  (let* ((col (current-column))
-         (point-line (line-number-at-pos))
-         (mark-line (progn (exchange-point-and-mark) (line-number-at-pos)))
-         (direction (if (< point-line mark-line) :up :down)))
+         (point-line (mc/line-number-at-pos))
+         (mark-line (progn (exchange-point-and-mark) (mc/line-number-at-pos)))
+         (direction (if (< point-line mark-line) :up :down))
+         (style (cond
+                 ;; called from lisp
+                 ((and arg (symbolp arg))
+                  arg)
+                 ;; negative argument
+                 ((< (prefix-numeric-value arg) 0)
+                  'ignore)
+                 (arg 'pad)
+                 (t mc/edit-lines-empty-lines))))
    (deactivate-mark)
    (when (and (eq direction :up) (bolp))
-      (forward-line -1)
+      (previous-logical-line 1 nil)
      (move-to-column col))
-    (while (not (eq (line-number-at-pos) point-line))
-      (mc/create-fake-cursor-at-point)
-      (if (eq direction :up) (forward-line -1) (forward-line 1))
+    ;; Add the cursors
+    (while (not (eq (mc/line-number-at-pos) point-line))
+      ;; Pad the line
+      (when (eq style 'pad)
+        (while (< (current-column) col)
+          (insert " ")))
+      ;; Error
+      (when (and (eq style 'error)
+                 (not (equal col (current-column))))
+        (error "Short line encountered in `mc/edit-lines'"))
+      ;; create the cursor
+      (unless (and (eq style 'ignore)
+                   (not (equal col (current-column))))
+        (mc/create-fake-cursor-at-point))
+      ;; proceed to next
+      (if (eq direction :up)
+          (previous-logical-line 1 nil)
+        (next-logical-line 1 nil))
      (move-to-column col))
    (multiple-cursors-mode)))

--- a/mc-hide-unmatched-lines-mode.el
+++ b/mc-hide-unmatched-lines-mode.el
@ -0,0 +1,109 @@
+;;; mc-hide-unmatched-lines-mode.el  -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2014 Aleksey Fedotov
+
+;; Author: Aleksey Fedotov <lexa@cfotr.com>
+;; Keywords: editing cursors
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This minor mode when enabled hides all lines where no cursors (and
+;; also hum/lines-to-expand below and above) To make use of this mode
+;; press "C-'" while multiple-cursor-mode is active. You can still
+;; edit lines while you are in mc-hide-unmatched-lines mode. To leave
+;; this mode press "<return>" or "C-g"
+;;
+
+;;; Code:
+
+(require 'multiple-cursors-core)
+(require 'mc-mark-more)
+
+(defvar hum/hide-unmatched-lines-mode-map (make-sparse-keymap)
+  "Keymap for hide unmatched lines is mainly for rebinding C-g")
+
+(define-key hum/hide-unmatched-lines-mode-map (kbd "C-g") 'hum/keyboard-quit)
+(define-key hum/hide-unmatched-lines-mode-map (kbd "<return>") 'hum/keyboard-quit)
+
+(defun hum/keyboard-quit ()
+  "Leave hide-unmatched-lines mode"
+  (interactive)
+  (mc-hide-unmatched-lines-mode 0))
+
+;; used only in in multiple-cursors-mode-disabled-hook
+(defun hum/disable-hum-mode ()
+  (mc-hide-unmatched-lines-mode 0))
+
+;;;###autoload
+(define-minor-mode mc-hide-unmatched-lines-mode
+  "Minor mode when enabled hides all lines where no cursors (and
+also hum/lines-to-expand below and above) To make use of this
+mode press \"C-'\" while multiple-cursor-mode is active. You can
+still edit lines while you are in mc-hide-unmatched-lines
+mode. To leave this mode press <return> or \"C-g\""
+  :init-value nil
+  :lighter " hu"
+  :keymap hum/hide-unmatched-lines-mode-map
+  (if mc-hide-unmatched-lines-mode
+      ;;just in case if mc mode will be disabled while hide-unmatched-lines is active
+      (progn
+        (hum/hide-unmatched-lines)
+        (add-hook 'multiple-cursors-mode-disabled-hook 'hum/disable-hum-mode t t))
+    (progn
+      (hum/unhide-unmatched-lines)
+      (remove-hook 'multiple-cursors-mode-disabled-hook 'hum/disable-hum-mode))))
+
+(defconst hum/invisible-overlay-name 'hum/invisible-overlay-name)
+
+(defcustom hum/lines-to-expand 2
+  "How many lines below and above cursor to show"
+  :type '(integer)
+  :group 'multiple-cursors)
+
+(defcustom hum/placeholder "..."
+  "Placeholder which will be placed instead of hidden text"
+  :type '(string)
+  :group 'multiple-cursors)
+
+(defun hum/add-invisible-overlay (begin end)
+  (let ((overlay (make-overlay begin
+                               end
+                               (current-buffer)
+                               t
+                               nil
+                               )))
+    (overlay-put overlay hum/invisible-overlay-name t)
+    (overlay-put overlay 'invisible t)
+    (overlay-put overlay 'intangible t)
+    (overlay-put overlay 'evaporate t)
+    (overlay-put overlay 'after-string hum/placeholder)))
+
+(defun hum/hide-unmatched-lines ()
+  (let ((begin (point-min)))
+    (mc/for-each-cursor-ordered
+     (save-excursion
+       (goto-char (mc/cursor-beg cursor))
+       (if (< begin (line-beginning-position (- hum/lines-to-expand)))
+           (hum/add-invisible-overlay begin (line-end-position (- hum/lines-to-expand))))
+       (setq begin (line-beginning-position (+ 2 hum/lines-to-expand)))))
+    (hum/add-invisible-overlay begin (point-max))))
+
+(defun hum/unhide-unmatched-lines ()
+  (remove-overlays nil nil hum/invisible-overlay-name t))
+
+(define-key mc/keymap (kbd "C-'") 'mc-hide-unmatched-lines-mode)
+
+(provide 'mc-hide-unmatched-lines-mode)
--- a/mc-mark-more.el
+++ b/mc-mark-more.el
@ -1,6 +1,6 @@
-;;; mc-mark-more.el
+;;; mc-mark-more.el  -*- lexical-binding: t; -*-

-;; Copyright (C) 2012 Magnar Sveen
+;; Copyright (C) 2012-2016 Magnar Sveen

 ;; Author: Magnar Sveen <magnars@gmail.com>
 ;; Keywords: editing cursors
@ -29,6 +29,7 @@

 (require 'multiple-cursors-core)
 (require 'thingatpt)
+(require 'sgml-mode)

 (defun mc/cursor-end (cursor)
  (if (overlay-get cursor 'mark-active)
@ -55,7 +56,7 @@
    beg))

 (defun mc/furthest-cursor-before-point ()
-  (let ((beg (min (mark) (point)))
+  (let ((beg (if mark-active (min (mark) (point)) (point)))
        furthest)
    (mc/for-each-fake-cursor
     (when (< (mc/cursor-beg cursor) beg)
@ -64,7 +65,7 @@
    furthest))

 (defun mc/furthest-cursor-after-point ()
-  (let ((end (max (mark) (point)))
+  (let ((end (if mark-active (max (mark) (point)) (point)))
        furthest)
    (mc/for-each-fake-cursor
     (when (> (mc/cursor-end cursor) end)
@ -72,6 +73,18 @@
       (setq furthest cursor)))
    furthest))

+(defun mc/fake-cursor-at-point (&optional point)
+  "Return the fake cursor with its point right at POINT (defaults
+to (point)), or nil."
+  (setq point (or point (point)))
+  (let ((cursors (mc/all-fake-cursors))
+        (c nil))
+    (catch 'found
+      (while (setq c (pop cursors))
+        (when (eq (marker-position (overlay-get c 'point))
+                  point)
+          (throw 'found c))))))
+
 (defun mc/region-strings ()
  (let ((strings (list (buffer-substring-no-properties (point) (mark)))))
    (mc/for-each-fake-cursor
@ -84,99 +97,231 @@
  "How should mc/mark-more-* search for more matches?

 Match everything: nil
-Match only whole words: 'words
-Match only whole symbols: 'symbols
+Match only whole words: \\='words
+Match only whole symbols: \\='symbols

 Use like case-fold-search, don't recommend setting it globally.")

 (defun mc/mark-more-like-this (skip-last direction)
  (let ((case-fold-search nil)
        (re (regexp-opt (mc/region-strings) mc/enclose-search-term))
-        (point-out-of-order (ecase direction
+        (point-out-of-order (cl-ecase direction
                              (forwards       (< (point) (mark)))
                              (backwards (not (< (point) (mark))))))
-        (furthest-cursor (ecase direction
+        (furthest-cursor (cl-ecase direction
                           (forwards  (mc/furthest-cursor-after-point))
                           (backwards (mc/furthest-cursor-before-point))))
-        (start-char (ecase direction
+        (start-char (cl-ecase direction
                      (forwards  (mc/furthest-region-end))
                      (backwards (mc/first-region-start))))
-        (search-function (ecase direction
+        (search-function (cl-ecase direction
                           (forwards  'search-forward-regexp)
                           (backwards 'search-backward-regexp)))
-        (match-point-getter (ecase direction
+        (match-point-getter (cl-ecase direction
                              (forwards 'match-beginning)
                              (backwards 'match-end))))
-    (mc/save-excursion
-     (goto-char start-char)
-     (when skip-last
-       (mc/remove-fake-cursor furthest-cursor))
-     (if (funcall search-function re nil t)
-         (progn
-           (push-mark (funcall match-point-getter 0))
-           (when point-out-of-order
-             (exchange-point-and-mark))
-           (mc/create-fake-cursor-at-point))
-       (error "no more matches found.")))))
+    (if (and skip-last (not furthest-cursor))
+        (error "No cursors to be skipped")
+      (mc/save-excursion
+       (goto-char start-char)
+       (when skip-last
+         (mc/remove-fake-cursor furthest-cursor))
+       (if (funcall search-function re nil t)
+           (progn
+             (push-mark (funcall match-point-getter 0))
+             (when point-out-of-order
+               (exchange-point-and-mark))
+             (mc/create-fake-cursor-at-point))
+         (user-error "no more matches found."))))))

 ;;;###autoload
 (defun mc/mark-next-like-this (arg)
  "Find and mark the next part of the buffer matching the currently active region
+If no region is active add a cursor on the next line
 With negative ARG, delete the last one instead.
 With zero ARG, skip the last one and mark next."
  (interactive "p")
-  (if (region-active-p)
-      (if (< arg 0)
-          (mc/remove-fake-cursor (mc/furthest-cursor-after-point))
-        (mc/mark-more-like-this (= arg 0) 'forwards))
-    (mc/mark-lines arg 'forwards))
+  (if (< arg 0)
+      (let ((cursor (mc/furthest-cursor-after-point)))
+        (if cursor
+            (mc/remove-fake-cursor cursor)
+          (error "No cursors to be unmarked")))
+    (if (region-active-p)
+        (mc/mark-more-like-this (= arg 0) 'forwards)
+      (mc/mark-lines arg 'forwards)))
  (mc/maybe-multiple-cursors-mode))

+;;;###autoload
+(defun mc/mark-next-like-this-word (arg)
+  "Find and mark the next part of the buffer matching the currently active region
+If no region is active, mark the word at the point and find the next match
+With negative ARG, delete the last one instead.
+With zero ARG, skip the last one and mark next."
+  (interactive "p")
+  (if (< arg 0)
+      (let ((cursor (mc/furthest-cursor-after-point)))
+        (if cursor
+            (mc/remove-fake-cursor cursor)
+          (error "No cursors to be unmarked")))
+    (if (region-active-p)
+        (mc/mark-more-like-this (= arg 0) 'forwards)
+      (mc--select-thing-at-point 'word)
+      (mc/mark-more-like-this (= arg 0) 'forwards)))
+  (mc/maybe-multiple-cursors-mode))
+
+(defun mc/mark-next-like-this-symbol (arg)
+  "Find and mark the next part of the buffer matching the currently active region
+If no region is active, mark the symbol at the point and find the next match
+With negative ARG, delete the last one instead.
+With zero ARG, skip the last one and mark next."
+  (interactive "p")
+  (if (< arg 0)
+      (let ((cursor (mc/furthest-cursor-after-point)))
+        (if cursor
+            (mc/remove-fake-cursor cursor)
+          (error "No cursors to be unmarked")))
+    (if (region-active-p)
+        (mc/mark-more-like-this (= arg 0) 'forwards)
+      (mc--select-thing-at-point 'symbol)
+      (mc/mark-more-like-this (= arg 0) 'forwards)))
+  (mc/maybe-multiple-cursors-mode))
+
+
 ;;;###autoload
 (defun mc/mark-next-word-like-this (arg)
+  "Find and mark the next word of the buffer matching the currently active region
+The matching region must be a whole word to be a match
+If no region is active add a cursor on the next line
+With negative ARG, delete the last one instead.
+With zero ARG, skip the last one and mark next."
  (interactive "p")
  (let ((mc/enclose-search-term 'words))
    (mc/mark-next-like-this arg)))

 ;;;###autoload
 (defun mc/mark-next-symbol-like-this (arg)
+  "Find and mark the next symbol of the buffer matching the currently active region
+The matching region must be a whole symbol to be a match
+If no region is active add a cursor on the next line
+With negative ARG, delete the last one instead.
+With zero ARG, skip the last one and mark next."
  (interactive "p")
  (let ((mc/enclose-search-term 'symbols))
    (mc/mark-next-like-this arg)))

 ;;;###autoload
 (defun mc/mark-previous-like-this (arg)
-  "Find and mark the previous part of the buffer matching the currently active region
+  "Find and mark the previous part of the buffer matching the
+currently active region.
+
+If no region is active ,add a cursor on the previous line.
+
 With negative ARG, delete the last one instead.
+
 With zero ARG, skip the last one and mark next."
  (interactive "p")
-  (if (region-active-p)
-      (if (< arg 0)
-          (mc/remove-fake-cursor (mc/furthest-cursor-before-point))
-        (mc/mark-more-like-this (= arg 0) 'backwards))
-    (mc/mark-lines arg 'backwards))
+  (if (< arg 0)
+      (let ((cursor (mc/furthest-cursor-before-point)))
+        (if cursor
+            (mc/remove-fake-cursor cursor)
+          (error "No cursors to be unmarked")))
+    (if (region-active-p)
+        (mc/mark-more-like-this (= arg 0) 'backwards)
+      (mc/mark-lines arg 'backwards)))
  (mc/maybe-multiple-cursors-mode))

+;;;###autoload
+(defun mc/mark-previous-like-this-word (arg)
+  "Find and mark the previous part of the buffer matching the
+currently active region.
+
+If no region is active, mark the word at the point and find the
+previous match.
+
+With negative ARG, delete the last one instead.
+
+With zero ARG, skip the last one and mark previous."
+  (interactive "p")
+  (if (< arg 0)
+      (let ((cursor (mc/furthest-cursor-after-point)))
+        (if cursor
+            (mc/remove-fake-cursor cursor)
+          (error "No cursors to be unmarked")))
+    (if (region-active-p)
+        (mc/mark-more-like-this (= arg 0) 'backwards)
+      (mc--select-thing-at-point 'word)
+      (mc/mark-more-like-this (= arg 0) 'backwards)))
+  (mc/maybe-multiple-cursors-mode))
+
+(defun mc/mark-previous-like-this-symbol (arg)
+  "Find and mark the previous part of the buffer matching the
+currently active region.
+
+If no region is active, mark the symbol at the point and find the
+previous match.
+
+With negative ARG, delete the last one instead.
+
+With zero ARG, skip the last one and mark previous."
+  (interactive "p")
+  (if (< arg 0)
+      (let ((cursor (mc/furthest-cursor-after-point)))
+        (if cursor
+            (mc/remove-fake-cursor cursor)
+          (error "No cursors to be unmarked")))
+    (if (region-active-p)
+        (mc/mark-more-like-this (= arg 0) 'backwards)
+      (mc--select-thing-at-point 'symbol)
+      (mc/mark-more-like-this (= arg 0) 'backwards)))
+  (mc/maybe-multiple-cursors-mode))
+
+
 ;;;###autoload
 (defun mc/mark-previous-word-like-this (arg)
+  "Find and mark the previous part of the buffer matching the
+currently active region.
+
+The matching region must be a whole word to be a match.
+
+If no region is active, add a cursor on the previous line.
+
+With negative ARG, delete the last one instead.
+
+With zero ARG, skip the last one and mark next."
  (interactive "p")
  (let ((mc/enclose-search-term 'words))
    (mc/mark-previous-like-this arg)))

 ;;;###autoload
 (defun mc/mark-previous-symbol-like-this (arg)
+  "Find and mark the previous part of the buffer matching
+the currently active region.
+
+The matching region must be a whole symbol to be a match.
+
+If no region is active add a cursor on the previous line.
+
+With negative ARG, delete the last one instead.
+
+With zero ARG, skip the last one and mark next."
  (interactive "p")
  (let ((mc/enclose-search-term 'symbols))
    (mc/mark-previous-like-this arg)))

 (defun mc/mark-lines (num-lines direction)
-  (dotimes (i num-lines)
-    (mc/create-fake-cursor-at-point)
-    (ecase direction
-      (forwards (loop do (next-logical-line 1 nil)
-                      while (mc/all-fake-cursors (point) (1+ (point)))))
-      (backwards (loop do (previous-logical-line 1 nil)
-                       while (mc/all-fake-cursors (point) (1+ (point))))))))
+  (dotimes (i (if (= num-lines 0) 1 num-lines))
+    (mc/save-excursion
+     (let ((furthest-cursor (cl-ecase direction
+                              (forwards  (mc/furthest-cursor-after-point))
+                              (backwards (mc/furthest-cursor-before-point)))))
+       (when (overlayp furthest-cursor)
+         (goto-char (overlay-get furthest-cursor 'point))
+         (when (= num-lines 0)
+           (mc/remove-fake-cursor furthest-cursor))))
+     (cl-ecase direction
+       (forwards (next-logical-line 1 nil))
+       (backwards (previous-logical-line 1 nil)))
+     (mc/create-fake-cursor-at-point))))

 ;;;###autoload
 (defun mc/mark-next-lines (arg)
@ -204,13 +349,15 @@ With zero ARG, skip the last one and mark next."

 ;;;###autoload
 (defun mc/skip-to-next-like-this ()
-  "Skip the current one and select the next part of the buffer matching the currently active region."
+  "Skip the current one and select the next part of the buffer
+matching the currently active region."
  (interactive)
  (mc/mark-next-like-this 0))

 ;;;###autoload
 (defun mc/skip-to-previous-like-this ()
-  "Skip the current one and select the prev part of the buffer matching the currently active region."
+  "Skip the current one and select the prev part of the buffer
+matching the currently active region."
  (interactive)
  (mc/mark-previous-like-this 0))

@ -235,7 +382,7 @@ With zero ARG, skip the last one and mark next."
       (when point-first (exchange-point-and-mark)))))
  (if (> (mc/num-cursors) 1)
      (multiple-cursors-mode 1)
-    (multiple-cursors-mode 0)))
+    (mc/disable-multiple-cursors-mode)))

 (defun mc--select-thing-at-point (thing)
  (let ((bound (bounds-of-thing-at-point thing)))
@ -263,26 +410,55 @@ With zero ARG, skip the last one and mark next."
    (mc/mark-all-like-this)))

 ;;;###autoload
-(defun mc/mark-all-in-region (beg end)
+(defun mc/mark-all-in-region (beg end &optional search)
  "Find and mark all the parts in the region matching the given search"
  (interactive "r")
-  (let ((search (read-from-minibuffer "Mark all in region: "))
+  (let ((search (or search (read-from-minibuffer "Mark all in region: ")))
        (case-fold-search nil))
    (if (string= search "")
        (message "Mark aborted")
      (progn
        (mc/remove-fake-cursors)
        (goto-char beg)
-        (while (search-forward search end t)
-          (push-mark (match-beginning 0))
-          (mc/create-fake-cursor-at-point))
-        (let ((first (mc/furthest-cursor-before-point)))
-          (if (not first)
-              (error "Search failed for %S" search)
-            (mc/pop-state-from-overlay first)))
-        (if (> (mc/num-cursors) 1)
-            (multiple-cursors-mode 1)
-          (multiple-cursors-mode 0))))))
+	(let ((lastmatch))
+          (while (search-forward search end t)
+            (push-mark (match-beginning 0))
+            (mc/create-fake-cursor-at-point)
+	    (setq lastmatch t))
+          (unless lastmatch
+	    (error "Search failed for %S" search)))
+	(goto-char (match-end 0))
+	(if (< (mc/num-cursors) 3)
+            (mc/disable-multiple-cursors-mode)
+          (mc/pop-state-from-overlay (mc/furthest-cursor-before-point))
+          (multiple-cursors-mode 1))))))
+
+;;;###autoload
+(defun mc/mark-all-in-region-regexp (beg end)
+  "Find and mark all the parts in the region matching the given regexp."
+  (interactive "r")
+  (let ((search (read-regexp "Mark regexp in region: "))
+        (case-fold-search nil))
+    (if (string= search "")
+        (message "Mark aborted")
+      (progn
+        (mc/remove-fake-cursors)
+        (goto-char beg)
+        (let ((lastmatch))
+          (while (and (< (point) end) ; can happen because of (forward-char)
+                      (search-forward-regexp search end t))
+            (push-mark (match-beginning 0))
+            (mc/create-fake-cursor-at-point)
+            (setq lastmatch (point))
+            (when (= (point) (match-beginning 0))
+              (forward-char)))
+          (unless lastmatch
+            (error "Search failed for %S" search)))
+        (goto-char (match-end 0))
+        (if (< (mc/num-cursors) 3)
+            (mc/disable-multiple-cursors-mode)
+          (mc/pop-state-from-overlay (mc/furthest-cursor-before-point))
+          (multiple-cursors-mode 1))))))

 (when (not (fboundp 'set-temporary-overlay-map))
  ;; Backport this function from newer emacs versions
@ -322,31 +498,40 @@ remove the keymap depends on user input and KEEP-PRED:

      (push alist emulation-mode-map-alists))))

+(defvar mc/mark-more-like-this-extended-keymap (make-sparse-keymap))
+
+(define-key mc/mark-more-like-this-extended-keymap (kbd "<up>") 'mc/mmlte--up)
+(define-key mc/mark-more-like-this-extended-keymap (kbd "<down>") 'mc/mmlte--down)
+(define-key mc/mark-more-like-this-extended-keymap (kbd "<left>") 'mc/mmlte--left)
+(define-key mc/mark-more-like-this-extended-keymap (kbd "<right>") 'mc/mmlte--right)
+
 ;;;###autoload
 (defun mc/mark-more-like-this-extended ()
-  "Like mark-more-like-this, but then lets you adjust with arrows key.
+  "Like mark-more-like-this, but then lets you adjust with arrow keys.
 The adjustments work like this:

-   <up>    Mark previous like this and set direction to 'up
-   <down>  Mark next like this and set direction to 'down
+   <up>    Mark previous like this and set direction to \\='up
+   <down>  Mark next like this and set direction to \\='down

-If direction is 'up:
+If direction is \\='up:

   <left>  Skip past the cursor furthest up
   <right> Remove the cursor furthest up

-If direction is 'down:
+If direction is \\='down:

   <left>  Remove the cursor furthest down
   <right> Skip past the cursor furthest down

-The bindings for these commands can be changed. See `mc/mark-more-like-this-extended-keymap'."
+The bindings for these commands can be changed.
+See `mc/mark-more-like-this-extended-keymap'."
  (interactive)
  (mc/mmlte--down)
-  (set-temporary-overlay-map mc/mark-more-like-this-extended-keymap t))
+  (set-transient-map mc/mark-more-like-this-extended-keymap t))

 (defvar mc/mark-more-like-this-extended-direction nil
-  "When using mc/mark-more-like-this-extended are we working on the next or previous cursors?")
+  "When using mc/mark-more-like-this-extended
+are we working on the next or previous cursors?")

 (make-variable-buffer-local 'mc/mark-more-like-this-extended)

@ -381,13 +566,6 @@ The bindings for these commands can be changed. See `mc/mark-more-like-this-exte
    (mc/skip-to-next-like-this))
  (mc/mmlte--message))

-(defvar mc/mark-more-like-this-extended-keymap (make-sparse-keymap))
-
-(define-key mc/mark-more-like-this-extended-keymap (kbd "<up>") 'mc/mmlte--up)
-(define-key mc/mark-more-like-this-extended-keymap (kbd "<down>") 'mc/mmlte--down)
-(define-key mc/mark-more-like-this-extended-keymap (kbd "<left>") 'mc/mmlte--left)
-(define-key mc/mark-more-like-this-extended-keymap (kbd "<right>") 'mc/mmlte--right)
-
 (defvar mc--restrict-mark-all-to-symbols nil)

 ;;;###autoload
@ -419,6 +597,7 @@ With prefix, it behaves the same as original `mc/mark-all-like-this'"
        (when (<= (mc/num-cursors) before)
          (mc/mark-all-like-this))))))

+;;;###autoload
 (defun mc/mark-all-dwim (arg)
  "Tries even harder to guess what you want to mark all of.

@ -426,16 +605,16 @@ If the region is active and spans multiple lines, it will behave
 as if `mc/mark-all-in-region'. With the prefix ARG, it will call
 `mc/edit-lines' instead.

-If the region is inactive or on a single line, it will behave like 
+If the region is inactive or on a single line, it will behave like
 `mc/mark-all-like-this-dwim'."
  (interactive "P")
  (if (and (use-region-p)
           (not (> (mc/num-cursors) 1))
-           (not (= (line-number-at-pos (region-beginning))
-                   (line-number-at-pos (region-end)))))
+           (not (= (mc/line-number-at-pos (region-beginning))
+                   (mc/line-number-at-pos (region-end)))))
      (if arg
          (call-interactively 'mc/edit-lines)
-       (call-interactively 'mc/mark-all-in-region))
+        (call-interactively 'mc/mark-all-in-region))
    (progn
      (setq this-command 'mc/mark-all-like-this-dwim)
      (mc/mark-all-like-this-dwim arg))))
@ -491,7 +670,7 @@ If the region is inactive or on a single line, it will behave like
   (last
    (progn
      (when (looking-at "<") (forward-char 1))
-      (when (looking-back ">") (forward-char -1))
+      (when (looking-back ">" 1) (forward-char -1))
      (sgml-get-context)))))

 (defun mc--on-tag-name-p ()
@ -504,8 +683,9 @@ If the region is inactive or on a single line, it will behave like
         (<= (point) end))))

 ;;;###autoload
-(defun mc/add-cursor-on-click (event)
-  "Add a cursor where you click."
+(defun mc/toggle-cursor-on-click (event)
+  "Add a cursor where you click, or remove a fake cursor that is
+already there."
  (interactive "e")
  (mouse-minibuffer-check event)
  ;; Use event-end in case called from mouse-drag-region.
@ -514,12 +694,20 @@ If the region is inactive or on a single line, it will behave like
    (if (not (windowp (posn-window position)))
        (error "Position not in text area of window"))
    (select-window (posn-window position))
-    (if (numberp (posn-point position))
-        (save-excursion
-          (goto-char (posn-point position))
-          (mc/create-fake-cursor-at-point)))
+    (let ((pt (posn-point position)))
+      (if (numberp pt)
+          ;; is there a fake cursor with the actual *point* right where we are?
+          (let ((existing (mc/fake-cursor-at-point pt)))
+            (if existing
+                (mc/remove-fake-cursor existing)
+              (save-excursion
+                (goto-char pt)
+                (mc/create-fake-cursor-at-point))))))
    (mc/maybe-multiple-cursors-mode)))

+;;;###autoload
+(defalias 'mc/add-cursor-on-click 'mc/toggle-cursor-on-click)
+
 ;;;###autoload
 (defun mc/mark-sgml-tag-pair ()
  "Mark the tag we're in and its pair for renaming."
--- a/mc-mark-pop.el
+++ b/mc-mark-pop.el
@ -1,4 +1,4 @@
-;;; mc-mark-pop.el --- Pop cursors off of the mark stack
+;;; mc-mark-pop.el --- Pop cursors off of the mark stack  -*- lexical-binding: t; -*-

 (require 'multiple-cursors-core)

--- a/mc-separate-operations.el
+++ b/mc-separate-operations.el
@ -1,6 +1,6 @@
-;;; mc-separate-operations.el - functions that work differently on each cursor
+;;; mc-separate-operations.el - functions that work differently on each cursor  -*- lexical-binding: t; -*-

-;; Copyright (C) 2012 Magnar Sveen
+;; Copyright (C) 2012-2016 Magnar Sveen

 ;; Author: Magnar Sveen <magnars@gmail.com>
 ;; Keywords: editing cursors
@ -29,16 +29,24 @@

 (require 'multiple-cursors-core)

-;;;###autoload
-(defun mc/insert-numbers (arg)
-  "Insert increasing numbers for each cursor, starting at 0 or ARG."
-  (interactive "P")
-  (setq mc--insert-numbers-number (or arg 0))
-  (mc/for-each-cursor-ordered
-   (mc/execute-command-for-fake-cursor 'mc--insert-number-and-increase cursor)))
+(defcustom mc/insert-numbers-default 0
+  "The default number at which to start counting for
+`mc/insert-numbers'"
+  :type 'integer
+  :group 'multiple-cursors)

 (defvar mc--insert-numbers-number 0)

+;;;###autoload
+(defun mc/insert-numbers (arg)
+  "Insert increasing numbers for each cursor, starting at
+`mc/insert-numbers-default' or ARG."
+  (interactive "P")
+  (setq mc--insert-numbers-number (or (and arg (prefix-numeric-value arg))
+                                      mc/insert-numbers-default))
+  (mc/for-each-cursor-ordered
+   (mc/execute-command-for-fake-cursor 'mc--insert-number-and-increase cursor)))
+
 (defun mc--insert-number-and-increase ()
  (interactive)
  (insert (number-to-string mc--insert-numbers-number))
@ -53,6 +61,32 @@
                            (mc/cursor-end cursor)) strings))))
    (nreverse strings)))

+(defvar mc--insert-letters-number 0)
+
+;;;###autoload
+(defun mc/insert-letters (arg)
+  "Insert increasing letters for each cursor, starting at 0 or ARG.
+     Where letter[0]=a letter[2]=c letter[26]=aa"
+  (interactive "P")
+  (setq mc--insert-letters-number (or (and arg (prefix-numeric-value arg))
+                                      0))
+  (mc/for-each-cursor-ordered
+   (mc/execute-command-for-fake-cursor 'mc--insert-letter-and-increase cursor)))
+
+(defun mc--number-to-letters (number)
+  (let ((letter
+         (char-to-string
+          (+ (mod number 26) ?a)))
+        (number2 (/ number 26)))
+    (if (> number2 0)
+        (concat (mc--number-to-letters (- number2 1)) letter)
+      letter)))
+
+(defun mc--insert-letter-and-increase ()
+  (interactive)
+  (insert (mc--number-to-letters mc--insert-letters-number))
+  (setq mc--insert-letters-number (1+ mc--insert-letters-number)))
+
 (defvar mc--strings-to-replace nil)

 (defun mc--replace-region-strings-1 ()
@ -72,7 +106,8 @@
      (progn
        (mc/mark-next-lines 1)
        (mc/reverse-regions)
-        (multiple-cursors-mode 0))
+        (mc/disable-multiple-cursors-mode)
+        )
    (unless (use-region-p)
      (mc/execute-command-for-all-cursors 'mark-sexp))
    (setq mc--strings-to-replace (nreverse (mc--ordered-region-strings)))
@ -86,5 +121,31 @@
  (setq mc--strings-to-replace (sort (mc--ordered-region-strings) 'string<))
  (mc--replace-region-strings))

+
+;;;###autoload
+(defun mc/vertical-align (character)
+  "Aligns all cursors vertically with a given CHARACTER to the one with the
+highest column number (the rightest).
+Might not behave as intended if more than one cursors are on the same line."
+  (interactive "c")
+  (let ((rightest-column (current-column)))
+    (mc/execute-command-for-all-cursors
+     (lambda () "get the rightest cursor"
+       (interactive)
+       (setq rightest-column (max (current-column) rightest-column))
+       ))
+    (mc/execute-command-for-all-cursors
+     (lambda ()
+       (interactive)
+       (let ((missing-spaces (- rightest-column (current-column))))
+         (save-excursion (insert (make-string missing-spaces character)))
+         (forward-char missing-spaces))))))
+
+;;;###autoload
+(defun mc/vertical-align-with-space ()
+  "Aligns all cursors with whitespace like `mc/vertical-align' does"
+  (interactive)
+  (mc/vertical-align 32))
+
 (provide 'mc-separate-operations)
 ;;; mc-separate-operations.el ends here
--- a/multiple-cursors-core.el
+++ b/multiple-cursors-core.el
@ -1,6 +1,6 @@
-;;; multiple-cursors-core.el --- An experiment in multiple cursors for emacs.
+;;; multiple-cursors-core.el --- An experiment in multiple cursors for emacs.  -*- lexical-binding: t; -*-

-;; Copyright (C) 2012 Magnar Sveen
+;; Copyright (C) 2012-2016 Magnar Sveen

 ;; Author: Magnar Sveen <magnars@gmail.com>
 ;; Keywords: editing cursors
@ -25,8 +25,7 @@

 ;;; Code:

-(require 'cl)
-
+(require 'cl-lib)
 (require 'rect)

 (defface mc/cursor-face
@ -34,6 +33,23 @@
  "The face used for fake cursors"
  :group 'multiple-cursors)

+(defface mc/cursor-bar-face
+  `((t (:height 1 :background ,(face-attribute 'cursor :background))))
+  "The face used for fake cursors if the cursor-type is bar"
+  :group 'multiple-cursors)
+
+(defcustom mc/match-cursor-style t
+  "If non-nil, attempt to match the cursor style that the user
+has selected.  Namely, use vertical bars the user has configured
+Emacs to use that cursor.
+
+If nil, just use standard rectangle cursors for all fake cursors.
+
+In some modes/themes, the bar fake cursors are either not
+rendered or shift text."
+  :type '(boolean)
+  :group 'multiple-cursors)
+
 (defface mc/region-face
  '((t :inherit region))
  "The face used for fake regions"
@ -51,9 +67,9 @@
               (cons (cons 'apply (cons 'activate-cursor-for-undo (list id))) buffer-undo-list))))))

 (defun mc/all-fake-cursors (&optional start end)
-  (remove-if-not 'mc/fake-cursor-p
-                 (overlays-in (or start (point-min))
-                              (or end   (point-max)))))
+  (cl-remove-if-not 'mc/fake-cursor-p
+                    (overlays-in (or start (point-min))
+                                 (or end   (point-max)))))

 (defmacro mc/for-each-fake-cursor (&rest forms)
  "Runs the body for each fake cursor, bound to the name cursor"
@ -97,16 +113,43 @@
       (set-marker ,p nil)
       (set-marker ,s nil))))

+(defun mc/cursor-is-bar ()
+  "Return non-nil if the cursor is a bar."
+  (let ((cursor-type
+         (if (eq cursor-type t)
+             (frame-parameter nil 'cursor-type)
+           cursor-type)))
+    (or (eq cursor-type 'bar)
+        (and (listp cursor-type)
+             (eq (car cursor-type) 'bar)))))
+
+(defun mc/line-number-at-pos (&optional pos absolute)
+  "Faster implementation of `line-number-at-pos'."
+  (if pos
+      (save-excursion
+        (if absolute
+            (save-restriction
+              (widen)
+              (goto-char pos)
+              (string-to-number (format-mode-line "%l")))
+          (goto-char pos)
+          (string-to-number (format-mode-line "%l"))))
+    (string-to-number (format-mode-line "%l"))))
+
 (defun mc/make-cursor-overlay-at-eol (pos)
  "Create overlay to look like cursor at end of line."
  (let ((overlay (make-overlay pos pos nil nil nil)))
-    (overlay-put overlay 'after-string (propertize " " 'face 'mc/cursor-face))
+    (if (and mc/match-cursor-style (mc/cursor-is-bar))
+  (overlay-put overlay 'before-string (propertize "|" 'face 'mc/cursor-bar-face))
+      (overlay-put overlay 'after-string (propertize " " 'face 'mc/cursor-face)))
    overlay))

 (defun mc/make-cursor-overlay-inline (pos)
  "Create overlay to look like cursor inside text."
  (let ((overlay (make-overlay pos (1+ pos) nil nil nil)))
-    (overlay-put overlay 'face 'mc/cursor-face)
+    (if (and mc/match-cursor-style (mc/cursor-is-bar))
+  (overlay-put overlay 'before-string (propertize "|" 'face 'mc/cursor-bar-face))
+      (overlay-put overlay 'face 'mc/cursor-face))
    overlay))

 (defun mc/make-cursor-overlay-at-point ()
@ -130,16 +173,29 @@ highlights the entire width of the window."
                                  mark-ring
                                  mark-active
                                  yank-undo-function
-                                  kill-ring-yank-pointer
                                  autopair-action
                                  autopair-wrap-action
-                                  er/history)
+                                  temporary-goal-column
+                                  er/history
+                                  dabbrev--abbrev-char-regexp
+                                  dabbrev--check-other-buffers
+                                  dabbrev--friend-buffer-list
+                                  dabbrev--last-abbrev-location
+                                  dabbrev--last-abbreviation
+                                  dabbrev--last-buffer
+                                  dabbrev--last-buffer-found
+                                  dabbrev--last-direction
+                                  dabbrev--last-expansion
+                                  dabbrev--last-expansion-location
+                                  dabbrev--last-table)
  "A list of vars that need to be tracked on a per-cursor basis.")

 (defun mc/store-current-state-in-overlay (o)
  "Store relevant info about point and mark in the given overlay."
  (overlay-put o 'point (set-marker (make-marker) (point)))
-  (overlay-put o 'mark (set-marker (make-marker) (mark)))
+  (overlay-put o 'mark (set-marker (make-marker)
+           (let ((mark-even-if-inactive t))
+             (mark))))
  (dolist (var mc/cursor-specific-vars)
    (when (boundp var) (overlay-put o var (symbol-value var))))
  o)
@ -173,11 +229,42 @@ highlights the entire width of the window."

 (defun mc/create-cursor-id ()
  "Returns a unique cursor id"
-  (incf mc--current-cursor-id))
+  (cl-incf mc--current-cursor-id))
+
+(defvar mc--max-cursors-original nil
+  "This variable maintains the original maximum number of cursors.
+When `mc/create-fake-cursor-at-point' is called and
+`mc/max-cursors' is overridden, this value serves as a backup so
+that `mc/max-cursors' can take on a new value.  When
+`mc/remove-fake-cursors' is called, the values are reset.")
+
+(defcustom mc/max-cursors nil
+  "Safety ceiling for the number of active cursors.
+If your emacs slows down or freezes when using too many cursors,
+customize this value appropriately.
+
+Cursors will be added until this value is reached, at which point
+you can either temporarily override the value or abort the
+operation entirely.
+
+If this value is nil, there is no ceiling."
+  :type '(integer)
+  :group 'multiple-cursors)

 (defun mc/create-fake-cursor-at-point (&optional id)
-  "Add a fake cursor and possibly a fake active region overlay based on point and mark.
-Saves the current state in the overlay to be restored later."
+  "Add a fake cursor and possibly a fake active region overlay
+based on point and mark.
+
+Saves the current state in the overlay
+to be restored later."
+  (unless mc--max-cursors-original
+    (setq mc--max-cursors-original mc/max-cursors))
+  (when mc/max-cursors
+    (unless (< (mc/num-cursors) mc/max-cursors)
+      (if (yes-or-no-p (format "%d active cursors. Continue? " (mc/num-cursors)))
+          (setq mc/max-cursors (read-number "Enter a new, temporary maximum: "))
+        (mc/remove-fake-cursors)
+        (error "Aborted: too many cursors"))))
  (let ((overlay (mc/make-cursor-overlay-at-point)))
    (overlay-put overlay 'mc-id (or id (mc/create-cursor-id)))
    (overlay-put overlay 'type 'fake-cursor)
@ -189,7 +276,8 @@ Saves the current state in the overlay to be restored later."
    overlay))

 (defun mc/execute-command (cmd)
-  "Run command, simulating the parts of the command loop that makes sense for fake cursors."
+  "Run command, simulating the parts of the command loop that
+makes sense for fake cursors."
  (setq this-command cmd)
  (run-hooks 'pre-command-hook)
  (unless (eq this-command 'ignore)
@ -231,25 +319,35 @@ cursor with updated info."
 ;; Intercept some reading commands so you won't have to
 ;; answer them for every single cursor

-(defadvice read-char (around mc-support activate)
-  (if (not multiple-cursors-mode)
-      ad-do-it
-    (unless mc--read-char
-      (setq mc--read-char ad-do-it))
-    (setq ad-return-value mc--read-char)))
-
-(defadvice read-quoted-char (around mc-support activate)
-  (if (not multiple-cursors-mode)
-      ad-do-it
-    (unless mc--read-quoted-char
-      (setq mc--read-quoted-char ad-do-it))
-    (setq ad-return-value mc--read-quoted-char)))
+(defvar mc--input-function-cache nil)

 (defun mc--reset-read-prompts ()
-  (setq mc--read-char nil)
-  (setq mc--read-quoted-char nil))
+  (setq mc--input-function-cache nil))

-(mc--reset-read-prompts)
+(defmacro mc--cache-input-function (fn-name args-cache-key-fn)
+  "Advise FN-NAME to cache its value in a private variable. Cache
+is to be used by mc/execute-command-for-all-fake-cursors and
+caches will be reset by mc--reset-read-prompts. ARGS-CACHE-KEY-FN
+should transform FN-NAME's args to a unique cache-key so that
+different calls to FN-NAME during a command can return multiple
+values."
+  (let ((mc-name (intern (concat "mc--" (symbol-name fn-name)))))
+    `(progn
+       (defun ,mc-name (orig-fun &rest args)
+         (if (not (bound-and-true-p multiple-cursors-mode))
+             (apply orig-fun args)
+           (let* ((cache-key (cons ,(symbol-name fn-name) (,args-cache-key-fn args)))
+                  (cached-value (assoc cache-key mc--input-function-cache))
+                  (return-value (if cached-value (cdr cached-value) (apply orig-fun args))))
+             (unless cached-value
+               (push (cons cache-key return-value) mc--input-function-cache))
+             return-value)))
+       (advice-add ',fn-name :around #',mc-name))))
+
+(mc--cache-input-function read-char car)
+(mc--cache-input-function read-quoted-char car)
+(mc--cache-input-function register-read-with-preview car) ; used by insert-register
+(mc--cache-input-function read-char-from-minibuffer car)  ; used by zap-to-char

 (defun mc/fake-cursor-p (o)
  "Predicate to check if an overlay is a fake cursor"
@ -257,15 +355,17 @@ cursor with updated info."

 (defun mc/cursor-with-id (id)
  "Find the first cursor with the given id, or nil"
-  (find-if #'(lambda (o) (and (mc/fake-cursor-p o)
-                              (= id (overlay-get o 'mc-id))))
-           (overlays-in (point-min) (point-max))))
+  (cl-find-if #'(lambda (o) (and (mc/fake-cursor-p o)
+                            (= id (overlay-get o 'mc-id))))
+              (overlays-in (point-min) (point-max))))

 (defvar mc--stored-state-for-undo nil
  "Variable to keep the state of the real cursor while undoing a fake one")

+;;;###autoload
 (defun activate-cursor-for-undo (id)
-  "Called when undoing to temporarily activate the fake cursor which action is being undone."
+  "Called when undoing to temporarily activate the fake cursor
+which action is being undone."
  (let ((cursor (mc/cursor-with-id id)))
    (when cursor
      (setq mc--stored-state-for-undo (mc/store-current-state-in-overlay
@ -279,276 +379,15 @@ cursor with updated info."
    (mc/pop-state-from-overlay mc--stored-state-for-undo)
    (setq mc--stored-state-for-undo nil)))

-(defun mc/prompt-for-inclusion-in-whitelist (original-command)
-  "Asks the user, then adds the command either to the once-list or the all-list."
-  (let ((all-p (y-or-n-p (format "Do %S for all cursors?" original-command))))
-    (if all-p
-        (add-to-list 'mc/cmds-to-run-for-all original-command)
-      (add-to-list 'mc/cmds-to-run-once original-command))
-    (mc/save-lists)
-    all-p))
-
-(defun mc/num-cursors ()
-  "The number of cursors (real and fake) in the buffer."
-  (1+ (count-if 'mc/fake-cursor-p
-                (overlays-in (point-min) (point-max)))))
-
-(defvar mc--this-command nil
-  "Used to store the original command being run.")
-(make-variable-buffer-local 'mc--this-command)
-
-(defun mc/make-a-note-of-the-command-being-run ()
-  "Used with pre-command-hook to store the original command being run.
-Since that cannot be reliably determined in the post-command-hook.
-
-Specifically, this-original-command isn't always right, because it could have
-been remapped. And certain modes (cua comes to mind) will change their
-remapping based on state. So a command that changes the state will afterwards
-not be recognized through the command-remapping lookup."
-  (unless mc--executing-command-for-fake-cursor
-    (let ((cmd (or (command-remapping this-original-command)
-                   this-original-command)))
-      (setq mc--this-command (and (not (eq cmd 'god-mode-self-insert))
-                                  cmd)))))
-
-(defun mc/execute-this-command-for-all-cursors ()
-  "Wrap around `mc/execute-this-command-for-all-cursors-1' to protect hook."
-  (condition-case error
-      (mc/execute-this-command-for-all-cursors-1)
-    (error
-     (message "[mc] problem in `mc/execute-this-command-for-all-cursors': %s"
-              (error-message-string error)))))
-
-;; execute-kbd-macro should never be run for fake cursors. The real cursor will
-;; execute the keyboard macro, resulting in new commands in the command loop,
-;; and the fake cursors can pick up on those instead.
-(defadvice execute-kbd-macro (around skip-fake-cursors activate)
-  (unless mc--executing-command-for-fake-cursor
-    ad-do-it))
-
-(defun mc/execute-this-command-for-all-cursors-1 ()
-  "Used with post-command-hook to execute supported commands for all cursors.
-
-It uses two lists of commands to know what to do: the run-once
-list and the run-for-all list. If a command is in neither of these lists,
-it will prompt for the proper action and then save that preference.
-
-Some commands are so unsupported that they are even prevented for
-the original cursor, to inform about the lack of support."
-  (unless mc--executing-command-for-fake-cursor
-
-    (if (eq 1 (mc/num-cursors)) ;; no fake cursors? disable mc-mode
-        (multiple-cursors-mode 0)
-      (when this-original-command
-        (let ((original-command (or mc--this-command
-                                    (command-remapping this-original-command)
-                                    this-original-command)))
-
-          ;; skip keyboard macros, since they will generate actual commands that are
-          ;; also run in the command loop - we'll handle those later instead.
-          (when (functionp original-command)
-
-            ;; if it's a lambda, we can't know if it's supported or not
-            ;; - so go ahead and assume it's ok, because we're just optimistic like that
-            (if (or (not (symbolp original-command))
-                    ;; lambda registered by smartrep
-                    (string-prefix-p "(" (symbol-name original-command)))
-                (mc/execute-command-for-all-fake-cursors original-command)
-
-              ;; smartrep `intern's commands into own obarray to help
-              ;; `describe-bindings'.  So, let's re-`intern' here to
-              ;; make the command comparable by `eq'.
-              (setq original-command (intern (symbol-name original-command)))
-
-              ;; otherwise it's a symbol, and we can be more thorough
-              (if (get original-command 'mc--unsupported)
-                  (message "%S is not supported with multiple cursors%s"
-                           original-command
-                           (get original-command 'mc--unsupported))
-                (when (and original-command
-                           (not (memq original-command mc--default-cmds-to-run-once))
-                           (not (memq original-command mc/cmds-to-run-once))
-                           (or (memq original-command mc--default-cmds-to-run-for-all)
-                               (memq original-command mc/cmds-to-run-for-all)
-                               (mc/prompt-for-inclusion-in-whitelist original-command)))
-                  (mc/execute-command-for-all-fake-cursors original-command))))))))))
-
-(defun mc/remove-fake-cursors ()
-  "Remove all fake cursors.
-Do not use to conclude editing with multiple cursors. For that
-you should disable multiple-cursors-mode."
-  (mc/for-each-fake-cursor
-   (mc/remove-fake-cursor cursor)))
-
-(defun mc/keyboard-quit ()
-  "Deactivate mark if there are any active, otherwise exit multiple-cursors-mode."
-  (interactive)
-  (if (not (use-region-p))
-      (multiple-cursors-mode 0)
-    (deactivate-mark)))
-
-(defvar mc/keymap nil
-  "Keymap while multiple cursors are active.
-Main goal of the keymap is to rebind C-g and <return> to conclude
-multiple cursors editing.")
-(unless mc/keymap
-  (setq mc/keymap (make-sparse-keymap))
-  (define-key mc/keymap (kbd "C-g") 'mc/keyboard-quit)
-  (define-key mc/keymap (kbd "<return>") 'multiple-cursors-mode)
-  (when (fboundp 'phi-search)
-    (define-key mc/keymap (kbd "C-s") 'phi-search))
-  (when (fboundp 'phi-search-backward)
-    (define-key mc/keymap (kbd "C-r") 'phi-search-backward)))
-
-(defun mc--all-equal (list)
-  "Are all the items in LIST equal?"
-  (let ((first (car list))
-        (all-equal t))
-    (while (and all-equal list)
-      (setq all-equal (equal first (car list)))
-      (setq list (cdr list)))
-    all-equal))
-
-(defun mc--kill-ring-entries ()
-  "Return the latest kill-ring entry for each cursor.
-The entries are returned in the order they are found in the buffer."
-  (let (entries)
-    (mc/for-each-cursor-ordered
-     (setq entries (cons (car (overlay-get cursor 'kill-ring)) entries)))
-    (reverse entries)))
-
-(defun mc--maybe-set-killed-rectangle ()
-  "Add the latest kill-ring entry for each cursor to killed-rectangle.
-So you can paste it in later with `yank-rectangle'."
-  (let ((entries (mc--kill-ring-entries)))
-    (unless (mc--all-equal entries)
-      (setq killed-rectangle entries))))
-
-(defvar mc/unsupported-minor-modes '(auto-complete-mode flyspell-mode)
-  "List of minor-modes that does not play well with multiple-cursors.
-They are temporarily disabled when multiple-cursors are active.")
-
-(defvar mc/temporarily-disabled-minor-modes nil
-  "The list of temporarily disabled minor-modes.")
-(make-variable-buffer-local 'mc/temporarily-disabled-minor-modes)
-
-(defun mc/temporarily-disable-minor-mode (mode)
-  "If MODE is available and turned on, remember that and turn it off."
-  (when (and (boundp mode) (eval mode))
-    (add-to-list 'mc/temporarily-disabled-minor-modes mode)
-    (funcall mode -1)))
-
-(defun mc/temporarily-disable-unsupported-minor-modes ()
-  (mapc 'mc/temporarily-disable-minor-mode mc/unsupported-minor-modes))
-
-(defun mc/enable-minor-mode (mode)
-  (funcall mode 1))
-
-(defun mc/enable-temporarily-disabled-minor-modes ()
-  (mapc 'mc/enable-minor-mode mc/temporarily-disabled-minor-modes)
-  (setq mc/temporarily-disabled-minor-modes nil))
-
-(defcustom mc/mode-line
-  `(" mc:" (:eval (format ,(propertize "%d" 'face 'font-lock-warning-face)
-                          (mc/num-cursors))))
-  "What to display in the mode line while multiple-cursors-mode is active."
+(defcustom mc/always-run-for-all nil
+  "Disables whitelisting and always executes commands for every fake cursor."
+  :type '(boolean)
  :group 'multiple-cursors)
-(put 'mc/mode-line 'risky-local-variable t)

-(define-minor-mode multiple-cursors-mode
-  "Mode while multiple cursors are active."
-  nil mc/mode-line mc/keymap
-  (if multiple-cursors-mode
-      (progn
-        (mc/temporarily-disable-unsupported-minor-modes)
-        (add-hook 'pre-command-hook 'mc/make-a-note-of-the-command-being-run nil t)
-        (add-hook 'post-command-hook 'mc/execute-this-command-for-all-cursors t t)
-        (run-hooks 'multiple-cursors-mode-enabled-hook))
-    (remove-hook 'post-command-hook 'mc/execute-this-command-for-all-cursors t)
-    (remove-hook 'pre-command-hook 'mc/make-a-note-of-the-command-being-run t)
-    (setq mc--this-command nil)
-    (mc--maybe-set-killed-rectangle)
-    (mc/remove-fake-cursors)
-    (mc/enable-temporarily-disabled-minor-modes)
-    (run-hooks 'multiple-cursors-mode-disabled-hook)))
-
-(add-hook 'after-revert-hook #'(lambda () (multiple-cursors-mode 0)))
-
-(defun mc/maybe-multiple-cursors-mode ()
-  "Enable multiple-cursors-mode if there is more than one currently active cursor."
-  (if (> (mc/num-cursors) 1)
-      (multiple-cursors-mode 1)
-    (multiple-cursors-mode 0)))
-
-(defmacro unsupported-cmd (cmd msg)
-  "Adds command to list of unsupported commands and prevents it
-from being executed if in multiple-cursors-mode."
-  `(progn
-     (put (quote ,cmd) 'mc--unsupported ,msg)
-     (defadvice ,cmd (around unsupported-advice activate)
-       "command isn't supported with multiple cursors"
-       (unless (and multiple-cursors-mode (called-interactively-p 'any))
-         ad-do-it))))
-
-;; Commands that does not work with multiple-cursors
-(unsupported-cmd isearch-forward ". Feel free to add a compatible version.")
-(unsupported-cmd isearch-backward ". Feel free to add a compatible version.")
-
-;; Make sure pastes from other programs are added to all kill-rings when yanking
-(defadvice current-kill (before interprogram-paste-for-all-cursors activate)
-  (let ((interprogram-paste (and (= n 0)
-                                 interprogram-paste-function
-                                 (funcall interprogram-paste-function))))
-    (when interprogram-paste
-      ;; Add interprogram-paste to normal kill ring, just
-      ;; like current-kill usually does for itself.
-      ;; We have to do the work for it tho, since the funcall only returns
-      ;; something once. It is not a pure function.
-      (let ((interprogram-cut-function nil))
-        (if (listp interprogram-paste)
-            (mapc 'kill-new (nreverse interprogram-paste))
-          (kill-new interprogram-paste))
-        ;; And then add interprogram-paste to the kill-rings
-        ;; of all the other cursors too.
-        (mc/for-each-fake-cursor
-         (let ((kill-ring (overlay-get cursor 'kill-ring))
-               (kill-ring-yank-pointer (overlay-get cursor 'kill-ring-yank-pointer)))
-           (if (listp interprogram-paste)
-               (mapc 'kill-new (nreverse interprogram-paste))
-             (kill-new interprogram-paste))
-           (overlay-put cursor 'kill-ring kill-ring)
-           (overlay-put cursor 'kill-ring-yank-pointer kill-ring-yank-pointer)))))))
-
-(defvar mc/list-file "~/.emacs.d/.mc-lists.el"
-  "The position of the file that keeps track of your preferences
-for running commands with multiple cursors.")
-
-(defun mc/dump-list (list-symbol)
-  "Insert (setq 'LIST-SYMBOL LIST-VALUE) to current buffer."
-  (symbol-macrolet ((value (symbol-value list-symbol)))
-    (insert "(setq " (symbol-name list-symbol) "\n"
-            "      '(")
-    (newline-and-indent)
-    (set list-symbol
-         (sort value (lambda (x y) (string-lessp (symbol-name x)
-                                                 (symbol-name y)))))
-    (mapc #'(lambda (cmd) (insert (format "%S" cmd)) (newline-and-indent))
-          value)
-    (insert "))")
-    (newline)))
-
-(defun mc/save-lists ()
-  "Saves preferences for running commands with multiple cursors to `mc/list-file'"
-  (with-temp-file mc/list-file
-    (emacs-lisp-mode)
-    (insert ";; This file is automatically generated by the multiple-cursors extension.")
-    (newline)
-    (insert ";; It keeps track of your preferences for running commands with multiple cursors.")
-    (newline)
-    (newline)
-    (mc/dump-list 'mc/cmds-to-run-for-all)
-    (newline)
-    (mc/dump-list 'mc/cmds-to-run-once)))
+(defcustom mc/always-repeat-command nil
+  "Disables confirmation for `mc/repeat-command' command."
+  :type '(boolean)
+  :group 'multiple-cursors)

 (defvar mc/cmds-to-run-once nil
  "Commands to run only once in multiple-cursors-mode.")
@ -560,9 +399,13 @@ for running commands with multiple cursors.")
                                     mc/edit-ends-of-lines
                                     mc/edit-beginnings-of-lines
                                     mc/mark-next-like-this
+                                     mc/mark-next-like-this-word
+                                     mc/mark-next-like-this-symbol
                                     mc/mark-next-word-like-this
                                     mc/mark-next-symbol-like-this
                                     mc/mark-previous-like-this
+                                     mc/mark-previous-like-this-word
+                                     mc/mark-previous-like-this-symbol
                                     mc/mark-previous-word-like-this
                                     mc/mark-previous-symbol-like-this
                                     mc/mark-all-like-this
@ -576,6 +419,7 @@ for running commands with multiple cursors.")
                                     mc/mark-all-dwim
                                     mc/mark-sgml-tag-pair
                                     mc/insert-numbers
+                                     mc/insert-letters
                                     mc/sort-regions
                                     mc/reverse-regions
                                     mc/cycle-forward
@ -592,15 +436,23 @@ for running commands with multiple cursors.")
                                     mc/skip-to-next-like-this
                                     mc/skip-to-previous-like-this
                                     rrm/switch-to-multiple-cursors
+                                     mc-hide-unmatched-lines-mode
+                                     mc/repeat-command
+                                     hum/keyboard-quit
+                                     hum/unhide-invisible-overlays
                                     save-buffer
                                     ido-exit-minibuffer
+                                     ivy-done
                                     exit-minibuffer
                                     minibuffer-complete-and-exit
                                     execute-extended-command
+                                     eval-expression
                                     undo
                                     redo
                                     undo-tree-undo
                                     undo-tree-redo
+                                     undo-fu-only-undo
+                                     undo-fu-only-redo
                                     universal-argument
                                     universal-argument-more
                                     universal-argument-other-key
@ -630,7 +482,11 @@ for running commands with multiple cursors.")
                                     windmove-left
                                     windmove-right
                                     windmove-up
-                                     windmove-down))
+                                     windmove-down
+                                     repeat-complex-command))
+
+(defvar mc/cmds-to-run-for-all nil
+  "Commands to run for all cursors in multiple-cursors-mode")

 (defvar mc--default-cmds-to-run-for-all nil
  "Default set of commands that should be mirrored by all cursors")
@ -679,6 +535,8 @@ for running commands with multiple cursors.")
                                        py-electric-backspace
                                        c-electric-backspace
                                        org-delete-backward-char
+                                        cperl-electric-backspace
+                                        python-indent-dedent-line-backspace
                                        paredit-backward-delete
                                        autopair-backspace
                                        just-one-space
@ -688,6 +546,7 @@ for running commands with multiple cursors.")
                                        exchange-point-and-mark
                                        cua-set-mark
                                        cua-replace-region
+                                        cua-delete-region
                                        move-end-of-line
                                        beginning-of-line
                                        move-beginning-of-line
@ -709,16 +568,337 @@ for running commands with multiple cursors.")
                                        smart-up
                                        smart-down))

-(defvar mc/cmds-to-run-for-all nil
-  "Commands to run for all cursors in multiple-cursors-mode")
+(defun mc/prompt-for-inclusion-in-whitelist (original-command)
+  "Asks the user, then adds the command either to the once-list or the all-list."
+  (let ((all-p (y-or-n-p (format "Do %S for all cursors?" original-command))))
+    (if all-p
+        (add-to-list 'mc/cmds-to-run-for-all original-command)
+      (add-to-list 'mc/cmds-to-run-once original-command))
+    (mc/save-lists)
+    all-p))

-(load mc/list-file t) ;; load, but no errors if it does not exist yet please
+(defun mc/num-cursors ()
+  "The number of cursors (real and fake) in the buffer."
+  (1+ (cl-count-if 'mc/fake-cursor-p
+                   (overlays-in (point-min) (point-max)))))
+
+(defvar mc--this-command nil
+  "Used to store the original command being run.")
+(make-variable-buffer-local 'mc--this-command)
+
+(defun mc/make-a-note-of-the-command-being-run ()
+  "Used with pre-command-hook to store the original command being run.
+Since that cannot be reliably determined in the post-command-hook.
+
+Specifically, this-original-command isn't always right, because it could have
+been remapped. And certain modes (cua comes to mind) will change their
+remapping based on state. So a command that changes the state will afterwards
+not be recognized through the command-remapping lookup."
+  (unless mc--executing-command-for-fake-cursor
+    (let ((cmd (or (command-remapping this-original-command)
+                   this-original-command)))
+      (setq mc--this-command (and (not (eq cmd 'god-mode-self-insert))
+                                  cmd)))))
+
+(defun mc/execute-this-command-for-all-cursors ()
+  "Wrap around `mc/execute-this-command-for-all-cursors-1' to protect hook."
+  (condition-case error
+      (mc/execute-this-command-for-all-cursors-1)
+    (error
+     (message "[mc] problem in `mc/execute-this-command-for-all-cursors': %s"
+              (error-message-string error)))))
+
+;; execute-kbd-macro should never be run for fake cursors. The real cursor will
+;; execute the keyboard macro, resulting in new commands in the command loop,
+;; and the fake cursors can pick up on those instead.
+(defadvice execute-kbd-macro (around skip-fake-cursors activate)
+  (unless mc--executing-command-for-fake-cursor
+    ad-do-it))
+
+(defun mc/execute-this-command-for-all-cursors-1 ()
+  "Used with post-command-hook to execute supported commands for all cursors.
+
+It uses two lists of commands to know what to do: the run-once
+list and the run-for-all list. If a command is in neither of these lists,
+it will prompt for the proper action and then save that preference.
+
+Some commands are so unsupported that they are even prevented for
+the original cursor, to inform about the lack of support."
+  (unless mc--executing-command-for-fake-cursor
+
+    (if (eq 1 (mc/num-cursors)) ;; no fake cursors? disable mc-mode
+        (mc/disable-multiple-cursors-mode)
+      (when this-original-command
+        (let ((original-command (or mc--this-command
+                                    (command-remapping this-original-command)
+                                    this-original-command)))
+
+          ;; skip keyboard macros, since they will generate actual commands that are
+          ;; also run in the command loop - we'll handle those later instead.
+          (when (functionp original-command)
+
+            ;; if it's a lambda, we can't know if it's supported or not
+            ;; - so go ahead and assume it's ok, because we're just optimistic like that
+            (if (or (not (symbolp original-command))
+                    ;; lambda registered by smartrep
+                    (string-prefix-p "(" (symbol-name original-command)))
+                (mc/execute-command-for-all-fake-cursors original-command)
+
+              ;; smartrep `intern's commands into own obarray to help
+              ;; `describe-bindings'.  So, let's re-`intern' here to
+              ;; make the command comparable by `eq'.
+              (setq original-command (intern (symbol-name original-command)))
+
+              ;; otherwise it's a symbol, and we can be more thorough
+              (if (get original-command 'mc--unsupported)
+                  (message "%S is not supported with multiple cursors%s"
+                           original-command
+                           (get original-command 'mc--unsupported))
+
+                ;; lazy-load the user's list file
+                (mc/load-lists)
+
+                (when (and original-command
+                           (not (memq original-command mc--default-cmds-to-run-once))
+                           (not (memq original-command mc/cmds-to-run-once))
+                           (or mc/always-run-for-all
+                               (memq original-command mc--default-cmds-to-run-for-all)
+                               (memq original-command mc/cmds-to-run-for-all)
+                               (mc/prompt-for-inclusion-in-whitelist original-command)))
+                  (mc/execute-command-for-all-fake-cursors original-command))))))))))
+
+(defun mc/remove-fake-cursors ()
+  "Remove all fake cursors.
+Do not use to conclude editing with multiple cursors. For that
+you should disable multiple-cursors-mode."
+  (mc/for-each-fake-cursor
+   (mc/remove-fake-cursor cursor))
+  (when mc--max-cursors-original
+    (setq mc/max-cursors mc--max-cursors-original))
+  (setq mc--max-cursors-original nil))
+
+(defun mc/keyboard-quit ()
+  "Deactivate mark if there are any active, otherwise exit multiple-cursors-mode."
+  (interactive)
+  (if (not (use-region-p))
+      (mc/disable-multiple-cursors-mode)
+    (deactivate-mark)))
+
+(defun mc/repeat-command ()
+  "Run last command from `command-history' for every fake cursor."
+  (interactive)
+  (when (or mc/always-repeat-command
+            (y-or-n-p (format "[mc] repeat complex command: %s? " (caar command-history))))
+    (mc/execute-command-for-all-fake-cursors
+     (lambda () (interactive)
+       (cl-letf (((symbol-function 'read-from-minibuffer)
+                  (lambda (p &optional i k r h d m) (read i))))
+         (repeat-complex-command 0))))))
+
+(defvar mc/keymap nil
+  "Keymap while multiple cursors are active.
+Main goal of the keymap is to rebind C-g and <return> to conclude
+multiple cursors editing.")
+(unless mc/keymap
+  (setq mc/keymap (make-sparse-keymap))
+  (define-key mc/keymap (kbd "C-g") 'mc/keyboard-quit)
+  (define-key mc/keymap (kbd "<return>") 'multiple-cursors-mode)
+  (define-key mc/keymap (kbd "C-:") 'mc/repeat-command)
+  (when (fboundp 'phi-search)
+    (define-key mc/keymap (kbd "C-s") 'phi-search))
+  (when (fboundp 'phi-search-backward)
+    (define-key mc/keymap (kbd "C-r") 'phi-search-backward)))
+
+(defun mc--all-equal (list)
+  "Are all the items in LIST equal?"
+  (let ((first (car list))
+        (all-equal t))
+    (while (and all-equal list)
+      (setq all-equal (equal first (car list)))
+      (setq list (cdr list)))
+    all-equal))
+
+(defun mc--kill-ring-entries ()
+  "Return the latest kill-ring entry for each cursor.
+The entries are returned in the order they are found in the buffer."
+  (let (entries)
+    (mc/for-each-cursor-ordered
+     (setq entries (cons (car (overlay-get cursor 'kill-ring)) entries)))
+    (reverse entries)))
+
+(defun mc--maybe-set-killed-rectangle ()
+  "Add the latest kill-ring entry for each cursor to killed-rectangle.
+So you can paste it in later with `yank-rectangle'."
+  (let ((entries (let (mc/max-cursors) (mc--kill-ring-entries))))
+    (unless (mc--all-equal entries)
+      (setq killed-rectangle entries))))
+
+(defvar mc/unsupported-minor-modes '(company-mode auto-complete-mode flyspell-mode jedi-mode)
+  "List of minor-modes that does not play well with multiple-cursors.
+They are temporarily disabled when multiple-cursors are active.")
+
+(defvar mc/temporarily-disabled-minor-modes nil
+  "The list of temporarily disabled minor-modes.")
+(make-variable-buffer-local 'mc/temporarily-disabled-minor-modes)
+
+(defun mc/temporarily-disable-minor-mode (mode)
+  "If MODE is available and turned on, remember that and turn it off."
+  (when (and (boundp mode) (symbol-value mode))
+    (add-to-list 'mc/temporarily-disabled-minor-modes mode)
+    (funcall mode -1)))
+
+(defun mc/temporarily-disable-unsupported-minor-modes ()
+  (mapc 'mc/temporarily-disable-minor-mode mc/unsupported-minor-modes))
+
+(defun mc/enable-minor-mode (mode)
+  (funcall mode 1))
+
+(defun mc/enable-temporarily-disabled-minor-modes ()
+  (mapc 'mc/enable-minor-mode mc/temporarily-disabled-minor-modes)
+  (setq mc/temporarily-disabled-minor-modes nil))
+
+(defcustom mc/mode-line
+  `(" mc:" (:eval (format ,(propertize "%d" 'face 'font-lock-warning-face)
+                          (mc/num-cursors))))
+  "What to display in the mode line while multiple-cursors-mode is active."
+  :type '(sexp)
+  :group 'multiple-cursors)
+(put 'mc/mode-line 'risky-local-variable t)
+
+;;;###autoload
+(define-minor-mode multiple-cursors-mode
+  "Mode while multiple cursors are active."
+  :init-value nil
+  :lighter mc/mode-line
+  :keymap mc/keymap
+  (if multiple-cursors-mode
+      (progn
+        (mc/temporarily-disable-unsupported-minor-modes)
+        (add-hook 'pre-command-hook 'mc/make-a-note-of-the-command-being-run nil t)
+        (add-hook 'post-command-hook 'mc/execute-this-command-for-all-cursors t t)
+        (run-hooks 'multiple-cursors-mode-enabled-hook))
+    (remove-hook 'post-command-hook 'mc/execute-this-command-for-all-cursors t)
+    (remove-hook 'pre-command-hook 'mc/make-a-note-of-the-command-being-run t)
+    (setq mc--this-command nil)
+    (mc--maybe-set-killed-rectangle)
+    (mc/remove-fake-cursors)
+    (mc/enable-temporarily-disabled-minor-modes)
+    (run-hooks 'multiple-cursors-mode-disabled-hook)))
+
+(defun mc/disable-multiple-cursors-mode ()
+  "Disable multiple-cursors-mode and run the corresponding hook."
+  (multiple-cursors-mode 0)
+  (run-hooks 'multiple-cursors-mode-disabled-hook))
+
+(add-hook 'after-revert-hook 'mc/disable-multiple-cursors-mode)
+
+(defun mc/maybe-multiple-cursors-mode ()
+  "Enable multiple-cursors-mode if there is more than one currently active cursor."
+  (if (> (mc/num-cursors) 1)
+      (multiple-cursors-mode 1)
+    (mc/disable-multiple-cursors-mode)))
+
+(defmacro unsupported-cmd (cmd msg)
+  "Adds command to list of unsupported commands and prevents it
+from being executed if in multiple-cursors-mode."
+  `(progn
+     (put (quote ,cmd) 'mc--unsupported ,msg)
+     (defadvice ,cmd (around unsupported-advice activate)
+       "command isn't supported with multiple cursors"
+       (unless (and multiple-cursors-mode (called-interactively-p 'any))
+         ad-do-it))))
+
+;; Commands that does not work with multiple-cursors
+(unsupported-cmd isearch-forward ". Feel free to add a compatible version.")
+(unsupported-cmd isearch-backward ". Feel free to add a compatible version.")
+
+;; Make sure pastes from other programs are added to all kill-rings when yanking
+(defadvice current-kill (before interprogram-paste-for-all-cursors
+        (n &optional do-not-move) activate)
+  (let ((interprogram-paste (and (= n 0)
+                                 interprogram-paste-function
+                                 (funcall interprogram-paste-function))))
+    (when interprogram-paste
+      ;; Add interprogram-paste to normal kill ring, just
+      ;; like current-kill usually does for itself.
+      ;; We have to do the work for it though, since the funcall only returns
+      ;; something once. It is not a pure function.
+      (let ((interprogram-cut-function nil))
+        (if (listp interprogram-paste)
+            (mapc 'kill-new (nreverse interprogram-paste))
+          (kill-new interprogram-paste))
+        ;; And then add interprogram-paste to the kill-rings
+        ;; of all the other cursors too.
+        (mc/for-each-fake-cursor
+         (let ((kill-ring (overlay-get cursor 'kill-ring))
+               (kill-ring-yank-pointer (overlay-get cursor 'kill-ring-yank-pointer)))
+           (if (listp interprogram-paste)
+               (mapc 'kill-new (nreverse interprogram-paste))
+             (kill-new interprogram-paste))
+           (overlay-put cursor 'kill-ring kill-ring)
+           (overlay-put cursor 'kill-ring-yank-pointer kill-ring-yank-pointer)))))))
+
+(defadvice execute-extended-command (after execute-extended-command-for-all-cursors () activate)
+  (when multiple-cursors-mode
+    (unless (or mc/always-run-for-all
+                (not (symbolp this-command))
+                (memq this-command mc/cmds-to-run-for-all)
+                (memq this-command mc/cmds-to-run-once)
+                (memq this-command mc--default-cmds-to-run-for-all)
+                (memq this-command mc--default-cmds-to-run-once))
+      (mc/prompt-for-inclusion-in-whitelist this-command))
+    (when (or mc/always-run-for-all
+              (memq this-command mc/cmds-to-run-for-all)
+              (memq this-command mc--default-cmds-to-run-for-all))
+      (mc/execute-command-for-all-fake-cursors this-command))))
+
+(defcustom mc/list-file (locate-user-emacs-file ".mc-lists.el")
+  "The position of the file that keeps track of your preferences
+for running commands with multiple cursors."
+  :type 'file
+  :group 'multiple-cursors)
+
+(defvar mc--list-file-loaded nil
+  "Whether the list file has already been loaded.")
+
+(defun mc/load-lists ()
+  "Loads preferences for running commands with multiple cursors from `mc/list-file'"
+  (unless mc--list-file-loaded
+    (load mc/list-file 'noerror 'nomessage)
+    (setq mc--list-file-loaded t)))
+
+(defun mc/dump-list (list-symbol)
+  "Insert (setq 'LIST-SYMBOL LIST-VALUE) to current buffer."
+  (cl-symbol-macrolet ((value (symbol-value list-symbol)))
+    (insert "(setq " (symbol-name list-symbol) "\n"
+            "      '(")
+    (newline-and-indent)
+    (set list-symbol
+         (sort value (lambda (x y) (string-lessp (symbol-name x)
+                                            (symbol-name y)))))
+    (mapc #'(lambda (cmd) (insert (format "%S" cmd)) (newline-and-indent))
+          value)
+    (insert "))")
+    (newline)))
+
+(defun mc/save-lists ()
+  "Saves preferences for running commands with multiple cursors to `mc/list-file'"
+  (with-temp-file mc/list-file
+    (emacs-lisp-mode)
+    (when (> emacs-major-version 30)
+      (insert ";;   -*- lexical-binding: t; -*-\n"))
+    (insert ";; This file is automatically generated by the multiple-cursors extension.\n")
+    (insert ";; It keeps track of your preferences for running commands with multiple cursors.\n\n")
+    (mc/dump-list 'mc/cmds-to-run-for-all)
+    (newline)
+    (mc/dump-list 'mc/cmds-to-run-once)))

 (provide 'multiple-cursors-core)
+(require 'mc-cycle-cursors)
+(require 'mc-hide-unmatched-lines-mode)

 ;; Local Variables:
 ;; coding: utf-8
-;; byte-compile-warnings: (not cl-functions)
 ;; End:

 ;;; multiple-cursors-core.el ends here
--- a/multiple-cursors-pkg.el
+++ b/multiple-cursors-pkg.el
@ -1,2 +0,0 @@
-(define-package "multiple-cursors" "1.3.0"
-                "Multiple cursors for Emacs.")
--- a/multiple-cursors.el
+++ b/multiple-cursors.el
@ -1,10 +1,12 @@
-;;; multiple-cursors.el --- Multiple cursors for emacs.
+;;; multiple-cursors.el --- Multiple cursors for emacs.  -*- lexical-binding: t; -*-

-;; Copyright (C) 2012-2013 Magnar Sveen
+;; Copyright (C) 2012-2016 Magnar Sveen

 ;; Author: Magnar Sveen <magnars@gmail.com>
-;; Version: 1.2.2
+;; Package-Version: 1.5.0
+;; Package-Requires: ((cl-lib "0.5"))
 ;; Keywords: editing cursors
+;; Homepage: https://github.com/magnars/multiple-cursors.el

 ;; This program is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
@ -22,7 +24,7 @@
 ;;; Commentary:

 ;; Multiple cursors for Emacs. This is some pretty crazy functionality, so yes,
-;; there are kinks. Don't be afraid tho, I've been using it since 2011 with
+;; there are kinks. Don't be afraid though, I've been using it since 2011 with
 ;; great success and much merriment.

 ;; ## Basic usage
@ -61,12 +63,14 @@
 ;; ### Mark one more occurrence

 ;;  - `mc/mark-next-like-this`: Adds a cursor and region at the next part of the buffer forwards that matches the current region.
+;;  - `mc/mark-next-like-this-word`: Adds a cursor and region at the next part of the buffer forwards that matches the current region, if  no region is selected it selects the word at the point.
+;;  - `mc/mark-next-like-this-symbol`: Adds a cursor and region at the next part of the buffer forwards that matches the current region, if  no region is selected it selects the symbol at the point.
 ;;  - `mc/mark-next-word-like-this`: Like `mc/mark-next-like-this` but only for whole words.
 ;;  - `mc/mark-next-symbol-like-this`: Like `mc/mark-next-like-this` but only for whole symbols.
 ;;  - `mc/mark-previous-like-this`: Adds a cursor and region at the next part of the buffer backwards that matches the current region.
 ;;  - `mc/mark-previous-word-like-this`: Like `mc/mark-previous-like-this` but only for whole words.
 ;;  - `mc/mark-previous-symbol-like-this`: Like `mc/mark-previous-like-this` but only for whole symbols.
-;;  - `mc/mark-more-like-this-extended`: Use arrow keys to quickly mark/skip next/previous occurances.
+;;  - `mc/mark-more-like-this-extended`: Use arrow keys to quickly mark/skip next/previous occurrences.
 ;;  - `mc/add-cursor-on-click`: Bind to a mouse event to add cursors by clicking. See tips-section.

 ;; ### Mark many occurrences
@ -85,6 +89,7 @@
 ;;  - `set-rectangular-region-anchor`: Think of this one as `set-mark` except you're marking a rectangular region.
 ;;  - `mc/mark-sgml-tag-pair`: Mark the current opening and closing tag.
 ;;  - `mc/insert-numbers`: Insert increasing numbers for each cursor, top to bottom.
+;;  - `mc/insert-letters`: Insert increasing letters for each cursor, top to bottom.
 ;;  - `mc/sort-regions`: Sort the marked regions alphabetically.
 ;;  - `mc/reverse-regions`: Reverse the order of the marked regions.

@ -100,6 +105,10 @@
 ;; - Try pressing `mc/mark-next-like-this` with no region selected. It will just add a cursor
 ;;   on the next line.
 ;;
+;; - Try pressing `mc/mark-next-like-this-word` or
+;;   `mc/mark-next-like-this-symbol` with no region selected. It will
+;;   mark the symbol and add a cursor at the next occurrence
+;;
 ;; - Try pressing `mc/mark-all-like-this-dwim` on a tagname in html-mode.
 ;;
 ;; - Notice that the number of cursors active can be seen in the modeline.
@ -145,7 +154,6 @@

 ;; * isearch-forward and isearch-backward aren't supported with multiple cursors.
 ;;   You should feel free to add a simplified version that can work with it.
-;; * Commands run with `M-x` won't be repeated for all cursors.
 ;; * All key bindings that refer to lambdas are always run for all cursors. If you
 ;;   need to limit it, you will have to give it a name.
 ;; * Redo might screw with your cursors. Undo works very well.
@ -179,8 +187,11 @@

 ;;; Code:

+(defgroup multiple-cursors nil
+  "Multiple cursors for emacs."
+  :group 'editing)
+
 (require 'mc-edit-lines)
-(require 'mc-cycle-cursors)
 (require 'mc-mark-more)
 (require 'mc-mark-pop)
 (require 'rectangular-region-mode)
--- a/rectangular-region-mode.el
+++ b/rectangular-region-mode.el
@ -1,6 +1,6 @@
-;;; rectangular-region-mode.el
+;;; rectangular-region-mode.el  -*- lexical-binding: t; -*-

-;; Copyright (C) 2012 Magnar Sveen
+;; Copyright (C) 2012-2016 Magnar Sveen

 ;; Author: Magnar Sveen <magnars@gmail.com>
 ;; Keywords: editing cursors
@ -38,6 +38,8 @@
 (define-key rectangular-region-mode-map (kbd "C-g") 'rrm/keyboard-quit)
 (define-key rectangular-region-mode-map (kbd "<return>") 'rrm/switch-to-multiple-cursors)

+(defvar rectangular-region-mode nil)
+
 (defun rrm/keyboard-quit ()
  "Exit rectangular-region-mode."
  (interactive)
@ -50,8 +52,9 @@
 (defun set-rectangular-region-anchor ()
  "Anchors the rectangular region at point.

-Think of this one as `set-mark' except you're marking a rectangular region. It is
-an exceedingly quick way of adding multiple cursors to multiple lines."
+Think of this one as `set-mark' except you're marking a
+rectangular region. It is an exceedingly quick way of adding
+multiple cursors to multiple lines."
  (interactive)
  (set-marker rrm/anchor (point))
  (push-mark (point))
@ -73,9 +76,9 @@ an exceedingly quick way of adding multiple cursors to multiple lines."
    (rrm/remove-rectangular-region-overlays)
    (let* ((annoying-arrows-mode nil)
           (point-column (current-column))
-           (point-line (line-number-at-pos))
+           (point-line (mc/line-number-at-pos))
           (anchor-column (save-excursion (goto-char rrm/anchor) (current-column)))
-           (anchor-line (save-excursion (goto-char rrm/anchor) (line-number-at-pos)))
+           (anchor-line (save-excursion (goto-char rrm/anchor) (mc/line-number-at-pos)))
           (left-column (if (< point-column anchor-column) point-column anchor-column))
           (right-column (if (> point-column anchor-column) point-column anchor-column))
           (navigation-step (if (< point-line anchor-line) 1 -1)))
@ -83,7 +86,7 @@ an exceedingly quick way of adding multiple cursors to multiple lines."
      (set-mark (point))
      (move-to-column point-column)
      (mc/save-excursion
-       (while (not (= anchor-line (line-number-at-pos)))
+       (while (not (= anchor-line (mc/line-number-at-pos)))
         (forward-line navigation-step)
         (move-to-column anchor-column)
         (when (= anchor-column (current-column))
@ -106,9 +109,12 @@ an exceedingly quick way of adding multiple cursors to multiple lines."
  (when rectangular-region-mode
    (rrm/switch-to-multiple-cursors)))

+;;;###autoload
 (define-minor-mode rectangular-region-mode
  "A mode for creating a rectangular region to edit"
-  nil " rr" rectangular-region-mode-map
+  :init-value nil
+  :lighter " rr"
+  :keymap rectangular-region-mode-map
  (if rectangular-region-mode
      (progn
        (add-hook 'after-change-functions 'rrm/switch-to-multiple-cursors t t)
--- a/run-travis-ci.sh
+++ b/run-travis-ci.sh
@ -1,13 +0,0 @@
-#!/bin/sh -e
-
-cd "$(dirname "$0")"
-
-ECUKES_EMACS=${EMACS:-$(which emacs)}
-export ECUKES_EMACS
-
-echo "*** Emacs version ***"
-echo "ECUKES_EMACS = $ECUKES_EMACS"
-"$ECUKES_EMACS" --version
-echo
-
-exec ./run-tests.sh $TAGS