Improve tag order for non-QWERTY layouts

add hop
fixes #356
2025-11-04 09:40:10 +01:00 · 2021-11-21 05:29:43 +01:00 · 2021-11-20 15:54:52 -05:00 · 2021-11-14 21:22:06 -05:00 · 2021-11-14 17:01:11 -05:00 · 2021-11-14 16:32:44 -05:00
57 changed files with 2305 additions and 2241 deletions
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,7 +1,43 @@
 # Changelog

-### 3.7
+## Unreleased

+## 3.8.5
+
+- Restores <kbd>Tab</kbd>/<kbd>Shift</kbd>+<kbd>Tab</kbd> functionality, [#356](https://github.com/acejump/AceJump/issues/356)
+
+## 3.8.4
+
+- Fixes Declaration Mode in Rider, [#379](https://github.com/acejump/AceJump/issues/379), thanks to @igor-akhmetov for helping diagnose!
+- Fixes highlight offset on high-DPI screens, [#362](https://github.com/acejump/AceJump/issues/362), thanks to @chylex for [the PR](https://github.com/acejump/AceJump/pull/384)!
+
+## 3.8.3
+
+- Displays regular expression for regex-based queries
+- Fixes a bug when current search text was enabled causing word and line mode tags to not be displayed, [#376](https://github.com/acejump/AceJump/issues/376)
+
+## 3.8.2
+
+- Add option to display current search text, [#375](https://github.com/acejump/AceJump/issues/375)
+- Fixes a bug where editor was not focused, [#374](https://github.com/acejump/AceJump/issues/374)
+- Thanks to @SaiKai for the PRs!
+
+## 3.8.1
+
+- Hotfix for stale cache, [#373](https://github.com/acejump/AceJump/issues/373)
+
+## 3.8.0
+- Allow jumping between splitters in the editor, [#371](https://github.com/acejump/AceJump/pull/371)
+- Adds support for unicode search and selection, [#368](https://github.com/acejump/AceJump/issues/368)
+
+## 3.7.1
+- Fix settings display issue, [#363](https://github.com/acejump/AceJump/issues/363)
+- Update AceJump extension API to include tag information, [#357](https://github.com/acejump/AceJump/pull/357)
+- Allow defining jump mode with boundaries, [#358](https://github.com/acejump/AceJump/pull/358)
+- Use Kotlin classes for actions, [#359](https://github.com/acejump/AceJump/pull/359)
+- Thanks to @AlexPl292 for the PRs!
+
+## 3.7.0
 - Improvements to tag latency
 - Redesign settings panel
  - Add missing configuration for definition mode color
@@ -11,223 +47,225 @@
 - Jump-to-End mode jumps to the end of a word
 - Fixes toggle keys not resetting mode when pressed twice
 - Increase limit for what is considered a large file
- Thanks to @chylex for [all the PRs](https://github.com/acejump/AceJump/pulls?q=is%3Apr+author%3Achylex)!
+- Major refactoring, [#350](https://github.com/acejump/AceJump/pull/353)
+- [Many bug fixes](https://github.com/acejump/AceJump/issues/348#issuecomment-739454920): [#338](https://github.com/acejump/AceJump/issues/338), [#336](https://github.com/acejump/AceJump/issues/336), [#329](https://github.com/acejump/AceJump/issues/329), [#327](https://github.com/acejump/AceJump/issues/327), [#310](https://github.com/acejump/AceJump/issues/310), [#233](https://github.com/acejump/AceJump/issues/233), [#228](https://github.com/acejump/AceJump/issues/228), [#187](https://github.com/acejump/AceJump/issues/187), [#147](https://github.com/acejump/AceJump/issues/147), [#132](https://github.com/acejump/AceJump/issues/132), [#71](https://github.com/acejump/AceJump/issues/71)
+- Huge thanks to @chylex for [all the PRs](https://github.com/acejump/AceJump/pulls?q=is%3Apr+author%3Achylex)!

-### 3.6.3
+## 3.6.3

 - Vote for your favorite <a href="https://twitter.com/breandan/status/1274169810411274241">AceJump logo</a>!
 - Fixes potential bug.
 - Increases test coverage.

-### 3.6.2
+## 3.6.2

 - Fixes [#226](https://github.com/acejump/AceJump/issues/226). Thanks @AlexPl292!
 - Update Pinyin engine.

-### 3.6.1
+## 3.6.1

 - Fixes [#324](https://github.com/acejump/AceJump/issues/324). Thanks @AlexPl292!
 - Fixes [#325](https://github.com/acejump/AceJump/issues/325).
 - Fixes Pinyin support.

-### 3.6.0
+## 3.6.0

 - Adds support for Chinese [#314](https://github.com/acejump/AceJump/issues/314).
 - Fixes constantly loading settings page [#303](https://github.com/acejump/AceJump/issues/303).
 - Honor camel humps [#315](https://github.com/acejump/AceJump/issues/315). Thanks to @clojj.
 - Support dynamic application reloading [#322](https://github.com/acejump/AceJump/issues/322).

-### 3.5.9
+## 3.5.9

 - Fix a build configuration error affecting plugins which depend on AceJump. Fixes [#305](https://github.com/acejump/AceJump/issues/305).

-### 3.5.8
+## 3.5.8

 - Tagging improvements
 - Support for external plugin integration
 - Fixes [#304](https://github.com/acejump/AceJump/issues/304), [#255](https://github.com/acejump/AceJump/issues/255)

-### 3.5.7
+## 3.5.7

 - <kbd>Tab</kbd>/<kbd>Enter</kbd> will now scroll horizontally if results are not visible.
 - Fixes [#294](https://github.com/acejump/AceJump/issues/294) "Access is allowed from event dispatch thread only" error

-### 3.5.6
+## 3.5.6

 - Key prioritization for most common keyboard layouts and fixes for a number of minor issues.
 - Fixes: Index OOB [#242](https://github.com/acejump/AceJump/issues/242), Missing editor [#249](https://github.com/acejump/AceJump/issues/249), [#275](https://github.com/acejump/AceJump/issues/275), Forgotten block caret [#278](https://github.com/acejump/AceJump/issues/278), QWERTZ layout [#273](https://github.com/acejump/AceJump/issues/273)

-### 3.5.5
+## 3.5.5

 - <kbd>Enter</kbd> will now escape exit from AceJump when there is a single visible tag. [#274](https://github.com/acejump/AceJump/issues/274)
 - <kbd>Shift</kbd>+<kbd>Tab</kbd> to scroll to previous occurrences now works properly. [#179](https://github.com/acejump/AceJump/issues/179)
 - Fixes an error with sticky block caret mode. [#269](https://github.com/acejump/AceJump/issues/269)

-### 3.5.4
+## 3.5.4

 - Introduces cyclical selection: press Enter or Shift + Enter to cycle through tags on the screen. Press Escape to return to the editor.

-### 3.5.3
+## 3.5.3

 - Fixes for two regressions affecting caret color and shift-selection.

-### 3.5.2
+## 3.5.2

 - Various improvements to settings page, including a keyboard layout selector.
 - Shorter tags on average, AceJump tries to use a single-character tag more often.
 - Tag characters are now prioritized by user-defined order from the settings page.
 - Fixes an issue when running the plugin on platform version 2018.3 and above.

-### 3.5.1
+## 3.5.1

 - Now supports searching for CaPiTaLiZeD letters (typing capital letters in the query will force a case-sensitive search).
 - **Declaration Mode**: Press the AceJump shortcut a second time to activate Declaration Mode, which will jump to the declaration of a variable in the editor.
 - Keep hitting the AceJump shortcut to cycle between modes (default, declaration, target, disabled).
 - Bug fix: AceJump settings should now properly persist after restarting the IDE.

-### 3.5.0
+## 3.5.0

 - Adds two new features. "**Word-Mode**" and quick tag selection.
 - **Word Mode** removes search and addresses latency issues raised in [#161](https://github.com/acejump/AceJump/issues/161). To learn more about **Word Mode**, see the [readme](https://github.com/johnlindquist/AceJump#tips).
 - Pressing <kbd>Enter</kbd> during a search will jump to the next visible match (or closest match, if next is not visible), as per [#133](https://github.com/acejump/AceJump/issues/133).

-### 3.4.3
+## 3.4.3

 - Stability improvements and tagging optimizations. Fixes [#206](https://github.com/acejump/AceJump/issues/206), [#202](https://github.com/acejump/AceJump/issues/202).

-### 3.4.2
+## 3.4.2

 - Fixes [a regression](https://github.com/johnlindquist/AceJump/issues/197) affecting older platform versions.

-### 3.4.1
+## 3.4.1

 - Fixes a regression affecting tag alignment when line spacing is greater than 1.0. Minor speed improvements.

-### 3.4.0
+## 3.4.0

 - Restores original scroll position if tab search cancelled. Minor improvements to latency and tag painting.

-### 3.3.6
+## 3.3.6

 - Fix for [#129](https://github.com/acejump/AceJump/issues/129).

-### 3.3.5
+## 3.3.5

 - Minor bugfix release. Improve handling of window resizing.

-### 3.3.4
+## 3.3.4

 - Add a settings page. (Settings > Tools > AceJump)

-### 3.3.3
+## 3.3.3

 - Improve latency and fix a bug in line selection mode.

-### 3.3.2
+## 3.3.2

 - AceJump now persists target mode state when scrolling or tabbing.

-### 3.3.1
+## 3.3.1

 - Fixes a minor regression where tags are not displaying correctly.

-### 3.3.0
+## 3.3.0

 - AceJump now searches the entire document. Press TAB to get the next set of results!

-### 3.2.7
+## 3.2.7

 - Minor fixes and stability improvements.

-### 3.2.6
+## 3.2.6

 - Fixes an error affecting older versions of the IntelliJ Platform.

-### 3.2.5
+## 3.2.5

 - AceJump 3 now supports older IntelliJ Platform and Kotlin versions.

-### 3.2.4
+## 3.2.4

 - Tagging improvements (tags now shorter on average) and visual updates.

-### 3.2.3
+## 3.2.3

 - Fixes a critical issue affecting users with multiple editor windows open.

-### 3.2.2
+## 3.2.2

 - Adds scrolling support and fixes some line spacing issues.

-### 3.2.1
+## 3.2.1

 - AceJump now synchronizes font style changes in real-time.

-### 3.2.0
+## 3.2.0

 - Support Back/Forward navigation in the IntelliJ Platform.

-### 3.1.8
+## 3.1.8

 - Fixes some errors that occur when the user closes an editor prematurely.

-### 3.1.6
+## 3.1.6

 - Fixes a rare tag collision scenario and UninitializedPropertyAccess exception

-### 3.1.5
+## 3.1.5

 - Allow users to enter target mode directly by pressing Ctrl+Alt+;

-### 3.1.4
+## 3.1.4

 - Fixes the "Assertion Failed" exception popup

-### 3.1.3
+## 3.1.3

 - Fixes an error affecting some users during startup.

-### 3.1.2
+## 3.1.2

 - Fixes an Android Studio regression.

-### 3.1.1
+## 3.1.1

 - Hotfix for broken target mode.

-### 3.1.0
+## 3.1.0

 - Removes the search box, lots of small usability improvements.

-### 3.0.7
+## 3.0.7

 - No longer tags "folded" regions and minor alignment adjustments.

-### 3.0.6
+## 3.0.6

 - Fixes alignment issues, removes top and bottom alignments until there is a better way to visually differentiate adjacent tags.

-### 3.0.5
+## 3.0.5

 - Hotfix for target mode.

-### 3.0.4
+## 3.0.4

 - Adds *Line Mode* - press <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>;</kbd> to activate.

-### 3.0.3
+## 3.0.3

 - Updates to tag placement and performance improvements.

-### 3.0.2
+## 3.0.2

 - Fixes target mode and default shortcut activation for Mac users.

-### 3.0.1
+## 3.0.1

 - Fixes target-mode issues affecting users with non-default shortcuts and adds support for Home/End.

-### 3.0.0
+## 3.0.0

 - Major rewrite of AceJump. Introducing:
    * Realtime search: Just type the word where you want to jump and AceJump will do the rest.
@@ -235,82 +273,82 @@
    * Keyboard-aware tagging: Tries to minimize finger travel distance on QWERTY keyboards.
    * Colorful highlighting: AceJump will now highlight the editor text, as you type.

-### 2.0.13
+## 2.0.13

 - Fix a regression affecting *Target Mode* and line-based navigation.

-### 2.0.12
+## 2.0.12

 - Fix ClassCastException when input letter not present: [#73](https://github.com/acejump/AceJump/issues/73)

-### 2.0.11
+## 2.0.11

 - One hundred percent all natural Kotlin.

-### 2.0.10
+## 2.0.10

 - Support 2016.2, remove upper version limit, update internal Kotlin version

-### 2.0.9
+## 2.0.9

 - Compile on Java 7 to address: [#61](https://github.com/acejump/AceJump/issues/61)

-### 2.0.8
+## 2.0.8

 - Compile on Java 6 to address: [#59](https://github.com/acejump/AceJump/issues/59)

-### 2.0.7
+## 2.0.7

 - Language update for Kotlin 1.0 release.

-### 2.0.6
+## 2.0.6

 - Fixing "lost focus" bugs mentioned here: [#41](https://github.com/acejump/AceJump/issues/41)

-### 2.0.5
+## 2.0.5

 - Fixing "backspace" bugs mentioned here: [#20](https://github.com/acejump/AceJump/issues/20)

-### 2.0.4
+## 2.0.4

 - Fixing "code folding" bugs mentioned here: [#24](https://github.com/acejump/AceJump/issues/24)

-### 2.0.3
+## 2.0.3

 - More work on Ubuntu focus bug

-### 2.0.2
+## 2.0.2

 - Fixed bug when there's only 1 search result

-### 2.0.1
+## 2.0.1

 - Fixing Ubuntu focus bug

-### 2.0.0
+## 2.0.0

 - Major release: Added "target mode", many speed increases, multi-char search implemented

-### 1.1.0
+## 1.1.0

 - Switching to Kotlin for the code base

-### 1.0.4
+## 1.0.4

 - Fixing [#9](https://github.com/acejump/AceJump/issues/9) and [#6](https://github.com/acejump/AceJump/issues/6)

-### 1.0.3
+## 1.0.3

 - Fixed minor visual lag when removing the "jumpers" from the editor

-### 1.0.2
+## 1.0.2

 - Cleaning up minor bugs (npe when editor not in focus, not removing layers)

-### 1.0.1
+## 1.0.1

 - Adding a new jump: "Enter" will take you to the first non-whitespace char in a new line (compare to "Home" which takes you to a new line)

-### 1.0.0
+## 1.0.0

 - Cleaned up code base for release
--- a/README.md
+++ b/README.md
@@ -28,7 +28,7 @@ AceJump search is [smart case](http://ideavim.sourceforge.net/vim/usr_27.html#vi

 ## Tips

- Press <kbd>Tab</kbd> when searching to jump to the next group of matches in the editor.
+- Press <kbd>Tab</kbd> when searching to jump to the next group of matches in the editor. *This feature is unavailable in `3.6.4-3.8.4`.*

 - If you make a mistake searching, just press <kbd>Backspace</kbd> to restart from scratch.

@@ -91,21 +91,56 @@ The build artifact will be placed in `build/distributions/`.

 *Miscellaneous: AceJump is built using [Gradle](https://gradle.com/) with the [Gradle Kotlin DSL](https://docs.gradle.org/5.1/userguide/kotlin_dsl.html) and the [gradle-intellij-plugin](https://github.com/JetBrains/gradle-intellij-plugin).*

+## Extending
+
+AceJump can be used by other [IntelliJ Platform](https://plugins.jetbrains.com/docs/intellij/welcome.html) plugins. To do so, add the following snippet to your `build.gradle.kts` file:
+
+```kotlin
+intellij {
+  plugins.set("AceJump:<LATEST_VERSION>")
+}
+```
+
+Callers who pass an instance of [`Editor`](https://github.com/JetBrains/intellij-community/blob/master/platform/editor-ui-api/src/com/intellij/openapi/editor/Editor.java) into `SessionManager.start(editor)` will receive a [`Session`](src/main/kotlin/org/acejump/session/Session.kt) instance in return. Sessions are disposed after use.
+
+To use AceJump externally, please see the following example:
+
+```kotlin
+import org.acejump.session.SessionManager
+import org.acejump.session.AceJumpListener
+import org.acejump.boundaries.StandardBoundaries.*
+import org.acejump.search.Pattern.*
+
+val aceJumpSession = SessionManager.start(editorInstance)
+
+aceJumpSession.addAceJumpListener(object: AceJumpListener {
+  override fun finished() {
+    // ...
+  }
+})
+
+// Sessions provide these endpoints for external consumers:
+
+/*1.*/ aceJumpSession.markResults(sortedSetOf(/*...*/)) // Pass a set of offsets
+/*2.*/ aceJumpSession.startRegexSearch("[aeiou]+", WHOLE_FILE) // Search for regex
+/*3.*/ aceJumpSession.startRegexSearch(ALL_WORDS, VISIBLE_ON_SCREEN) // Search for Pattern
+```
+
+Custom boundaries for search (i.e. current line before caret etc.) can also be defined using the [Boundaries](src/main/kotlin/org/acejump/boundaries/Boundaries.kt) interface.
+
 ## Contributing

 AceJump is supported by community members like you. Contributions are highly welcome!

-If you would like to [contribute](https://github.com/acejump/AceJump/pulls), here are a few of the ways you can help improve AceJump:
+If you would like to [contribute](https://github.com/acejump/AceJump/pulls?q=is%3Apr), here are a few of the ways you can help improve AceJump:

 * [Improve test coverage](https://github.com/acejump/AceJump/issues/139)
-* [Add option to place the caret after the search text](https://github.com/acejump/AceJump/issues/225)
-* [Support user-configurable keyboard layouts](https://github.com/acejump/AceJump/issues/172)
-* [Speed up tagging on large files](https://github.com/acejump/AceJump/issues/217)
+* [Add action to repeat last search](https://github.com/acejump/AceJump/issues/316)
+* [Add configurable RegEx modes](https://github.com/acejump/AceJump/issues/215)
+* [Add font family and size options](https://github.com/acejump/AceJump/issues/192)
+* [Tag placement and visibility improvements](https://github.com/acejump/AceJump/issues/323)
 * [Animated documentation](https://github.com/acejump/AceJump/issues/145)
-* [Display current search text](https://github.com/acejump/AceJump/issues/227)
-* [Support for full screen tagging](https://github.com/acejump/AceJump/issues/144)
 * [Fold text between matches](https://github.com/acejump/AceJump/issues/255)
-* [Multi-platform support](https://github.com/acejump/AceJump/issues/229)

 To start [IntelliJ IDEA CE](https://github.com/JetBrains/intellij-community) with AceJump installed, run `./gradlew runIde -PluginDev [-x test]`.

@@ -128,7 +163,7 @@ AceJump is inspired by prior work, but adds several improvements, including:
 * **Line Mode**: Jump to the first, last, or first non-whitespace character of any line on-screen (<kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>;</kbd>).
 * **Word Mode**: Jump to the first character of any visible word on-screen in two keystrokes or less.
 * **Declaration Mode**: Jump to the declaration of a token (if it is available) rather than the token itself.
-* **Pinyin support**: Pinyin search and selection, e.g. to search for "拼音", activate AceJump and type: <kbd>p</kbd><kbd>y</kbd>
+* **Unicode support**: Unicode search and selection, e.g. to search for "拼音", activate AceJump and type: <kbd>p</kbd><kbd>y</kbd>

 The following plugins have a similar UI for navigating text and web browsing:

@@ -143,6 +178,7 @@ The following plugins have a similar UI for navigating text and web browsing:
 | [ace-jump-mode](https://github.com/winterTTr/ace-jump-mode)           |                           [⬇](https://melpa.org/#/ace-jump-mode)                            |                      [emacs](https://www.gnu.org/software/emacs/)                      |         :x:         |    [Emacs Lisp](https://www.gnu.org/software/emacs/manual/eintr.html)    |
 | [avy](https://github.com/abo-abo/avy)                                 |                                [⬇](https://melpa.org/#/avy)                                 |                      [emacs](https://www.gnu.org/software/emacs/)                      | :heavy_check_mark:  |    [Emacs Lisp](https://www.gnu.org/software/emacs/manual/eintr.html)    |
 | [EasyMotion](https://github.com/easymotion/vim-easymotion)            |                        [⬇](https://vimawesome.com/plugin/easymotion)                        |                               [Vim](http://www.vim.org/)                               |         :x:         |       [Vimscript](http://learnvimscriptthehardway.stevelosh.com/)        |
+| [Hop](https://github.com/phaazon/hop.nvim)                            |                        [⬇](https://github.com/phaazon/hop.nvim#installation)                |                               [NeoVim](https://neovim.io/)                             |  :heavy_check_mark: |                       [Lua](https://www.lua.org/)                        |
 | [Sublime EasyMotion](https://github.com/tednaleid/sublime-EasyMotion) |                     [⬇](https://packagecontrol.io/packages/EasyMotion)                      |                        [Sublime](https://www.sublimetext.com/)                         |         :x:         |                    [Python](https://www.python.org/)                     |
 | [AceJump](https://github.com/ice9js/ace-jump-sublime)                 |                       [⬇](https://packagecontrol.io/packages/AceJump)                       |                        [Sublime](https://www.sublimetext.com/)                         | :heavy_check_mark:  |                    [Python](https://www.python.org/)                     |
 | [Jumpy](https://github.com/DavidLGoldberg/jumpy)                      |                             [⬇](https://atom.io/packages/jumpy)                             |                                [Atom](https://atom.io/)                                | :heavy_check_mark:  |                 [CoffeeScript](http://coffeescript.org/)                 |
@@ -170,8 +206,8 @@ The following individuals have significantly improved AceJump through their cont

 * [John Lindquist](https://github.com/johnlindquist) for creating AceJump and supporting it for many years.
 * [Breandan Considine](https://github.com/breandan) for maintaining the project and adding some new features.
+* [chylex](https://github.com/chylex) for numerous [performance optimizations](https://github.com/acejump/AceJump/pulls?q=is%3Apr+author%3Achylex), [bug fixes](https://github.com/acejump/AceJump/issues/348#issuecomment-739454920) and [refactoring](https://github.com/acejump/AceJump/pull/353).
 * [Alex Plate](https://github.com/AlexPl292) for submitting [several PRs](https://github.com/acejump/AceJump/pulls?q=is%3Apr+author%3AAlexPl292).
-* [Daniel Chýlek](https://github.com/chylex) for several [performance optimizations](https://github.com/acejump/AceJump/pulls?q=is%3Apr+author%3Achylex).
 * [Sven Speckmaier](https://github.com/svensp) for [improving](https://github.com/acejump/AceJump/pull/214) search latency.
 * [Stefan Monnier](https://www.iro.umontreal.ca/~monnier/) for algorithmic advice and maintaining Emacs for several years.
 * [Fool's Mate](https://www.fools-mate.de/) for the [icon](https://github.com/acejump/AceJump/issues/313) and graphic design.
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,32 +1,73 @@
+import org.jetbrains.changelog.*
+import org.jetbrains.intellij.tasks.*
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

 plugins {
  idea apply true
-  kotlin("jvm") version "1.5.0"
-  id("org.jetbrains.intellij") version "0.7.2"
+  kotlin("jvm") version "1.6.0-RC2"
+  id("org.jetbrains.intellij") version "1.2.1"
+  id("org.jetbrains.changelog") version "1.3.1"
+  id("com.github.ben-manes.versions") version "0.39.0"
 }

 tasks {
  withType<KotlinCompile> {
    kotlinOptions.jvmTarget = JavaVersion.VERSION_1_8.toString()
  }
+
+  named<Zip>("buildPlugin") {
+    dependsOn("test")
+    archiveFileName.set("AceJump.zip")
+  }
+
+  withType<RunIdeTask> {
+    dependsOn("test")
+    findProperty("luginDev")?.let { args = listOf(projectDir.absolutePath) }
+  }
+
+  publishPlugin {
+    val intellijPublishToken: String? by project
+    token.set(intellijPublishToken)
+  }
+
+  patchPluginXml {
+    sinceBuild.set("203.7717.56")
+    changeNotes.set(provider {
+      changelog.getAll().values.take(2).last().toHTML()
+    })
+  }
+
+  runPluginVerifier {
+    ideVersions.set(listOf("2021.2.1"))
+  }
 }

-dependencies {
-  compileOnly(kotlin("stdlib-jdk8"))
+changelog {
+  version.set("3.8.5")
+  path.set("${project.projectDir}/CHANGES.md")
+  header.set(provider { "[${project.version}] - ${date()}" })
+  itemPrefix.set("-")
+  unreleasedTerm.set("Unreleased")
 }

 repositories {
  mavenCentral()
-  jcenter()
+  maven("https://jitpack.io")
+}
+
+dependencies {
+  // gradle-intellij-plugin doesn't attach sources properly for Kotlin :(
+  implementation(platform("org.jetbrains.kotlin:kotlin-bom"))
+  compileOnly(kotlin("stdlib-jdk8"))
+  implementation("com.anyascii:anyascii:0.3.0")
 }

 intellij {
-  version = "2021.1"
-  pluginName = "AceJump"
-  updateSinceUntilBuild = false
-  setPlugins("java", "IdeaVIM:0.66")
+  version.set("2021.2.1")
+  pluginName.set("AceJump")
+  updateSinceUntilBuild.set(false)
+  plugins.set(listOf("java"))
 }

 group = "org.acejump"
-version = "chylex-8"
+version = "3.8.5"
--- a/gradle/wrapper/gradle-wrapper.jar
+++ b/gradle/wrapper/gradle-wrapper.jar
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.3-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
--- a/2
+++ b/2
@@ -72,7 +72,7 @@ case "`uname`" in
  Darwin* )
    darwin=true
    ;;
-  MSYS* | MINGW* )
+  MINGW* )
    msys=true
    ;;
  NONSTOP* )
--- a/src/main/kotlin/org/acejump/AceUtil.kt
+++ b/src/main/kotlin/org/acejump/AceUtil.kt
@@ -1,26 +1,54 @@
 package org.acejump

-import com.intellij.openapi.editor.Editor
-import com.intellij.openapi.editor.actions.EditorActionUtil
+import com.anyascii.AnyAscii
+import com.intellij.diff.util.DiffUtil.getLineCount
+import com.intellij.openapi.editor.*
 import it.unimi.dsi.fastutil.ints.IntArrayList
+import org.acejump.config.AceConfig
+import kotlin.math.*

+/**
+ * This annotation is a marker which means that the annotated function is
+ *   used in external plugins.
+ */
+
+@Retention(AnnotationRetention.SOURCE)
 annotation class ExternalUsage

 /**
 * Returns an immutable version of the currently edited document.
 */
-val Editor.immutableText
-  get() = this.document.immutableCharSequence
+val Editor.immutableText get() = EditorsCache.getText(this)
+
+object EditorsCache {
+  private var stale = true
+  fun invalidate() {
+    stale = true
+    editorTexts.clear()
+  }
+
+  private val editorTexts = mutableMapOf<Editor, CharSequence>()
+
+  fun getText(editor: Editor) =
+    if (stale || editor !in editorTexts)
+      editor.document.immutableCharSequence
+        .let { if (AceConfig.mapToASCII) it.mapToASCII() else it }
+        .also { editorTexts[editor] = it; stale = false }
+    else editorTexts[editor]!!
+}
+
+fun CharSequence.mapToASCII() =
+  map { AnyAscii.transliterate("$it").first() }.joinToString("")

 /**
 * Returns true if [this] contains [otherText] at the specified offset.
 */
-fun CharSequence.matchesAt(selfOffset: Int, otherText: String, ignoreCase: Boolean): Boolean {
-  return this.regionMatches(selfOffset, otherText, 0, otherText.length, ignoreCase)
-}
+fun CharSequence.matchesAt(selfOffset: Int, otherText: String, ignoreCase: Boolean) =
+  regionMatches(selfOffset, otherText, 0, otherText.length, ignoreCase)

 /**
- * Calculates the length of a common prefix in [this] starting at index [selfOffset], and [otherText] starting at index 0.
+ * Calculates the length of a common prefix in [this] starting
+ * at index [selfOffset], and [otherText] starting at index 0.
 */
 fun CharSequence.countMatchingCharacters(selfOffset: Int, otherText: String): Int {
  var i = 0
@@ -38,17 +66,17 @@ fun CharSequence.countMatchingCharacters(selfOffset: Int, otherText: String): In
 * Determines which characters form a "word" for the purposes of functions below.
 */
 val Char.isWordPart
-  get() = this in 'a'..'z' || this.isJavaIdentifierPart()
+  get() = this.isJavaIdentifierPart()

 /**
 * Finds index of the first character in a word.
 */
-inline fun CharSequence.wordStart(pos: Int, isPartOfWord: (Char) -> Boolean = Char::isWordPart): Int {
+inline fun CharSequence.wordStart(
+  pos: Int, isPartOfWord: (Char) -> Boolean = Char::isWordPart
+): Int {
  var start = pos

-  while (start > 0 && isPartOfWord(this[start - 1])) {
-    --start
-  }
+  while (start > 0 && isPartOfWord(this[start - 1])) --start

  return start
 }
@@ -56,57 +84,28 @@ inline fun CharSequence.wordStart(pos: Int, isPartOfWord: (Char) -> Boolean = Ch
 /**
 * Finds index of the last character in a word.
 */
-inline fun CharSequence.wordEnd(pos: Int, isPartOfWord: (Char) -> Boolean = Char::isWordPart): Int {
+inline fun CharSequence.wordEnd(
+  pos: Int, isPartOfWord: (Char) -> Boolean = Char::isWordPart
+): Int {
  var end = pos
-  val limit = length - 1

-  while (end < limit && isPartOfWord(this[end + 1])) {
-    ++end
-  }
+  while (end < length - 1 && isPartOfWord(this[end + 1])) ++end

  return end
 }

 /**
- * Finds index of the previous "camelHumps" hump in a word.
+ * Finds index of the first word character following a sequence of non-word
+ * characters following the end of a word.
 */
-inline fun CharSequence.humpStart(pos: Int, isPartOfWord: (Char) -> Boolean = Char::isWordPart): Int {
-  var start = pos
-  
-  while (start > 0 && isPartOfWord(this[start - 1]) && !EditorActionUtil.isHumpBound(this, start, true)) {
-    --start
-  }
-  
-  return start
-}
-
-/**
- * Finds index of the next "camelHumps" hump in a word.
- */
-inline fun CharSequence.humpEnd(pos: Int, isPartOfWord: (Char) -> Boolean = Char::isWordPart): Int {
-  var end = pos
-  
-  while (end < length - 1 && isPartOfWord(this[end + 1]) && !EditorActionUtil.isHumpBound(this, end + 1, false)) {
-    ++end
-  }
-  
-  return end
-}
-
-/**
- * Finds index of the first word character following a sequence of non-word characters following the end of a word.
- */
-inline fun CharSequence.wordEndPlus(pos: Int, isPartOfWord: (Char) -> Boolean = Char::isWordPart): Int {
+inline fun CharSequence.wordEndPlus(
+  pos: Int, isPartOfWord: (Char) -> Boolean = Char::isWordPart
+): Int {
  var end = this.wordEnd(pos, isPartOfWord)
-  val limit = length - 1

-  while (end < limit && !isPartOfWord(this[end + 1])) {
-    ++end
-  }
+  while (end < length - 1 && !isPartOfWord(this[end + 1])) ++end

-  if (end < limit && isPartOfWord(this[end + 1])) {
-    ++end
-  }
+  if (end < length - 1 && isPartOfWord(this[end + 1])) ++end

  return end
 }
@@ -120,3 +119,137 @@ fun MutableMap<Editor, IntArrayList>.clone(): MutableMap<Editor, IntArrayList> {

  return clone
 }
+
+fun Editor.offsetCenter(first: Int, second: Int): LogicalPosition {
+  val firstIndexLine = offsetToLogicalPosition(first).line
+  val lastIndexLine = offsetToLogicalPosition(second).line
+  val center = (firstIndexLine + lastIndexLine) / 2
+  return offsetToLogicalPosition(getLineStartOffset(center))
+}
+
+fun Editor.getView(): IntRange {
+  val firstVisibleLine = max(0, getVisualLineAtTopOfScreen() - 1)
+  val firstLine = visualLineToLogicalLine(firstVisibleLine)
+  val startOffset = getLineStartOffset(firstLine)
+
+  val height = getScreenHeight() + 2
+  val lastLine = visualLineToLogicalLine(firstVisibleLine + height)
+  var endOffset = getLineEndOffset(lastLine, true)
+  endOffset = normalizeOffset(lastLine, endOffset)
+  endOffset = min(max(0, document.textLength - 1), endOffset + 1)
+
+  return startOffset..endOffset
+}
+
+/**
+ * Returns the offset of the start of the requested line.
+ *
+ * @param line   The logical line to get the start offset for.
+ *
+ * @return 0 if line is &lt 0, file size of line is bigger than file, else the
+ *         start offset for the line
+ */
+
+fun Editor.getLineStartOffset(line: Int) =
+  when {
+    line < 0 -> 0
+    line >= getLineCount(document) -> getFileSize()
+    else -> document.getLineStartOffset(line)
+  }
+
+/**
+ * Returns the offset of the end of the requested line.
+ *
+ * @param line     The logical line to get the end offset for
+ *
+ * @param allowEnd True include newline
+ *
+ * @return 0 if line is &lt 0, file size of line is bigger than file, else the
+ * end offset for the line
+ */
+
+fun Editor.getLineEndOffset(line: Int, allowEnd: Boolean = true) =
+  when {
+    line < 0 -> 0
+    line >= getLineCount(document) -> getFileSize(allowEnd)
+    else -> document.getLineEndOffset(line) - if (allowEnd) 0 else 1
+  }
+
+/**
+ * Gets the number of lines than can be displayed on the screen at one time.
+ * This is rounded down to the nearest whole line if there is a partial line
+ * visible at the bottom of the screen.
+ *
+ * @return The number of screen lines
+ */
+
+fun Editor.getScreenHeight() =
+  (scrollingModel.visibleArea.y + scrollingModel.visibleArea.height -
+    getVisualLineAtTopOfScreen() * lineHeight) / lineHeight
+
+
+/**
+ * This is a set of helper methods for working with editors.
+ * All line and column values are zero based.
+ */
+
+fun Editor.getVisualLineAtTopOfScreen() =
+  (scrollingModel.verticalScrollOffset + lineHeight - 1) / lineHeight
+
+/**
+ * Gets the actual number of characters in the file
+ *
+ * @param countNewLines True include newline
+ *
+ * @return The file's character count
+ */
+
+fun Editor.getFileSize(countNewLines: Boolean = false): Int {
+  val len = document.textLength
+  val doc = document.charsSequence
+  return if (countNewLines || len == 0 || doc[len - 1] != '\n') len else len - 1
+}
+
+/**
+ * Ensures that the supplied logical line is within the range 0 (incl) and the
+ * number of logical lines in the file (excl).
+ *
+ * @param line   The logical line number to normalize
+ *
+ * @return The normalized logical line number
+ */
+
+fun Editor.normalizeLine(line: Int) = max(0, min(line, getLineCount(document) - 1))
+
+/**
+ * Converts a visual line number to a logical line number.
+ *
+ * @param line   The visual line number to convert
+ *
+ * @return The logical line number
+ */
+
+fun Editor.visualLineToLogicalLine(line: Int) =
+  normalizeLine(visualToLogicalPosition(
+    VisualPosition(line.coerceAtLeast(0), 0)).line)
+
+
+/**
+ * Ensures that the supplied offset for the given logical line is within the
+ * range for the line. If allowEnd is true, the range will allow for the offset
+ * to be one past the last character on the line.
+ *
+ * @param line     The logical line number
+ *
+ * @param offset   The offset to normalize
+ *
+ * @param allowEnd true if the offset can be one past the last character on the
+ *                 line, false if not
+ *
+ * @return The normalized column number
+ */
+
+fun Editor.normalizeOffset(line: Int, offset: Int, allowEnd: Boolean = true) =
+  if (getFileSize(allowEnd) == 0) 0 else
+    max(min(offset, getLineEndOffset(line, allowEnd)), getLineStartOffset(line))
+
--- a/src/main/kotlin/org/acejump/action/AceAction.kt
+++ b/src/main/kotlin/org/acejump/action/AceAction.kt
@@ -0,0 +1,92 @@
+package org.acejump.action
+
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.actionSystem.CommonDataKeys.EDITOR
+import com.intellij.openapi.fileEditor.TextEditor
+import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx
+import com.intellij.openapi.project.DumbAwareAction
+import com.intellij.util.IncorrectOperationException
+import org.acejump.boundaries.Boundaries
+import org.acejump.boundaries.StandardBoundaries.*
+import org.acejump.input.JumpMode
+import org.acejump.input.JumpMode.*
+import org.acejump.search.Pattern
+import org.acejump.search.Pattern.*
+import org.acejump.session.Session
+import org.acejump.session.SessionManager
+
+/**
+ * Base class for keyboard-activated actions that create or update an AceJump [Session].
+ */
+sealed class AceAction: DumbAwareAction() {
+  final override fun update(action: AnActionEvent) {
+    action.presentation.isEnabled = action.getData(EDITOR) != null
+  }
+
+  final override fun actionPerformed(e: AnActionEvent) {
+    val editor = e.getData(EDITOR) ?: return
+    val project = e.project
+  
+    if (project != null) {
+      try {
+        val openEditors = FileEditorManagerEx.getInstanceEx(project).splitters.selectedEditors
+          .mapNotNull { (it as? TextEditor)?.editor }
+          .sortedBy { if (it === editor) 0 else 1 }
+        invoke(SessionManager.start(editor, openEditors))
+      } catch (e: IncorrectOperationException) {
+        invoke(SessionManager.start(editor))
+      }
+    }
+    else {
+      invoke(SessionManager.start(editor))
+    }
+  }
+  
+  abstract operator fun invoke(session: Session)
+
+  /**
+   * Generic action type that toggles a specific [JumpMode].
+   */
+  abstract class BaseToggleJumpModeAction(private val mode: JumpMode): AceAction() {
+    final override fun invoke(session: Session) = session.toggleJumpMode(mode)
+  }
+
+  /**
+   * Generic action type that starts a regex search.
+   */
+  abstract class BaseRegexSearchAction(private val pattern: Pattern, private val boundaries: Boundaries): AceAction() {
+    override fun invoke(session: Session) = session.startRegexSearch(pattern, boundaries)
+  }
+
+  /**
+   * Initiates an AceJump session in the first [JumpMode], or cycles to the next [JumpMode] as defined in configuration.
+   */
+  class ActivateOrCycleMode: AceAction() {
+    override fun invoke(session: Session) = session.cycleNextJumpMode()
+  }
+
+  /**
+   * Initiates an AceJump session in the last [JumpMode], or cycles to the previous [JumpMode] as defined in configuration.
+   */
+  class ActivateOrReverseCycleMode: AceAction() {
+    override fun invoke(session: Session) = session.cyclePreviousJumpMode()
+  }
+
+  // @formatter:off
+
+  class ToggleJumpMode        : BaseToggleJumpModeAction(JUMP)
+  class ToggleJumpEndMode     : BaseToggleJumpModeAction(JUMP_END)
+  class ToggleTargetMode      : BaseToggleJumpModeAction(TARGET)
+  class ToggleDeclarationMode : BaseToggleJumpModeAction(DECLARATION)
+
+
+  class StartAllWordsMode          : BaseRegexSearchAction(ALL_WORDS, WHOLE_FILE)
+  class StartAllWordsBackwardsMode : BaseRegexSearchAction(ALL_WORDS, BEFORE_CARET)
+  class StartAllWordsForwardMode   : BaseRegexSearchAction(ALL_WORDS, AFTER_CARET)
+  class StartAllLineStartsMode     : BaseRegexSearchAction(LINE_STARTS, WHOLE_FILE)
+  class StartAllLineEndsMode       : BaseRegexSearchAction(LINE_ENDS, WHOLE_FILE)
+  class StartAllLineIndentsMode    : BaseRegexSearchAction(LINE_INDENTS, WHOLE_FILE)
+  class StartAllLineMarksMode      : BaseRegexSearchAction(LINE_ALL_MARKS, WHOLE_FILE)
+
+  // @formatter:on
+}
--- a/src/main/kotlin/org/acejump/action/AceEditorAction.kt
+++ b/src/main/kotlin/org/acejump/action/AceEditorAction.kt
@@ -4,54 +4,63 @@ import com.intellij.openapi.actionSystem.DataContext
 import com.intellij.openapi.editor.Caret
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.editor.actionSystem.EditorActionHandler
-import org.acejump.search.Pattern
+import org.acejump.boundaries.StandardBoundaries.*
+import org.acejump.search.Pattern.*
 import org.acejump.session.Session
 import org.acejump.session.SessionManager

 /**
 * Base class for keyboard-activated overrides of existing editor actions, that have a different meaning during an AceJump [Session].
 */
-abstract class AceEditorAction(private val originalHandler: EditorActionHandler) : EditorActionHandler() {
-  final override fun isEnabledForCaret(editor: Editor, caret: Caret, dataContext: DataContext?): Boolean {
-    return SessionManager[editor] != null || originalHandler.isEnabled(editor, caret, dataContext)
-  }
+sealed class AceEditorAction(private val originalHandler: EditorActionHandler): EditorActionHandler() {
+  final override fun isEnabledForCaret(editor: Editor, caret: Caret, dataContext: DataContext?): Boolean =
+    SessionManager[editor] != null || originalHandler.isEnabled(editor, caret, dataContext)

  final override fun doExecute(editor: Editor, caret: Caret?, dataContext: DataContext?) {
    val session = SessionManager[editor]

-    if (session != null) {
-      run(session)
-    }
-    else if (originalHandler.isEnabled(editor, caret, dataContext)) {
+    if (session != null) run(session)
+    else if (originalHandler.isEnabled(editor, caret, dataContext))
      originalHandler.execute(editor, caret, dataContext)
  }
-  }

  protected abstract fun run(session: Session)

  // Actions

-  class Reset(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) {
+  class Reset(originalHandler: EditorActionHandler): AceEditorAction(originalHandler) {
    override fun run(session: Session) = session.end()
  }

-  class ClearSearch(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) {
+  class ClearSearch(originalHandler: EditorActionHandler): AceEditorAction(originalHandler) {
    override fun run(session: Session) = session.restart()
  }

-  class TagImmediately(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) {
-    override fun run(session: Session) = session.tagImmediately()
+  class SelectBackward(originalHandler: EditorActionHandler): AceEditorAction(originalHandler) {
+    override fun run(session: Session) = session.visitPreviousTag()
  }

-  class SearchLineStarts(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) {
-    override fun run(session: Session) = session.startRegexSearch(Pattern.LINE_STARTS)
+  class SelectForward(originalHandler: EditorActionHandler): AceEditorAction(originalHandler) {
+    override fun run(session: Session) = session.visitNextTag()
  }

-  class SearchLineEnds(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) {
-    override fun run(session: Session) = session.startRegexSearch(Pattern.LINE_ENDS)
+  class ScrollToNextScreenful(originalHandler: EditorActionHandler): AceEditorAction(originalHandler) {
+    override fun run(session: Session) { session.scrollToNextScreenful() }
  }

-  class SearchLineIndents(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) {
-    override fun run(session: Session) = session.startRegexSearch(Pattern.LINE_INDENTS)
+  class ScrollToPreviousScreenful(originalHandler: EditorActionHandler): AceEditorAction(originalHandler) {
+    override fun run(session: Session) { session.scrollToPreviousScreenful() }
+  }
+
+  class SearchLineStarts(originalHandler: EditorActionHandler): AceEditorAction(originalHandler) {
+    override fun run(session: Session) = session.startRegexSearch(LINE_STARTS, WHOLE_FILE)
+  }
+
+  class SearchLineEnds(originalHandler: EditorActionHandler): AceEditorAction(originalHandler) {
+    override fun run(session: Session) = session.startRegexSearch(LINE_ENDS, WHOLE_FILE)
+  }
+
+  class SearchLineIndents(originalHandler: EditorActionHandler): AceEditorAction(originalHandler) {
+    override fun run(session: Session) = session.startRegexSearch(LINE_INDENTS, WHOLE_FILE)
  }
 }
--- a/src/main/kotlin/org/acejump/action/AceKeyboardAction.kt
+++ b/src/main/kotlin/org/acejump/action/AceKeyboardAction.kt
@@ -1,81 +0,0 @@
-package org.acejump.action
-
-import com.intellij.openapi.actionSystem.AnActionEvent
-import com.intellij.openapi.actionSystem.CommonDataKeys.EDITOR
-import com.intellij.openapi.fileEditor.TextEditor
-import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx
-import com.intellij.openapi.project.DumbAwareAction
-import com.intellij.util.IncorrectOperationException
-import org.acejump.boundaries.Boundaries
-import org.acejump.boundaries.StandardBoundaries.*
-import org.acejump.search.Pattern
-import org.acejump.session.Session
-import org.acejump.session.SessionManager
-
-/**
- * Base class for keyboard-activated actions that create or update an AceJump [Session].
- */
-abstract class AceKeyboardAction : DumbAwareAction() {
-  final override fun update(action: AnActionEvent) {
-    action.presentation.isEnabled = action.getData(EDITOR) != null
-  }
-  
-  final override fun actionPerformed(e: AnActionEvent) {
-    val editor = e.getData(EDITOR) ?: return
-    val project = e.project
-    
-    if (project != null) {
-      try {
-        val openEditors = FileEditorManagerEx.getInstanceEx(project)
-          .splitters
-          .selectedEditors
-          .mapNotNull { (it as? TextEditor)?.editor }
-          .sortedBy { if (it === editor) 0 else 1 }
-        invoke(SessionManager.start(editor, openEditors))
-      } catch (e: IncorrectOperationException) {
-        invoke(SessionManager.start(editor))
-      }
-    }
-    else {
-      invoke(SessionManager.start(editor))
-    }
-  }
-  
-  abstract operator fun invoke(session: Session)
-  
-  /**
-   * Generic action type that starts a regex search.
-   */
-  abstract class BaseRegexSearchAction(private val pattern: Pattern, private val boundaries: Boundaries) : AceKeyboardAction() {
-    override fun invoke(session: Session) {
-      session.defaultBoundary = boundaries
-      session.startRegexSearch(pattern)
-    }
-  }
-  
-  /**
-   * Starts or ends an AceJump session in quick jump mode.
-   */
-  object ActivateAceJump : AceKeyboardAction() {
-    override fun invoke(session: Session) = session.startJumpMode()
-  }
-  
-  /**
-   * Starts or cycles main AceJump modes.
-   */
-  object ActivateAceJumpSpecial : AceKeyboardAction() {
-    override fun invoke(session: Session) = session.startOrCycleSpecialModes()
-  }
-  
-  // @formatter:off
-  
-  object StartAllWordsMode          : BaseRegexSearchAction(Pattern.ALL_WORDS, VISIBLE_ON_SCREEN)
-  object StartAllWordsBackwardsMode : BaseRegexSearchAction(Pattern.ALL_WORDS, BEFORE_CARET.intersection(VISIBLE_ON_SCREEN))
-  object StartAllWordsForwardMode   : BaseRegexSearchAction(Pattern.ALL_WORDS, AFTER_CARET.intersection(VISIBLE_ON_SCREEN))
-  object StartAllLineStartsMode     : BaseRegexSearchAction(Pattern.LINE_STARTS, VISIBLE_ON_SCREEN)
-  object StartAllLineEndsMode       : BaseRegexSearchAction(Pattern.LINE_ENDS, VISIBLE_ON_SCREEN)
-  object StartAllLineIndentsMode    : BaseRegexSearchAction(Pattern.LINE_INDENTS, VISIBLE_ON_SCREEN)
-  object StartAllLineMarksMode      : BaseRegexSearchAction(Pattern.LINE_ALL_MARKS, VISIBLE_ON_SCREEN)
-  
-  // @formatter:on
-}
--- a/src/main/kotlin/org/acejump/action/AceTagAction.kt
+++ b/src/main/kotlin/org/acejump/action/AceTagAction.kt
@@ -1,484 +0,0 @@
-package org.acejump.action
-
-import com.intellij.find.actions.ShowUsagesAction
-import com.intellij.openapi.actionSystem.ActionManager
-import com.intellij.openapi.actionSystem.IdeActions
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.command.CommandProcessor
-import com.intellij.openapi.command.UndoConfirmationPolicy
-import com.intellij.openapi.command.WriteCommandAction
-import com.intellij.openapi.editor.CaretState
-import com.intellij.openapi.editor.Document
-import com.intellij.openapi.editor.Editor
-import com.intellij.openapi.editor.LogicalPosition
-import com.intellij.openapi.editor.actionSystem.DocCommandGroupId
-import com.intellij.openapi.editor.actions.EditorActionUtil
-import com.intellij.openapi.fileEditor.TextEditor
-import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx
-import com.intellij.openapi.fileEditor.ex.IdeDocumentHistory
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.ui.playback.commands.ActionCommand
-import com.intellij.openapi.util.TextRange
-import com.intellij.psi.PsiDocumentManager
-import com.intellij.psi.codeStyle.CodeStyleManager
-import org.acejump.*
-import org.acejump.search.SearchProcessor
-import kotlin.math.max
-
-/**
- * Base class for actions available after typing a tag.
- */
-sealed class AceTagAction {
-  abstract operator fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int, shiftMode: Boolean, isFinal: Boolean)
-  
-  abstract class BaseJumpAction : AceTagAction() {
-    override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int, shiftMode: Boolean, isFinal: Boolean) {
-      val caretModel = editor.caretModel
-      val oldCarets = if (shiftMode) caretModel.caretsAndSelections else emptyList()
-      
-      recordCaretPosition(editor)
-      
-      if (isFinal) {
-        ensureEditorFocused(editor)
-      }
-      
-      moveCaretTo(editor, getCaretOffset(editor, searchProcessor, offset))
-      
-      if (shiftMode) {
-        caretModel.caretsAndSelections = oldCarets + caretModel.caretsAndSelections
-      }
-    }
-    
-    abstract fun getCaretOffset(editor: Editor, searchProcessor: SearchProcessor, offset: Int): Int
-  }
-  
-  abstract class BaseWordAction : BaseJumpAction() {
-    final override fun getCaretOffset(editor: Editor, searchProcessor: SearchProcessor, offset: Int): Int {
-      val matchingChars = countMatchingCharacters(editor, searchProcessor, offset)
-      val targetOffset = offset + matchingChars
-      val isInsideWord = matchingChars > 0 && editor.immutableText.let { it[targetOffset - 1].isWordPart && it[targetOffset].isWordPart }
-      
-      return getCaretOffset(editor, offset, targetOffset, isInsideWord)
-    }
-    
-    abstract fun getCaretOffset(editor: Editor, queryStartOffset: Int, queryEndOffset: Int, isInsideWord: Boolean): Int
-  }
-  
-  abstract class BaseSelectAction : AceTagAction() {
-    final override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int, shiftMode: Boolean, isFinal: Boolean) {
-      if (shiftMode) {
-        val caretModel = editor.caretModel
-        val oldCarets = caretModel.caretsAndSelections
-        val oldOffsetPosition = caretModel.logicalPosition
-        
-        invoke(editor, searchProcessor, offset)
-        
-        if (caretModel.caretsAndSelections.any { isSelectionOverlapping(oldOffsetPosition, it) }) {
-          oldCarets.removeAll { isSelectionOverlapping(oldOffsetPosition, it) }
-        }
-        
-        caretModel.caretsAndSelections = oldCarets + caretModel.caretsAndSelections
-      }
-      else {
-        invoke(editor, searchProcessor, offset)
-      }
-    }
-    
-    private fun isSelectionOverlapping(offset: LogicalPosition, oldCaret: CaretState): Boolean {
-      return oldCaret.caretPosition == offset || oldCaret.selectionStart == offset || oldCaret.selectionEnd == offset
-    }
-    
-    protected abstract operator fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int)
-  }
-  
-  abstract class BasePerCaretWriteAction(private val selector: AceTagAction) : AceTagAction() {
-    final override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int, shiftMode: Boolean, isFinal: Boolean) {
-      val oldCarets = editor.caretModel.caretsAndSelections
-      selector(editor, searchProcessor, offset, shiftMode = false, isFinal = isFinal)
-      val range = editor.selectionModel.let { TextRange(it.selectionStart, it.selectionEnd) }
-      
-      editor.caretModel.caretsAndSelections = oldCarets
-      invoke(editor, range, shiftMode)
-    }
-    
-    protected abstract operator fun invoke(editor: Editor, range: TextRange, shiftMode: Boolean)
-    
-    protected fun insertAtCarets(editor: Editor, text: String) {
-      val document = editor.document
-      
-      editor.caretModel.runForEachCaret {
-        if (it.hasSelection()) {
-          document.replaceString(it.selectionStart, it.selectionEnd, text)
-          fixIndents(editor, it.selectionStart, it.selectionEnd)
-        }
-        else {
-          document.insertString(it.offset, text)
-          fixIndents(editor, it.offset, it.offset + text.length)
-        }
-      }
-    }
-    
-    private fun fixIndents(editor: Editor, startOffset: Int, endOffset: Int) {
-      val project = editor.project ?: return
-      val document = editor.document
-      val documentManager = PsiDocumentManager.getInstance(project)
-      
-      documentManager.commitAllDocuments()
-      
-      val file = documentManager.getPsiFile(document) ?: return
-      val text = document.charsSequence
-      
-      if (startOffset > 0 && endOffset > startOffset + 1 && text[endOffset - 1] == '\n' && text[startOffset - 1] == '\n') {
-        CodeStyleManager.getInstance(project).adjustLineIndent(file, TextRange(startOffset, endOffset - 1))
-      }
-      else {
-        CodeStyleManager.getInstance(project).adjustLineIndent(file, TextRange(startOffset, endOffset))
-      }
-    }
-  }
-  
-  private companion object {
-    fun countMatchingCharacters(editor: Editor, searchProcessor: SearchProcessor, offset: Int): Int {
-      return editor.immutableText.countMatchingCharacters(offset, searchProcessor.query.rawText)
-    }
-    
-    fun recordCaretPosition(editor: Editor) = with(editor) {
-      project?.let { addCurrentPositionToHistory(it, document) }
-    }
-    
-    fun moveCaretTo(editor: Editor, offset: Int) = with(editor) {
-      selectionModel.removeSelection(true)
-      caretModel.removeSecondaryCarets()
-      caretModel.moveToOffset(offset)
-    }
-    
-    fun selectRange(editor: Editor, fromOffset: Int, toOffset: Int, cursorOffset: Int = toOffset) = with(editor) {
-      selectionModel.removeSelection(true)
-      selectionModel.setSelection(fromOffset, toOffset)
-      caretModel.moveToOffset(cursorOffset)
-    }
-    
-    fun performAction(actionName: String) {
-      val actionManager = ActionManager.getInstance()
-      val action = actionManager.getAction(actionName)
-      if (action != null) {
-        actionManager.tryToExecute(action, ActionCommand.getInputEvent(null), null, null, true)
-      }
-    }
-    
-    fun ensureEditorFocused(editor: Editor) {
-      val project = editor.project ?: return
-      val fem = FileEditorManagerEx.getInstanceEx(project)
-      
-      val window = fem.windows.firstOrNull { (it.selectedEditor?.selectedWithProvider?.fileEditor as? TextEditor)?.editor === editor }
-      if (window != null && window !== fem.currentWindow) {
-        fem.currentWindow = window
-      }
-    }
-    
-    private fun addCurrentPositionToHistory(project: Project, document: Document) {
-      CommandProcessor.getInstance().executeCommand(project, {
-        with(IdeDocumentHistory.getInstance(project)) {
-          setCurrentCommandHasMoves()
-          includeCurrentCommandAsNavigation()
-          includeCurrentPlaceAsChangePlace()
-        }
-      }, "AceJumpHistoryAppender", DocCommandGroupId.noneGroupId(document), UndoConfirmationPolicy.DO_NOT_REQUEST_CONFIRMATION, document)
-    }
-  }
-  
-  // Actions
-  
-  /**
-   * On default action, places the caret at the first character of the search query.
-   * On shift action, adds the new caret to existing carets.
-   */
-  object JumpToSearchStart : BaseJumpAction() {
-    override fun getCaretOffset(editor: Editor, searchProcessor: SearchProcessor, offset: Int): Int {
-      return offset
-    }
-  }
-  
-  /**
-   * On default action, places the caret at the last character of the search query.
-   * On shift action, adds the new caret to existing carets.
-   */
-  object JumpToSearchEnd : BaseJumpAction() {
-    override fun getCaretOffset(editor: Editor, searchProcessor: SearchProcessor, offset: Int): Int {
-      return offset + max(0, countMatchingCharacters(editor, searchProcessor, offset) - 1)
-    }
-  }
-  
-  /**
-   * On default action, places the caret just past the last character of the search query.
-   * On shift action, adds the new caret to existing carets.
-   */
-  object JumpPastSearchEnd : BaseJumpAction() {
-    override fun getCaretOffset(editor: Editor, searchProcessor: SearchProcessor, offset: Int): Int {
-      return offset + countMatchingCharacters(editor, searchProcessor, offset)
-    }
-  }
-  
-  /**
-   * On default action, places the caret at the start of a word. Word detection uses [Character.isJavaIdentifierPart] to count some special
-   * characters, such as underscores, as part of a word. If there is no word at the last character of the search query, then the caret is
-   * placed at the first character of the search query.
-   *
-   * On shift action, adds the new caret to existing carets.
-   */
-  object JumpToWordStart : BaseWordAction() {
-    override fun getCaretOffset(editor: Editor, queryStartOffset: Int, queryEndOffset: Int, isInsideWord: Boolean): Int {
-      return if (isInsideWord)
-        editor.immutableText.wordStart(queryEndOffset)
-      else
-        queryStartOffset
-    }
-  }
-  
-  /**
-   * On default action, places the caret at the end of a word. Word detection uses [Character.isJavaIdentifierPart] to count some special
-   * characters, such as underscores, as part of a word. If there is no word at the last character of the search query, then the caret is
-   * placed after the last character of the search query.
-   *
-   * On shift action, adds the new caret to existing carets.
-   */
-  object JumpToWordEnd : BaseWordAction() {
-    override fun getCaretOffset(editor: Editor, queryStartOffset: Int, queryEndOffset: Int, isInsideWord: Boolean): Int {
-      return if (isInsideWord)
-        editor.immutableText.wordEnd(queryEndOffset) + 1
-      else
-        queryEndOffset
-    }
-  }
-  
-  /**
-   * On default action, places the caret at the end of the line.
-   * On shift action, adds the new caret to existing carets.
-   */
-  object JumpToLineEnd : BaseWordAction() {
-    override fun getCaretOffset(editor: Editor, queryStartOffset: Int, queryEndOffset: Int, isInsideWord: Boolean): Int {
-      val document = editor.document
-      val line = document.getLineNumber(queryEndOffset)
-      return document.getLineEndOffset(line)
-    }
-  }
-  
-  /**
-   * On default action, selects all characters covered by the search query.
-   * On shift action, adds the new selection to existing selections.
-   */
-  object SelectQuery : BaseSelectAction() {
-    override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int) {
-      recordCaretPosition(editor)
-      
-      val startOffset = JumpToSearchStart.getCaretOffset(editor, searchProcessor, offset)
-      val endOffset = JumpPastSearchEnd.getCaretOffset(editor, searchProcessor, offset)
-      
-      selectRange(editor, startOffset, endOffset)
-    }
-  }
-  
-  /**
-   * On default action, places the caret at the end of a word, and also selects the entire word. Word detection uses
-   * [Character.isJavaIdentifierPart] to count some special characters, such as underscores, as part of a word. If there is no word at the
-   * last character of the search query, then the caret is placed after the last character of the search query, and all text between the
-   * start and end of the search query is selected.
-   *
-   * On shift action, adds the new selection to existing selections.
-   */
-  object SelectWord : BaseSelectAction() {
-    override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int) {
-      val chars = editor.immutableText
-      val queryEndOffset = JumpToSearchEnd.getCaretOffset(editor, searchProcessor, offset)
-      
-      if (chars[queryEndOffset].isWordPart) {
-        recordCaretPosition(editor)
-        
-        val startOffset = JumpToWordStart.getCaretOffset(editor, offset, queryEndOffset, isInsideWord = true)
-        val endOffset = JumpToWordEnd.getCaretOffset(editor, offset, queryEndOffset, isInsideWord = true)
-        
-        selectRange(editor, startOffset, endOffset)
-      }
-      else {
-        SelectQuery(editor, searchProcessor, offset, shiftMode = false, isFinal = true)
-      }
-    }
-  }
-  
-  /**
-   * On default action, places the caret at the end of a camel hump inside a word, and also selects the hump. If there is no word at the
-   * last character of the search query, then the search query is selected. See [SelectWord] and [SelectQuery] for details.
-   *
-   * On shift action, adds the new selection to existing selections.
-   */
-  object SelectHump : BaseSelectAction() {
-    override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int) {
-      val chars = editor.immutableText
-      val queryEndOffset = JumpToSearchEnd.getCaretOffset(editor, searchProcessor, offset)
-      
-      if (chars[queryEndOffset].isWordPart) {
-        recordCaretPosition(editor)
-        
-        val startOffset = chars.humpStart(queryEndOffset)
-        val endOffset = chars.humpEnd(queryEndOffset) + 1
-        
-        selectRange(editor, startOffset, endOffset)
-      }
-      else {
-        SelectQuery(editor, searchProcessor, offset, shiftMode = false, isFinal = true)
-      }
-    }
-  }
-  
-  /**
-   * On default action, selects the line at the tag, excluding the indent.
-   * On shift action, adds the new selection to existing selections.
-   */
-  object SelectLine : BaseSelectAction() {
-    override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int) {
-      JumpToSearchEnd(editor, searchProcessor, offset, shiftMode = false, isFinal = true)
-      
-      val document = editor.document
-      val line = editor.caretModel.logicalPosition.line
-      val lineStart = EditorActionUtil.findFirstNonSpaceOffsetOnTheLine(document, line)
-      val lineEnd = document.getLineEndOffset(line)
-      
-      selectRange(editor, lineStart, lineEnd)
-    }
-  }
-  
-  /**
-   * On default action, places the caret at the last character of the search query, and then performs Extend Selection a set amount of
-   * times.
-   *
-   * On shift action, adds the new selection to existing selections.
-   */
-  class SelectExtended(private val extendCount: Int) : BaseSelectAction() {
-    override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int) {
-      JumpToSearchEnd(editor, searchProcessor, offset, shiftMode = false, isFinal = true)
-      
-      repeat(extendCount) {
-        performAction(IdeActions.ACTION_EDITOR_SELECT_WORD_AT_CARET)
-      }
-    }
-  }
-  
-  /**
-   * On default action, selects the range between the caret and a position decided by the provided [BaseJumpAction].
-   * On shift action, adds the new selection to existing selections.
-   */
-  class SelectToCaret(private val jumper: BaseJumpAction) : BaseSelectAction() {
-    override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int) {
-      val caretModel = editor.caretModel
-      val oldOffset = caretModel.offset
-      val oldSelection = editor.selectionModel.takeIf { it.hasSelection(false) }?.let { it.selectionStart..it.selectionEnd }
-  
-      jumper(editor, searchProcessor, offset, shiftMode = false, isFinal = true)
-      
-      val newOffset = caretModel.offset
-      
-      if (oldSelection == null) {
-        selectRange(editor, oldOffset, newOffset)
-      }
-      else {
-        selectRange(editor, minOf(oldOffset, newOffset, oldSelection.first), maxOf(oldOffset, newOffset, oldSelection.last), newOffset)
-      }
-    }
-  }
-  
-  /**
-   * On default action, selects the range between [firstOffset] and a position decided by the provided [BaseJumpAction].
-   * On shift action, adds the new selection to existing selections.
-   */
-  class SelectBetweenPoints(private val firstOffset: Int, private val secondOffsetJumper: BaseJumpAction) : BaseSelectAction() {
-    override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int) {
-      secondOffsetJumper(editor, searchProcessor, offset, shiftMode = false, isFinal = true)
-      selectRange(editor, firstOffset, editor.caretModel.offset)
-    }
-  }
-  
-  /**
-   * Selects text based on the provided [selector] action and clones it at every existing caret, selecting the cloned text. If a caret
-   * has a selection, the selected text will be replaced.
-   */
-  class CloneToCaret(selector: AceTagAction) : BasePerCaretWriteAction(selector) {
-    override fun invoke(editor: Editor, range: TextRange, shiftMode: Boolean) {
-      WriteCommandAction.writeCommandAction(editor.project).withName("AceJump Clone").run<Throwable> {
-        insertAtCarets(editor, editor.document.getText(range))
-      }
-    }
-  }
-  
-  /**
-   * Selects text based on the provided [selector] action and clones it to every existing caret, selecting the cloned text and deleting
-   * the original. If a caret has a selection, the selected text will be replaced.
-   */
-  open class MoveToCaret(selector: AceTagAction) : BasePerCaretWriteAction(selector) {
-    override fun invoke(editor: Editor, range: TextRange, shiftMode: Boolean) {
-      val difference = if (shiftMode) editor.caretModel.caretsAndSelections.sumBy {
-        val start = it.selectionStart?.let(editor::logicalPositionToOffset)
-        val end = it.selectionEnd?.let(editor::logicalPositionToOffset)
-        if (start == null || end == null || end > range.endOffset) 0 else range.length - (end - start)
-      } else 0
-      
-      WriteCommandAction.writeCommandAction(editor.project).withName("AceJump Move").run<Throwable> {
-        val document = editor.document
-        val text = document.getText(range)
-        document.deleteString(range.startOffset, range.endOffset)
-        insertAtCarets(editor, text)
-      }
-      
-      if (shiftMode) {
-        editor.selectionModel.removeSelection(true)
-        editor.caretModel.moveToOffset(range.startOffset + difference)
-      }
-    }
-  }
-  
-  /**
-   * On default action, performs the Go To Declaration action, available via `Navigate | Declaration or Usages`.
-   * On shift action, performs the Go To Type Declaration action, available via `Navigate | Type Declaration`.
-   * Always places the caret at the start of the word.
-   */
-  object GoToDeclaration : AceTagAction() {
-    override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int, shiftMode: Boolean, isFinal: Boolean) {
-      JumpToWordStart(editor, searchProcessor, offset, shiftMode = false, isFinal = isFinal)
-      ApplicationManager.getApplication().invokeLater { performAction(if (shiftMode) IdeActions.ACTION_GOTO_TYPE_DECLARATION else IdeActions.ACTION_GOTO_DECLARATION) }
-    }
-  }
-  
-  /**
-   * On default action, performs the Show Usages action, available via the context menu.
-   * On shift action, performs the Find Usages action, available via the context menu.
-   * Always places the caret at the start of the word.
-   */
-  object ShowUsages : AceTagAction() {
-    override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int, shiftMode: Boolean, isFinal: Boolean) {
-      JumpToWordStart(editor, searchProcessor, offset, shiftMode = false, isFinal = isFinal)
-      ApplicationManager.getApplication().invokeLater { performAction(if (shiftMode) IdeActions.ACTION_FIND_USAGES else ShowUsagesAction.ID) }
-    }
-  }
-  
-  /**
-   * Performs the Show Context Actions action, available via the context menu or Alt+Enter.
-   * Always places the caret at the start of the word.
-   */
-  object ShowIntentions : AceTagAction() {
-    override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int, shiftMode: Boolean, isFinal: Boolean) {
-      JumpToWordStart(editor, searchProcessor, offset, shiftMode = false, isFinal = isFinal)
-      ApplicationManager.getApplication().invokeLater { performAction(IdeActions.ACTION_SHOW_INTENTION_ACTIONS) }
-    }
-  }
-  
-  /**
-   * On default action, performs the Refactor This action, available via the main menu.
-   * On shift action, performs the Rename... refactoring, available via the main menu.
-   * Always places the caret at the start of the word.
-   */
-  object Refactor : AceTagAction() {
-    override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int, shiftMode: Boolean, isFinal: Boolean) {
-      JumpToWordStart(editor, searchProcessor, offset, shiftMode = false, isFinal = isFinal)
-      ApplicationManager.getApplication().invokeLater { performAction(if (shiftMode) IdeActions.ACTION_RENAME else "Refactorings.QuickListPopupAction") }
-    }
-  }
-}
--- a/src/main/kotlin/org/acejump/action/AceVimAction.kt
+++ b/src/main/kotlin/org/acejump/action/AceVimAction.kt
@@ -1,148 +0,0 @@
-package org.acejump.action
-
-import org.acejump.boundaries.Boundaries
-import org.acejump.boundaries.StandardBoundaries.AFTER_CARET
-import org.acejump.boundaries.StandardBoundaries.BEFORE_CARET
-import org.acejump.boundaries.StandardBoundaries.VISIBLE_ON_SCREEN
-import org.acejump.modes.ActionMode
-import org.acejump.modes.VimJumpMode
-import org.acejump.search.Pattern
-import org.acejump.session.Session
-
-sealed class AceVimAction : AceKeyboardAction() {
-  protected abstract val boundary: Boundaries
-  
-  final override fun invoke(session: Session) {
-    session.defaultBoundary = boundary
-    start(session)
-  }
-  
-  protected open fun start(session: Session) {
-    session.startJumpMode(::VimJumpMode)
-  }
-  
-  class JumpToChar : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN
-  }
-  
-  class JumpToCharAfterCaret : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN.intersection(AFTER_CARET)
-  }
-  
-  class JumpToCharBeforeCaret : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN.intersection(BEFORE_CARET)
-  }
-  
-  class LWordsAfterCaret : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN.intersection(AFTER_CARET)
-    override fun start(session: Session) {
-      super.start(session)
-      session.startRegexSearch(Pattern.VIM_LWORD)
-    }
-  }
-  
-  class UWordsAfterCaret : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN.intersection(AFTER_CARET)
-    override fun start(session: Session) {
-      super.start(session)
-      session.startRegexSearch(Pattern.VIM_UWORD)
-    }
-  }
-  
-  class LWordsBeforeCaret : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN.intersection(BEFORE_CARET)
-    override fun start(session: Session) {
-      super.start(session)
-      session.startRegexSearch(Pattern.VIM_LWORD)
-    }
-  }
-  
-  class UWordsBeforeCaret : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN.intersection(BEFORE_CARET)
-    override fun start(session: Session) {
-      super.start(session)
-      session.startRegexSearch(Pattern.VIM_UWORD)
-    }
-  }
-  
-  class LWordEndsAfterCaret : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN.intersection(AFTER_CARET)
-    override fun start(session: Session) {
-      super.start(session)
-      session.startRegexSearch(Pattern.VIM_LWORD_END)
-    }
-  }
-  
-  class UWordEndsAfterCaret : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN.intersection(AFTER_CARET)
-    override fun start(session: Session) {
-      super.start(session)
-      session.startRegexSearch(Pattern.VIM_UWORD_END)
-    }
-  }
-  
-  class LWordEndsBeforeCaret : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN.intersection(BEFORE_CARET)
-    override fun start(session: Session) {
-      super.start(session)
-      session.startRegexSearch(Pattern.VIM_LWORD_END)
-    }
-  }
-  
-  class UWordEndsBeforeCaret : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN.intersection(BEFORE_CARET)
-    override fun start(session: Session) {
-      super.start(session)
-      session.startRegexSearch(Pattern.VIM_UWORD_END)
-    }
-  }
-  
-  class GoToDeclaration : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN
-    override fun start(session: Session) {
-      session.startJumpMode { ActionMode(AceTagAction.GoToDeclaration, shiftMode = false) }
-    }
-  }
-  
-  class GoToTypeDeclaration : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN
-    override fun start(session: Session) {
-      session.startJumpMode { ActionMode(AceTagAction.GoToDeclaration, shiftMode = true) }
-    }
-  }
-  
-  class ShowIntentions : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN
-    override fun start(session: Session) {
-      session.startJumpMode { ActionMode(AceTagAction.ShowIntentions, shiftMode = false) }
-    }
-  }
-  
-  class ShowUsages : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN
-    override fun start(session: Session) {
-      session.startJumpMode { ActionMode(AceTagAction.ShowUsages, shiftMode = false) }
-    }
-  }
-  
-  class FindUsages : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN
-    override fun start(session: Session) {
-      session.startJumpMode { ActionMode(AceTagAction.ShowUsages, shiftMode = true) }
-    }
-  }
-  
-  class Refactor : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN
-    override fun start(session: Session) {
-      session.startJumpMode { ActionMode(AceTagAction.Refactor, shiftMode = false) }
-    }
-  }
-  
-  class Rename : AceVimAction() {
-    override val boundary = VISIBLE_ON_SCREEN
-    override fun start(session: Session) {
-      session.startJumpMode { ActionMode(AceTagAction.Refactor, shiftMode = true) }
-    }
-  }
-}
--- a/src/main/kotlin/org/acejump/action/TagJumper.kt
+++ b/src/main/kotlin/org/acejump/action/TagJumper.kt
@@ -0,0 +1,125 @@
+package org.acejump.action
+
+import com.intellij.openapi.actionSystem.*
+import com.intellij.openapi.actionSystem.IdeActions.*
+import com.intellij.openapi.command.CommandProcessor
+import com.intellij.openapi.command.UndoConfirmationPolicy
+import com.intellij.openapi.editor.Document
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.editor.actionSystem.DocCommandGroupId
+import com.intellij.openapi.fileEditor.TextEditor
+import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx
+import com.intellij.openapi.fileEditor.ex.IdeDocumentHistory
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.ui.playback.commands.ActionCommand
+import org.acejump.*
+import org.acejump.input.JumpMode
+import org.acejump.input.JumpMode.*
+import org.acejump.search.SearchProcessor
+import org.acejump.search.Tag
+
+/**
+ * Performs [JumpMode] navigation and actions.
+ */
+internal class TagJumper(private val mode: JumpMode, private val searchProcessor: SearchProcessor?) {
+  /**
+   * Moves caret to a specific offset in the editor according to the positioning and selection rules of the current [JumpMode].
+   */
+  fun visit(tag: Tag) {
+    val editor = tag.editor
+    val offset = tag.offset
+    
+    if (mode === JUMP_END || mode === TARGET) {
+      val chars = editor.immutableText
+      val matchingChars = searchProcessor?.let { chars.countMatchingCharacters(offset, it.query.rawText) } ?: 0
+      val targetOffset = offset + matchingChars
+      val isInsideWord = matchingChars > 0 && chars[targetOffset - 1].isWordPart && chars[targetOffset].isWordPart
+      val finalTargetOffset = if (isInsideWord) chars.wordEnd(targetOffset) + 1 else targetOffset
+
+      if (mode === JUMP_END) {
+        moveCaretTo(editor, finalTargetOffset)
+      } else if (mode === TARGET) {
+        if (isInsideWord) {
+          selectRange(editor, chars.wordStart(targetOffset), finalTargetOffset)
+        } else {
+          selectRange(editor, offset, finalTargetOffset)
+        }
+      }
+    } else {
+      moveCaretTo(editor, offset)
+    }
+  }
+
+  /**
+   * Updates caret and selection by [visit]ing a specific offset in the editor, and applying session-finalizing [JumpMode] actions such as
+   * using the Go To Declaration action, or selecting text between caret and target offset/word if Shift was held during the jump.
+   */
+  fun jump(tag: Tag, shiftMode: Boolean, isCrossEditor: Boolean) {
+    val editor = tag.editor
+    val oldOffset = editor.caretModel.offset
+
+    visit(tag)
+
+    if (mode === DECLARATION) {
+      performAction(ActionManager.getInstance().getAction(if (shiftMode) ACTION_GOTO_TYPE_DECLARATION else ACTION_GOTO_DECLARATION))
+      return
+    }
+
+    if (shiftMode && !isCrossEditor) {
+      val newOffset = editor.caretModel.offset
+
+      if (mode === TARGET) {
+        selectRange(
+          editor, oldOffset, when {
+            newOffset < oldOffset -> editor.selectionModel.selectionStart
+            else -> editor.selectionModel.selectionEnd
+          }
+        )
+      } else {
+        selectRange(editor, oldOffset, newOffset)
+      }
+    }
+  }
+
+  private companion object {
+    private fun moveCaretTo(editor: Editor, offset: Int) = with(editor) {
+      ensureEditorFocused(this)
+      project?.let { addCurrentPositionToHistory(it, document) }
+      selectionModel.removeSelection(true)
+      caretModel.moveToOffset(offset)
+    }
+
+    private fun selectRange(editor: Editor, fromOffset: Int, toOffset: Int) = with(editor) {
+      ensureEditorFocused(this)
+      selectionModel.removeSelection(true)
+      selectionModel.setSelection(fromOffset, toOffset)
+      caretModel.moveToOffset(toOffset)
+    }
+  
+    private fun ensureEditorFocused(editor: Editor) {
+      val project = editor.project ?: return
+      val fem = FileEditorManagerEx.getInstanceEx(project)
+    
+      val window = fem.windows.firstOrNull { (it.selectedEditor?.selectedWithProvider?.fileEditor as? TextEditor)?.editor === editor }
+      if (window != null && window !== fem.currentWindow) {
+        fem.currentWindow = window
+      }
+    }
+
+    private fun addCurrentPositionToHistory(project: Project, document: Document) {
+      CommandProcessor.getInstance().executeCommand(
+        project, {
+          with(IdeDocumentHistory.getInstance(project)) {
+            setCurrentCommandHasMoves()
+            includeCurrentCommandAsNavigation()
+            includeCurrentPlaceAsChangePlace()
+          }
+        }, "AceJumpHistoryAppender", DocCommandGroupId.noneGroupId(document),
+        UndoConfirmationPolicy.DO_NOT_REQUEST_CONFIRMATION, document
+      )
+    }
+
+    private fun performAction(action: AnAction) = ActionManager.getInstance()
+      .tryToExecute(action, ActionCommand.getInputEvent(null), null, null, true)
+  }
+}
--- a/src/main/kotlin/org/acejump/action/TagScroller.kt
+++ b/src/main/kotlin/org/acejump/action/TagScroller.kt
@@ -0,0 +1,64 @@
+package org.acejump.action
+
+import com.intellij.openapi.editor.*
+import org.acejump.*
+import org.acejump.search.SearchProcessor
+
+internal class TagScroller(private val editor: Editor, private val searchProcessor: SearchProcessor) {
+  fun scroll(forward: Boolean = true): Boolean {
+    val position = if (forward) findNextPosition() else findPreviousPosition()
+    return if (position != null) true.also { scrollTo(position) } else false
+  }
+
+  private fun scrollTo(position: LogicalPosition) = editor.run {
+    scrollingModel.disableAnimation()
+    scrollingModel.scrollTo(position, ScrollType.CENTER)
+
+    val firstInView = textMatches.first { it in editor.getView() }
+    val horizontalOffset = offsetToLogicalPosition(firstInView).column
+    if (horizontalOffset > scrollingModel.visibleArea.width)
+      scrollingModel.scrollHorizontally(horizontalOffset)
+  }
+
+  val textMatches by lazy { searchProcessor.results[editor]!! }
+
+  private fun findPreviousPosition(): LogicalPosition? {
+    val prevIndex = textMatches.toList().dropLastWhile { it > editor.getView().first }
+      .lastOrNull() ?: textMatches.lastOrNull() ?: return null
+
+    val prevLineNum = editor.offsetToLogicalPosition(prevIndex).line
+
+    // Try to capture as many previous results as will fit in a screenful
+    fun maximizeCoverageOfPreviousOccurrence(): LogicalPosition {
+      val minVisibleLine = prevLineNum - editor.getScreenHeight()
+      val firstVisibleIndex = editor.getLineStartOffset(minVisibleLine)
+      val firstIndex = textMatches.dropWhile { it < firstVisibleIndex }.first()
+      return editor.offsetCenter(firstIndex, prevIndex)
+    }
+
+    return maximizeCoverageOfPreviousOccurrence()
+  }
+
+  /**
+   * Returns the center of the next set of results that will fit in the editor.
+   * [textMatches] must be sorted prior to using Scroller. If [textMatches] have
+   * not previously been sorted, the result of calling this method is undefined.
+   */
+
+  private fun findNextPosition(): LogicalPosition? {
+    val nextIndex = textMatches.dropWhile { it <= editor.getView().last }
+      .firstOrNull() ?: textMatches.firstOrNull() ?: return null
+
+    val nextLineNum = editor.offsetToLogicalPosition(nextIndex).line
+
+    // Try to capture as many subsequent results as will fit in a screenful
+    fun maximizeCoverageOfNextOccurrence(): LogicalPosition {
+      val maxVisibleLine = nextLineNum + editor.getScreenHeight()
+      val lastVisibleIndex = editor.getLineEndOffset(maxVisibleLine, true)
+      val lastIndex = textMatches.toList().dropLastWhile { it > lastVisibleIndex }.last()
+      return editor.offsetCenter(nextIndex, lastIndex)
+    }
+
+    return maximizeCoverageOfNextOccurrence()
+  }
+}
--- a/src/main/kotlin/org/acejump/action/TagVisitor.kt
+++ b/src/main/kotlin/org/acejump/action/TagVisitor.kt
@@ -0,0 +1,70 @@
+package org.acejump.action
+
+import com.intellij.openapi.editor.*
+import com.intellij.openapi.editor.ScrollType.*
+import org.acejump.*
+import org.acejump.search.SearchProcessor
+import org.acejump.search.Tag
+import kotlin.math.abs
+
+/**
+ * Enables navigation between currently active tags.
+ */
+internal class TagVisitor(private val editor: Editor, private val searchProcessor: SearchProcessor, private val tagJumper: TagJumper) {
+  /**
+   * Places caret at the closest tag following the caret position, according
+   * to the rules of the current jump mode (see [TagJumper.visit]).
+   * If the caret is at or past the last tag, it moves to the first tag instead.
+   * If there is only one tag, it immediately performs the jump action as described in [TagJumper.jump].
+   */
+  fun visitNext(): Boolean =
+    visit(SelectionModel::getSelectionEnd) { if (it < 0) -it - 1 else it + 1 }
+
+  /**
+   * Places caret at the closest tag preceding the caret position, according to
+   * the rules of the current jump mode (see [TagJumper.visit]).
+   * If the caret is at or before the first tag, it moves to the last tag instead.
+   * If there is only one tag, it immediately performs the jump action as described in [TagJumper.jump].
+   */
+  fun visitPrevious(): Boolean =
+    visit(SelectionModel::getSelectionStart) { if (it < 0) -it - 2 else it - 1 }
+
+  /**
+   * Scrolls to the closest result to the caret.
+   */
+  fun scrollToClosest() {
+    val caret = editor.caretModel.offset
+    val results = searchProcessor.results[editor].takeUnless { it.isNullOrEmpty() } ?: return
+    val index = results.binarySearch(caret).let { if (it < 0) -it - 1 else it }
+
+    val targetOffset = listOfNotNull(
+      results.getOrNull(index - 1),
+      results.getOrNull(index)
+    ).minByOrNull { abs(it - caret) }
+
+    if (targetOffset != null)
+      editor.scrollingModel.scrollTo(editor.offsetToLogicalPosition(targetOffset), RELATIVE)
+  }
+
+  private inline fun visit(caretPosition: SelectionModel.() -> Int, indexModifier: (Int) -> Int): Boolean {
+    val results = searchProcessor.results[editor].takeUnless { it.isNullOrEmpty() } ?: return false
+    val nextIndex = indexModifier(results.binarySearch(caretPosition(editor.selectionModel)))
+
+    val targetOffset = results.getInt(
+      when {
+        nextIndex < 0 -> results.lastIndex
+        nextIndex > results.lastIndex -> 0
+        else -> nextIndex
+      }
+    )
+
+    val onlyResult = results.size == 1
+
+    if (onlyResult) tagJumper.jump(Tag(editor, targetOffset), shiftMode = false, isCrossEditor = false)
+    else tagJumper.visit(Tag(editor, targetOffset))
+
+    editor.scrollingModel.scrollToCaret(RELATIVE)
+    return onlyResult
+  }
+
+}
--- a/src/main/kotlin/org/acejump/boundaries/Boundaries.kt
+++ b/src/main/kotlin/org/acejump/boundaries/Boundaries.kt
@@ -5,14 +5,16 @@ import kotlin.math.max
 import kotlin.math.min

 /**
- * Defines a (possibly) disjoint set of editor offsets that partitions the whole editor into two groups - offsets inside the range, and
+ * Defines a (possibly) disjoint set of editor offsets that partitions
+ * the whole editor into two groups - offsets inside the range, and
 * offsets outside the range.
 */
 interface Boundaries {
  /**
-   * Returns a range of editor offsets, starting at the first offset in the boundary, and ending at the last offset in the boundary.
-   * May include offsets outside the boundary, for ex. when the boundary is rectangular and the file has long lines which are only
-   * partially visible.
+   * Returns a range of editor offsets, starting at the first offset in the
+   * boundary, and ending at the last offset in the boundary. May include
+   * offsets outside the boundary, for ex. when the boundary is rectangular
+   * and the file has long lines which are only partially visible.
   */
  fun getOffsetRange(editor: Editor, cache: EditorOffsetCache = EditorOffsetCache.Uncached): IntRange

@@ -22,23 +24,19 @@ interface Boundaries {
  fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache = EditorOffsetCache.Uncached): Boolean

  /**
-   * Creates a boundary so that an offset/range is within the boundary iff it is within both original boundaries.
+   * Creates a boundary so that an offset/range is within the boundary
+   * iff it is within both original boundaries.
   */
-  fun intersection(other: Boundaries): Boundaries {
-    if (this === other) {
-      return this
-    }
-    
-    return object : Boundaries {
+  fun intersection(other: Boundaries): Boundaries =
+    if (this === other) this
+    else object: Boundaries {
      override fun getOffsetRange(editor: Editor, cache: EditorOffsetCache): IntRange {
        val b1 = this@Boundaries.getOffsetRange(editor, cache)
        val b2 = other.getOffsetRange(editor, cache)
        return max(b1.first, b2.first)..min(b1.last, b2.last)
      }

-      override fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache): Boolean {
-        return this@Boundaries.isOffsetInside(editor, offset, cache) && other.isOffsetInside(editor, offset, cache)
-      }
-    }
+      override fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache): Boolean =
+        this@Boundaries.isOffsetInside(editor, offset, cache) && other.isOffsetInside(editor, offset, cache)
    }
 }
--- a/src/main/kotlin/org/acejump/boundaries/EditorOffsetCache.kt
+++ b/src/main/kotlin/org/acejump/boundaries/EditorOffsetCache.kt
@@ -6,11 +6,13 @@ import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap
 import java.awt.Point

 /**
- * Optionally caches slow operations of (1) retrieving the currently visible editor area, and (2) converting between editor offsets and
+ * Optionally caches slow operations of (1) retrieving the currently
+ * visible editor area, and (2) converting between editor offsets and
 * pixel coordinates.
 *
- * To avoid unnecessary overhead, there is no automatic detection of when the editor, its contents, or its visible area has changed, so the
- * cache must only be used for a single rendered frame of a single [Editor].
+ * To avoid unnecessary overhead, there is no automatic detection of when
+ * the editor, its contents, or its visible area has changed, so the cache
+ * must only be used for a single rendered frame of a single [Editor].
 */
 sealed class EditorOffsetCache {
  /**
@@ -29,63 +31,47 @@ sealed class EditorOffsetCache {
  abstract fun offsetToXY(editor: Editor, offset: Int): Point

  companion object {
-    fun new(): EditorOffsetCache {
-      return Cache()
-    }
+    fun new(): EditorOffsetCache = Cache()
  }

-  private class Cache : EditorOffsetCache() {
+  private class Cache: EditorOffsetCache() {
    private var visibleArea: Pair<Point, Point>? = null
    private val pointToOffset = Object2IntOpenHashMap<Point>().apply { defaultReturnValue(-1) }
    private val offsetToPoint = Int2ObjectOpenHashMap<Point>()

-    override fun visibleArea(editor: Editor): Pair<Point, Point> {
-      return visibleArea ?: Uncached.visibleArea(editor).also { visibleArea = it }
-    }
+    override fun visibleArea(editor: Editor): Pair<Point, Point> =
+      visibleArea ?: Uncached.visibleArea(editor).also { visibleArea = it }

-    override fun xyToOffset(editor: Editor, pos: Point): Int {
-      val offset = pointToOffset.getInt(pos)
-      
-      if (offset != -1) {
-        return offset
-      }
-      
-      return Uncached.xyToOffset(editor, pos).also {
+    override fun xyToOffset(editor: Editor, pos: Point): Int =
+      pointToOffset.getInt(pos).let { offset ->
+        if (offset != -1) offset
+        else Uncached.xyToOffset(editor, pos).also {
          @Suppress("ReplacePutWithAssignment")
          pointToOffset.put(pos, it)
        }
      }

-    override fun offsetToXY(editor: Editor, offset: Int): Point {
-      val pos = offsetToPoint.get(offset)
-      
-      if (pos != null) {
-        return pos
-      }
-      
-      return Uncached.offsetToXY(editor, offset).also {
+    override fun offsetToXY(editor: Editor, offset: Int) =
+      offsetToPoint.get(offset) ?: Uncached.offsetToXY(editor, offset).also {
        @Suppress("ReplacePutWithAssignment")
        offsetToPoint.put(offset, it)
      }
  }
+
+  object Uncached: EditorOffsetCache() {
+    override fun visibleArea(editor: Editor): Pair<Point, Point> =
+      editor.scrollingModel.visibleArea.let { visibleRect ->
+        Pair(
+          visibleRect.location, visibleRect.location.apply {
+            translate(visibleRect.width, visibleRect.height)
          }
-  
-  object Uncached : EditorOffsetCache() {
-    override fun visibleArea(editor: Editor): Pair<Point, Point> {
-      val visibleRect = editor.scrollingModel.visibleArea
-      
-      return Pair(
-        visibleRect.location,
-        visibleRect.location.apply { translate(visibleRect.width, visibleRect.height) }
        )
      }

-    override fun xyToOffset(editor: Editor, pos: Point): Int {
-      return editor.logicalPositionToOffset(editor.xyToLogicalPosition(pos))
-    }
+    override fun xyToOffset(editor: Editor, pos: Point): Int =
+      editor.logicalPositionToOffset(editor.xyToLogicalPosition(pos))

-    override fun offsetToXY(editor: Editor, offset: Int): Point {
-      return editor.offsetToXY(offset, true, false)
-    }
+    override fun offsetToXY(editor: Editor, offset: Int): Point =
+      editor.offsetToXY(offset, true, false)
  }
 }
--- a/src/main/kotlin/org/acejump/boundaries/StandardBoundaries.kt
+++ b/src/main/kotlin/org/acejump/boundaries/StandardBoundaries.kt
@@ -3,6 +3,14 @@ package org.acejump.boundaries
 import com.intellij.openapi.editor.Editor

 enum class StandardBoundaries : Boundaries {
+  WHOLE_FILE {
+    override fun getOffsetRange(editor: Editor, cache: EditorOffsetCache) =
+      0 until editor.document.textLength
+    
+    override fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache) =
+      offset in (0 until editor.document.textLength)
+  },
+  
  VISIBLE_ON_SCREEN {
    override fun getOffsetRange(editor: Editor, cache: EditorOffsetCache): IntRange {
      val (topLeft, bottomRight) = cache.visibleArea(editor)
@@ -13,16 +21,15 @@ enum class StandardBoundaries : Boundaries {
    }
    
    override fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache): Boolean {
-      
-      // If we are not using a cache, calling getOffsetRange will cause additional 1-2 pixel coordinate -> offset lookups, which is a lot
+      // If we are not using a cache, calling getOffsetRange will cause
+      // additional 1-2 pixel coordinate -> offset lookups, which is a lot
      // more expensive than one lookup compared against the visible area.
      
-      // However, if we are using a cache, it's likely that the topmost and bottommost positions are already cached whereas the provided
-      // offset isn't, so we save a lookup for every offset outside the range.
+      // However, if we are using a cache, it's likely that the topmost and
+      // bottommost positions are already cached whereas the provided offset
+      // isn't, so we save a lookup for every offset outside the range.
      
-      if (cache !== EditorOffsetCache.Uncached && offset !in getOffsetRange(editor, cache)) {
-        return false
-      }
+      if (cache !== EditorOffsetCache.Uncached && offset !in getOffsetRange(editor, cache)) return false
      
      val (topLeft, bottomRight) = cache.visibleArea(editor)
      val pos = cache.offsetToXY(editor, offset)
@@ -34,22 +41,18 @@ enum class StandardBoundaries : Boundaries {
  },
  
  BEFORE_CARET {
-    override fun getOffsetRange(editor: Editor, cache: EditorOffsetCache): IntRange {
-      return 0 until editor.caretModel.offset
-    }
+    override fun getOffsetRange(editor: Editor, cache: EditorOffsetCache) =
+      0..(editor.caretModel.offset)
    
-    override fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache): Boolean {
-      return offset < editor.caretModel.offset
-    }
+    override fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache): Boolean =
+      offset <= editor.caretModel.offset
  },
  
  AFTER_CARET {
-    override fun getOffsetRange(editor: Editor, cache: EditorOffsetCache): IntRange {
-      return (editor.caretModel.offset + 1) until editor.document.textLength
-    }
+    override fun getOffsetRange(editor: Editor, cache: EditorOffsetCache) =
+      editor.caretModel.offset until editor.document.textLength
    
-    override fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache): Boolean {
-      return offset > editor.caretModel.offset
-    }
+    override fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache): Boolean =
+      offset >= editor.caretModel.offset
  }
 }
--- a/src/main/kotlin/org/acejump/config/AceConfig.kt
+++ b/src/main/kotlin/org/acejump/config/AceConfig.kt
@@ -7,31 +7,35 @@ import com.intellij.openapi.components.Storage
 import org.acejump.input.KeyLayoutCache

 /**
- * Ensures consistiency between [AceSettings] and [AceSettingsPanel]. Persists the state of the AceJump IDE settings across IDE restarts.
+ * Ensures consistency between [AceSettings] and [AceSettingsPanel].
+ * Persists the state of the AceJump IDE settings across IDE restarts.
 * [https://www.jetbrains.org/intellij/sdk/docs/basics/persisting_state_of_components.html]
 */
@State(name = "AceConfig", storages = [(Storage("\$APP_CONFIG\$/AceJump.xml"))])
-class AceConfig : PersistentStateComponent<AceSettings> {
+class AceConfig: PersistentStateComponent<AceSettings> {
  private var aceSettings = AceSettings()

  companion object {
-    val settings
-      get() = ServiceManager.getService(AceConfig::class.java).aceSettings
+    val settings get() = ServiceManager.getService(AceConfig::class.java).aceSettings

+    // @formatter:off
    val layout get()              = settings.layout
+    val cycleModes get()          = settings.let { arrayOf(it.cycleMode1, it.cycleMode2, it.cycleMode3, it.cycleMode4) }
    val minQueryLength get()      = settings.minQueryLength
    val jumpModeColor get()       = settings.jumpModeColor
-    val advancedModeColor get() = settings.advancedModeColor
-    val betweenPointsModeColor get() = settings.betweenPointsModeColor
+    val jumpEndModeColor get()    = settings.jumpEndModeColor
+    val targetModeColor get()     = settings.targetModeColor
+    val definitionModeColor get() = settings.definitionModeColor
    val textHighlightColor get()  = settings.textHighlightColor
    val tagForegroundColor get()  = settings.tagForegroundColor
    val tagBackgroundColor get()  = settings.tagBackgroundColor
-    val acceptedTagColor get() = settings.acceptedTagColor
+    val searchWholeFile get()     = settings.searchWholeFile
+    val mapToASCII get()        = settings.mapToASCII
+    val showSearchNotification get()          = settings.showSearchNotification
+    // @formatter:on
  }

-  override fun getState(): AceSettings {
-    return aceSettings
-  }
+  override fun getState() = aceSettings

  override fun loadState(state: AceSettings) {
    aceSettings = state
--- a/src/main/kotlin/org/acejump/config/AceConfigurable.kt
+++ b/src/main/kotlin/org/acejump/config/AceConfigurable.kt
@@ -4,7 +4,7 @@ import com.intellij.openapi.options.Configurable
 import org.acejump.config.AceConfig.Companion.settings
 import org.acejump.input.KeyLayoutCache

-class AceConfigurable : Configurable {
+class AceConfigurable: Configurable {
  private val panel by lazy(::AceSettingsPanel)

  override fun getDisplayName() = "AceJump"
@@ -14,26 +14,40 @@ class AceConfigurable : Configurable {
  override fun isModified() =
    panel.allowedChars != settings.allowedChars ||
      panel.keyboardLayout != settings.layout ||
+      panel.cycleMode1 != settings.cycleMode1 ||
+      panel.cycleMode2 != settings.cycleMode2 ||
+      panel.cycleMode3 != settings.cycleMode3 ||
+      panel.cycleMode4 != settings.cycleMode4 ||
      panel.minQueryLengthInt != settings.minQueryLength ||
      panel.jumpModeColor != settings.jumpModeColor ||
-      panel.advancedModeColor != settings.advancedModeColor ||
-      panel.betweenPointsModeColor != settings.betweenPointsModeColor ||
+      panel.jumpEndModeColor != settings.jumpEndModeColor ||
+      panel.targetModeColor != settings.targetModeColor ||
+      panel.definitionModeColor != settings.definitionModeColor ||
      panel.textHighlightColor != settings.textHighlightColor ||
      panel.tagForegroundColor != settings.tagForegroundColor ||
      panel.tagBackgroundColor != settings.tagBackgroundColor ||
-      panel.acceptedTagColor != settings.acceptedTagColor
+      panel.searchWholeFile != settings.searchWholeFile ||
+      panel.mapToASCII != settings.mapToASCII ||
+      panel.showSearchNotification != settings.showSearchNotification

  override fun apply() {
    settings.allowedChars = panel.allowedChars
    settings.layout = panel.keyboardLayout
+    settings.cycleMode1 = panel.cycleMode1
+    settings.cycleMode2 = panel.cycleMode2
+    settings.cycleMode3 = panel.cycleMode3
+    settings.cycleMode4 = panel.cycleMode4
    settings.minQueryLength = panel.minQueryLengthInt ?: settings.minQueryLength
    panel.jumpModeColor?.let { settings.jumpModeColor = it }
-    panel.advancedModeColor?.let { settings.advancedModeColor = it }
-    panel.betweenPointsModeColor?.let { settings.betweenPointsModeColor = it }
+    panel.jumpEndModeColor?.let { settings.jumpEndModeColor = it }
+    panel.targetModeColor?.let { settings.targetModeColor = it }
+    panel.definitionModeColor?.let { settings.definitionModeColor = it }
    panel.textHighlightColor?.let { settings.textHighlightColor = it }
    panel.tagForegroundColor?.let { settings.tagForegroundColor = it }
    panel.tagBackgroundColor?.let { settings.tagBackgroundColor = it }
-    panel.acceptedTagColor?.let { settings.acceptedTagColor = it }
+    settings.searchWholeFile = panel.searchWholeFile
+    settings.mapToASCII = panel.mapToASCII
+    settings.showSearchNotification = panel.showSearchNotification
    KeyLayoutCache.reset(settings)
  }

--- a/src/main/kotlin/org/acejump/config/AceSettings.kt
+++ b/src/main/kotlin/org/acejump/config/AceSettings.kt
@@ -1,6 +1,8 @@
 package org.acejump.config

+import com.intellij.util.xmlb.Converter
 import com.intellij.util.xmlb.annotations.OptionTag
+import org.acejump.input.JumpMode
 import org.acejump.input.KeyLayout
 import org.acejump.input.KeyLayout.QWERTY
 import java.awt.Color
@@ -8,16 +10,23 @@ import java.awt.Color
 data class AceSettings(
  var layout: KeyLayout = QWERTY,
  var allowedChars: String = layout.allChars,
+  var cycleMode1: JumpMode = JumpMode.JUMP,
+  var cycleMode2: JumpMode = JumpMode.DECLARATION,
+  var cycleMode3: JumpMode = JumpMode.TARGET,
+  var cycleMode4: JumpMode = JumpMode.JUMP_END,
  var minQueryLength: Int = 1,

  @OptionTag("jumpModeRGB", converter = ColorConverter::class)
  var jumpModeColor: Color = Color(0xFFFFFF),

-  @OptionTag("advancedModeRGB", converter = ColorConverter::class)
-  var advancedModeColor: Color = Color(0xFFB700),
+  @OptionTag("jumpEndModeRGB", converter = ColorConverter::class)
+  var jumpEndModeColor: Color = Color(0x33E78A),

-  @OptionTag("betweenPointsModeRGB", converter = ColorConverter::class)
-  var betweenPointsModeColor: Color = Color(0x6FC5FF),
+  @OptionTag("targetModeRGB", converter = ColorConverter::class)
+  var targetModeColor: Color = Color(0xFFB700),
+
+  @OptionTag("definitionModeRGB", converter = ColorConverter::class)
+  var definitionModeColor: Color = Color(0x6FC5FF),

  @OptionTag("textHighlightRGB", converter = ColorConverter::class)
  var textHighlightColor: Color = Color(0x394B58),
@@ -28,6 +37,14 @@ data class AceSettings(
  @OptionTag("tagBackgroundRGB", converter = ColorConverter::class)
  var tagBackgroundColor: Color = Color(0x008299),

-  @OptionTag("acceptedTagRGB", converter = ColorConverter::class)
-  var acceptedTagColor: Color = Color(0x394B58)
+  var searchWholeFile: Boolean = true,
+
+  var mapToASCII : Boolean = false,
+
+  var showSearchNotification : Boolean = false
 )
+
+internal class ColorConverter: Converter<Color>() {
+  override fun toString(value: Color) = value.rgb.toString()
+  override fun fromString(value: String) = value.toIntOrNull()?.let(::Color)
+}
--- a/src/main/kotlin/org/acejump/config/AceSettingsPanel.kt
+++ b/src/main/kotlin/org/acejump/config/AceSettingsPanel.kt
@@ -2,12 +2,14 @@ package org.acejump.config

 import com.intellij.openapi.ui.ComboBox
 import com.intellij.ui.ColorPanel
+import com.intellij.ui.components.JBCheckBox
 import com.intellij.ui.components.JBTextArea
 import com.intellij.ui.components.JBTextField
 import com.intellij.ui.layout.Cell
 import com.intellij.ui.layout.GrowPolicy.MEDIUM_TEXT
 import com.intellij.ui.layout.GrowPolicy.SHORT_TEXT
 import com.intellij.ui.layout.panel
+import org.acejump.input.JumpMode
 import org.acejump.input.KeyLayout
 import java.awt.Color
 import java.awt.Font
@@ -25,19 +27,30 @@ internal class AceSettingsPanel {
  private val tagCharsField = JBTextField()
  private val keyboardLayoutCombo = ComboBox<KeyLayout>()
  private val keyboardLayoutArea = JBTextArea().apply { isEditable = false }
+  private val cycleModeCombo1 = ComboBox<JumpMode>()
+  private val cycleModeCombo2 = ComboBox<JumpMode>()
+  private val cycleModeCombo3 = ComboBox<JumpMode>()
+  private val cycleModeCombo4 = ComboBox<JumpMode>()
  private val minQueryLengthField = JBTextField()
  private val jumpModeColorWheel = ColorPanel()
-  private val advancedModeColorWheel = ColorPanel()
-  private val betweenPointsModeColorWheel = ColorPanel()
+  private val jumpEndModeColorWheel = ColorPanel()
+  private val targetModeColorWheel = ColorPanel()
+  private val definitionModeColorWheel = ColorPanel()
  private val textHighlightColorWheel = ColorPanel()
  private val tagForegroundColorWheel = ColorPanel()
  private val tagBackgroundColorWheel = ColorPanel()
-  private val acceptedTagColorWheel = ColorPanel()
+  private val searchWholeFileCheckBox = JBCheckBox()
+  private val mapToASCIICheckBox = JBCheckBox()
+  private val showSearchNotificationCheckBox = JBCheckBox()

  init {
    tagCharsField.apply { font = Font("monospaced", font.style, font.size) }
    keyboardLayoutArea.apply { font = Font("monospaced", font.style, font.size) }
    keyboardLayoutCombo.setupEnumItems { keyChars = it.rows.joinToString("\n") }
+    cycleModeCombo1.setupEnumItems { cycleMode1 = it }
+    cycleModeCombo2.setupEnumItems { cycleMode2 = it }
+    cycleModeCombo3.setupEnumItems { cycleMode3 = it }
+    cycleModeCombo4.setupEnumItems { cycleMode4 = it }
  }

  internal val rootPanel: JPanel = panel {
@@ -50,18 +63,36 @@ internal class AceSettingsPanel {
      row("Keyboard design:") { short(keyboardLayoutArea) }
    }

-    titledRow("Behavior") {
-      row("Minimum typed characters (1-10):") { short(minQueryLengthField) }
+    titledRow("Modes") {
+      row("Cycle order:") { cell { cycleModeCombo1() } }
+      row("") {
+        cell(isVerticalFlow = true) {
+          cycleModeCombo2()
+          cycleModeCombo3()
+          cycleModeCombo4()
+        }
+      }
    }

    titledRow("Colors") {
      row("Jump mode caret background:") { short(jumpModeColorWheel) }
-      row("Advanced mode caret background:") { short(advancedModeColorWheel) }
-      row("Between Points mode caret background:") { short(betweenPointsModeColorWheel) }
+      row("Jump to End mode caret background:") { short(jumpEndModeColorWheel) }
+      row("Target mode caret background:") { short(targetModeColorWheel) }
+      row("Definition mode caret background:") { short(definitionModeColorWheel) }
      row("Searched text background:") { short(textHighlightColorWheel) }
      row("Tag foreground:") { short(tagForegroundColorWheel) }
      row("Tag background:") { short(tagBackgroundColorWheel) }
-      row("Accepted tag position background:") { short(acceptedTagColorWheel) }
+    }
+
+    titledRow("Behavior") {
+      row { short(searchWholeFileCheckBox.apply { text = "Search whole file" }) }
+      row("Minimum typed characters (1-10):") { short(minQueryLengthField) }
+    }
+    titledRow("Language Settings") {
+      row { short(mapToASCIICheckBox.apply { text = "Map unicode to ASCII" }) }
+    }
+    titledRow("Visual") {
+      row { short(showSearchNotificationCheckBox.apply { text = "Show hint with search text" }) }
    }
  }

@@ -69,35 +100,51 @@ internal class AceSettingsPanel {
  internal var allowedChars by tagCharsField
  internal var keyboardLayout by keyboardLayoutCombo
  internal var keyChars by keyboardLayoutArea
+  internal var cycleMode1 by cycleModeCombo1
+  internal var cycleMode2 by cycleModeCombo2
+  internal var cycleMode3 by cycleModeCombo3
+  internal var cycleMode4 by cycleModeCombo4
  internal var minQueryLength by minQueryLengthField
  internal var jumpModeColor by jumpModeColorWheel
-  internal var advancedModeColor by advancedModeColorWheel
-  internal var betweenPointsModeColor by betweenPointsModeColorWheel
+  internal var jumpEndModeColor by jumpEndModeColorWheel
+  internal var targetModeColor by targetModeColorWheel
+  internal var definitionModeColor by definitionModeColorWheel
  internal var textHighlightColor by textHighlightColorWheel
  internal var tagForegroundColor by tagForegroundColorWheel
  internal var tagBackgroundColor by tagBackgroundColorWheel
-  internal var acceptedTagColor by acceptedTagColorWheel
+  internal var searchWholeFile by searchWholeFileCheckBox
+  internal var mapToASCII by mapToASCIICheckBox
+  internal var showSearchNotification by showSearchNotificationCheckBox

  internal var minQueryLengthInt
    get() = minQueryLength.toIntOrNull()?.coerceIn(1, 10)
-    set(value) { minQueryLength = value.toString() }
+    set(value) {
+      minQueryLength = value.toString()
+    }

  fun reset(settings: AceSettings) {
    allowedChars = settings.allowedChars
    keyboardLayout = settings.layout
+    cycleMode1 = settings.cycleMode1
+    cycleMode2 = settings.cycleMode2
+    cycleMode3 = settings.cycleMode3
+    cycleMode4 = settings.cycleMode4
    minQueryLength = settings.minQueryLength.toString()
    jumpModeColor = settings.jumpModeColor
-    advancedModeColor = settings.advancedModeColor
-    betweenPointsModeColor = settings.betweenPointsModeColor
+    jumpEndModeColor = settings.jumpEndModeColor
+    targetModeColor = settings.targetModeColor
+    definitionModeColor = settings.definitionModeColor
    textHighlightColor = settings.textHighlightColor
    tagForegroundColor = settings.tagForegroundColor
    tagBackgroundColor = settings.tagBackgroundColor
-    acceptedTagColor = settings.acceptedTagColor
+    searchWholeFile = settings.searchWholeFile
+    mapToASCII = settings.mapToASCII
+    showSearchNotification = settings.showSearchNotification
  }

  // Removal pending support for https://youtrack.jetbrains.com/issue/KT-8575

-  private operator fun JTextComponent.getValue(a: AceSettingsPanel, p: KProperty<*>) = text.toLowerCase()
+  private operator fun JTextComponent.getValue(a: AceSettingsPanel, p: KProperty<*>) = text.lowercase()
  private operator fun JTextComponent.setValue(a: AceSettingsPanel, p: KProperty<*>, s: String) = setText(s)

  private operator fun ColorPanel.getValue(a: AceSettingsPanel, p: KProperty<*>) = selectedColor
@@ -106,10 +153,10 @@ internal class AceSettingsPanel {
  private operator fun JCheckBox.getValue(a: AceSettingsPanel, p: KProperty<*>) = isSelected
  private operator fun JCheckBox.setValue(a: AceSettingsPanel, p: KProperty<*>, selected: Boolean) = setSelected(selected)

-  private operator fun <T> ComboBox<T>.getValue(a: AceSettingsPanel, p: KProperty<*>) = selectedItem as T
+  private inline operator fun <reified T> ComboBox<T>.getValue(a: AceSettingsPanel, p: KProperty<*>) = selectedItem as T
  private operator fun <T> ComboBox<T>.setValue(a: AceSettingsPanel, p: KProperty<*>, item: T) = setSelectedItem(item)

-  private inline fun <reified T : Enum<T>> ComboBox<T>.setupEnumItems(crossinline onChanged: (T) -> Unit) {
+  private inline fun <reified T: Enum<T>> ComboBox<T>.setupEnumItems(crossinline onChanged: (T) -> Unit) {
    T::class.java.enumConstants.forEach(this::addItem)
    addActionListener { onChanged(selectedItem as T) }
  }
--- a/src/main/kotlin/org/acejump/config/ColorConverter.kt
+++ b/src/main/kotlin/org/acejump/config/ColorConverter.kt
@@ -1,14 +0,0 @@
-package org.acejump.config
-
-import com.intellij.util.xmlb.Converter
-import java.awt.Color
-
-internal class ColorConverter : Converter<Color>() {
-  override fun toString(value: Color): String {
-    return value.rgb.toString()
-  }
-  
-  override fun fromString(value: String): Color? {
-    return value.toIntOrNull()?.let(::Color)
-  }
-}
--- a/src/main/kotlin/org/acejump/input/EditorKeyListener.kt
+++ b/src/main/kotlin/org/acejump/input/EditorKeyListener.kt
@@ -6,10 +6,11 @@ import com.intellij.openapi.editor.actionSystem.TypedAction
 import com.intellij.openapi.editor.actionSystem.TypedActionHandler

 /**
- * If at least one session exists, this listener redirects all characters, typed in [Editor]s with attached sessions, to the appropriate
- * sessions' own handlers.
+ * If at least one session exists, this listener redirects all characters
+ * typed in [Editor]s with attached sessions to the appropriate sessions'
+ * own handlers.
 */
-internal object EditorKeyListener : TypedActionHandler {
+internal object EditorKeyListener: TypedActionHandler {
  private val action = TypedAction.getInstance()
  private val attached = mutableMapOf<Editor, TypedActionHandler>()
  private var originalHandler: TypedActionHandler? = null
--- a/src/main/kotlin/org/acejump/input/JumpMode.kt
+++ b/src/main/kotlin/org/acejump/input/JumpMode.kt
@@ -0,0 +1,80 @@
+package org.acejump.input
+
+import com.intellij.openapi.editor.colors.impl.AbstractColorsScheme
+import org.acejump.config.AceConfig
+import java.awt.Color
+
+/**
+ * Describes modes that determine the behavior of a "jump" to a tag.
+ * Most modes have two variations:
+ *   - **Default jump** happens when jumping without holding the Shift key
+ *   - **Shift jump** happens when jumping while holding the Shift key
+ */
+enum class JumpMode {
+  /**
+   * Default value at the start of a session. If the session does not get
+   * assigned a proper [JumpMode] by the time the user requests a jump, the
+   * results of the jump are undefined.
+   */
+  DISABLED,
+  
+  /**
+   * On default jump, places the caret at the first character of the search
+   * query. On shift jump, does the above but also selects all text between
+   * the original and new caret positions.
+   */
+  JUMP,
+  
+  /**
+   * On default jump, places the caret at the end of a word. Word detection
+   * uses [Character.isJavaIdentifierPart] to count some special characters,
+   * such as underscores, as part of a word. If there is no word at the first
+   * character of the search query, then the caret is placed after the last
+   * character of the search query.
+   *
+   * On shift jump, does the above but also selects all text between
+   * the original and new caret positions.
+   */
+  JUMP_END,
+  
+  /**
+   * On default jump, places the caret at the end of a word, and also selects
+   * the entire word. Word detection uses [Character.isJavaIdentifierPart] to
+   * count some special characters, such as underscores, as part of a word.
+   * If there is no word at the first character of the search query, then the
+   * caret is placed after the last character of the search query, and all
+   * text between the start and end of the search query is selected.
+   *
+   * On shift jump, does the above but also selects all text between the
+   * start of the original caret position and the end of the new selection.
+   */
+  TARGET,
+  
+  /**
+   * On default jump, performs the Go To Declaration action, available
+   * via `Navigate | Declaration or Usages`.
+   *
+   * On shift jump, performs the Go To Type Declaration action, available
+   * via `Navigate | Type Declaration`.
+   *
+   * Always places the caret at the first character of the search query.
+   */
+  DECLARATION;
+  
+  val caretColor: Color
+    get() = when (this) {
+      JUMP        -> AceConfig.jumpModeColor
+      JUMP_END    -> AceConfig.jumpEndModeColor
+      DECLARATION -> AceConfig.definitionModeColor
+      TARGET      -> AceConfig.targetModeColor
+      DISABLED    -> AbstractColorsScheme.INHERITED_COLOR_MARKER
+    }
+  
+  override fun toString() = when (this) {
+    DISABLED -> "(Skip)"
+    JUMP     -> "Jump"
+    JUMP_END -> "Jump to End"
+    TARGET   -> "Target"
+    DECLARATION   -> "Definition"
+  }
+}
--- a/src/main/kotlin/org/acejump/input/JumpModeTracker.kt
+++ b/src/main/kotlin/org/acejump/input/JumpModeTracker.kt
@@ -0,0 +1,56 @@
+package org.acejump.input
+
+import org.acejump.config.AceConfig
+
+/**
+ * Remembers the current [JumpMode] for a session. Allows cycling
+ * [JumpMode]s according to the order defined in configuration, or
+ * toggling one specific [JumpMode] on or off.
+ */
+internal class JumpModeTracker {
+  private var currentMode = JumpMode.DISABLED
+  private var currentIndex = 0
+
+  /**
+   * Switches to the next/previous [JumpMode] defined in configuration,
+   * skipping any [JumpMode]s that are not assigned. If at least two
+   * [JumpMode]s are assigned in the cycle order, then cycling will
+   * wrap around. If only one [JumpMode] is assigned, then cycling will
+   * toggle that one mode.
+   */
+  fun cycle(forward: Boolean): JumpMode {
+    val cycleModes = AceConfig.cycleModes
+    val direction = if (forward) 1 else -1
+    val start = if (currentIndex == 0 && !forward) 0 else currentIndex - 1
+
+    for (offset in 1 until cycleModes.size) {
+      val index = (start + cycleModes.size + (offset * direction)) % cycleModes.size
+
+      if (cycleModes[index] != JumpMode.DISABLED) {
+        currentMode = cycleModes[index]
+        currentIndex = index + 1
+        return currentMode
+      }
+    }
+
+    currentMode = JumpMode.DISABLED
+    currentIndex = 0
+    return currentMode
+  }
+
+  /**
+   * Switches to the specified [JumpMode]. If the current mode already
+   * equals the specified one, it resets to [JumpMode.DISABLED].
+   */
+  fun toggle(newMode: JumpMode): JumpMode {
+    if (currentMode == newMode) {
+      currentMode = JumpMode.DISABLED
+      currentIndex = 0
+    } else {
+      currentMode = newMode
+      currentIndex = AceConfig.cycleModes.indexOfFirst { it == newMode } + 1
+    }
+
+    return currentMode
+  }
+}
--- a/src/main/kotlin/org/acejump/input/KeyLayout.kt
+++ b/src/main/kotlin/org/acejump/input/KeyLayout.kt
@@ -1,8 +1,14 @@
 package org.acejump.input

+import it.unimi.dsi.fastutil.objects.Object2IntMap
+import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap
+import java.awt.geom.Point2D
+import kotlin.math.floor
+
 /**
- * Defines common keyboard layouts. Each layout has a key priority order, based on each key's distance from the home row and how
- * ergonomically difficult they are to press.
+ * Defines common keyboard layouts. Each layout has a key priority order,
+ * based on each key's distance from the home row and how ergonomically
+ * difficult they are to press.
 */
@Suppress("unused")
 enum class KeyLayout(internal val rows: Array<String>, priority: String) {
@@ -18,7 +24,38 @@ enum class KeyLayout(internal val rows: Array<String>, priority: String) {
  internal val allChars = rows.joinToString("").toCharArray().apply(CharArray::sort).joinToString("")
  internal val allPriorities = priority.mapIndexed { index, char -> char to index }.toMap()
  
+  private val keyDistances: Map<Char, Object2IntMap<Char>> by lazy {
+    val keyDistanceMap = mutableMapOf<Char, Object2IntMap<Char>>()
+    val keyLocations = mutableMapOf<Char, Point2D>()
+    
+    for ((rowIndex, rowChars) in rows.withIndex()) {
+      val keyY = rowIndex * 1.2F // Slightly increase cost of traveling between rows.
+      
+      for ((columnIndex, char) in rowChars.withIndex()) {
+        val keyX = columnIndex + (0.25F * rowIndex) // Assume a 1/4-key uniform stagger.
+        keyLocations[char] = Point2D.Float(keyX, keyY)
+      }
+    }
+    
+    for (fromChar in allChars) {
+      val distances = Object2IntOpenHashMap<Char>()
+      val fromLocation = keyLocations.getValue(fromChar)
+      
+      for (toChar in allChars) {
+        distances[toChar] = floor(2F * fromLocation.distanceSq(keyLocations.getValue(toChar))).toInt()
+      }
+      
+      keyDistanceMap[fromChar] = distances
+    }
+    
+    keyDistanceMap
+  }
+  
  internal inline fun priority(crossinline tagToChar: (String) -> Char): (String) -> Int? {
    return { allPriorities[tagToChar(it)] }
  }
+  
+  internal fun distanceBetweenKeys(char1: Char, char2: Char): Int {
+    return keyDistances.getValue(char1).getValue(char2)
+  }
 }
--- a/src/main/kotlin/org/acejump/input/KeyLayoutCache.kt
+++ b/src/main/kotlin/org/acejump/input/KeyLayoutCache.kt
@@ -7,48 +7,6 @@ import org.acejump.config.AceSettings
 * with repeated keys (ex. FF, JJ) or adjacent keys (ex. GH, UJ).
 */
 internal object KeyLayoutCache {
-  /**
-   * Stores keys ordered by proximity to other keys for the QWERTY layout.
-   * TODO: Support more layouts, perhaps generate automatically.
-   */
-  private val qwertyCharacterDistances = mapOf(
-    'j' to "jikmnhuolbgypvftcdrxsezawq8796054321",
-    'f' to "ftgvcdryhbxseujnzawqikmolp5463728190",
-    'k' to "kolmjipnhubgyvftcdrxsezawq9807654321",
-    'd' to "drfcxsetgvzawyhbqujnikmolp4352617890",
-    'l' to "lkopmjinhubgyvftcdrxsezawq0987654321",
-    's' to "sedxzawrfcqtgvyhbujnikmolp3241567890",
-    'a' to "aqwszedxrfctgvyhbujnikmolp1234567890",
-    'h' to "hujnbgyikmvftolcdrpxsezawq6758493021",
-    'g' to "gyhbvftujncdrikmxseolzawpq5647382910",
-    'y' to "yuhgtijnbvfrokmcdeplxswzaq6758493021",
-    't' to "tygfruhbvcdeijnxswokmzaqpl5647382910",
-    'u' to "uijhyokmnbgtplvfrcdexswzaq7869504321",
-    'r' to "rtfdeygvcxswuhbzaqijnokmpl4536271890",
-    'n' to "nbhjmvgyuiklocftpxdrzseawq7685940321",
-    'v' to "vcfgbxdrtyhnzseujmawikqolp5463728190",
-    'm' to "mnjkbhuilvgyopcftxdrzseawq8970654321",
-    'c' to "cxdfvzsertgbawyhnqujmikolp4352617890",
-    'b' to "bvghncftyujmxdrikzseolawqp6574839201",
-    'i' to "iokjuplmnhybgtvfrcdexswzaq8970654321",
-    'e' to "erdswtfcxzaqygvuhbijnokmpl3425167890",
-    'x' to "xzsdcawerfvqtgbyhnujmikolp3241567890",
-    'z' to "zasxqwedcrfvtgbyhnujmikolp1234567890",
-    'o' to "oplkimjunhybgtvfrcdexswzaq9087654321",
-    'w' to "wesaqrdxztfcygvuhbijnokmpl2314567890",
-    'p' to "plokimjunhybgtvfrcdexswzaq0987654321",
-    'q' to "qwaeszrdxtfcygvuhbijnokmpl1234567890",
-    '1' to "1234567890qawzsexdrcftvgybhunjimkolp",
-    '2' to "2134567890qwasezxdrcftvgybhunjimkolp",
-    '3' to "3241567890weqasdrzxcftvgybhunjimkolp",
-    '4' to "4352617890erwsdftqazxcvgybhunjimkolp",
-    '5' to "5463728190rtedfgywsxcvbhuqaznjimkolp",
-    '6' to "6574839201tyrfghuedcvbnjiwsxmkoqazlp",
-    '7' to "7685940321yutghjirfvbnmkoedclpwsxqaz",
-    '8' to "8796054321uiyhjkotgbnmlprfvedcwsxqaz",
-    '9' to "9807654321ioujklpyhnmtgbrfvedcwsxqaz",
-    '0' to "0987654321opiklujmyhntgbrfvedcwsxqaz").mapValues { (_, v) -> v.mapIndexed { index, char -> char to index }.toMap() }
-  
  /**
   * Sorts tags according to current keyboard layout settings, and some predefined rules that force tags with digits, and tags with two
   * keys far apart, to be sorted after other (easier to type) tags.
@@ -65,11 +23,8 @@ internal object KeyLayoutCache {
  /**
   * Called before any lazily initialized properties are used, to ensure that they are initialized even if the settings are missing.
   */
-  fun ensureInitialized(settings: AceSettings) {
-    if (!::tagOrder.isInitialized) {
-      reset(settings)
-    }
-  }
+  fun ensureInitialized(settings: AceSettings) =
+    if (!::tagOrder.isInitialized) reset(settings) else Unit

  /**
   * Re-initializes cached data according to updated settings.
@@ -77,7 +32,7 @@ internal object KeyLayoutCache {
  fun reset(settings: AceSettings) {
    tagOrder = compareBy(
      { it[0].isDigit() || it[1].isDigit() },
-      { qwertyCharacterDistances.getValue(it[0]).getValue(it[1]) },
+      { settings.layout.distanceBetweenKeys(it[0], it[1]) },
      settings.layout.priority { it[0] }
    )
    
@@ -88,6 +43,8 @@ internal object KeyLayoutCache {
      .joinToString("")
      .ifEmpty(settings.layout::allChars)
    
-    allPossibleTags = allPossibleChars.flatMap { a -> allPossibleChars.map { b -> "$a$b".intern() } }.sortedWith(tagOrder)
+    allPossibleTags = allPossibleChars.flatMap { a ->
+      allPossibleChars.map { b -> "$a$b".intern() }
+    }.sortedWith(tagOrder)
  }
 }
--- a/src/main/kotlin/org/acejump/modes/ActionMode.kt
+++ b/src/main/kotlin/org/acejump/modes/ActionMode.kt
@@ -1,12 +0,0 @@
-package org.acejump.modes
-
-import org.acejump.action.AceTagAction
-import org.acejump.search.Tag
-import org.acejump.session.SessionState
-
-class ActionMode(private val action: AceTagAction, private val shiftMode: Boolean) : JumpMode() {
-  override fun accept(state: SessionState, acceptedTag: Tag): Boolean {
-    state.act(action, acceptedTag, shiftMode, isFinal = true)
-    return true
-  }
-}
--- a/src/main/kotlin/org/acejump/modes/AdvancedMode.kt
+++ b/src/main/kotlin/org/acejump/modes/AdvancedMode.kt
@@ -1,73 +0,0 @@
-package org.acejump.modes
-
-import org.acejump.action.AceTagAction
-import org.acejump.config.AceConfig
-import org.acejump.search.Tag
-import org.acejump.session.SessionState
-import org.acejump.session.TypeResult
-
-class AdvancedMode : SessionMode {
-  companion object {
-    private val JUMP_HINT = arrayOf(
-      "<f>[J]</f>ump / <f>[L]</f> past Query",
-      "<f>[E]</f> Word End / <f>[M]</f> Line End"
-    )
-    
-    val JUMP_ALT_HINT = JUMP_HINT.map { it.replace("<f>[J]</f>ump ", "<f>[J]</f> at Tag ") }.toTypedArray()
-    
-    val JUMP_ACTION_MAP = mapOf(
-      'J' to AceTagAction.JumpToSearchStart,
-      'L' to AceTagAction.JumpPastSearchEnd,
-      'E' to AceTagAction.JumpToWordEnd,
-      'M' to AceTagAction.JumpToLineEnd
-    )
-    
-    val SELECT_HINT = arrayOf(
-      "Select <f>[W]</f>ord / <f>[H]</f>ump",
-      "Select <f>[Q]</f>uery / <f>[N]</f> Line / <f>[1-9]</f> Expansion"
-    )
-    
-    val SELECT_ACTION_MAP = mapOf(
-      'W' to AceTagAction.SelectWord,
-      'H' to AceTagAction.SelectHump,
-      'Q' to AceTagAction.SelectQuery,
-      'N' to AceTagAction.SelectLine,
-      *('1'..'9').mapIndexed { index, char -> char to AceTagAction.SelectExtended(index + 1) }.toTypedArray()
-    )
-    
-    private val ALL_HINTS = arrayOf(
-      *JUMP_HINT,
-      *SELECT_HINT,
-    )
-    
-    private val ALL_ACTION_MAP = mapOf(
-      *JUMP_ACTION_MAP.map { it.key to it.value }.toTypedArray(),
-      *SELECT_ACTION_MAP.map { it.key to it.value }.toTypedArray(),
-    )
-  }
-  
-  override val caretColor
-    get() = AceConfig.advancedModeColor
-  
-  override fun type(state: SessionState, charTyped: Char, acceptedTag: Tag?): TypeResult {
-    if (acceptedTag == null) {
-      return state.type(charTyped)
-    }
-    
-    val action = ALL_ACTION_MAP[charTyped.toUpperCase()]
-    if (action != null) {
-      state.act(action, acceptedTag, shiftMode = charTyped.isUpperCase(), isFinal = true)
-      return TypeResult.EndSession
-    }
-    
-    return TypeResult.Nothing
-  }
-  
-  override fun accept(state: SessionState, acceptedTag: Tag): Boolean {
-    return false
-  }
-  
-  override fun getHint(acceptedTag: Int?, hasQuery: Boolean): Array<String>? {
-    return ALL_HINTS.takeIf { acceptedTag != null }
-  }
-}
--- a/src/main/kotlin/org/acejump/modes/BetweenPointsMode.kt
+++ b/src/main/kotlin/org/acejump/modes/BetweenPointsMode.kt
@@ -1,92 +0,0 @@
-package org.acejump.modes
-
-import com.intellij.openapi.editor.CaretState
-import org.acejump.action.AceTagAction
-import org.acejump.config.AceConfig
-import org.acejump.search.Tag
-import org.acejump.session.SessionState
-import org.acejump.session.TypeResult
-
-class BetweenPointsMode : SessionMode {
-  private companion object {
-    private val TYPE_TAG_HINT = arrayOf(
-      "<b>Type to Search...</b>"
-    )
-    
-    private val ACTION_MODE_HINT = arrayOf(
-      "<f>[C]</f>lone to Caret...",
-      "<f>[M]</f>ove to Caret..."
-    )
-    
-    private val ACTION_MODE_MAP = mapOf(
-      'C' to (AceTagAction::CloneToCaret),
-      'M' to (AceTagAction::MoveToCaret)
-    )
-  }
-  
-  override val caretColor
-    get() = AceConfig.betweenPointsModeColor
-  
-  private var actionMode: ((AceTagAction.BaseSelectAction) -> AceTagAction)? = null
-  private var originalCarets: List<CaretState>? = null
-  private var firstOffset: Int? = null
-  
-  override fun type(state: SessionState, charTyped: Char, acceptedTag: Tag?): TypeResult {
-    val actionMode = actionMode
-    if (actionMode == null) {
-      this.actionMode = ACTION_MODE_MAP[charTyped.toUpperCase()]
-      return TypeResult.Nothing
-    }
-    
-    if (acceptedTag == null) {
-      return state.type(charTyped)
-    }
-    
-    if (firstOffset == null) {
-      val selectAction = AdvancedMode.SELECT_ACTION_MAP[charTyped.toUpperCase()]
-      if (selectAction != null) {
-        state.act(actionMode(selectAction), acceptedTag, shiftMode = charTyped.isUpperCase(), isFinal = true)
-        return TypeResult.EndSession
-      }
-    }
-    
-    val jumpAction = AdvancedMode.JUMP_ACTION_MAP[charTyped.toUpperCase()]
-    if (jumpAction == null) {
-      return TypeResult.Nothing
-    }
-    
-    val firstOffset = firstOffset
-    if (firstOffset == null) {
-      val caretModel = acceptedTag.editor.caretModel
-      this.originalCarets = caretModel.caretsAndSelections
-      
-      state.act(jumpAction, acceptedTag, shiftMode = false, isFinal = false)
-      this.firstOffset = caretModel.offset
-      return TypeResult.RestartSearch
-    }
-    
-    originalCarets?.let { acceptedTag.editor.caretModel.caretsAndSelections = it }
-    
-    state.act(
-      actionMode(AceTagAction.SelectBetweenPoints(firstOffset, jumpAction)),
-      acceptedTag,
-      shiftMode = charTyped.isUpperCase(),
-      isFinal = true
-    )
-    
-    return TypeResult.EndSession
-  }
-  
-  override fun accept(state: SessionState, acceptedTag: Tag): Boolean {
-    return false
-  }
-  
-  override fun getHint(acceptedTag: Int?, hasQuery: Boolean): Array<String>? {
-    return when {
-      actionMode == null  -> ACTION_MODE_HINT
-      acceptedTag == null -> TYPE_TAG_HINT.takeUnless { hasQuery }
-      firstOffset == null -> AdvancedMode.JUMP_ALT_HINT + AdvancedMode.SELECT_HINT
-      else                -> AdvancedMode.JUMP_ALT_HINT
-    }
-  }
-}
--- a/src/main/kotlin/org/acejump/modes/JumpMode.kt
+++ b/src/main/kotlin/org/acejump/modes/JumpMode.kt
@@ -1,29 +0,0 @@
-package org.acejump.modes
-
-import org.acejump.action.AceTagAction
-import org.acejump.config.AceConfig
-import org.acejump.search.Tag
-import org.acejump.session.SessionState
-import org.acejump.session.TypeResult
-
-open class JumpMode : SessionMode {
-  override val caretColor
-    get() = AceConfig.jumpModeColor
-  
-  protected var wasUpperCase = false
-    private set
-  
-  override fun type(state: SessionState, charTyped: Char, acceptedTag: Tag?): TypeResult {
-    wasUpperCase = charTyped.isUpperCase()
-    return state.type(charTyped)
-  }
-  
-  override fun accept(state: SessionState, acceptedTag: Tag): Boolean {
-    state.act(AceTagAction.JumpToSearchStart, acceptedTag, wasUpperCase, isFinal = true)
-    return true
-  }
-  
-  override fun getHint(acceptedTag: Int?, hasQuery: Boolean): Array<String>? {
-    return null
-  }
-}
--- a/src/main/kotlin/org/acejump/modes/SessionMode.kt
+++ b/src/main/kotlin/org/acejump/modes/SessionMode.kt
@@ -1,14 +0,0 @@
-package org.acejump.modes
-
-import org.acejump.search.Tag
-import org.acejump.session.SessionState
-import org.acejump.session.TypeResult
-import java.awt.Color
-
-interface SessionMode {
-  val caretColor: Color
-  
-  fun type(state: SessionState, charTyped: Char, acceptedTag: Tag?): TypeResult
-  fun accept(state: SessionState, acceptedTag: Tag): Boolean
-  fun getHint(acceptedTag: Int?, hasQuery: Boolean): Array<String>?
-}
--- a/src/main/kotlin/org/acejump/modes/VimJumpMode.kt
+++ b/src/main/kotlin/org/acejump/modes/VimJumpMode.kt
@@ -1,17 +0,0 @@
-package org.acejump.modes
-
-import org.acejump.action.AceTagAction
-import org.acejump.search.Tag
-import org.acejump.session.SessionState
-
-class VimJumpMode : JumpMode() {
-  override fun accept(state: SessionState, acceptedTag: Tag): Boolean {
-    val action = if (acceptedTag.editor.selectionModel.hasSelection())
-      AceTagAction.SelectToCaret(AceTagAction.JumpToSearchStart)
-    else
-      AceTagAction.JumpToSearchStart
-    
-    state.act(action, acceptedTag, wasUpperCase, isFinal = true)
-    return true
-  }
-}
--- a/src/main/kotlin/org/acejump/search/Pattern.kt
+++ b/src/main/kotlin/org/acejump/search/Pattern.kt
@@ -5,9 +5,5 @@ enum class Pattern(val regex: String) {
  LINE_ENDS("\\n|\\Z"),
  LINE_INDENTS("[^\\s].*|^\\n"),
  LINE_ALL_MARKS(LINE_ENDS.regex + "|" + LINE_STARTS.regex + "|" + LINE_INDENTS.regex),
-  ALL_WORDS("(?<=[^a-zA-Z0-9_]|\\A)[a-zA-Z0-9_]"),
-  VIM_LWORD("(?<=[^a-zA-Z0-9_]|\\A)[a-zA-Z0-9_]"),
-  VIM_UWORD("(?<=\\s|\\A)[^\\s]"),
-  VIM_LWORD_END("[a-zA-Z0-9_](?=[^a-zA-Z0-9_]|\\Z)"),
-  VIM_UWORD_END("[^\\s](?=\\s|\\Z)")
+  ALL_WORDS("(?<=[^a-zA-Z0-9_]|\\A)[a-zA-Z0-9_]");
 }
--- a/src/main/kotlin/org/acejump/search/SearchProcessor.kt
+++ b/src/main/kotlin/org/acejump/search/SearchProcessor.kt
@@ -3,25 +3,25 @@ package org.acejump.search
 import com.intellij.openapi.editor.Editor
 import it.unimi.dsi.fastutil.ints.IntArrayList
 import org.acejump.boundaries.Boundaries
-import org.acejump.clone
 import org.acejump.immutableText
 import org.acejump.isWordPart
 import org.acejump.matchesAt

 /**
- * Searches editor text for matches of a [SearchQuery], and updates previous results when the user [type]s a character.
+ * Searches editor text for matches of a [SearchQuery], and updates
+ * previous results when the user [type]s a character.
 */
-class SearchProcessor private constructor(
-  private val editors: List<Editor>, query: SearchQuery, results: MutableMap<Editor, IntArrayList>
+internal class SearchProcessor private constructor(
+  private val editors: List<Editor>,
+  query: SearchQuery,
+  results: MutableMap<Editor, IntArrayList>
 ) {
  companion object {
-    fun fromChar(editors: List<Editor>, char: Char, boundaries: Boundaries): SearchProcessor {
-      return SearchProcessor(editors, SearchQuery.Literal(char.toString()), boundaries)
-    }
+    fun fromChar(editors: List<Editor>, char: Char, boundaries: Boundaries) =
+      SearchProcessor(editors, SearchQuery.Literal(char.toString()), boundaries)

-    fun fromRegex(editors: List<Editor>, pattern: String, boundaries: Boundaries): SearchProcessor {
-      return SearchProcessor(editors, SearchQuery.RegularExpression(pattern), boundaries)
-    }
+    fun fromRegex(editors: List<Editor>, pattern: String, boundaries: Boundaries) =
+      SearchProcessor(editors, SearchQuery.RegularExpression(pattern), boundaries)
  }
  
  private constructor(editors: List<Editor>, query: SearchQuery, boundaries: Boundaries) : this(editors, query, mutableMapOf()) {
@@ -35,7 +35,9 @@ class SearchProcessor private constructor(
        var result = regex.find(editor.immutableText, offsetRange.first)
        
        while (result != null) {
-          val index = result.range.first // For some reason regex matches can be out of bounds, but boundary check prevents an exception.
+          // For some reason regex matches can be out of bounds, but
+          // boundary check prevents an exception.
+          val index = result.range.first
          val highlightEnd = index + query.getHighlightLength("", index)
          
          if (highlightEnd > offsetRange.last) {
@@ -53,32 +55,38 @@ class SearchProcessor private constructor(
    }
  }
  
-  internal var query = query
+  var query: SearchQuery = query
    private set
  
-  internal var results = results
+  var results: MutableMap<Editor, IntArrayList> = results
    private set
  
  /**
-   * Appends a character to the search query and removes all search results that no longer match the query. If the last typed character
-   * transitioned the search query from a non-word to a word, it notifies the [Tagger] to reassign all tags. If the new query does not
-   * make sense because it would remove every result, the change is reverted and this function returns false.
+   * Appends a character to the search query and removes all search results
+   * that no longer match the query. If the last typed character transitioned
+   * the search query from a non-word to a word, it notifies the [Tagger] to
+   * reassign all tags. If the new query is invalid because it would remove
+   * every result, the change is reverted and this function returns false.
   */
  fun type(char: Char, tagger: Tagger): Boolean {
    val newQuery = query.rawText + char
    val canMatchTag = tagger.canQueryMatchAnyTag(newQuery)
    
-    // If the typed character is not compatible with any existing tag or as a continuation of any previous occurrence, reject the query
-    // change and return false to indicate that nothing else should happen.
+    // If the typed character is not compatible with any existing tag or as
+    // a continuation of any previous occurrence, reject the query change
+    // and return false to indicate that nothing else should happen.
    
    if (newQuery.length > 1 && !canMatchTag && !isContinuation(newQuery)) {
      return false
    }
  
-    // If the typed character transitioned the search query from a non-word to a word, and the typed character does not belong to an
-    // existing tag, we basically restart the search at the beginning of every new word, and unmark existing results so that all tags get
-    // regenerated immediately afterwards. Although this causes tags to change, it is one solution for conflicts between tag characters and
-    // search query characters, and moving searches across word boundaries during search should be fairly uncommon.
+    // If the typed character transitioned the search query from a non-word
+    // to a word, and the typed character does not belong to an existing tag,
+    // we basically restart the search at the beginning of every new word,
+    // and unmark existing results so that all tags get regenerated immediately
+    // afterwards. Although this causes tags to change, it is one solution for
+    // conflicts between tag characters and search query characters, and moving
+    // searches across word boundaries during search should be fairly uncommon.
  
    if (!canMatchTag && newQuery.length >= 2 && !newQuery[newQuery.length - 2].isWordPart && char.isWordPart) {
      query = SearchQuery.Literal(char.toString())
@@ -99,8 +107,7 @@ class SearchProcessor private constructor(
          }
        }
      }
-    }
-    else {
+    } else {
      removeObsoleteResults(newQuery, tagger)
      query = SearchQuery.Literal(newQuery)
    }
@@ -123,7 +130,8 @@ class SearchProcessor private constructor(
  }
  
  /**
-   * After updating the query, removes all results that no longer match the search query.
+   * After updating the query, removes all results that no longer match
+   * the search query.
   */
  private fun removeObsoleteResults(newQuery: String, tagger: Tagger) {
    val lastCharOffset = newQuery.lastIndex
@@ -132,16 +140,17 @@ class SearchProcessor private constructor(
  
    for ((editor, offsets) in results.entries.toList()) {
      val chars = editor.immutableText
-      
      val remaining = IntArrayList()
      val iter = offsets.iterator()
    
      while (iter.hasNext()) {
        val offset = iter.nextInt()
        val endOffset = offset + lastCharOffset
-        val lastTypedCharMatches = endOffset < chars.length && chars[endOffset].equals(lastChar, ignoreCase)
+        val lastTypedCharMatches = endOffset < chars.length &&
+          chars[endOffset].equals(lastChar, ignoreCase)
      
-        if (lastTypedCharMatches || tagger.isQueryCompatibleWithTagAt(newQuery, Tag(editor, offset))) {
+        if (lastTypedCharMatches ||
+          tagger.isQueryCompatibleWithTagAt(newQuery, Tag(editor, offset))) {
          remaining.add(offset)
        }
      }
@@ -149,8 +158,4 @@ class SearchProcessor private constructor(
      results[editor] = remaining
    }
  }
-  
-  fun clone(): SearchProcessor {
-    return SearchProcessor(editors, query, results.clone())
-  }
 }
--- a/src/main/kotlin/org/acejump/search/SearchQuery.kt
+++ b/src/main/kotlin/org/acejump/search/SearchQuery.kt
@@ -19,27 +19,27 @@ internal sealed class SearchQuery {
  abstract fun toRegex(): Regex?

  /**
-   * Searches for all occurrences of a literal text query. If the first character of the query is lowercase, then the entire query will be
+   * Searches for all occurrences of a literal text query. If the first
+   * character of the query is lowercase, then the entire query will be
   * case-insensitive.
   *
-   * Each occurrence must either match the entire query, or match the query up to a point so that the rest of the query matches the
-   * beginning of a tag at the location of the occurrence.
+   * Each occurrence must either match the entire query, or match the query
+   * up to a point so that the rest of the query matches the  beginning of
+   * a tag at the location of the occurrence.
   */
-  class Literal(override val rawText: String) : SearchQuery() {
+  class Literal(override var rawText: String): SearchQuery() {
    init {
      require(rawText.isNotEmpty())
    }

-    override fun getHighlightLength(text: CharSequence, offset: Int): Int {
-      return text.countMatchingCharacters(offset, rawText)
-    }
+    override fun getHighlightLength(text: CharSequence, offset: Int): Int =
+      text.countMatchingCharacters(offset, rawText)

    override fun toRegex(): Regex {
      val options = mutableSetOf(RegexOption.MULTILINE)

-      if (rawText.first().isLowerCase()) {
+      if (rawText.first().isLowerCase())
        options.add(RegexOption.IGNORE_CASE)
-      }

      return Regex(Regex.escape(rawText), options)
    }
@@ -48,15 +48,12 @@ internal sealed class SearchQuery {
  /**
   * Searches for all matches of a regular expression.
   */
-  class RegularExpression(private val pattern: String) : SearchQuery() {
+  class RegularExpression(private var pattern: String): SearchQuery() {
    override val rawText = ""

-    override fun getHighlightLength(text: CharSequence, offset: Int): Int {
-      return 1
-    }
+    override fun getHighlightLength(text: CharSequence, offset: Int) = 1

-    override fun toRegex(): Regex {
-      return Regex(pattern, setOf(RegexOption.MULTILINE, RegexOption.IGNORE_CASE))
-    }
+    override fun toRegex(): Regex =
+      Regex(pattern, setOf(RegexOption.MULTILINE, RegexOption.IGNORE_CASE))
  }
 }
--- a/src/main/kotlin/org/acejump/search/Solver.kt
+++ b/src/main/kotlin/org/acejump/search/Solver.kt
@@ -4,13 +4,13 @@ import com.intellij.openapi.editor.Editor
 import it.unimi.dsi.fastutil.ints.IntList
 import it.unimi.dsi.fastutil.ints.IntOpenHashSet
 import org.acejump.boundaries.EditorOffsetCache
-import org.acejump.boundaries.StandardBoundaries
+import org.acejump.boundaries.StandardBoundaries.VISIBLE_ON_SCREEN
 import org.acejump.config.AceConfig
 import org.acejump.immutableText
 import org.acejump.input.KeyLayoutCache
 import org.acejump.isWordPart
 import org.acejump.wordEndPlus
-import java.util.IdentityHashMap
+import java.util.*
 import kotlin.math.max

 /*
@@ -54,7 +54,7 @@ internal class Solver private constructor(
  private val editorPriority: List<Editor>,
  private val queryLength: Int,
  private val newResults: Map<Editor, IntList>,
-  private val allResults: Map<Editor, IntList>,
+  private val allResults: Map<Editor, IntList>
 ) {
  companion object {
    fun solve(
@@ -63,37 +63,34 @@ internal class Solver private constructor(
      newResults: Map<Editor, IntList>,
      allResults: Map<Editor, IntList>,
      tags: List<String>,
-      caches: Map<Editor, EditorOffsetCache>,
-    ): Map<String, Tag> {
-      return Solver(editorPriority, max(1, query.rawText.length), newResults, allResults).map(tags, caches)
-    }
+      caches: Map<Editor, EditorOffsetCache>
+    ): Map<String, Tag> =
+      Solver(editorPriority, max(1, query.rawText.length), newResults, allResults)
+        .map(tags, caches)
  }

  private var newTags = HashMap<String, Tag>(KeyLayoutCache.allPossibleTags.size)
  private val newTagIndices = newResults.keys.associateWith { IntOpenHashSet() }

-  private var allWordFragments = HashSet<String>(allResults.values.sumBy(IntList::size)).apply {
+  private var allWordFragments =
+    HashSet<String>(allResults.values.sumOf(IntList::size)).apply {
      for ((editor, offsets) in allResults) {
-      val chars = editor.immutableText
        val iter = offsets.iterator()
-      while (iter.hasNext()) {
-        forEachWordFragment(chars, iter.nextInt(), this::add)
-      }
+        while (iter.hasNext()) forEachWordFragment(editor, iter.nextInt()) { add(it) }
      }
    }

-  private fun generateEligibleSites(availableTags: List<String>): Map<String, MutableList<Tag>> {
+  fun map(availableTags: List<String>, caches: Map<Editor, EditorOffsetCache>): Map<String, Tag> {
    val eligibleSitesByTag = HashMap<String, MutableList<Tag>>(100)
    val tagsByFirstLetter = availableTags.groupBy { it[0] }
    
    for ((editor, offsets) in newResults) {
-      val chars = editor.immutableText
      val iter = offsets.iterator()
      while (iter.hasNext()) {
        val site = iter.nextInt()
        
        for ((firstLetter, tags) in tagsByFirstLetter.entries) {
-          if (canTagBeginWithChar(chars, site, firstLetter)) {
+          if (canTagBeginWithChar(editor, site, firstLetter)) {
            for (tag in tags) {
              eligibleSitesByTag.getOrPut(tag, ::mutableListOf).add(Tag(editor, site))
            }
@@ -102,32 +99,11 @@ internal class Solver private constructor(
      }
    }
    
-    return eligibleSitesByTag
-  }
-  
-  private fun generateMatchingSites(
-    eligibleSites: Map<String, MutableList<Tag>>,
-    caches: Map<Editor, EditorOffsetCache>,
-  ): Map<String, Iterator<Tag>> {
-    val matchingSites = HashMap<MutableList<Tag>, Iterator<Tag>>()
-    val matchingSitesSorted = IdentityHashMap<String, Iterator<Tag>>() // Keys are guaranteed to be from a single collection.
+    val matchingSites = HashMap<MutableList<Tag>, MutableList<Tag>>()
+    // Keys are guaranteed to be from a single collection.
+    val matchingSitesAsArrays = IdentityHashMap<String, MutableList<Tag>>()
    
    val siteOrder = siteOrder(caches)
-    
-    for ((mark, tags) in eligibleSites.entries) {
-      matchingSitesSorted[mark] = matchingSites.getOrPut(tags) {
-        @Suppress("ConvertLambdaToReference")
-        tags.toMutableList().apply { sortWith(siteOrder) }.iterator()
-      }
-    }
-    
-    return matchingSitesSorted
-  }
-  
-  fun map(availableTags: List<String>, caches: Map<Editor, EditorOffsetCache>): Map<String, Tag> {
-    val eligibleSitesByTag = generateEligibleSites(availableTags)
-    val matchingSitesSorted = generateMatchingSites(eligibleSitesByTag, caches)
-    
    val tagOrder = KeyLayoutCache.tagOrder
      .thenComparingInt { eligibleSitesByTag.getValue(it).size }
      .thenBy(AceConfig.layout.priority(String::last))
@@ -136,15 +112,21 @@ internal class Solver private constructor(
      sortWith(tagOrder)
    }

+    for ((mark, tags) in eligibleSitesByTag.entries) {
+      matchingSitesAsArrays[mark] = matchingSites.getOrPut(tags) {
+        tags.toMutableList().apply { sortWith(siteOrder) }
+      }
+    }
+
    var totalAssigned = 0
-    val totalResults = newResults.values.sumBy(IntList::size)
+    val totalResults = newResults.values.sumOf(IntList::size)
    
    for (tag in sortedTags) {
      if (totalAssigned == totalResults) {
        break
      }

-      if (tryToAssignTag(tag, matchingSitesSorted.getValue(tag))) {
+      if (tryToAssignTag(tag, matchingSitesAsArrays.getValue(tag))) {
        totalAssigned++
      }
    }
@@ -152,24 +134,15 @@ internal class Solver private constructor(
    return newTags
  }

-  private fun tryToAssignTag(mark: String, tags: Iterator<Tag>): Boolean {
-    if (newTags.containsKey(mark)) {
-      return false
-    }
+  private fun tryToAssignTag(mark: String, tags: List<Tag>): Boolean {
+    if (newTags.containsKey(mark)) return false

-    while (tags.hasNext()) {
-      val tag = tags.next()
-      val assigned = newTagIndices.getValue(tag.editor)
-      
-      if (tag.offset !in assigned) {
-        newTags[mark] = tag
-        assigned.add(tag.offset)
+    val tag = tags.firstOrNull { it.offset !in newTagIndices.getValue(it.editor) } ?: return false
+    @Suppress("ReplacePutWithAssignment")
+    newTags.put(mark, tag)
+    newTagIndices.getValue(tag.editor).add(tag.offset)
    return true
  }
-    }
-    
-    return false
-  }

  private fun siteOrder(caches: Map<Editor, EditorOffsetCache>) = Comparator<Tag> { a, b ->
    val aEditor = a.editor
@@ -182,8 +155,8 @@ internal class Solver private constructor(
      return@Comparator if (aEditorIndex < bEditorIndex) -1 else 1
    }
  
-    val aIsVisible = StandardBoundaries.VISIBLE_ON_SCREEN.isOffsetInside(aEditor, a.offset, caches.getValue(aEditor))
-    val bIsVisible = StandardBoundaries.VISIBLE_ON_SCREEN.isOffsetInside(bEditor, b.offset, caches.getValue(bEditor))
+    val aIsVisible = VISIBLE_ON_SCREEN.isOffsetInside(aEditor, a.offset, caches.getValue(aEditor))
+    val bIsVisible = VISIBLE_ON_SCREEN.isOffsetInside(bEditor, b.offset, caches.getValue(bEditor))
    if (aIsVisible != bIsVisible) {
      // Sites in immediate view should come first.
      return@Comparator if (aIsVisible) -1 else 1
@@ -203,28 +176,22 @@ internal class Solver private constructor(
    }
  }

-  private fun canTagBeginWithChar(chars: CharSequence, site: Int, char: Char): Boolean {
-    if (char.toString() in allWordFragments) {
-      return false
-    }
-    
-    forEachWordFragment(chars, site) {
-      if (it + char in allWordFragments) {
-        return false
-      }
-    }
+  private fun canTagBeginWithChar(editor: Editor, site: Int, char: Char): Boolean {
+    if (char.toString() in allWordFragments) return false

+    forEachWordFragment(editor, site) { if (it + char in allWordFragments) return false }
    return true
  }

-  private inline fun forEachWordFragment(chars: CharSequence, site: Int, callback: (String) -> Unit) {
+  private inline fun forEachWordFragment(editor: Editor, site: Int, callback: (String) -> Unit) {
+    val chars = editor.immutableText
    val left = max(0, site + queryLength - 1)
    val right = chars.wordEndPlus(site)

    val builder = StringBuilder(1 + right - left)

    for (i in left..right) {
-      builder.append(chars[i].toLowerCase())
+      builder.append(chars[i].lowercase())
      callback(builder.toString())
    }
  }
--- a/src/main/kotlin/org/acejump/search/Tag.kt
+++ b/src/main/kotlin/org/acejump/search/Tag.kt
@@ -2,12 +2,4 @@ package org.acejump.search

 import com.intellij.openapi.editor.Editor

-data class Tag(val editor: Editor, val offset: Int) {
-  override fun equals(other: Any?): Boolean {
-    return other is Tag && other.offset == offset && other.editor === editor
-  }
-  
-  override fun hashCode(): Int {
-    return (offset * 31) + editor.hashCode()
-  }
-}
+data class Tag(val editor: Editor, val offset: Int)
--- a/src/main/kotlin/org/acejump/search/Tagger.kt
+++ b/src/main/kotlin/org/acejump/search/Tagger.kt
@@ -7,7 +7,7 @@ import it.unimi.dsi.fastutil.ints.IntArrayList
 import it.unimi.dsi.fastutil.ints.IntList
 import org.acejump.ExternalUsage
 import org.acejump.boundaries.EditorOffsetCache
-import org.acejump.boundaries.StandardBoundaries
+import org.acejump.boundaries.StandardBoundaries.VISIBLE_ON_SCREEN
 import org.acejump.immutableText
 import org.acejump.input.KeyLayoutCache.allPossibleTags
 import org.acejump.isWordPart
@@ -22,40 +22,40 @@ import kotlin.math.min
 * Assigns tags to search occurrences, updates them when the search query changes, and requests a jump if the search query matches a tag.
 * The ordering of [editors] may be used to prioritize tagging editors earlier in the list in case of conflicts.
 */
-class Tagger(private val editors: List<Editor>) {
+internal class Tagger(private val editors: List<Editor>) {
  private var tagMap = HashBiMap.create<String, Tag>()
-  
  val hasTags
    get() = tagMap.isNotEmpty()

  @ExternalUsage
-  internal val tags
+  val tags
    get() = tagMap.map { SimpleImmutableEntry(it.key, it.value) }.sortedBy { it.value.offset }
  
  /**
   * Removes all markers, allowing them to be regenerated from scratch.
   */
-  internal fun unmark() {
+  fun unmark() {
    tagMap = HashBiMap.create()
  }

  /**
-   * Assigns tags to as many results as possible, keeping previously assigned tags. Returns a [TaggingResult.Accept] if the current search
-   * query matches any existing tag and we should jump to it and end the session, or [TaggingResult.Mark] to continue the session with
-   * updated tag markers.
+   * Assigns tags to as many results as possible, keeping previously assigned
+   * tags. Returns a [TaggingResult.Jump] if the current search query matches
+   * any existing tag and we should jump to it and end the session, or
+   * [TaggingResult.Mark] to continue the session with updated tag markers.
   *
   * Note that the [results] collection will be mutated.
   */
-  internal fun update(query: SearchQuery, results: Map<Editor, IntList>): TaggingResult {
+  fun markOrJump(query: SearchQuery, results: Map<Editor, IntList>): TaggingResult {
    val isRegex = query is SearchQuery.RegularExpression
-    val queryText = if (isRegex) " ${query.rawText}" else query.rawText[0] + query.rawText.drop(1).toLowerCase()
+    val queryText = if (isRegex) " ${query.rawText}" else query.rawText[0] + query.rawText.drop(1).lowercase()

    val availableTags = allPossibleTags.filter { !queryText.endsWith(it[0]) && it !in tagMap }

    if (!isRegex) {
      for (entry in tagMap.entries) {
        if (entry solves queryText) {
-          return TaggingResult.Accept(entry.value)
+          return TaggingResult.Jump(query = queryText.substringBefore(entry.key), mark = entry.key, tag = entry.value)
        }
      }
      
@@ -66,23 +66,22 @@ class Tagger(private val editors: List<Editor>) {
      }
    }

-    if (!isRegex || tagMap.isEmpty()) {
+    if (!isRegex || tagMap.isEmpty())
      tagMap = assignTagsAndMerge(results, availableTags, query, queryText)
-    }

    val resultTags = results.flatMap { (editor, offsets) -> offsets.map { Tag(editor, it) } }
    return TaggingResult.Mark(createTagMarkers(resultTags, query.rawText.ifEmpty { null }))
  }

-  fun clone(): Tagger {
-    return Tagger(editors).also { it.tagMap.putAll(tagMap) }
-  }
-  
  /**
-   * Assigns as many unassigned tags as possible, and merges them with the existing compatible tags.
+   * Assigns as many unassigned tags as possible, and merges them with
+   * the existing compatible tags.
   */
  private fun assignTagsAndMerge(
-    results: Map<Editor, IntList>, availableTags: List<String>, query: SearchQuery, queryText: String,
+    results: Map<Editor, IntList>,
+    availableTags: List<String>,
+    query: SearchQuery,
+    queryText: String
  ): HashBiMap<String, Tag> {
    val caches = results.keys.associateWith { EditorOffsetCache.new() }

@@ -90,14 +89,13 @@ class Tagger(private val editors: List<Editor>) {
      val cache = caches.getValue(editor)
      
      offsets.sort { a, b ->
-        val aIsVisible = StandardBoundaries.VISIBLE_ON_SCREEN.isOffsetInside(editor, a, cache)
-        val bIsVisible = StandardBoundaries.VISIBLE_ON_SCREEN.isOffsetInside(editor, b, cache)
+        val aIsVisible = VISIBLE_ON_SCREEN.isOffsetInside(editor, a, cache)
+        val bIsVisible = VISIBLE_ON_SCREEN.isOffsetInside(editor, b, cache)

      when {
        aIsVisible && !bIsVisible -> -1
        bIsVisible && !aIsVisible -> 1
-          else                      -> 0
-        }
+        else -> 0}
      }
    }

@@ -107,11 +105,9 @@ class Tagger(private val editors: List<Editor>) {
    }
    
    val vacantResults: Map<Editor, IntList>
-    
    if (oldCompatibleTags.isEmpty()) {
      vacantResults = results
-    }
-    else {
+    } else {
      val vacant = mutableMapOf<Editor, IntList>()
      
      for ((editor, offsets) in results) {
@@ -120,6 +116,7 @@ class Tagger(private val editors: List<Editor>) {
        
        while (iter.hasNext()) {
          val tag = Tag(editor, iter.nextInt())
+
        if (tag !in oldCompatibleTags.values) {
            list.add(tag.offset)
          }
@@ -134,10 +131,12 @@ class Tagger(private val editors: List<Editor>) {
    allAssignedTags.putAll(oldCompatibleTags)
    allAssignedTags.putAll(Solver.solve(editors, query, vacantResults, results, availableTags, caches))
    
-    val assignedMarkers = allAssignedTags.keys.groupBy { it[0] }
-    
    return allAssignedTags.mapKeysTo(HashBiMap.create(allAssignedTags.size)) { (tag, _) ->
-      if (canShortenTag(tag, assignedMarkers, queryText))
+      // Avoid matching query - will trigger a jump.
+      // TODO: lift this constraint.
+      val queryEndsWith = queryText.endsWith(tag[0]) || queryText.endsWith(tag)
+
+      if (!queryEndsWith && canShortenTag(tag, allAssignedTags.keys))
        tag[0].toString()
      else
        tag
@@ -202,9 +201,9 @@ class Tagger(private val editors: List<Editor>) {
      else -> false
    }

-    private infix fun Char.isUnlike(other: Char): Boolean {
-      return this.isWordPart xor other.isWordPart || this.isWhitespace() xor other.isWhitespace()
-    }
+    private infix fun Char.isUnlike(other: Char) =
+      this.isWordPart xor other.isWordPart ||
+        this.isWhitespace() xor other.isWhitespace()

    private fun getPlaintextPortion(query: String, marker: String) = when {
      query.endsWith(marker, true) -> query.dropLast(marker.length)
@@ -218,16 +217,12 @@ class Tagger(private val editors: List<Editor>) {
      else -> ""
    }

-    private fun canShortenTag(marker: String, markers: Map<Char, List<String>>, queryText: String): Boolean {
-      // Avoid matching query - will trigger a jump.
-      // TODO: lift this constraint.
-      val queryEndsWith = queryText.endsWith(marker[0]) || queryText.endsWith(marker)
-      if (queryEndsWith) {
+    private fun canShortenTag(marker: String, markers: Collection<String>): Boolean {
+      for (other in markers)
+        if (marker != other && marker[0] == other[0])
          return false
-      }

-      val startingWithSameLetter = markers[marker[0]]
-      return startingWithSameLetter == null || startingWithSameLetter.singleOrNull() == marker
+      return true
    }
  }
 }
--- a/src/main/kotlin/org/acejump/search/TaggingResult.kt
+++ b/src/main/kotlin/org/acejump/search/TaggingResult.kt
@@ -3,7 +3,7 @@ package org.acejump.search
 import com.intellij.openapi.editor.Editor
 import org.acejump.view.TagMarker

-internal sealed class TaggingResult {
-  class Accept(val tag: Tag) : TaggingResult()
-  class Mark(val markers: MutableMap<Editor, Collection<TagMarker>>) : TaggingResult()
+sealed class TaggingResult {
+  class Jump(val query: String, val mark: String, val tag: Tag): TaggingResult()
+  class Mark(val markers: MutableMap<Editor, Collection<TagMarker>>): TaggingResult()
 }
--- a/src/main/kotlin/org/acejump/session/AceJumpListener.kt
+++ b/src/main/kotlin/org/acejump/session/AceJumpListener.kt
@@ -0,0 +1,5 @@
+package org.acejump.session
+
+interface AceJumpListener {
+  fun finished(mark: String?, query: String?)
+}
--- a/src/main/kotlin/org/acejump/session/EditorSettings.kt
+++ b/src/main/kotlin/org/acejump/session/EditorSettings.kt
@@ -3,10 +3,15 @@ package org.acejump.session
 import com.intellij.openapi.editor.Editor

 /**
- * Holds [Editor] caret settings. The settings are saved the moment a [Session] starts, modified to indicate AceJump states, and restored
- * once the [Session] ends.
+ * Holds [Editor] caret settings. The settings are saved the
+ * moment a [Session] starts, modified to indicate AceJump
+ * states, and restored once the [Session] ends.
 */
-internal data class EditorSettings(private val isBlockCursor: Boolean, private val isBlinkCaret: Boolean, private val isReadOnly: Boolean) {
+internal data class EditorSettings(
+  private val isBlockCursor: Boolean,
+  private val isBlinkCaret: Boolean,
+  private val isReadOnly: Boolean
+) {
  companion object {
    fun setup(editor: Editor): EditorSettings {
      val settings = editor.settings
@@ -26,22 +31,6 @@ internal data class EditorSettings(private val isBlockCursor: Boolean, private v
    }
  }

-  fun startEditing(editor: Editor) {
-    editor.document.setReadOnly(isReadOnly)
-  }
-  
-  fun stopEditing(editor: Editor) {
-    editor.document.setReadOnly(true)
-  }
-  
-  fun onTagAccepted(editor: Editor) = editor.let {
-    it.settings.isBlockCursor = isBlockCursor
-  }
-  
-  fun onTagUnaccepted(editor: Editor) = editor.let {
-    it.settings.isBlockCursor = true
-  }
-  
  fun restore(editor: Editor) {
    val settings = editor.settings
    val document = editor.document
--- a/src/main/kotlin/org/acejump/session/Session.kt
+++ b/src/main/kotlin/org/acejump/session/Session.kt
@@ -1,51 +1,75 @@
 package org.acejump.session

-import com.intellij.codeInsight.hint.HintManager
-import com.intellij.codeInsight.hint.HintManagerImpl
-import com.intellij.codeInsight.hint.HintUtil
 import com.intellij.openapi.actionSystem.DataContext
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.editor.ScrollType
 import com.intellij.openapi.editor.actionSystem.TypedActionHandler
-import com.intellij.openapi.editor.colors.EditorColors
-import com.intellij.openapi.editor.colors.impl.AbstractColorsScheme
-import com.intellij.ui.LightweightHint
-import org.acejump.ExternalUsage
+import com.intellij.openapi.editor.colors.EditorColors.CARET_COLOR
+import com.intellij.util.containers.ContainerUtil
+import it.unimi.dsi.fastutil.ints.IntArrayList
+import org.acejump.*
+import org.acejump.action.TagScroller
+import org.acejump.action.TagJumper
+import org.acejump.action.TagVisitor
 import org.acejump.boundaries.Boundaries
-import org.acejump.boundaries.StandardBoundaries
-import org.acejump.clone
+import org.acejump.boundaries.EditorOffsetCache
+import org.acejump.boundaries.StandardBoundaries.VISIBLE_ON_SCREEN
+import org.acejump.boundaries.StandardBoundaries.WHOLE_FILE
 import org.acejump.config.AceConfig
-import org.acejump.immutableText
 import org.acejump.input.EditorKeyListener
+import org.acejump.input.JumpMode
+import org.acejump.input.JumpModeTracker
 import org.acejump.input.KeyLayoutCache
-import org.acejump.modes.AdvancedMode
-import org.acejump.modes.BetweenPointsMode
-import org.acejump.modes.JumpMode
-import org.acejump.modes.SessionMode
-import org.acejump.search.*
+import org.acejump.search.Pattern
+import org.acejump.search.SearchProcessor
+import org.acejump.search.Tagger
+import org.acejump.search.TaggingResult
 import org.acejump.view.TagCanvas
 import org.acejump.view.TextHighlighter
+import java.util.*

 /**
- * Manages an AceJump session for a single [Editor].
+ * Manages an AceJump session for one or more [Editor]s.
 */
 class Session(private val mainEditor: Editor, private val jumpEditors: List<Editor>) {
-  private val editorSettings = EditorSettings.setup(mainEditor)
-  private lateinit var mode: SessionMode
+  private val listeners: MutableList<AceJumpListener> =
+    ContainerUtil.createLockFreeCopyOnWriteList()

-  private var state: SessionStateImpl? = null
-  private var tagger = Tagger(jumpEditors)
+  private var boundaries: Boundaries = defaultBoundaries

-  private var acceptedTag: Tag? = null
+  private companion object {
+    private val defaultBoundaries
+      get() = if (AceConfig.searchWholeFile) WHOLE_FILE else VISIBLE_ON_SCREEN
+  }
+
+  private val originalSettings = EditorSettings.setup(mainEditor)
+
+  private val jumpModeTracker = JumpModeTracker()
+  private var jumpMode = JumpMode.DISABLED
    set(value) {
      field = value

-      if (value != null) {
-        tagCanvases.values.forEach(TagCanvas::removeMarkers)
-        editorSettings.onTagAccepted(mainEditor)
+      if (value === JumpMode.DISABLED) {
+        end()
+      } else {
+        searchProcessor?.let { textHighlighter.render(it.results, it.query, jumpMode) }
+        mainEditor.colorsScheme.setColor(CARET_COLOR, value.caretColor)
+        mainEditor.contentComponent.repaint()
      }
    }

+  private var searchProcessor: SearchProcessor? = null
+  private var tagger = Tagger(jumpEditors)
+
+  private val tagJumper
+    get() = TagJumper(jumpMode, searchProcessor)
+
+  private val tagVisitor
+    get() = searchProcessor?.let { TagVisitor(mainEditor, it, tagJumper) }
+
+  private val tagScroller
+    get() = searchProcessor?.let { TagScroller(mainEditor, it) }
+
  private val textHighlighter = TextHighlighter()
  private val tagCanvases = jumpEditors.associateWith(::TagCanvas)

@@ -53,209 +77,230 @@ class Session(private val mainEditor: Editor, private val jumpEditors: List<Edit
  val tags
    get() = tagger.tags

-  var defaultBoundary: Boundaries = StandardBoundaries.VISIBLE_ON_SCREEN
-  
  init {
    KeyLayoutCache.ensureInitialized(AceConfig.settings)

-    EditorKeyListener.attach(mainEditor, object : TypedActionHandler {
+    EditorKeyListener.attach(mainEditor, object: TypedActionHandler {
      override fun execute(editor: Editor, charTyped: Char, context: DataContext) {
-        val state = state ?: return
+        var processor = searchProcessor
        val hadTags = tagger.hasTags

-        editorSettings.startEditing(editor)
-        val result = mode.type(state, charTyped, acceptedTag)
-        editorSettings.stopEditing(editor)
-        
-        when (result) {
-          TypeResult.Nothing          -> updateHint()
-          is TypeResult.UpdateResults -> updateSearch(result.processor, markImmediately = hadTags)
-          is TypeResult.ChangeMode    -> setMode(result.mode)
-          
-          TypeResult.RestartSearch    -> restart().also {
-            this@Session.state = SessionStateImpl(jumpEditors, tagger, defaultBoundary)
-            updateHint()
+        if (processor == null) {
+          processor = SearchProcessor.fromChar(
+            jumpEditors, charTyped, boundaries
+          ).also { searchProcessor = it }
+        } else if (!processor.type(charTyped, tagger)) {
+          return
        }

-          TypeResult.EndSession       -> end()
-        }
+        updateSearch(
+          processor, markImmediately = hadTags,
+          shiftMode = charTyped.isUpperCase()
+        )
      }
    })
  }

  /**
-   * Updates text highlights and tag markers according to the current search state. Dispatches jumps if the search query matches a tag.
+   * Updates text highlights and tag markers according to the current
+   * search state. Dispatches jumps if the search query matches a tag.
+   * If all tags are outside view, scrolls to the closest one.
   */
-  private fun updateSearch(processor: SearchProcessor, markImmediately: Boolean) {
+  private fun updateSearch(
+    processor: SearchProcessor,
+    markImmediately: Boolean,
+    shiftMode: Boolean = false
+  ) {
    val query = processor.query
    val results = processor.results

-    if (!markImmediately && query.rawText.let { it.length < AceConfig.minQueryLength && it.all(Char::isLetterOrDigit) }) {
-      textHighlighter.renderOccurrences(results, query)
+    textHighlighter.render(results, query, jumpMode)
+
+    if (!markImmediately &&
+      query.rawText.let {
+        it.length < AceConfig.minQueryLength &&
+          it.all(Char::isLetterOrDigit)
+      }
+    ) {
      return
    }

-    when (val result = tagger.update(query, results.clone())) {
-      is TaggingResult.Accept -> {
-        acceptedTag = result.tag
-        textHighlighter.renderFinal(result.tag, processor.query)
-        
-        if (state?.let { mode.accept(it, result.tag) } == true) {
-          end()
-          return
-        }
+    when (val result = tagger.markOrJump(query, results.clone())) {
+      is TaggingResult.Jump -> {
+        tagJumper.jump(result.tag, shiftMode, isCrossEditor = mainEditor !== result.tag.editor)
+        tagCanvases.values.forEach(TagCanvas::removeMarkers)
+        end(result)
      }

      is TaggingResult.Mark -> {
+        val markers = result.markers
+        
        for ((editor, canvas) in tagCanvases) {
-          canvas.setMarkers(result.markers[editor].orEmpty())
+          canvas.setMarkers(markers[editor].orEmpty())
        }
        
-        textHighlighter.renderOccurrences(results, query)
+        if (jumpEditors.all { editor ->
+            val cache = EditorOffsetCache.new()
+            markers[editor].let { it == null || it.none { marker ->
+              VISIBLE_ON_SCREEN.isOffsetInside(editor, marker.offsetL, cache) ||
+              VISIBLE_ON_SCREEN.isOffsetInside(editor, marker.offsetR, cache) } }
+        }) {
+          tagVisitor?.scrollToClosest()
+        }
+      }
    }
  }

-    updateHint()
-  }
-  
-  private fun setMode(mode: SessionMode) {
-    this.mode = mode
-    mainEditor.colorsScheme.setColor(EditorColors.CARET_COLOR, mode.caretColor)
-    updateHint()
-  }
-  
-  private fun updateHint() {
-    val acceptedTag = acceptedTag
-    val editor = mainEditor
-    val offset = when {
-      acceptedTag == null           -> null
-      acceptedTag.editor === editor -> acceptedTag.offset
-      else                          -> mainEditor.caretModel.offset
-    }
-    
-    val hintArray = mode.getHint(offset, state?.currentProcessor.let { it != null && it.query.rawText.isNotEmpty() }) ?: return
-    val hintText = hintArray
-      .joinToString("\n")
-      .replace("<f>", "<span style=\"font-family:'${editor.colorsScheme.editorFontName}';font-weight:bold\">")
-      .replace("</f>", "</span>")
-    
-    val hint = LightweightHint(HintUtil.createInformationLabel(hintText))
-    val pos = offset?.let(editor::offsetToLogicalPosition) ?: editor.caretModel.logicalPosition
-    val point = HintManagerImpl.getHintPosition(hint, editor, pos, HintManager.ABOVE)
-    val info = HintManagerImpl.createHintHint(editor, point, hint, HintManager.ABOVE).setShowImmediately(true)
-    val flags = HintManager.UPDATE_BY_SCROLLING or HintManager.HIDE_BY_ESCAPE
-    HintManagerImpl.getInstanceImpl().showEditorHint(hint, editor, point, flags, 0, true, info)
-  }
-  
-  fun startJumpMode() {
-    startJumpMode(::JumpMode)
-  }
-  
-  fun startJumpMode(mode: () -> JumpMode) {
-    if (this::mode.isInitialized && mode is JumpMode) {
-      end()
-      return
-    }
-    
-    if (this::mode.isInitialized) {
-      restart()
-    }
-    
-    setMode(mode())
-    state = SessionStateImpl(jumpEditors, tagger, defaultBoundary)
-  }
-  
-  fun startOrCycleSpecialModes() {
-    if (!this::mode.isInitialized) {
-      setMode(AdvancedMode())
-      state = SessionStateImpl(jumpEditors, tagger, defaultBoundary)
-      return
-    }
-    
-    restart()
-    setMode(when (mode) {
-      is AdvancedMode -> BetweenPointsMode()
-      else            -> AdvancedMode()
-    })
-    
-    state = SessionStateImpl(jumpEditors, tagger, defaultBoundary)
-  }
-  
-  /**
-   * Starts a regular expression search. If a search was already active, it will be reset alongside its tags and highlights.
-   */
-  fun startRegexSearch(pattern: Pattern) {
-    if (!this::mode.isInitialized) {
-      setMode(JumpMode())
+  @ExternalUsage
+  fun markResults(resultsToMark: SortedSet<Int>) {
+    val jumpEditor = jumpEditors.singleOrNull() ?: return
+    markResults(mapOf(jumpEditor to resultsToMark))
  }
  
+  @ExternalUsage
+  fun markResults(resultsToMark: Map<Editor, Collection<Int>>) {
    tagger = Tagger(jumpEditors)
    tagCanvases.values.forEach { it.setMarkers(emptyList()) }
  
-    val processor = SearchProcessor.fromRegex(jumpEditors, pattern.regex, defaultBoundary).also {
-      state = SessionStateImpl(jumpEditors, tagger, defaultBoundary, it)
+    val processor = SearchProcessor.fromRegex(jumpEditors, "", defaultBoundaries)
+      .apply {
+        results.clear()
+        for ((editor, offsets) in resultsToMark) {
+          if (editor in jumpEditors) {
+            results[editor] = IntArrayList(offsets)
+          }
+        }
      }
  
    updateSearch(processor, markImmediately = true)
  }

-  fun tagImmediately() {
-    val state = state ?: return
-    val processor = state.currentProcessor
+  /**
+   * Starts a regular expression search. If a search was already active,
+   * it will be reset alongside its tags and highlights.
+   */

-    if (processor != null) {
+  @ExternalUsage
+  fun startRegexSearch(pattern: String, boundaries: Boundaries) {
+    tagger = Tagger(jumpEditors)
+    tagCanvases.values.forEach { it.setMarkers(emptyList()) }
+
+    val processor = SearchProcessor.fromRegex(
+      jumpEditors, pattern,
+      boundaries.intersection(defaultBoundaries)
+    ).also { searchProcessor = it }
    updateSearch(processor, markImmediately = true)
  }
-    else if (mode is AdvancedMode) {
-      val offset = mainEditor.caretModel.offset
-      val result = mainEditor.immutableText.getOrNull(offset)?.let(state::type)
-      if (result is TypeResult.UpdateResults) {
-        val tag = Tag(mainEditor, offset).also { acceptedTag = it }
-        textHighlighter.renderFinal(tag, result.processor.query)
-        updateHint()
+
+  /**
+   * Starts a regular expression search. If a search was already active,
+   * it will be reset alongside its tags and highlights.
+   */
+
+  @ExternalUsage
+  fun startRegexSearch(pattern: Pattern, boundaries: Boundaries) =
+    startRegexSearch(pattern.regex, boundaries)
+
+  /**
+   * See [JumpModeTracker.cycle].
+   */
+  fun cycleNextJumpMode() {
+    jumpMode = jumpModeTracker.cycle(forward = true)
  }
+
+  /**
+   * See [JumpModeTracker.cycle].
+   */
+  fun cyclePreviousJumpMode() {
+    jumpMode = jumpModeTracker.cycle(forward = false)
  }
+
+  /**
+   * See [JumpModeTracker.toggle]
+   */
+  fun toggleJumpMode(newMode: JumpMode) {
+    jumpMode = jumpModeTracker.toggle(newMode)
  }

+  @ExternalUsage
+  fun toggleJumpMode(newMode: JumpMode, boundaries: Boundaries) {
+    this.boundaries = this.boundaries.intersection(boundaries)
+    jumpMode = jumpModeTracker.toggle(newMode)
+  }
+
+  /**
+   * See [TagVisitor.visitPrevious]. If there are no tags, nothing happens.
+   */
+  fun visitPreviousTag() =
+    if (tagVisitor?.visitPrevious() == true) end() else Unit
+
+  /**
+   * See [TagVisitor.visitNext]. If there are no tags, nothing happens.
+   */
+  fun visitNextTag() =
+    if (tagVisitor?.visitNext() == true) end() else Unit
+
+  /**
+   * See [TagVisitor.visitPrevious]. If there are no tags, nothing happens.
+   */
+  fun scrollToNextScreenful() = tagScroller?.scroll(true)
+
+  /**
+   * See [TagVisitor.visitNext]. If there are no tags, nothing happens.
+   */
+  fun scrollToPreviousScreenful() = tagScroller?.scroll(false)
+
  /**
   * Ends this session.
   */
-  fun end() {
-    SessionManager.end(mainEditor)
-  }
+  fun end(taggingResult: TaggingResult? = null) =
+    SessionManager.end(mainEditor, taggingResult)

  /**
   * Clears any currently active search, tags, and highlights.
+   * Does not reset [JumpMode].
   */
  fun restart() {
-    state = null
    tagger = Tagger(jumpEditors)
-    acceptedTag = null
+    searchProcessor = null
    tagCanvases.values.forEach(TagCanvas::removeMarkers)
    textHighlighter.reset()
-    
-    HintManagerImpl.getInstanceImpl().hideAllHints()
-    editorSettings.onTagUnaccepted(mainEditor)
-    mainEditor.colorsScheme.setColor(EditorColors.CARET_COLOR, mode.caretColor)
-    jumpEditors.forEach { it.contentComponent.repaint() }
  }

  /**
-   * Should only be used from [SessionManager] to dispose a successfully ended session.
+   * Should only be used from [SessionManager] to dispose a
+   * successfully ended session.
   */
-  internal fun dispose() {
+  internal fun dispose(taggingResult: TaggingResult?) {
    tagger = Tagger(jumpEditors)
+    EditorKeyListener.detach(mainEditor)
    tagCanvases.values.forEach(TagCanvas::unbind)
    textHighlighter.reset()
-    EditorKeyListener.detach(mainEditor)
+    EditorsCache.invalidate()
+
+    val jumpResult = taggingResult as? TaggingResult.Jump
+    val mark = jumpResult?.mark
+    val query = jumpResult?.query
+    listeners.forEach { it.finished(mark, query) }

    if (!mainEditor.isDisposed) {
-      HintManagerImpl.getInstanceImpl().hideAllHints()
-      editorSettings.restore(mainEditor)
-      mainEditor.colorsScheme.setColor(EditorColors.CARET_COLOR, AbstractColorsScheme.INHERITED_COLOR_MARKER)
+      originalSettings.restore(mainEditor)
+      mainEditor.colorsScheme.setColor(CARET_COLOR, JumpMode.DISABLED.caretColor)
+    }

-      val focusedEditor = acceptedTag?.editor ?: mainEditor
+    val focusedEditor = jumpResult?.tag?.editor ?: mainEditor
+    if (!focusedEditor.isDisposed) {
      focusedEditor.scrollingModel.scrollToCaret(ScrollType.MAKE_VISIBLE)
    }
  }
+
+  @ExternalUsage
+  fun addAceJumpListener(listener: AceJumpListener) {
+    listeners += listener
+  }
+
+  @ExternalUsage
+  fun removeAceJumpListener(listener: AceJumpListener) {
+    listeners -= listener
+  }
 }
--- a/src/main/kotlin/org/acejump/session/SessionManager.kt
+++ b/src/main/kotlin/org/acejump/session/SessionManager.kt
@@ -1,50 +1,53 @@
 package org.acejump.session

 import com.intellij.openapi.editor.Editor
+import org.acejump.ExternalUsage
+import org.acejump.search.TaggingResult

 /**
- * Manages active [Session]s in [Editor]s. There may only be one [Session] per [Editor], but multiple [Session]s across multiple [Editor]s
- * may be active at once.
+ * Manages active [Session]s in [Editor]s. There may only be
+ * one [Session] per [Editor], but multiple [Session]s across
+ * multiple [Editor]s may be active at once.
 *
- * It is possible for an [Editor] to be disposed with an active [Session]. In such case, the reference to both will remain until a new
- * [Session] starts, at which point the [SessionManager.cleanup] method will purge disposed [Editor]s.
+ * It is possible for an [Editor] to be disposed with an active
+ * [Session]. In such case, the reference to both will remain
+ * until a new [Session] starts, at which point the
+ * [SessionManager.cleanup] method will purge disposed [Editor]s.
 */
+
+@ExternalUsage
 object SessionManager {
  private val sessions = HashMap<Editor, Session>(4)

  /**
-   * Starts a new [Session], or returns an existing [Session] if the specified [Editor] already has one.
+   * Starts a new [Session], or returns an existing [Session]
+   * if the specified [Editor] already has one.
   */
-  fun start(editor: Editor): Session {
-    return start(editor, listOf(editor))
-  }
+  fun start(editor: Editor): Session = start(editor, listOf(editor))

  /**
   * Starts a new multi-editor [Session], or returns an existing [Session] if the specified main [Editor] already has one.
   * The [mainEditor] is used for typing the search query and tag.
-   * The [jumpEditors] are all editors that will be searched and tagged.
+   * The [jumpEditors] are all editors that will be searched and tagged. The list is ordered so that editors earlier in the list will be
+   * prioritized for tagging in case of conflicts.
   */
  fun start(mainEditor: Editor, jumpEditors: List<Editor>): Session {
    return sessions.getOrPut(mainEditor) { cleanup(); Session(mainEditor, jumpEditors) }
  }
  
  /**
-   * Returns the active [Session] in the specified [Editor], or null if the [Editor] has no active session.
+   * Returns the active [Session] in the specified [Editor],
+   * or null if the [Editor] has no active session.
   */
-  operator fun get(editor: Editor): Session? {
-    return sessions[editor]
-  }
+  operator fun get(editor: Editor): Session? = sessions[editor]

  /**
-   * Ends the active [Session] in the specified [Editor], or does nothing if the [Editor] has no active session.
+   * Ends the active [Session] in the specified [Editor],
+   * or does nothing if the [Editor] has no active session.
   */
-  fun end(editor: Editor) {
-    sessions.remove(editor)?.dispose()
-  }
+  fun end(editor: Editor, taggingResult: TaggingResult?) =
+    sessions.remove(editor)?.dispose(taggingResult) ?: Unit

-  private fun cleanup() {
-    for (disposedEditor in sessions.keys.filter { it.isDisposed }) {
-      sessions.remove(disposedEditor)?.dispose()
-    }
-  }
+  private fun cleanup() = sessions.keys.filter { it.isDisposed }
+    .forEach { disposedEditor -> sessions.remove(disposedEditor)?.dispose(null) }
 }
--- a/src/main/kotlin/org/acejump/session/SessionState.kt
+++ b/src/main/kotlin/org/acejump/session/SessionState.kt
@@ -1,9 +0,0 @@
-package org.acejump.session
-
-import org.acejump.action.AceTagAction
-import org.acejump.search.Tag
-
-interface SessionState {
-  fun type(char: Char): TypeResult
-  fun act(action: AceTagAction, tag: Tag, shiftMode: Boolean, isFinal: Boolean)
-}
--- a/src/main/kotlin/org/acejump/session/SessionStateImpl.kt
+++ b/src/main/kotlin/org/acejump/session/SessionStateImpl.kt
@@ -1,36 +0,0 @@
-package org.acejump.session
-
-import com.intellij.openapi.editor.Editor
-import org.acejump.action.AceTagAction
-import org.acejump.boundaries.Boundaries
-import org.acejump.search.SearchProcessor
-import org.acejump.search.Tag
-import org.acejump.search.Tagger
-
-internal class SessionStateImpl(
-  private val jumpEditors: List<Editor>,
-  private val tagger: Tagger,
-  private val defaultBoundary: Boundaries,
-  processor: SearchProcessor? = null
-) : SessionState {
-  internal var currentProcessor: SearchProcessor? = processor
-  
-  override fun type(char: Char): TypeResult {
-    val processor = currentProcessor
-    
-    if (processor == null) {
-      val newProcessor = SearchProcessor.fromChar(jumpEditors, char, defaultBoundary)
-      return TypeResult.UpdateResults(newProcessor.also { currentProcessor = it })
-    }
-    
-    if (processor.type(char, tagger)) {
-      return TypeResult.UpdateResults(processor)
-    }
-    
-    return TypeResult.Nothing
-  }
-  
-  override fun act(action: AceTagAction, tag: Tag, shiftMode: Boolean, isFinal: Boolean) {
-    currentProcessor?.let { action(tag.editor, it, tag.offset, shiftMode, isFinal) }
-  }
-}
--- a/src/main/kotlin/org/acejump/session/TypeResult.kt
+++ b/src/main/kotlin/org/acejump/session/TypeResult.kt
@@ -1,12 +0,0 @@
-package org.acejump.session
-
-import org.acejump.modes.SessionMode
-import org.acejump.search.SearchProcessor
-
-sealed class TypeResult {
-  object Nothing : TypeResult()
-  class UpdateResults(val processor: SearchProcessor) : TypeResult()
-  class ChangeMode(val mode: SessionMode) : TypeResult()
-  object RestartSearch : TypeResult()
-  object EndSession : TypeResult()
-}
--- a/src/main/kotlin/org/acejump/view/TagCanvas.kt
+++ b/src/main/kotlin/org/acejump/view/TagCanvas.kt
@@ -5,7 +5,7 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.editor.event.CaretEvent
 import com.intellij.openapi.editor.event.CaretListener
 import org.acejump.boundaries.EditorOffsetCache
-import org.acejump.boundaries.StandardBoundaries
+import org.acejump.boundaries.StandardBoundaries.VISIBLE_ON_SCREEN
 import java.awt.Graphics
 import java.awt.Graphics2D
 import java.awt.Rectangle
@@ -16,17 +16,16 @@ import javax.swing.SwingUtilities
 /**
 * Holds all active tag markers and renders them on top of the editor.
 */
-internal class TagCanvas(private val editor: Editor) : JComponent(), CaretListener {
+internal class TagCanvas(private val editor: Editor): JComponent(), CaretListener {
  private var markers: Collection<TagMarker>? = null
-  
  init {
    val contentComponent = editor.contentComponent
    contentComponent.add(this)
    setBounds(0, 0, contentComponent.width, contentComponent.height)

-    if (ApplicationInfo.getInstance().build.components.first() < 173) {
-      SwingUtilities.convertPoint(this, location, editor.component.rootPane).let { setLocation(-it.x, -it.y) }
-    }
+    if (ApplicationInfo.getInstance().build.components.first() < 173)
+      SwingUtilities.convertPoint(this, location, editor.component.rootPane)
+        .let { setLocation(-it.x, -it.y) }

    editor.caretModel.addCaretListener(this)
  }
@@ -38,12 +37,11 @@ internal class TagCanvas(private val editor: Editor) : JComponent(), CaretListen
  }

  /**
-   * Ensures that all tags and the outline around the selected tag are repainted. It should not be necessary to repaint the entire tag
+   * Ensures that all tags and the outline around the selected tag are
+   * repainted. It should not be necessary to repaint the entire tag
   * canvas, but the cost of repainting visible tags is negligible.
   */
-  override fun caretPositionChanged(event: CaretEvent) {
-    repaint()
-  }
+  override fun caretPositionChanged(event: CaretEvent) = repaint()

  fun setMarkers(markers: Collection<TagMarker>) {
    this.markers = markers
@@ -51,14 +49,11 @@ internal class TagCanvas(private val editor: Editor) : JComponent(), CaretListen
  }
  
  fun removeMarkers() {
-    this.markers = emptyList()
+    markers = emptyList()
  }

-  override fun paint(g: Graphics) {
-    if (!markers.isNullOrEmpty()) {
-      super.paint(g)
-    }
-  }
+  override fun paint(g: Graphics) =
+    if (!markers.isNullOrEmpty()) super.paint(g) else Unit

  override fun paintChildren(g: Graphics) {
    super.paintChildren(g)
@@ -70,23 +65,24 @@ internal class TagCanvas(private val editor: Editor) : JComponent(), CaretListen
    val font = TagFont(editor)

    val cache = EditorOffsetCache.new()
-    val viewRange = StandardBoundaries.VISIBLE_ON_SCREEN.getOffsetRange(editor, cache)
+    val viewRange = VISIBLE_ON_SCREEN.getOffsetRange(editor, cache)
    val occupied = mutableListOf<Rectangle>()

-    // If there is a tag at the caret location, prioritize its rendering over all other tags. This is helpful for seeing which tag is
-    // currently selected while navigating highly clustered tags, although it does end up rearranging nearby tags which can be confusing.
+    // If there is a tag at the caret location, prioritize its rendering over
+    // all other tags. This is helpful for seeing which tag is currently
+    // selected while navigating highly clustered tags, although it does end
+    // up rearranging nearby tags which can be confusing.

-    // TODO instead of immediately painting, we could calculate the layout of everything first, and then remove tags that interfere with
+    // TODO: instead of immediately painting, we could calculate the layout
+    //  of everything first, and then remove tags that interfere with
    //  the caret tag to avoid changing the alignment of the caret tag
    
    val caretOffset = editor.caretModel.offset
    val caretMarker = markers.find { it.offsetL == caretOffset || it.offsetR == caretOffset }
    caretMarker?.paint(g, editor, cache, font, occupied)

-    for (marker in markers) {
-      if (marker.isOffsetInRange(viewRange) && marker !== caretMarker) {
+    for (marker in markers)
+      if (marker.isOffsetInRange(viewRange) && marker !== caretMarker)
        marker.paint(g, editor, cache, font, occupied)
  }
-    }
-  }
 }
--- a/src/main/kotlin/org/acejump/view/TagFont.kt
+++ b/src/main/kotlin/org/acejump/view/TagFont.kt
@@ -1,24 +1,20 @@
 package org.acejump.view

 import com.intellij.openapi.editor.Editor
-import com.intellij.openapi.editor.colors.EditorFontType
-import com.intellij.ui.ColorUtil
-import org.acejump.config.AceConfig
+import com.intellij.openapi.editor.colors.EditorFontType.BOLD
+import com.intellij.openapi.editor.colors.EditorFontType.PLAIN
 import java.awt.Font
 import java.awt.FontMetrics

 /**
 * Stores font metrics for aligning and rendering [TagMarker]s.
 */
-internal class TagFont(editor: Editor) {
-  val tagFont: Font = editor.colorsScheme.getFont(EditorFontType.BOLD)
+class TagFont(editor: Editor) {
+  val tagFont: Font = editor.colorsScheme.getFont(BOLD)
  val tagCharWidth = editor.component.getFontMetrics(tagFont).charWidth('W')

-  val foregroundColor = AceConfig.tagForegroundColor
-  var backgroundColor = AceConfig.tagBackgroundColor
-  val isForegroundDark = ColorUtil.isDark(foregroundColor)
-  
-  val editorFontMetrics: FontMetrics = editor.component.getFontMetrics(editor.colorsScheme.getFont(EditorFontType.PLAIN))
+  val editorFontMetrics: FontMetrics =
+    editor.component.getFontMetrics(editor.colorsScheme.getFont(PLAIN))
  val lineHeight = editor.lineHeight
  val baselineDistance = editor.ascent
 }
--- a/src/main/kotlin/org/acejump/view/TagMarker.kt
+++ b/src/main/kotlin/org/acejump/view/TagMarker.kt
@@ -1,10 +1,12 @@
 package org.acejump.view

 import com.intellij.openapi.editor.Editor
-import com.intellij.openapi.util.SystemInfo
+import com.intellij.ui.ColorUtil
+import com.intellij.ui.JreHiDpiUtil
 import com.intellij.ui.scale.JBUIScale
 import org.acejump.boundaries.EditorOffsetCache
-import org.acejump.boundaries.StandardBoundaries
+import org.acejump.boundaries.StandardBoundaries.VISIBLE_ON_SCREEN
+import org.acejump.config.AceConfig
 import org.acejump.countMatchingCharacters
 import org.acejump.immutableText
 import java.awt.Color
@@ -16,7 +18,7 @@ import kotlin.math.max
 /**
 * Describes a 1 or 2 character shortcut that points to a specific character in the editor.
 */
-internal class TagMarker(
+class TagMarker(
  private val tag: String,
  val offsetL: Int,
  val offsetR: Int,
@@ -28,13 +30,6 @@ internal class TagMarker(
  companion object {
    private const val ARC = 1

-    /**
-     * TODO This might be due to DPI settings.
-     */
-    private val HIGHLIGHT_OFFSET = if (SystemInfo.isMac) -0.5 else 0.0
-    
-    private val SHADOW_COLOR = Color(0F, 0F, 0F, 0.35F)
-    
    /**
     * Creates a new tag, precomputing some information about the nearby characters to reduce rendering overhead. If the last typed
     * character ([literalQueryText]) matches the first [tag] character, only the second [tag] character is displayed.
@@ -45,9 +40,9 @@ internal class TagMarker(
      val hasSpaceRight = offset + 1 >= chars.length || chars[offset + 1].isWhitespace()

      val displayedTag = if (literalQueryText != null && literalQueryText.last().equals(tag.first(), ignoreCase = true))
-        tag.drop(1).toUpperCase()
+        tag.drop(1).uppercase()
      else
-        tag.toUpperCase()
+        tag.uppercase()

      return TagMarker(displayedTag, offset, offset + max(0, matching - 1), tag.length - displayedTag.length, hasSpaceRight)
    }
@@ -57,9 +52,16 @@ internal class TagMarker(
     */
    private fun drawHighlight(g: Graphics2D, rect: Rectangle, color: Color) {
      g.color = color
-      g.translate(0.0, HIGHLIGHT_OFFSET)
+      
+      // Workaround for misalignment on high DPI screens.
+      if (JreHiDpiUtil.isJreHiDPI(g)) {
+        g.translate(0.0, -0.5)
        g.fillRoundRect(rect.x, rect.y, rect.width, rect.height + 1, ARC, ARC)
-      g.translate(0.0, -HIGHLIGHT_OFFSET)
+        g.translate(0.0, 0.5)
+      }
+      else {
+        g.fillRoundRect(rect.x, rect.y, rect.width, rect.height + 1, ARC, ARC)
+      }
    }

    /**
@@ -71,12 +73,12 @@ internal class TagMarker(

      g.font = font.tagFont

-      if (!font.isForegroundDark) {
-        g.color = SHADOW_COLOR
+      if (!ColorUtil.isDark(AceConfig.tagForegroundColor)) {
+        g.color = Color(0F, 0F, 0F, 0.35F)
        g.drawString(text, x + 1, y + 1)
      }

-      g.color = font.foregroundColor
+      g.color = AceConfig.tagForegroundColor
      g.drawString(text, x, y)
    }
  }
@@ -85,9 +87,7 @@ internal class TagMarker(
   * Returns true if the left-aligned offset is in the range. Use to cull tags outside visible range.
   * Only the left offset is checked, because if the tag was right-aligned on the last index of the range, it would not be visible anyway.
   */
-  fun isOffsetInRange(range: IntRange): Boolean {
-    return offsetL in range
-  }
+  fun isOffsetInRange(range: IntRange): Boolean = offsetL in range

  /**
   * Paints the tag, taking into consideration visual space around characters in the editor, as well as all other previously painted tags.
@@ -96,7 +96,7 @@ internal class TagMarker(
  fun paint(g: Graphics2D, editor: Editor, cache: EditorOffsetCache, font: TagFont, occupied: MutableList<Rectangle>): Rectangle? {
    val rect = alignTag(editor, cache, font, occupied) ?: return null

-    drawHighlight(g, rect, font.backgroundColor)
+    drawHighlight(g, rect, AceConfig.tagBackgroundColor)
    drawForeground(g, font, rect.location, tag)

    occupied.add(JBUIScale.scale(2).let { Rectangle(rect.x - it, rect.y, rect.width + (2 * it), rect.height) })
@@ -104,7 +104,7 @@ internal class TagMarker(
  }

  private fun alignTag(editor: Editor, cache: EditorOffsetCache, font: TagFont, occupied: List<Rectangle>): Rectangle? {
-    val boundaries = StandardBoundaries.VISIBLE_ON_SCREEN
+    val boundaries = VISIBLE_ON_SCREEN

    if (hasSpaceRight || offsetL == 0 || editor.immutableText[offsetL - 1].let { it == '\n' || it == '\r' }) {
      val rectR = createRightAlignedTagRect(editor, cache, font)
@@ -112,14 +112,12 @@ internal class TagMarker(
    }

    val rectL = createLeftAlignedTagRect(editor, cache, font)
-    if (occupied.none(rectL::intersects)) {
+    if (occupied.none(rectL::intersects))
      return rectL.takeIf { boundaries.isOffsetInside(editor, offsetL, cache) }
-    }

    val rectR = createRightAlignedTagRect(editor, cache, font)
-    if (occupied.none(rectR::intersects)) {
+    if (occupied.none(rectR::intersects))
      return rectR.takeIf { boundaries.isOffsetInside(editor, offsetR, cache) }
-    }

    return null
  }
--- a/src/main/kotlin/org/acejump/view/TextHighlighter.kt
+++ b/src/main/kotlin/org/acejump/view/TextHighlighter.kt
@@ -1,45 +1,56 @@
 package org.acejump.view

+import com.intellij.codeInsight.CodeInsightBundle
+import com.intellij.codeInsight.hint.*
+import com.intellij.codeInsight.hint.HintManagerImpl.HIDE_BY_ESCAPE
+import com.intellij.codeInsight.hint.HintManagerImpl.HIDE_BY_TEXT_CHANGE
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.editor.colors.EditorFontType
-import com.intellij.openapi.editor.markup.CustomHighlighterRenderer
-import com.intellij.openapi.editor.markup.HighlighterLayer
-import com.intellij.openapi.editor.markup.HighlighterTargetArea
-import com.intellij.openapi.editor.markup.RangeHighlighter
-import it.unimi.dsi.fastutil.ints.IntArrayList
+import com.intellij.openapi.editor.markup.*
+import com.intellij.openapi.editor.markup.HighlighterTargetArea.EXACT_RANGE
+import com.intellij.ui.*
+import com.intellij.util.ui.*
 import it.unimi.dsi.fastutil.ints.IntList
+import org.acejump.*
 import org.acejump.boundaries.EditorOffsetCache
 import org.acejump.config.AceConfig
-import org.acejump.immutableText
+import org.acejump.input.JumpMode
 import org.acejump.search.SearchQuery
-import org.acejump.search.Tag
-import java.awt.Color
-import java.awt.Graphics
+import java.awt.*
+import javax.swing.*
+import kotlin.math.max

 /**
 * Renders highlights for search occurrences.
 */
 internal class TextHighlighter {
+  private companion object { private const val LAYER = HighlighterLayer.LAST + 1 }
  private var previousHighlights = mutableMapOf<Editor, Array<RangeHighlighter>>()
+  private var previousHint: LightweightHint? = null

  /**
-   * Removes all current highlights and re-creates them from scratch. Must be called whenever any of the method parameters change.
+   * Label for the search notification.
   */
-  fun renderOccurrences(results: Map<Editor, IntList>, query: SearchQuery) {
-    render(results, when (query) {
-      is SearchQuery.RegularExpression -> RegexRenderer
+  private class NotificationLabel constructor(text: String?): JLabel(text) {
+    init {
+      background = HintUtil.getInformationColor()
+      foreground = JBColor.foreground()
+      this.isOpaque = true
+    }
+  }
+
+  /**
+   * Removes all current highlights and re-creates them from scratch.
+   * Must be called whenever any of the method parameters change.
+   */
+  fun render(results: Map<Editor, IntList>, query: SearchQuery, jumpMode: JumpMode) {
+
+    val renderer = when {
+      query is SearchQuery.RegularExpression -> RegexRenderer
+      jumpMode === JumpMode.TARGET -> SearchedWordWithOutlineRenderer
      else -> SearchedWordRenderer
-    }, query::getHighlightLength)
    }

-  /**
-   * Removes all current highlights and re-adds a single highlight at the position of the accepted tag with a different color.
-   */
-  fun renderFinal(tag: Tag, query: SearchQuery) {
-    render(mutableMapOf(tag.editor to IntArrayList(intArrayOf(tag.offset))), AcceptedTagRenderer, query::getHighlightLength)
-  }
-  
-  private inline fun render(results: Map<Editor, IntList>, renderer: CustomHighlighterRenderer, getHighlightLength: (CharSequence, Int) -> Int) {
    for ((editor, offsets) in results) {
      val highlights = previousHighlights[editor]

@@ -51,87 +62,158 @@ internal class TextHighlighter {
      val enableBulkEditing = modifications > 1000

      try {
-        if (enableBulkEditing) {
-          document.isInBulkUpdate = true
-        }
+        if (enableBulkEditing) document.isInBulkUpdate = true

        highlights?.forEach(markup::removeHighlighter)
        previousHighlights[editor] = Array(offsets.size) { index ->
          val start = offsets.getInt(index)
-          val end = start + getHighlightLength(chars, start)
+          val end = start + query.getHighlightLength(chars, start)

-          markup.addRangeHighlighter(start, end, LAYER, null, HighlighterTargetArea.EXACT_RANGE).apply {
-            customRenderer = renderer
-          }
+          markup.addRangeHighlighter(start, end, LAYER, null, EXACT_RANGE)
+            .apply { customRenderer = renderer }
        }
      } finally {
-        if (enableBulkEditing) {
-          document.isInBulkUpdate = false
-        }
+        if (enableBulkEditing) document.isInBulkUpdate = false
      }
    }

+    if (AceConfig.showSearchNotification)
+      showSearchNotification(results, query, jumpMode)
+
    for (editor in previousHighlights.keys.toList()) {
-      if (!results.containsKey(editor)) {
-        previousHighlights.remove(editor)?.forEach(editor.markupModel::removeHighlighter)
+      if (!results.containsKey(editor))
+        previousHighlights.remove(editor)
+          ?.forEach(editor.markupModel::removeHighlighter)
    }
  }
+
+  /**
+   * Show a notification with the current search text.
+   */
+  private fun showSearchNotification(results: Map<Editor, IntList>,
+                                     query: SearchQuery, jumpMode: JumpMode) {
+    // clear previous hint
+    previousHint?.hide()
+
+    // add notification hint to first editor
+    results.keys.first().let {
+      val component: JComponent = it.component
+
+      val label1: JLabel = NotificationLabel(" " +
+        CodeInsightBundle.message("incremental.search.tooltip.prefix"))
+      label1.font = UIUtil.getLabelFont().deriveFont(Font.BOLD)
+
+      val queryText = " " +
+        if (query is SearchQuery.RegularExpression) query.toRegex().toString()
+        else query.rawText[0] + query.rawText.drop(1).lowercase()
+      val label2 = NotificationLabel(queryText)
+
+      val label3 = NotificationLabel(
+        "Found ${results.values.flatMap { it.asIterable() }.size}" +
+        " results in ${results.keys.size}" +
+        " editor" + if(1 != results.keys.size) "s" else "."
+      )
+
+      val panel = JPanel(BorderLayout()).apply {
+        add(label1, BorderLayout.WEST)
+        add(label2, BorderLayout.CENTER)
+        add(label3, BorderLayout.EAST)
+        border = BorderFactory.createLineBorder(
+          if (jumpMode == JumpMode.DISABLED) Color.BLACK else jumpMode.caretColor
+        )
+
+        preferredSize = Dimension(it.contentComponent.width +
+          label1.preferredSize.width, preferredSize.height)
+      }
+
+      val hint = LightweightHint(panel)
+
+      val x = SwingUtilities.convertPoint(component, 0, 0, component).x
+      val y: Int = -hint.component.preferredSize.height
+      val p = SwingUtilities.convertPoint(component, x, y,
+        component.rootPane.layeredPane)
+
+      HintManagerImpl.getInstanceImpl().showEditorHint(
+        hint,
+        it,
+        p,
+        HIDE_BY_ESCAPE or HIDE_BY_TEXT_CHANGE,
+        0,
+        false,
+        HintHint(it, p).setAwtTooltip(false)
+      )
+      previousHint = hint
+    }
  }

  fun reset() {
    previousHighlights.keys.forEach { it.markupModel.removeAllHighlighters() }
    previousHighlights.clear()
+    previousHint?.hide()
  }

  /**
   * Renders a filled highlight in the background of a searched text occurrence.
   */
-  private object SearchedWordRenderer : CustomHighlighterRenderer {
-    override fun paint(editor: Editor, highlighter: RangeHighlighter, g: Graphics) {
-      drawFilled(g, editor, highlighter.startOffset, highlighter.endOffset, AceConfig.textHighlightColor)
-    }
-  }
+  private object SearchedWordRenderer: CustomHighlighterRenderer {
+    override fun paint(editor: Editor, highlighter: RangeHighlighter, g: Graphics) =
+      drawFilled(g, editor, highlighter.startOffset, highlighter.endOffset)

-  /**
-   * Renders a filled highlight in the background of the first highlighted position. Used for regex search queries.
-   */
-  private object RegexRenderer : CustomHighlighterRenderer {
-    override fun paint(editor: Editor, highlighter: RangeHighlighter, g: Graphics) {
-      drawSingle(g, editor, highlighter.startOffset, AceConfig.textHighlightColor)
-    }
-  }
-  
-  /**
-   * Renders a filled highlight in the background of the accepted tag position and search query.
-   */
-  private object AcceptedTagRenderer : CustomHighlighterRenderer {
-    override fun paint(editor: Editor, highlighter: RangeHighlighter, g: Graphics) {
-      drawFilled(g, editor, highlighter.startOffset, highlighter.endOffset, AceConfig.acceptedTagColor)
-    }
-  }
-  
-  private companion object {
-    private const val LAYER = HighlighterLayer.LAST + 1
-    
-    private fun drawFilled(g: Graphics, editor: Editor, startOffset: Int, endOffset: Int, color: Color) {
+    private fun drawFilled(g: Graphics, editor: Editor, startOffset: Int, endOffset: Int) {
      val start = EditorOffsetCache.Uncached.offsetToXY(editor, startOffset)
      val end = EditorOffsetCache.Uncached.offsetToXY(editor, endOffset)

-      g.color = color
-      g.fillRect(start.x, start.y + 1, end.x - start.x, editor.lineHeight - 1)
+      g.color = AceConfig.textHighlightColor
+      g.fillRect(start.x, start.y, end.x - start.x, editor.lineHeight)

      g.color = AceConfig.tagBackgroundColor
      g.drawRect(start.x, start.y, end.x - start.x, editor.lineHeight)
    }
+  }

-    private fun drawSingle(g: Graphics, editor: Editor, offset: Int, color: Color) {
+  /**
+   * Renders a filled highlight in the background of a searched
+   * text occurrence, as well as an outline indicating the range
+   * of characters that will be selected by [JumpMode.TARGET].
+   */
+  private object SearchedWordWithOutlineRenderer: CustomHighlighterRenderer {
+    override fun paint(editor: Editor, highlighter: RangeHighlighter, g: Graphics) {
+      SearchedWordRenderer.paint(editor, highlighter, g)
+
+      val chars = editor.immutableText
+      val startOffset = highlighter.startOffset
+
+      if (chars.getOrNull(startOffset)?.isWordPart == true)
+        drawOutline(g, editor, chars.wordStart(startOffset), chars.wordEnd(startOffset) + 1)
+    }
+
+    private fun drawOutline(g: Graphics, editor: Editor, startOffset: Int, endOffset: Int) {
+      val start = EditorOffsetCache.Uncached.offsetToXY(editor, startOffset)
+      val end = EditorOffsetCache.Uncached.offsetToXY(editor, endOffset)
+
+      g.color = AceConfig.targetModeColor
+      g.drawRect(max(0, start.x - JBUI.scale(1)), start.y,
+        end.x - start.x + JBUI.scale(2), editor.lineHeight)
+    }
+  }
+
+  /**
+   * Renders a filled highlight in the background of the first highlighted
+   * position. Used for regex search queries.
+   */
+  private object RegexRenderer: CustomHighlighterRenderer {
+    override fun paint(editor: Editor, highlighter: RangeHighlighter, g: Graphics) =
+      drawSingle(g, editor, highlighter.startOffset)
+
+    private fun drawSingle(g: Graphics, editor: Editor, offset: Int) {
      val pos = EditorOffsetCache.Uncached.offsetToXY(editor, offset)
-      val char = editor.immutableText.getOrNull(offset)?.takeUnless { it == '\n' || it == '\t' } ?: ' '
+      val char = editor.immutableText.getOrNull(offset)
+        ?.takeUnless { it == '\n' || it == '\t' } ?: ' '
      val font = editor.colorsScheme.getFont(EditorFontType.PLAIN)
      val lastCharWidth = editor.component.getFontMetrics(font).charWidth(char)

-      g.color = color
-      g.fillRect(pos.x, pos.y + 1, lastCharWidth, editor.lineHeight - 1)
+      g.color = AceConfig.textHighlightColor
+      g.fillRect(pos.x, pos.y, lastCharWidth, editor.lineHeight)

      g.color = AceConfig.tagBackgroundColor
      g.drawRect(pos.x, pos.y, lastCharWidth, editor.lineHeight)
--- a/src/main/resources/META-INF/plugin.xml
+++ b/src/main/resources/META-INF/plugin.xml
@@ -1,6 +1,6 @@
-<idea-plugin>
+<idea-plugin url="https://github.com/acejump/AceJump">
  <name>AceJump</name>
-  <id>AceJump-chylex</id>
+  <id>AceJump</id>

  <description><![CDATA[
    AceJump allows you to quickly navigate the caret to any position visible in the editor.
@@ -23,8 +23,14 @@
                         implementationClass="org.acejump.action.AceEditorAction$Reset"/>
    <editorActionHandler action="EditorBackSpace" order="first"
                         implementationClass="org.acejump.action.AceEditorAction$ClearSearch"/>
+    <editorActionHandler action="EditorStartNewLine" order="first"
+                         implementationClass="org.acejump.action.AceEditorAction$SelectBackward"/>
    <editorActionHandler action="EditorEnter" order="first"
-                         implementationClass="org.acejump.action.AceEditorAction$TagImmediately"/>
+                         implementationClass="org.acejump.action.AceEditorAction$SelectForward"/>
+    <editorActionHandler action="EditorTab" order="first"
+                         implementationClass="org.acejump.action.AceEditorAction$ScrollToNextScreenful"/>
+    <editorActionHandler action="EditorUnindentSelection" order="first"
+                         implementationClass="org.acejump.action.AceEditorAction$ScrollToPreviousScreenful"/>
    <editorActionHandler action="EditorUp" order="first"
                         implementationClass="org.acejump.action.AceEditorAction$SearchLineStarts"/>
    <editorActionHandler action="EditorLeft" order="first"
@@ -35,101 +41,60 @@
                         implementationClass="org.acejump.action.AceEditorAction$SearchLineEnds"/>
    <editorActionHandler action="EditorLineEnd" order="first"
                         implementationClass="org.acejump.action.AceEditorAction$SearchLineEnds"/>
+
  </extensions>

  <actions>
    <action id="AceAction"
-            class="org.acejump.action.AceKeyboardAction$ActivateAceJump"
-            text="Activate AceJump">
+            class="org.acejump.action.AceAction$ActivateOrCycleMode"
+            text="Activate / Cycle AceJump Mode">
      <keyboard-shortcut keymap="Mac OS X" first-keystroke="ctrl SEMICOLON"/>
      <keyboard-shortcut keymap="Mac OS X 10.5+" first-keystroke="ctrl SEMICOLON"/>
      <keyboard-shortcut keymap="$default" first-keystroke="ctrl SEMICOLON"/>
    </action>
-    <action id="AceSpecialAction"
-            class="org.acejump.action.AceKeyboardAction$ActivateAceJumpSpecial"
-            text="Activate / Cycle AceJump Special Modes">
+    <action id="AceReverseAction"
+            class="org.acejump.action.AceAction$ActivateOrReverseCycleMode"
+            text="Activate / Reverse Cycle AceJump Mode"/>
+    <action id="AceWordStartAction"
+            class="org.acejump.action.AceAction$ToggleJumpMode"
+            text="Start AceJump in Jump Mode"/>
+    <action id="AceWordEndAction"
+            class="org.acejump.action.AceAction$ToggleJumpEndMode"
+            text="Start AceJump in Jump End Mode"/>
+    <action id="AceTargetAction"
+            class="org.acejump.action.AceAction$ToggleTargetMode"
+            text="Start AceJump in Target Mode">
      <keyboard-shortcut keymap="Mac OS X" first-keystroke="ctrl alt SEMICOLON"/>
      <keyboard-shortcut keymap="Mac OS X 10.5+" first-keystroke="ctrl alt SEMICOLON"/>
      <keyboard-shortcut keymap="$default" first-keystroke="ctrl alt SEMICOLON"/>
    </action>
+    <action id="AceDeclarationAction"
+            class="org.acejump.action.AceAction$ToggleDeclarationMode"
+            text="Start AceJump in Declaration Mode"/>
    <action id="AceLineAction"
-            class="org.acejump.action.AceKeyboardAction$StartAllLineMarksMode"
+            class="org.acejump.action.AceAction$StartAllLineMarksMode"
            text="Start AceJump in All Line Marks Mode">
      <keyboard-shortcut keymap="Mac OS X" first-keystroke="ctrl shift SEMICOLON"/>
      <keyboard-shortcut keymap="Mac OS X 10.5+" first-keystroke="ctrl shift SEMICOLON"/>
      <keyboard-shortcut keymap="$default" first-keystroke="ctrl shift SEMICOLON"/>
    </action>
    <action id="AceLineStartsAction"
-            class="org.acejump.action.AceKeyboardAction$StartAllLineStartsMode"
+            class="org.acejump.action.AceAction$StartAllLineStartsMode"
            text="Start AceJump in All Line Starts Mode"/>
    <action id="AceLineEndsAction"
-            class="org.acejump.action.AceKeyboardAction$StartAllLineEndsMode"
+            class="org.acejump.action.AceAction$StartAllLineEndsMode"
            text="Start AceJump in All Line Ends Mode"/>
    <action id="AceLineIndentsAction"
-            class="org.acejump.action.AceKeyboardAction$StartAllLineIndentsMode"
+            class="org.acejump.action.AceAction$StartAllLineIndentsMode"
            text="Start AceJump in All Line Indents Mode"/>
    <action id="AceWordAction"
-            class="org.acejump.action.AceKeyboardAction$StartAllWordsMode"
+            class="org.acejump.action.AceAction$StartAllWordsMode"
            text="Start AceJump in All Words Mode"/>
    <action id="AceWordForwardAction"
-            class="org.acejump.action.AceKeyboardAction$StartAllWordsForwardMode"
+            class="org.acejump.action.AceAction$StartAllWordsForwardMode"
            text="Start AceJump in All Words After Caret Mode"/>
    <action id="AceWordBackwardsAction"
-            class="org.acejump.action.AceKeyboardAction$StartAllWordsBackwardsMode"
+            class="org.acejump.action.AceAction$StartAllWordsBackwardsMode"
            text="Start AceJump in All Words Before Caret Mode"/>
-    <action id="AceVimAction_JumpToChar"
-            class="org.acejump.action.AceVimAction$JumpToChar"
-            text="AceJump Vim - JumpToChar"/>
-    <action id="AceVimAction_JumpToCharBeforeCaret"
-            class="org.acejump.action.AceVimAction$JumpToCharBeforeCaret"
-            text="AceJump Vim - JumpToCharBeforeCaret"/>
-    <action id="AceVimAction_JumpToCharAfterCaret"
-            class="org.acejump.action.AceVimAction$JumpToCharAfterCaret"
-            text="AceJump Vim - JumpToCharAfterCaret"/>
-    <action id="AceVimAction_LWordsAfterCaret"
-            class="org.acejump.action.AceVimAction$LWordsAfterCaret"
-            text="AceJump Vim - LWordsAfterCaret"/>
-    <action id="AceVimAction_UWordsAfterCaret"
-            class="org.acejump.action.AceVimAction$UWordsAfterCaret"
-            text="AceJump Vim - UWordsAfterCaret"/>
-    <action id="AceVimAction_LWordsBeforeCaret"
-            class="org.acejump.action.AceVimAction$LWordsBeforeCaret"
-            text="AceJump Vim - LWordsBeforeCaret"/>
-    <action id="AceVimAction_UWordsBeforeCaret"
-            class="org.acejump.action.AceVimAction$UWordsBeforeCaret"
-            text="AceJump Vim - UWordsBeforeCaret"/>
-    <action id="AceVimAction_LWordEndsAfterCaret"
-            class="org.acejump.action.AceVimAction$LWordEndsAfterCaret"
-            text="AceJump Vim - LWordEndsAfterCaret"/>
-    <action id="AceVimAction_UWordEndsAfterCaret"
-            class="org.acejump.action.AceVimAction$UWordEndsAfterCaret"
-            text="AceJump Vim - UWordEndsAfterCaret"/>
-    <action id="AceVimAction_LWordEndsBeforeCaret"
-            class="org.acejump.action.AceVimAction$LWordEndsBeforeCaret"
-            text="AceJump Vim - LWordEndsBeforeCaret"/>
-    <action id="AceVimAction_UWordEndsBeforeCaret"
-            class="org.acejump.action.AceVimAction$UWordEndsBeforeCaret"
-            text="AceJump Vim - UWordEndsBeforeCaret"/>
-    <action id="AceVimAction_GoToDeclaration"
-            class="org.acejump.action.AceVimAction$GoToDeclaration"
-            text="AceJump Vim - GoToDeclaration"/>
-    <action id="AceVimAction_GoToTypeDeclaration"
-            class="org.acejump.action.AceVimAction$GoToTypeDeclaration"
-            text="AceJump Vim - GoToTypeDeclaration"/>
-    <action id="AceVimAction_ShowIntentions"
-            class="org.acejump.action.AceVimAction$ShowIntentions"
-            text="AceJump Vim - ShowIntentions"/>
-    <action id="AceVimAction_ShowUsages"
-            class="org.acejump.action.AceVimAction$ShowUsages"
-            text="AceJump Vim - ShowUsages"/>
-    <action id="AceVimAction_FindUsages"
-            class="org.acejump.action.AceVimAction$FindUsages"
-            text="AceJump Vim - FindUsages"/>
-    <action id="AceVimAction_Refactor"
-            class="org.acejump.action.AceVimAction$Refactor"
-            text="AceJump Vim - Refactor"/>
-    <action id="AceVimAction_Rename"
-            class="org.acejump.action.AceVimAction$Rename"
-            text="AceJump Vim - Rename"/>
  </actions>
 </idea-plugin>
--- a/src/test/kotlin/AceTest.kt
+++ b/src/test/kotlin/AceTest.kt
@@ -1,5 +1,8 @@
-
-import org.acejump.action.AceKeyboardAction
+import com.intellij.openapi.actionSystem.IdeActions.ACTION_EDITOR_ENTER
+import com.intellij.openapi.actionSystem.IdeActions.ACTION_EDITOR_START_NEW_LINE
+import com.intellij.openapi.editor.actions.EnterAction
+import org.acejump.action.AceAction
+import org.acejump.config.AceConfig
 import org.acejump.test.util.BaseTest

 /**
@@ -27,6 +30,30 @@ class AceTest : BaseTest() {
  fun `test a query containing a { character`() =
    assertEquals("abcd{dabc cdab".search("cd{"), setOf(2))

+  fun `test that jumping to first occurrence succeeds`() {
+    "<caret>testing 1234".search("1")
+
+    takeAction(ACTION_EDITOR_ENTER)
+
+    myFixture.checkResult("testing <caret>1234")
+  }
+
+  fun `test that jumping to second occurrence succeeds`() {
+    "<caret>testing 1234".search("ti")
+
+    takeAction(ACTION_EDITOR_ENTER)
+
+    myFixture.checkResult("tes<caret>ting 1234")
+  }
+
+  fun `test that jumping to previous occurrence succeeds`() {
+    "te<caret>sting 1234".search("t")
+
+    takeAction(ACTION_EDITOR_START_NEW_LINE)
+
+    myFixture.checkResult("<caret>testing 1234")
+  }
+
  fun `test tag selection`() {
    "<caret>testing 1234".search("g")

@@ -35,10 +62,18 @@ class AceTest : BaseTest() {
    myFixture.checkResult("testin<caret>g 1234")
  }

+  fun `test shift selection`() {
+    "<caret>testing 1234".search("4")
+
+    typeAndWaitForResults(session.tags[0].key.uppercase())
+
+    myFixture.checkResult("<selection>testing 123<caret></selection>4")
+  }
+
  fun `test words before caret action`() {
    makeEditor("test words <caret> before caret is two")

-    takeAction(AceKeyboardAction.StartAllWordsBackwardsMode)
+    takeAction(AceAction.StartAllWordsBackwardsMode())

    assertEquals(2, session.tags.size)
  }
@@ -46,7 +81,7 @@ class AceTest : BaseTest() {
  fun `test words after caret action`() {
    makeEditor("test words <caret> after caret is four")

-    takeAction(AceKeyboardAction.StartAllWordsForwardMode)
+    takeAction(AceAction.StartAllWordsForwardMode())

    assertEquals(4, session.tags.size)
  }
@@ -54,7 +89,7 @@ class AceTest : BaseTest() {
  fun `test word mode`() {
    makeEditor("test word action")

-    takeAction(AceKeyboardAction.StartAllWordsMode)
+    takeAction(AceAction.StartAllWordsMode())

    assertEquals(3, session.tags.size)

@@ -63,11 +98,68 @@ class AceTest : BaseTest() {
    myFixture.checkResult("test <caret>word action")
  }

+  fun `test target mode`() {
+    "<caret>test target action".search("target")
+
+    takeAction(AceAction.ToggleTargetMode())
+    typeAndWaitForResults(session.tags[0].key)
+
+    myFixture.checkResult("test <selection>target<caret></selection> action")
+  }
+
+  fun `test cache invalidation`() {
+    "first line".search("first")
+    typeAndWaitForResults(session.tags[0].key)
+
+    repeat(3) { takeAction(EnterAction()) }
+
+    takeAction(AceAction.ToggleTargetMode())
+    typeAndWaitForResults("first")
+    typeAndWaitForResults(session.tags[0].key)
+
+    myFixture.checkResult("\n\n\n<selection>first<caret></selection> line")
+  }
+
  fun `test line mode`() {
    makeEditor("    test\n    three\n    lines\n")

-    takeAction(AceKeyboardAction.StartAllLineMarksMode)
+    takeAction(AceAction.StartAllLineMarksMode())

-    assertEquals(9, session.tags.size)
+    assertEquals(8, session.tags.size) // last empty line does not count
+  }
+
+  fun `test chinese selection`() {
+    AceConfig.settings.mapToASCII = true
+
+    "test 拼音 selection".search("py")
+
+    takeAction(AceAction.ToggleTargetMode())
+
+    typeAndWaitForResults(session.tags[0].key)
+
+    myFixture.checkResult("test <selection>拼音<caret></selection> selection")
+  }
+
+  fun `test japanese selection`() {
+    AceConfig.settings.mapToASCII = true
+
+    "あみだにょらい".search("am")
+
+    takeAction(AceAction.ToggleTargetMode())
+
+    typeAndWaitForResults(session.tags[0].key)
+
+    myFixture.checkResult("<selection>あみだにょらい<caret></selection>")
+  }
+
+  // https://github.com/acejump/AceJump/issues/355
+  fun `ignore test a word that is difficult to tag`() {
+    makeEditor("aaCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")
+
+    takeAction(AceAction.ActivateOrCycleMode())
+
+    typeAndWaitForResults("c")
+
+    assertEquals(2, session.tags.size)
  }
 }
--- a/src/test/kotlin/ExternalUsageTest.kt
+++ b/src/test/kotlin/ExternalUsageTest.kt
@@ -0,0 +1,169 @@
+import com.intellij.mock.MockVirtualFile
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.fileEditor.TextEditor
+import com.intellij.util.ui.UIUtil
+import it.unimi.dsi.fastutil.ints.IntArrayList
+import junit.framework.TestCase
+import org.acejump.action.AceAction
+import org.acejump.boundaries.Boundaries
+import org.acejump.boundaries.EditorOffsetCache
+import org.acejump.boundaries.StandardBoundaries.WHOLE_FILE
+import org.acejump.input.JumpMode
+import org.acejump.search.Pattern.ALL_WORDS
+import org.acejump.session.AceJumpListener
+import org.acejump.session.SessionManager
+import org.acejump.test.util.BaseTest
+
+/**
+ * Test [org.acejump.ExternalUsage] endpoints.
+ */
+
+class ExternalUsageTest: BaseTest() {
+  fun `test externally tagged results and listener notification`() {
+    makeEditor("test externally tagged results")
+
+    SessionManager.start(myFixture.editor).markResults(sortedSetOf(4, 10, 15))
+
+    TestCase.assertEquals(3, session.tags.size)
+
+    var shouldBeTrueAfterFinished = false
+    session.addAceJumpListener(object: AceJumpListener {
+      override fun finished(mark: String?, query: String?) {
+        shouldBeTrueAfterFinished = true
+      }
+    })
+
+    typeAndWaitForResults(session.tags[0].key)
+
+    TestCase.assertTrue(shouldBeTrueAfterFinished)
+  }
+  
+  fun `test externally tagged results with multiple editors`() {
+    val fileA = MockVirtualFile("a.txt", "first file")
+    val fileB = MockVirtualFile("b.txt", "second file with more markers")
+    myManager.openFile(fileA, true)
+    myManager.openFile(fileB, false)
+    
+    val mainEditor = (myManager.selectedEditor as TextEditor).editor
+    val editorA = (myManager.getEditors(fileA).single() as TextEditor).editor
+    val editorB = (myManager.getEditors(fileB).single() as TextEditor).editor
+    
+    val session = SessionManager.start(mainEditor, listOf(editorA, editorB))
+    
+    session.markResults(mapOf(
+      editorA to IntArrayList(intArrayOf(0, 6)),
+      editorB to IntArrayList(intArrayOf(0, 7, 22))
+    ))
+  
+    TestCase.assertEquals(5, session.tags.size)
+    TestCase.assertEquals(2, session.tags.count { it.value.editor === editorA })
+    TestCase.assertEquals(3, session.tags.count { it.value.editor === editorB })
+    
+    TestCase.assertEquals(listOf(0, 6), session.tags
+      .filter { it.value.editor === editorA }
+      .map { it.value.offset }
+      .sorted())
+    
+    TestCase.assertEquals(listOf(0, 7, 22), session.tags
+      .filter { it.value.editor === editorB }
+      .map { it.value.offset }
+      .sorted())
+  }
+
+  fun `test external pattern usage`() {
+    makeEditor("test external pattern usage")
+
+    SessionManager.start(myFixture.editor)
+      .startRegexSearch(ALL_WORDS, WHOLE_FILE)
+
+    TestCase.assertEquals(4, session.tags.size)
+  }
+
+  fun `test external regex usage`() {
+    makeEditor("test external regex usage")
+
+    SessionManager.start(myFixture.editor)
+      .startRegexSearch("[aeiou]+", WHOLE_FILE)
+
+    TestCase.assertEquals(8, session.tags.size)
+  }
+
+  fun `test external jump with bounds`() {
+    makeEditor("test word and word usage")
+
+    SessionManager.start(myFixture.editor)
+      .toggleJumpMode(JumpMode.JUMP, object : Boundaries {
+        override fun getOffsetRange(editor: Editor, cache: EditorOffsetCache): IntRange {
+          return 14..18
+        }
+
+        override fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache): Boolean {
+          return offset in 14..18
+        }
+      })
+
+    typeAndWaitForResults("word")
+
+    TestCase.assertEquals(1, session.tags.size)
+    TestCase.assertEquals(14, session.tags.single().value.offset)
+  }
+
+  fun `test listener query and mark`() {
+    "<caret>testing 1234".search("g")
+
+    var detectedMark: String? = null
+    var detectedQuery: String? = null
+    session.addAceJumpListener(object: AceJumpListener {
+      override fun finished(mark: String?, query: String?) {
+        detectedMark = mark
+        detectedQuery = query
+      }
+    })
+
+    val mark = session.tags[0].key
+    typeAndWaitForResults(mark)
+
+    TestCase.assertEquals(mark, detectedMark)
+    TestCase.assertEquals("g", detectedQuery)
+  }
+
+  fun `test listener after escape`() {
+    "<caret>testing 1234".search("g")
+
+    var detectedMark: String? = null
+    var detectedQuery: String? = null
+    session.addAceJumpListener(object: AceJumpListener {
+      override fun finished(mark: String?, query: String?) {
+        detectedMark = mark
+        detectedQuery = query
+      }
+    })
+
+    myFixture.performEditorAction("EditorEscape")
+    UIUtil.dispatchAllInvocationEvents()
+
+    TestCase.assertEquals(null, detectedMark)
+    TestCase.assertEquals(null, detectedQuery)
+  }
+
+  fun `test listener for word motion`() {
+    makeEditor("test word action")
+
+    takeAction(AceAction.StartAllWordsMode())
+
+    var detectedMark: String? = null
+    var detectedQuery: String? = null
+    session.addAceJumpListener(object: AceJumpListener {
+      override fun finished(mark: String?, query: String?) {
+        detectedMark = mark
+        detectedQuery = query
+      }
+    })
+
+    val mark = session.tags[1].key
+    typeAndWaitForResults(mark)
+
+    TestCase.assertEquals(mark, detectedMark)
+    TestCase.assertEquals("", detectedQuery)
+  }
+}
--- a/src/test/kotlin/LatencyTest.kt
+++ b/src/test/kotlin/LatencyTest.kt
@@ -1,4 +1,4 @@
-import org.acejump.action.AceKeyboardAction
+import org.acejump.action.AceAction
 import org.acejump.test.util.BaseTest
 import org.junit.Ignore
 import java.io.File
@@ -6,7 +6,7 @@ import kotlin.random.Random
 import kotlin.system.measureTimeMillis

@Ignore
-class LatencyTest : BaseTest() {
+class LatencyTest: BaseTest() {

  private fun `test tag latency`(editorText: String) {
    val chars = editorText.toCharArray().distinct().filter { !it.isWhitespace() }
@@ -15,7 +15,7 @@ class LatencyTest : BaseTest() {

      for (query in chars) {
        makeEditor(editorText)
-        myFixture.testAction(AceKeyboardAction.ActivateAceJumpSpecial)
+        myFixture.testAction(AceAction.ActivateOrCycleMode())
        time += measureTimeMillis { typeAndWaitForResults("$query") }
        // TODO assert(Tagger.markers.isNotEmpty()) { "Should be tagged: $query" }
        resetEditor()
@@ -38,8 +38,6 @@ class LatencyTest : BaseTest() {
  )

  fun `test lorem ipsum latency`() = `test tag latency`(
-    File(
-      javaClass.classLoader.getResource("lipsum.txt")!!.file
-    ).readText()
+    File(javaClass.classLoader.getResource("lipsum.txt")!!.file).readText()
  )
 }
--- a/src/test/kotlin/org/acejump/test/util/BaseTest.kt
+++ b/src/test/kotlin/org/acejump/test/util/BaseTest.kt
@@ -2,33 +2,24 @@ package org.acejump.test.util

 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.IdeActions
-import com.intellij.openapi.editor.impl.EditorImpl
 import com.intellij.openapi.fileTypes.PlainTextFileType
 import com.intellij.psi.PsiFile
-import com.intellij.testFramework.fixtures.BasePlatformTestCase
+import com.intellij.testFramework.FileEditorManagerTestCase
 import com.intellij.util.ui.UIUtil
-import org.acejump.action.AceKeyboardAction
+import org.acejump.action.AceAction
 import org.acejump.session.SessionManager

-abstract class BaseTest : BasePlatformTestCase() {
+abstract class BaseTest: FileEditorManagerTestCase() {
  companion object {
    inline fun averageTimeWithWarmup(warmupRuns: Int, timedRuns: Int, action: () -> Long): Long {
-      repeat(warmupRuns) {
-        action()
-      }
-      
+      repeat(warmupRuns) { action() }
      var time = 0L
-      
-      repeat(timedRuns) {
-        time += action()
-      }
-      
+      repeat(timedRuns) { time += action() }
      return time / timedRuns
    }
  }

-  protected val session
-    get() = SessionManager[myFixture.editor]!!
+  protected val session get() = SessionManager[myFixture.editor]!!

  override fun tearDown() {
    resetEditor()
@@ -38,16 +29,16 @@ abstract class BaseTest : BasePlatformTestCase() {
  fun takeAction(action: String) = myFixture.performEditorAction(action)
  fun takeAction(action: AnAction) = myFixture.testAction(action)

-  fun makeEditor(contents: String): PsiFile {
-    val file = myFixture.configureByText(PlainTextFileType.INSTANCE, contents)
-    (myFixture.editor as EditorImpl).scrollPane.viewport.setSize(1000, 100)
-    return file
-  }
+  fun makeEditor(contents: String): PsiFile =
+    myFixture.configureByText(PlainTextFileType.INSTANCE, contents)

  fun resetEditor() {
+    myFixture.editor?.let {
      takeAction(IdeActions.ACTION_EDITOR_ESCAPE)
      UIUtil.dispatchAllInvocationEvents()
-    assertEmpty(myFixture.editor.markupModel.allHighlighters)
+      assertEmpty(it.markupModel.allHighlighters)
+    }
+    myManager.closeAllFiles()
  }

  fun typeAndWaitForResults(string: String) {
@@ -55,13 +46,11 @@ abstract class BaseTest : BasePlatformTestCase() {
    UIUtil.dispatchAllInvocationEvents()
  }

-  private fun String.executeQuery(query: String) {
-    myFixture.run {
+  fun String.executeQuery(query: String) = myFixture.run {
    makeEditor(this@executeQuery)
-      testAction(AceKeyboardAction.ActivateAceJump)
+    testAction(AceAction.ActivateOrCycleMode())
    typeAndWaitForResults(query)
  }
-  }

  fun String.search(query: String): Set<Int> {
    this@search.executeQuery(query)
@@ -69,10 +58,8 @@ abstract class BaseTest : BasePlatformTestCase() {
    return myFixture.editor.markupModel.allHighlighters.map { it.startOffset }.toSet()
  }

-  private fun String.assertCorrectNumberOfTags(query: String) {
+  private fun String.assertCorrectNumberOfTags(query: String) =
    assertEquals(split(query.fold("") { prefix, char ->
      if ((prefix + char) in this) prefix + char else return
    }).size - 1, myFixture.editor.markupModel.allHighlighters.size)
-  }
-  
 }
Author	SHA1	Message	Date
chylex	35003b0bab	Improve tag order for non-QWERTY layouts	2021-11-21 05:29:43 +01:00
breandan	dc137e4d23	add hop	2021-11-20 15:54:52 -05:00
breandan	6858b745e6	fixes #356	2021-11-14 21:22:06 -05:00
breandan	1505e98d66	update changelog, migrate deprecated and fix compiler error	2021-11-14 17:01:11 -05:00
breandan	2b7015474e	fix markdown	2021-11-14 16:32:44 -05:00
breandan	8d62b0d130	Merge pull request #384 from chylex/dpi Workaround tag misalignment on high DPI screens	2021-11-14 16:25:55 -05:00
chylex	828940a53a	Update attribution in README	2021-11-14 22:24:03 +01:00
chylex	41071dbaf9	Workaround tag misalignment on high DPI screens Fixes #362.	2021-11-14 21:07:26 +01:00
breandan	cb10ff7789	reference IdeActions constants instead of hardcoded strings #379	2021-10-01 01:03:17 -04:00
breandan	71f8d7150d	update versions	2021-09-12 22:35:15 -04:00
breandan	e619f5feb0	update versions	2021-08-26 00:46:21 -04:00
breandan	9dd85c1815	fixes #379	2021-07-09 00:48:53 -07:00
breandan	194dc3a14e	update API usage example	2021-07-04 13:08:13 -04:00
breandan.considine	f1488f7fdf	update versions	2021-06-24 11:54:15 -04:00
breandan	952a9af9ad	run plugin verifier	2021-05-27 13:01:13 -04:00
breandan	86a7ad751f	update versions	2021-05-27 12:49:48 -04:00
breandan	650a00f491	remove closed ticket from wishlist	2021-05-17 21:10:10 -04:00
breandan	9573315eff	update change notes	2021-05-17 20:50:20 -04:00
breandan	eef4c2e08f	display regex for regex queries	2021-05-17 20:45:18 -04:00
breandan	d1277dcb8a	Merge pull request #377 from SaiKai/fix-line-mode prevent setting INHERITED_COLOR_MARKER as border color	2021-05-17 20:27:18 -04:00
Jonas Gutenschwager	7ef147c941	prevent setting INHERITED_COLOR_MARKER as border color	2021-05-17 23:10:45 +02:00
breandan	4504da02ba	clean up TextHighlighter and add release notes	2021-05-16 20:44:46 -04:00
breandan	7cce1b7034	Merge pull request #375 from SaiKai/display-search-text #227 Add a notification hint with the current search text	2021-05-16 20:18:01 -04:00
breandan	16fd472132	Merge pull request #374 from SaiKai/fix-focus-editor ensure editor focus also when using select function	2021-05-16 20:15:57 -04:00
Jonas Gutenschwager	3c231327d0	add a notification hint with the current search text	2021-05-17 01:09:22 +02:00
Jonas Gutenschwager	9284514ce3	ensure editor focus also when using select function	2021-05-16 22:07:17 +02:00
breandan	767a72a97c	update contribution wishlist	2021-05-13 22:49:22 -04:00
breandan	d1ad283c8c	bump versions	2021-05-13 22:43:45 -04:00
breandan	a169e3c751	fixes #373	2021-05-13 21:43:15 -04:00
breandan	0ee9f3e1cb	support unicode characters, fixes #368	2021-05-10 21:45:41 -04:00
breandan	a05e92f3cb	Merge pull request #371 from chylex/jump-across-splitters Implement jumping across splitters	2021-05-10 20:59:05 -04:00
chylex	17a762e4d8	Update version to 3.8.0	2021-05-10 16:20:34 +02:00
chylex	aaa3f5d922	Add unit test for markResults with multiple editors	2021-05-09 08:44:53 +02:00
chylex	d407fd5333	Fix tests	2021-05-08 02:54:04 +02:00
chylex	12ae15c0f7	Implement jumping across splitters	2021-05-08 02:25:14 +02:00
breandan	5fd99c7f9b	Merge remote-tracking branch 'origin/master'	2021-05-05 22:10:09 -04:00
breandan	d0cd15ef2c	update versions	2021-05-05 22:10:03 -04:00
breandan	e6184ca6d3	add Japanese support to wishlist	2021-04-25 11:00:10 -04:00
breandan	020b6c1c7c	update version to 3.7.1	2021-04-24 14:21:53 -04:00
breandan	9839a43da4	update wishlist	2021-04-17 17:09:53 -04:00
breandan	a7ebbcadb4	fixes #363	2021-04-17 16:13:15 -04:00
breandan	4622fbb20b	pass back necessary info instead of reconstructing Merge branch 'listener_update' of https://github.com/AlexPl292/AceJump into AlexPl292-listener_update # Conflicts: # src/test/kotlin/ExternalUsageTest.kt	2021-04-17 15:44:08 -04:00
breandan	b3df72ef81	Merge remote-tracking branch 'origin/master'	2021-04-14 21:50:00 -04:00
breandan	00ed423faa	update to RC	2021-04-14 21:49:54 -04:00
breandan	615ac0bc7a	remove item from wishlist	2021-04-13 10:55:18 -04:00
breandan	2c0a236ed8	update gradle	2021-04-11 00:21:26 -04:00
breandan	d6553cd358	Merge remote-tracking branch 'origin/master'	2021-04-10 17:51:13 -04:00
breandan	5bb9a98723	update to 2021.1	2021-04-10 17:51:02 -04:00
breandan	85163d4fb9	Merge pull request #358 from AlexPl292/jump_boundaries Allow defining jump mode with boundaries	2021-04-09 22:59:10 -04:00
breandan	02fee84923	Merge pull request #359 from AlexPl292/kotlin_objects Do not use kotlin objects for actions	2021-04-09 22:57:45 -04:00
Alex Plate	89c3f88fbf	Do not use kotlin objects for actions	2021-04-09 10:19:34 +03:00
Alex Plate	8fe050dc15	Allow defining jump mode with boundaries	2021-04-09 10:12:41 +03:00
breandan	61f0e3cf77	add test case for #355	2021-04-04 16:53:10 -04:00
breandan	27b897848d	note that tab scrolling is unavailable in 3.7, cf. #356	2021-04-04 14:13:05 -04:00
breandan	e17abbdabb	fix changenotes	2021-04-03 23:59:06 -04:00
breandan	5da53c603e	update changes and readme acknowledging #353 , #348 🎉 thanks @chylex !	2021-04-03 21:08:09 -04:00
breandan	59e0082236	document ExternalUsage endpoints in README.md #354	2021-04-03 20:37:22 -04:00
breandan	d2b1fb96dd	move ExternalUsage tests to new class and add test cases for pattern and regex #354	2021-04-03 20:19:04 -04:00
breandan	d5dfa95896	test whether listeners are notified post-disposal #354	2021-04-03 18:37:34 -04:00
breandan	a109ff7fce	notify listeners of Session disposal, cf. #354	2021-04-03 18:20:07 -04:00
breandan	b33ae482b0	reimplements #307 , cf. #354	2021-04-03 17:56:54 -04:00
breandan	c6b70109da	more reformatting	2021-04-03 16:13:17 -04:00
breandan	beb39c95c8	refactor, add EditorCache and reimplement Pinyin support	2021-04-03 11:43:33 -04:00
breandan	f675efbc12	Merge branch 'chylex-refactor-pr'	2021-04-03 09:01:17 -04:00