Set plugin version to chylex-42

Fixes multiple cursors with vim-surround commands `cs, ds, S` (but not `ys`).

.github/workflows/closeYoutrackOnCommit.yml

@@ -8,6 +8,9 @@ on:
   push:
     branches: [ master ]
     
+permissions:
+  contents: write
+
 jobs:
   build:
 

.github/workflows/codeql-analysis.yml

@@ -20,6 +20,11 @@ on:
   schedule:
     - cron: '44 12 * * 4'
 
+permissions:
+  actions: read
+  contents: read
+  security-events: write
+
 jobs:
   analyze:
     name: Analyze

.github/workflows/integrationsTest.yml

@@ -27,7 +27,7 @@ jobs:
           settings-path: ${{ github.workspace }} # location for the settings.xml file
 
       - name: Run tests
-        run: ./gradlew integrationsTest
+        run: ./gradlew --no-configuration-cache integrationsTest
         env:
           YOUTRACK_TOKEN: ${{ secrets.YOUTRACK_TOKEN }}
           GITHUB_OAUTH: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/runUiOctopusTests.yml

@@ -16,14 +16,14 @@ jobs:
           java-version: 17
       - name: Setup FFmpeg
         run: brew install ffmpeg
-      - name: Setup Gradle
+#      - name: Setup Gradle
-        uses: gradle/gradle-build-action@v2.4.2
+#        uses: gradle/gradle-build-action@v2.4.2
       - name: Build Plugin
         run: gradle :buildPlugin
       - name: Run Idea
         run: |
           mkdir -p build/reports
-          gradle runIdeForUiTests -Doctopus.handler=false > build/reports/idea.log &
+          gradle --no-configuration-cache runIdeForUiTests -Doctopus.handler=false > build/reports/idea.log &
       - name: Wait for Idea started
         uses: jtalk/url-health-check-action@v3
         with:
@@ -37,7 +37,7 @@ jobs:
         run: mv tests/ui-ij-tests/video build/reports
       - name: Move sandbox logs
         if: always()
-        run: mv build/idea-sandbox/system/log sandbox-idea-log
+        run: mv build/idea-sandbox/IC-2024.1.2/log_runIdeForUiTests idea-sandbox-log
       - name: Save report
         if: always()
         uses: actions/upload-artifact@v4
@@ -46,7 +46,7 @@ jobs:
           path: |
             build/reports
             tests/ui-ij-tests/build/reports
-            sandbox-idea-log
+            idea-sandbox-log
 #  build-for-ui-test-linux:
 #    runs-on: ubuntu-latest
 #    steps:

.github/workflows/runUiPyTests.yml

@@ -19,14 +19,14 @@ jobs:
           python-version: '3.10'
       - name: Setup FFmpeg
         run: brew install ffmpeg
-      - name: Setup Gradle
+#      - name: Setup Gradle
-        uses: gradle/gradle-build-action@v2.4.2
+#        uses: gradle/gradle-build-action@v2.4.2
       - name: Build Plugin
         run: gradle :buildPlugin
       - name: Run Idea
         run: |
           mkdir -p build/reports
-          gradle :runIdeForUiTests -PideaType=PC > build/reports/idea.log &
+          gradle --no-configuration-cache :runIdeForUiTests -PideaType=PC > build/reports/idea.log &
       - name: Wait for Idea started
         uses: jtalk/url-health-check-action@v3
         with:
@@ -40,7 +40,7 @@ jobs:
         run: mv tests/ui-py-tests/video build/reports
       - name: Move sandbox logs
         if: always()
-        run: mv build/idea-sandbox/system/log sandbox-idea-log
+        run: mv build/idea-sandbox/PC-2024.1.2/log_runIdeForUiTests idea-sandbox-log
       - name: Save report
         if: always()
         uses: actions/upload-artifact@v4
@@ -49,4 +49,4 @@ jobs:
           path: |
             build/reports
             tests/ui-py-tests/build/reports
-            sandbox-idea-log
+            idea-sandbox-log

.github/workflows/runUiTests.yml

@@ -16,14 +16,14 @@ jobs:
           java-version: 17
       - name: Setup FFmpeg
         run: brew install ffmpeg
-      - name: Setup Gradle
+#      - name: Setup Gradle
-        uses: gradle/gradle-build-action@v2.4.2
+#        uses: gradle/gradle-build-action@v2.4.2
       - name: Build Plugin
         run: gradle :buildPlugin
       - name: Run Idea
         run: |
           mkdir -p build/reports
-          gradle runIdeForUiTests > build/reports/idea.log &
+          gradle --no-configuration-cache runIdeForUiTests > build/reports/idea.log &
       - name: Wait for Idea started
         uses: jtalk/url-health-check-action@v3
         with:
@@ -37,7 +37,7 @@ jobs:
         run: mv tests/ui-ij-tests/video build/reports
       - name: Move sandbox logs
         if: always()
-        run: mv build/idea-sandbox/system/log sandbox-idea-log
+        run: mv build/idea-sandbox/IC-2024.1.2/log_runIdeForUiTests idea-sandbox-log
       - name: Save report
         if: always()
         uses: actions/upload-artifact@v4
@@ -46,7 +46,7 @@ jobs:
           path: |
             build/reports
             tests/ui-ij-tests/build/reports
-            sandbox-idea-log
+            idea-sandbox-log
 #  build-for-ui-test-linux:
 #    runs-on: ubuntu-latest
 #    steps:

.github/workflows/syncDoc.yml

@@ -10,6 +10,9 @@ on:
   push:
     branches: [ master ]
 
+permissions:
+  contents: write
+
 jobs:
   build:
 
@@ -34,6 +37,17 @@ jobs:
         id: update_authors
         run: cp -a origin/doc/. docs
 
+      # The Wiki for github should have no `.md` in references
+      # Otherwise, such links will lead to the raw text.
+      # However, the `.md` should exist to have a navigation in GitHub code.
+      - name: Replace `.md)` with `)`
+        run: |
+          # Define the directory you want to process
+          DIRECTORY="docs"
+
+          # Find all files in the directory and perform the replacement
+          find $DIRECTORY -type f -exec sed -i 's/\.md)/)/g' {} +
+
       - name: Commit changes
         uses: stefanzweifel/git-auto-commit-action@v4
         with:

.gitignore

@@ -1,5 +1,6 @@
 *.swp
 /.gradle/
+/.intellijPlatform/
 
 /.idea/
 !/.idea/scopes
@@ -26,9 +27,8 @@
 # Generated by gradle task "generateGrammarSource"
 vim-engine/src/main/java/com/maddyhome/idea/vim/parser/generated
 vim-engine/src/main/java/com/maddyhome/idea/vim/regexp/parser/generated
-# Generated JSONs for lazy classloading
-/vim-engine/src/main/resources/ksp-generated
-/src/main/resources/ksp-generated
 
 # Created by github automation
 settings.xml
+
+.kotlin

.idea/runConfigurations/IdeaVim_full_verification.xml

@@ -12,7 +12,7 @@
       <option name="taskNames">
         <list>
           <option value="check" />
-          <option value="runPluginVerifier" />
+          <option value="verifyPlugin" />
         </list>
       </option>
       <option name="vmOptions" value="" />
@@ -20,6 +20,7 @@
     <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
     <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
     <DebugAllEnabled>false</DebugAllEnabled>
+    <RunAsTest>false</RunAsTest>
     <method v="2" />
   </configuration>
 </component>

.teamcity/_Self/Constants.kt

@@ -5,13 +5,12 @@ object Constants {
   const val EAP_CHANNEL = "eap"
   const val DEV_CHANNEL = "Dev"
 
-  const val GITHUB_TESTS = "2024.1.1"
+  const val NVIM_TESTS = "2024.2.1"
-  const val NVIM_TESTS = "2024.1.1"
+  const val PROPERTY_TESTS = "2024.2.1"
-  const val PROPERTY_TESTS = "2024.1.1"
+  const val LONG_RUNNING_TESTS = "2024.2.1"
-  const val LONG_RUNNING_TESTS = "2024.1.1"
+  const val QODANA_TESTS = "2024.2.1"
-  const val QODANA_TESTS = "2024.1.1"
+  const val RELEASE = "2024.2.1"
-  const val RELEASE = "2024.1.1"
 
-  const val RELEASE_DEV = "2024.1.1"
+  const val RELEASE_DEV = "2024.2.1"
-  const val RELEASE_EAP = "2024.1.1"
+  const val RELEASE_EAP = "2024.2.1"
 }

.teamcity/_Self/Project.kt

@@ -8,7 +8,6 @@ import _Self.buildTypes.PropertyBased
 import _Self.buildTypes.Qodana
 import _Self.buildTypes.TestingBuildType
 import _Self.subprojects.GitHub
-import _Self.subprojects.OldTests
 import _Self.subprojects.Releases
 import _Self.vcsRoots.GitHubPullRequest
 import _Self.vcsRoots.ReleasesVcsRoot
@@ -18,7 +17,7 @@ import jetbrains.buildServer.configs.kotlin.v2019_2.Project
 object Project : Project({
   description = "Vim engine for JetBrains IDEs"
 
-  subProjects(Releases, OldTests, GitHub)
+  subProjects(Releases, GitHub)
 
   // VCS roots
   vcsRoot(GitHubPullRequest)
@@ -26,7 +25,7 @@ object Project : Project({
 
   // Active tests
   buildType(TestingBuildType("Latest EAP", "<default>", version = "LATEST-EAP-SNAPSHOT"))
-  buildType(TestingBuildType("2024.1.1", "<default>"))
+  buildType(TestingBuildType("2024.2.1", "<default>"))
   buildType(TestingBuildType("Latest EAP With Xorg", "<default>", version = "LATEST-EAP-SNAPSHOT"))
 
   buildType(PropertyBased)
@@ -43,6 +42,9 @@ object Project : Project({
 abstract class IdeaVimBuildType(init: BuildType.() -> Unit) : BuildType({
   artifactRules = """
         +:build/reports => build/reports
+        +:tests/java-tests/build/reports => java-tests/build/reports
+        +:tests/long-running-tests/build/reports => long-running-tests/build/reports
+        +:tests/property-tests/build/reports => property-tests/build/reports
         +:/mnt/agent/temp/buildTmp/ => /mnt/agent/temp/buildTmp/
     """.trimIndent()
 
@@ -52,7 +54,7 @@ abstract class IdeaVimBuildType(init: BuildType.() -> Unit) : BuildType({
     // These requirements define Linux-Medium configuration.
     // Unfortunately, requirement by name (teamcity.agent.name) doesn't work
     //   IDK the reason for it, but on our agents this property is empty
-    equals("teamcity.agent.hardware.cpuCount", "4")
+    equals("teamcity.agent.hardware.cpuCount", "16")
     equals("teamcity.agent.os.family", "Linux")
   }
 

.teamcity/_Self/buildTypes/Compatibility.kt

@@ -37,9 +37,12 @@ object Compatibility : IdeaVimBuildType({
               java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}eu.theblob42.idea.whichkey' [latest-IU] -team-city
               java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}IdeaVimExtension' [latest-IU] -team-city
               # Outdated java -jar verifier/verifier-cli-dev-all.jar check-plugin '${'$'}github.zgqq.intellij-enhance' [latest-IU] -team-city
-              java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}com.github.copilot' [latest-IU] -team-city
+              # java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}com.github.copilot' [latest-IU] -team-city
               java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}com.github.dankinsoid.multicursor' [latest-IU] -team-city
               java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}com.joshestein.ideavim-quickscope' [latest-IU] -team-city
+              java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}com.julienphalip.ideavim.peekaboo' [latest-IU] -team-city
+              java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}com.julienphalip.ideavim.switch' [latest-IU] -team-city
+              java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}com.julienphalip.ideavim.functiontextobj' [latest-IU] -team-city
             """.trimIndent()
     }
   }

.teamcity/_Self/buildTypes/PluginVerifier.kt

@@ -22,7 +22,7 @@ object PluginVerifier : IdeaVimBuildType({
 
   steps {
     gradle {
-      tasks = "clean runPluginVerifier"
+      tasks = "clean verifyPlugin"
       buildFile = ""
       enableStacktrace = true
     }

.teamcity/_Self/buildTypes/ReleaseEapFromBranch.kt

@@ -41,7 +41,7 @@ object ReleaseEapFromBranch : IdeaVimBuildType({
   vcs {
     root(ReleasesVcsRoot)
     branchFilter = """
-      +:heads/(releases/*)
+      +:heads/releases/*
       """.trimIndent()
 
     checkoutMode = CheckoutMode.AUTO

.teamcity/_Self/buildTypes/ReleasePlugin.kt

@@ -144,6 +144,7 @@ sealed class ReleasePlugin(private val releaseType: String) : IdeaVimBuildType({
     gradle {
       name = "Run Integrations"
       tasks = "releaseActions"
+      gradleParams = "--no-configuration-cache"
     }
 //    gradle {
 //      name = "Slack Notification"

.teamcity/_Self/buildTypes/TestingBuildType.kt

@@ -39,9 +39,11 @@ open class TestingBuildType(
 
   steps {
     gradle {
+      clearConditions()
       tasks = "clean test"
       buildFile = ""
       enableStacktrace = true
+      jdkHome = "/usr/lib/jvm/java-17-amazon-corretto"
     }
   }
 

.teamcity/_Self/subprojects/GitHub.kt

@@ -1,6 +1,5 @@
 package _Self.subprojects
 
-import _Self.Constants
 import _Self.IdeaVimBuildType
 import _Self.vcsRoots.GitHubPullRequest
 import jetbrains.buildServer.configs.kotlin.v2019_2.CheckoutMode
@@ -25,7 +24,6 @@ class GithubBuildType(command: String, desc: String) : IdeaVimBuildType({
 
   params {
     param("env.ORG_GRADLE_PROJECT_downloadIdeaSources", "false")
-    param("env.ORG_GRADLE_PROJECT_ideaVersion", Constants.GITHUB_TESTS)
     param("env.ORG_GRADLE_PROJECT_instrumentPluginCode", "false")
   }
 

.teamcity/_Self/subprojects/OldTests.kt

@@ -1,25 +0,0 @@
-package _Self.subprojects
-
-import _Self.buildTypes.TestingBuildType
-import jetbrains.buildServer.configs.kotlin.v2019_2.Project
-
-object OldTests : Project({
-  name = "Old IdeaVim tests"
-  description = "Tests for older versions of IJ"
-
-  buildType(TestingBuildType("IC-2018.1", "181-182", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2018.2", "181-182", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2018.3", "183", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2019.1", "191-193", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2019.2", "191-193", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2019.3", "191-193", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2020.1", "201", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2020.2", "202", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2020.3", "203-212", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2021.1", "203-212", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2021.2.2", "203-212", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2021.3.2", "213-221", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2022.2.3", branch = "222", javaPlugin = false))
-  buildType(TestingBuildType("IC-2023.1", "231-232", javaPlugin = false))
-  buildType(TestingBuildType("IC-2023.2", "231-232", javaPlugin = false))
-})

.teamcity/patches/buildTypes/IdeaVimTests_Latest_EAP.kts

@@ -1,39 +0,0 @@
-package patches.buildTypes
-
-import jetbrains.buildServer.configs.kotlin.v2019_2.*
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.GradleBuildStep
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.gradle
-import jetbrains.buildServer.configs.kotlin.v2019_2.ui.*
-
-/*
-This patch script was generated by TeamCity on settings change in UI.
-To apply the patch, change the buildType with id = 'IdeaVimTests_Latest_EAP'
-accordingly, and delete the patch script.
-*/
-changeBuildType(RelativeId("IdeaVimTests_Latest_EAP")) {
-    check(artifactRules == """
-        +:build/reports => build/reports
-        +:/mnt/agent/temp/buildTmp/ => /mnt/agent/temp/buildTmp/
-    """.trimIndent()) {
-        "Unexpected option value: artifactRules = $artifactRules"
-    }
-    artifactRules = """
-        +:build/reports => build/reports
-        +:/mnt/agent/temp/buildTmp/ => /mnt/agent/temp/buildTmp/
-        +:tests/java-tests/build/reports => tests/java-tests/build/reports
-    """.trimIndent()
-
-    expectSteps {
-        gradle {
-            tasks = "clean test"
-            buildFile = ""
-            enableStacktrace = true
-        }
-    }
-    steps {
-        update<GradleBuildStep>(0) {
-            clearConditions()
-            jdkHome = "/usr/lib/jvm/java-17-amazon-corretto"
-        }
-    }
-}

.teamcity/patches/buildTypes/ReleaseEapFromBranch.kts

@@ -1,19 +0,0 @@
-package patches.buildTypes
-
-import jetbrains.buildServer.configs.kotlin.v2019_2.*
-import jetbrains.buildServer.configs.kotlin.v2019_2.ui.*
-
-/*
-This patch script was generated by TeamCity on settings change in UI.
-To apply the patch, change the buildType with id = 'ReleaseEapFromBranch'
-accordingly, and delete the patch script.
-*/
-changeBuildType(RelativeId("ReleaseEapFromBranch")) {
-    vcs {
-
-        check(branchFilter == "+:heads/(releases/*)") {
-            "Unexpected option value: branchFilter = $branchFilter"
-        }
-        branchFilter = "heads/releases/*"
-    }
-}

AUTHORS.md

@@ -523,6 +523,46 @@ Contributors:
   [![icon][github]](https://github.com/LazyScaper)
    
   Jake
+* [![icon][mail]](mailto:the1xdeveloper@gmail.com)
+  [![icon][github]](https://github.com/The1xDeveloper)
+   
+  The1xDeveloper
+* [![icon][mail]](mailto:shaunewilliams@gmail.com)
+  [![icon][github]](https://github.com/shaunlebron)
+   
+  shaun
+* [![icon][mail]](mailto:i.i.babko@gmail.com)
+  [![icon][github]](https://github.com/igorbabko)
+   
+  Igor Babko
+* [![icon][mail]](mailto:533601+felixwiemuth@users.noreply.github.com)
+  [![icon][github]](https://github.com/felixwiemuth)
+   
+  Felix Wiemuth
+* [![icon][mail]](mailto:kirill.karnaukhov@jetbrains.com)
+  [![icon][github]](https://github.com/kkarnauk)
+   
+  Kirill Karnaukhov, 
+* [![icon][mail]](mailto:sander.hestvik@gmail.com)
+  [![icon][github]](https://github.com/SanderHestvik)
+   
+  SanderHestvik
+* [![icon][mail]](mailto:gregory.shrago@jetbrains.com)
+  [![icon][github]](https://github.com/gregsh)
+   
+  Greg Shrago
+* [![icon][mail]](mailto:jphalip@gmail.com)
+  [![icon][github]](https://github.com/jphalip)
+   
+  Julien Phalip
+* [![icon][mail]](mailto:j.trimailovas@gmail.com)
+  [![icon][github]](https://github.com/trimailov)
+   
+  Justas Trimailovas, 
+* [![icon][mail]](mailto:justast@wix.com)
+  [![icon][github]](https://github.com/justast-wix)
+   
+  Justas Trimailovas
 
 Previous contributors:
 
@@ -534,6 +574,10 @@ Previous contributors:
   [![icon][github]](https://github.com/kevin70)
    
   kk
+* [![icon][mail]](mailto:gregory.shrago@jetbrains.com)
+  [![icon][github]](https://github.com/gregsh)
+   
+  Greg Shrago
 
                         
 If you are a contributor and your name is not listed here, feel free to

CHANGES.md

@@ -27,8 +27,8 @@ usual beta standards.
 
 Since version 2.9.0, the changelog can be found on YouTrack
 
-To Be Released: https://youtrack.jetbrains.com/issues/VIM?q=%23%7BReady%20To%20Release%7D%20
+* [To Be Released](https://youtrack.jetbrains.com/issues/VIM?q=%23%7BReady%20To%20Release%7D%20)
-Latest Fixes: https://youtrack.jetbrains.com/issues/VIM?q=State:%20Fixed%20sort%20by:%20updated%20
+* [Version Fixes](https://youtrack.jetbrains.com/issues/VIM?q=State:%20Fixed%20sort%20by:%20%7BFix%20versions%7D%20asc)
 
 ## 2.9.0, 2024-02-20
 

CONTRIBUTING.md

@@ -62,12 +62,16 @@ for a few days or send it to a friend for testing.
 If you are looking for:
 
 - Vim commands (`w`, `<C-O>`, `p`, etc.):
-    - Any particular command: `package-info.java`.
+    - Any particular command:
+      - [Commands common for Fleet and IdeaVim](vim-engine/src/main/resources/ksp-generated/engine_commands.json)
+      - [IdeaVim only commands](src/main/resources/ksp-generated/intellij_commands.json)
     - How commands are executed in common: `EditorActionHandlerBase`.
     - Key mapping: `KeyHandler.handleKey()`.
 
 - Ex commands (`:set`, `:s`, `:nohlsearch`):
-    - Any particular ex command: package `com.maddyhome.idea.vim.ex.handler`.
+    - Any particular command:
+        - [Commands common for Fleet and IdeaVim](vim-engine/src/main/resources/ksp-generated/engine_ex_commands.json)
+        - [IdeaVim only commands](src/main/resources/ksp-generated/intellij_ex_commands.json)
     - Vim script grammar: `Vimscript.g4`.
     - Vim script parsing: package `com.maddyhome.idea.vim.vimscript.parser`.
     - Vim script executor: `Executor`.

README.md

@@ -109,7 +109,6 @@ etc
 
 See also:
 
-* [The list of all supported commands](src/main/java/com/maddyhome/idea/vim/package-info.java)
 * [Top feature requests and bugs](https://youtrack.jetbrains.com/issues/VIM?q=%23Unresolved+sort+by%3A+votes)
 * [Vimscript support roadmap](vimscript-info/VIMSCRIPT_ROADMAP.md)
 * [List of supported in-build functions](vimscript-info/FUNCTIONS_INFO.MD)
@@ -222,13 +221,13 @@ Ex commands or via `:map` command mappings:
     * Execute an action by `{action_id}`. Works from Ex command line.
     * Please don't use `:action` in mappings. Use `<Action>` instead.
 
-### Finding action ids:
+### Finding action IDs:
 
-* IJ provides `IdeaVim: track action Ids` command to show the id of the executed actions.
+* IJ provides `IdeaVim: track action IDs` command to show the id of the executed actions.
   This command can be found in "Search everywhere" (double `shift`).
 
     <details>
-        <summary><strong>"Track action Ids" Details</strong> (click to see)</summary>
+        <summary><strong>"Track action IDs" Details</strong> (click to see)</summary>
         <picture>
             <source media="(prefers-color-scheme: dark)" srcset="assets/readme/track_action_dark.gif">
             <img src="assets/readme/track_action_light.gif" alt="track action ids"/>
@@ -369,6 +368,8 @@ is the full list of synonyms.
 - Fancy constants for [undolevels](https://vimhelp.org/options.txt.html#%27undolevels%27):
   > The local value is set to -123456 when the global value is to be used.
 
+- Vi (not Vim) is a POSIX standard, and [has a spec](https://pubs.opengroup.org/onlinepubs/9699919799/utilities/vi.html)! Vim is mostly POSIX compliant when Vi compatibility is selected with the `'compatible'` option, but there are still some differences that can be changed with `'copoptions'`. The spec is interesting because it documents the behaviour of different commands in a stricter style than the user documentation, describing the current line and column after the command, for example. [More details can be found by reading `:help posix`](https://vimhelp.org/vi_diff.txt.html#posix).
+
 License
 -------
 

annotation-processors/build.gradle.kts

@@ -8,7 +8,7 @@
 
 plugins {
   kotlin("jvm")
-  kotlin("plugin.serialization") version "1.9.22"
+  kotlin("plugin.serialization") version "2.0.0"
 }
 
 val kotlinxSerializationVersion: String by project
@@ -21,7 +21,7 @@ repositories {
 }
 
 dependencies {
-  compileOnly("com.google.devtools.ksp:symbol-processing-api:2.0.0-1.0.22")
+  compileOnly("com.google.devtools.ksp:symbol-processing-api:2.1.0-1.0.29")
   implementation("org.jetbrains.kotlinx:kotlinx-serialization-json-jvm:$kotlinxSerializationVersion") {
     // kotlin stdlib is provided by IJ, so there is no need to include it into the distribution
     exclude("org.jetbrains.kotlin", "kotlin-stdlib")

annotation-processors/src/main/kotlin/com/intellij/vim/processors/CommandOrMotionProcessor.kt

@@ -37,7 +37,8 @@ class CommandOrMotionProcessor(private val environment: SymbolProcessorEnvironme
     Files.createDirectories(generatedDirPath)
 
     val filePath = generatedDirPath.resolve(environment.options["commands_file"]!!)
-    val fileContent = json.encodeToString(commands)
+    val sortedCommands = commands.sortedWith(compareBy({ it.keys }, { it.`class` }))
+    val fileContent = json.encodeToString(sortedCommands)
     filePath.writeText(fileContent)
 
     return emptyList()

annotation-processors/src/main/kotlin/com/intellij/vim/processors/ExCommandProcessor.kt

@@ -37,7 +37,8 @@ class ExCommandProcessor(private val environment: SymbolProcessorEnvironment): S
     Files.createDirectories(generatedDirPath)
 
     val filePath = generatedDirPath.resolve(environment.options["ex_commands_file"]!!)
-    val fileContent = json.encodeToString(commandToClass)
+    val sortedCommandToClass = commandToClass.toList().sortedWith(compareBy({ it.first }, { it.second })).toMap()
+    val fileContent = json.encodeToString(sortedCommandToClass)
     filePath.writeText(fileContent)
 
     return emptyList()

annotation-processors/src/main/kotlin/com/intellij/vim/processors/VimscriptFunctionProcessor.kt

@@ -37,7 +37,8 @@ class VimscriptFunctionProcessor(private val environment: SymbolProcessorEnviron
     Files.createDirectories(generatedDirPath)
 
     val filePath = generatedDirPath.resolve(environment.options["vimscript_functions_file"]!!)
-    val fileContent = json.encodeToString(nameToClass)
+    val sortedNameToClass = nameToClass.toList().sortedWith(compareBy({ it.first }, { it.second })).toMap()
+    val fileContent = json.encodeToString(sortedNameToClass)
     filePath.writeText(fileContent)
 
     return emptyList()

build.gradle.kts

@@ -32,6 +32,8 @@ import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.lib.RepositoryBuilder
 import org.intellij.markdown.ast.getTextInNode
 import org.jetbrains.changelog.Changelog
+import org.jetbrains.intellij.platform.gradle.TestFrameworkType
+import org.jetbrains.intellij.platform.gradle.tasks.aware.SplitModeAware
 import org.kohsuke.github.GHUser
 import java.net.HttpURLConnection
 import java.net.URL
@@ -43,19 +45,19 @@ buildscript {
   }
 
   dependencies {
-    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.22")
+    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:2.0.0")
     classpath("com.github.AlexPl292:mark-down-to-slack:1.1.2")
     classpath("org.eclipse.jgit:org.eclipse.jgit:6.6.0.202305301015-r")
 
     // This is needed for jgit to connect to ssh
-    classpath("org.eclipse.jgit:org.eclipse.jgit.ssh.apache:6.10.0.202406032230-r")
+    classpath("org.eclipse.jgit:org.eclipse.jgit.ssh.apache:7.1.0.202411261347-r")
     classpath("org.kohsuke:github-api:1.305")
 
-    classpath("io.ktor:ktor-client-core:2.3.12")
+    classpath("io.ktor:ktor-client-core:3.0.2")
-    classpath("io.ktor:ktor-client-cio:2.3.10")
+    classpath("io.ktor:ktor-client-cio:3.0.2")
-    classpath("io.ktor:ktor-client-auth:2.3.12")
+    classpath("io.ktor:ktor-client-auth:3.0.2")
-    classpath("io.ktor:ktor-client-content-negotiation:2.3.10")
+    classpath("io.ktor:ktor-client-content-negotiation:3.0.2")
-    classpath("io.ktor:ktor-serialization-kotlinx-json:2.3.12")
+    classpath("io.ktor:ktor-serialization-kotlinx-json:3.0.2")
 
     // This comes from the changelog plugin
 //        classpath("org.jetbrains:markdown:0.3.1")
@@ -64,28 +66,25 @@ buildscript {
 
 plugins {
   java
-  kotlin("jvm") version "1.9.22"
+  kotlin("jvm") version "2.0.0"
   application
   id("java-test-fixtures")
-
+  id("org.jetbrains.intellij.platform") version "2.2.0"
-  id("org.jetbrains.intellij") version "1.17.3"
+  id("org.jetbrains.changelog") version "2.2.1"
-  id("org.jetbrains.changelog") version "2.2.0"
-
   id("org.jetbrains.kotlinx.kover") version "0.6.1"
   id("com.dorongold.task-tree") version "4.0.0"
-
+  id("com.google.devtools.ksp") version "2.0.0-1.0.23"
-  id("com.google.devtools.ksp") version "1.9.22-1.0.17"
 }
 
+val moduleSources by configurations.registering
+
 // Import variables from gradle.properties file
 val javaVersion: String by project
 val kotlinVersion: String by project
 val ideaVersion: String by project
 val ideaType: String by project
-val downloadIdeaSources: String by project
 val instrumentPluginCode: String by project
 val remoteRobotVersion: String by project
-val splitModeVersion: String by project
 
 val publishChannels: String by project
 val publishToken: String by project
@@ -97,7 +96,9 @@ val releaseType: String? by project
 
 repositories {
   mavenCentral()
-  maven { url = uri("https://cache-redirector.jetbrains.com/intellij-dependencies") }
+  intellijPlatform {
+    defaultRepositories()
+  }
 }
 
 dependencies {
@@ -106,12 +107,34 @@ dependencies {
   compileOnly(project(":annotation-processors"))
 
   compileOnly("org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion")
-  compileOnly("org.jetbrains:annotations:24.1.0")
+  compileOnly("org.jetbrains:annotations:26.0.1")
+
+  intellijPlatform {
+    // Snapshots don't use installers
+    // https://plugins.jetbrains.com/docs/intellij/tools-intellij-platform-gradle-plugin-dependencies-extension.html#target-versions-installers
+    val useInstaller = "EAP-SNAPSHOT" !in ideaVersion
+
+    // Note that it is also possible to use local("...") to compile against a locally installed IDE
+    // E.g. local("/Users/{user}/Applications/IntelliJ IDEA Ultimate.app")
+    // Or something like: intellijIdeaUltimate(ideaVersion)
+    create(ideaType, ideaVersion, useInstaller)
+
+    pluginVerifier()
+    zipSigner()
+    instrumentationTools()
+
+    testFramework(TestFrameworkType.Platform)
+    testFramework(TestFrameworkType.JUnit5)
+
+    // AceJump is an optional dependency. We use their SessionManager class to check if it's active
+    plugin("AceJump", "3.8.19")
+    plugin("com.intellij.classic.ui", "242.20224.159")
+  }
+
+  moduleSources(project(":vim-engine", "sourcesJarArtifacts"))
 
   // --------- Test dependencies ----------
 
-  testImplementation(testFixtures(project(":")))
-
   testApi("com.squareup.okhttp3:okhttp:4.12.0")
 
   // https://mvnrepository.com/artifact/com.ensarsarajcic.neovim.java/neovim-api
@@ -125,14 +148,20 @@ dependencies {
   testFixturesImplementation("org.jetbrains.kotlin:kotlin-test:$kotlinVersion")
 
   // https://mvnrepository.com/artifact/org.mockito.kotlin/mockito-kotlin
-  testImplementation("org.mockito.kotlin:mockito-kotlin:5.3.1")
+  testImplementation("org.mockito.kotlin:mockito-kotlin:5.4.0")
 
-  testImplementation("org.junit.jupiter:junit-jupiter-api:5.10.3")
+  testImplementation("org.junit.jupiter:junit-jupiter-api:5.10.5")
-  testImplementation("org.junit.jupiter:junit-jupiter-engine:5.10.3")
+  testImplementation("org.junit.jupiter:junit-jupiter-engine:5.10.5")
-  testImplementation("org.junit.jupiter:junit-jupiter-params:5.10.3")
+  testImplementation("org.junit.jupiter:junit-jupiter-params:5.10.5")
-  testFixturesImplementation("org.junit.jupiter:junit-jupiter-api:5.10.3")
+  testFixturesImplementation("org.junit.jupiter:junit-jupiter-api:5.10.5")
-  testFixturesImplementation("org.junit.jupiter:junit-jupiter-engine:5.10.3")
+  testFixturesImplementation("org.junit.jupiter:junit-jupiter-engine:5.10.5")
-  testFixturesImplementation("org.junit.jupiter:junit-jupiter-params:5.10.3")
+  testFixturesImplementation("org.junit.jupiter:junit-jupiter-params:5.10.5")
+
+  // Temp workaround suggested in https://plugins.jetbrains.com/docs/intellij/tools-intellij-platform-gradle-plugin-faq.html#junit5-test-framework-refers-to-junit4
+  // Can be removed when IJPL-159134 is fixed
+//  testRuntimeOnly("junit:junit:4.13.2")
+  testImplementation("org.junit.vintage:junit-vintage-engine:5.10.5")
+//  testFixturesImplementation("org.junit.vintage:junit-vintage-engine:5.10.3")
 }
 
 configurations {
@@ -172,60 +201,91 @@ tasks {
       // See https://plugins.jetbrains.com/docs/intellij/using-kotlin.html#kotlin-standard-library
       // For the list of bundled versions
       apiVersion = "1.9"
-      freeCompilerArgs = listOf("-Xjvm-default=all-compatibility")
+      freeCompilerArgs = listOf(
+        "-Xjvm-default=all-compatibility",
+
+        // Needed to compile the AceJump which uses kotlin beta
+        //  Without these two option compilation fails
+        "-Xskip-prerelease-check",
+        "-Xallow-unstable-dependencies",
+      )
 //            allWarningsAsErrors = true
     }
   }
 
   compileTestKotlin {
+    enabled = false
+    
     kotlinOptions {
       jvmTarget = javaVersion
       apiVersion = "1.9"
+
+      // Needed to compile the AceJump which uses kotlin beta
+      //  Without these two option compilation fails
+      freeCompilerArgs += listOf("-Xskip-prerelease-check", "-Xallow-unstable-dependencies")
 //            allWarningsAsErrors = true
     }
   }
 
+  // Note that this will run the plugin installed in the IDE specified in dependencies. To run in a different IDE, use
+  // a custom task (see below)
   runIde {
     systemProperty("octopus.handler", System.getProperty("octopus.handler") ?: true)
   }
 
-  downloadRobotServerPlugin {
+  // Uncomment to run the plugin in a custom IDE, rather than the IDE specified as a compile target in dependencies
-    version.set(remoteRobotVersion)
+  // Note that the version must be greater than the plugin's target version, for obvious reasons
+  // You can also set splitMode and splitModeTarget here to test split mode in a custom IDE
+//  val runIdeCustom by intellijPlatformTesting.runIde.registering {
+//    type = IntelliJPlatformType.Rider
+//    version = "2024.1.2"
+//  }
+
+  // Uncomment to run the plugin in a locally installed IDE
+//  val runIdeLocal by intellijPlatformTesting.runIde.registering {
+//    localPath = file("/Users/{user}/Applications/WebStorm.app")
+//  }
+
+  val runIdeForUiTests by intellijPlatformTesting.runIde.registering {
+    task {
+      jvmArgumentProviders += CommandLineArgumentProvider {
+        listOf(
+          "-Drobot-server.port=8082",
+          "-Dide.mac.message.dialogs.as.sheets=false",
+          "-Djb.privacy.policy.text=<!--999.999-->",
+          "-Djb.consents.confirmation.enabled=false",
+          "-Dide.show.tips.on.startup.default.value=false",
+          "-Doctopus.handler=" + (System.getProperty("octopus.handler") ?: true),
+        )
+      }
     }
 
-  runIdeForUiTests {
+    plugins {
-    systemProperty("robot-server.port", "8082")
+      robotServerPlugin(remoteRobotVersion)
-    systemProperty("ide.mac.message.dialogs.as.sheets", "false")
+    }
-    systemProperty("jb.privacy.policy.text", "<!--999.999-->")
+  }
-    systemProperty("jb.consents.confirmation.enabled", "false")
-    systemProperty("ide.show.tips.on.startup.default.value", "false")
 
-    systemProperty("octopus.handler", System.getProperty("octopus.handler") ?: true)
+  val runIdeSplitMode by intellijPlatformTesting.runIde.registering {
+    splitMode = true
+    splitModeTarget = SplitModeAware.SplitModeTarget.FRONTEND
   }
 
   // Add plugin open API sources to the plugin ZIP
-  val createOpenApiSourceJar by registering(Jar::class) {
+  val sourcesJar by registering(Jar::class) {
-    // Java sources
+    dependsOn(moduleSources)
-    from(sourceSets.main.get().java) {
-      include("**/com/maddyhome/idea/vim/**/*.java")
-    }
-    from(project(":vim-engine").sourceSets.main.get().java) {
-      include("**/com/maddyhome/idea/vim/**/*.java")
-    }
-    // Kotlin sources
-    from(kotlin.sourceSets.main.get().kotlin) {
-      include("**/com/maddyhome/idea/vim/**/*.kt")
-    }
-    from(project(":vim-engine").kotlin.sourceSets.main.get().kotlin) {
-      include("**/com/maddyhome/idea/vim/**/*.kt")
-    }
     destinationDirectory.set(layout.buildDirectory.dir("libs"))
-    archiveClassifier.set("src")
+    archiveClassifier.set(DocsType.SOURCES)
+    from(sourceSets.main.map { it.kotlin })
+    from(provider {
+      moduleSources.map {
+        it.map { jarFile -> zipTree(jarFile) }
+      }
+    })
   }
 
   buildPlugin {
-    dependsOn(createOpenApiSourceJar)
+    dependsOn(sourcesJar)
-    from(createOpenApiSourceJar) { into("lib/src") }
+    from(sourcesJar) { into("lib/src") }
   }
 }
 
@@ -250,44 +310,51 @@ gradle.projectsEvaluated {
 
 // --- Intellij plugin
 
-intellij {
+intellijPlatform {
-  version.set(ideaVersion)
+  pluginConfiguration {
-  type.set(ideaType)
+    name = "IdeaVim"
-  pluginName.set("IdeaVim")
+    changeNotes.set(
+      """
+        Undo in IdeaVim now works like in Vim<br/>
+        Caret movement is no longer a separate undo step, and full insert is undoable in one step.<br/>
+        <a href="https://youtrack.jetbrains.com/issue/VIM-547/Undo-splits-Insert-mode-edits-into-separate-undo-chunks">Share Feedback</a>
+        <br/>
+        <br/>
+        <a href="https://youtrack.jetbrains.com/issues/VIM?q=State:%20Fixed%20Fix%20versions:%20${version.get()}">Changelog</a>
+        """.trimIndent()
+    )
 
-  updateSinceUntilBuild.set(false)
+    ideaVersion {
-
+      // Let the Gradle plugin set the since-build version. It defaults to the version of the IDE we're building against
-  downloadSources.set(downloadIdeaSources.toBoolean())
+      // specified as two components, `{branch}.{build}` (e.g., "241.15989"). There is no third component specified.
-  instrumentCode.set(instrumentPluginCode.toBoolean())
+      // The until-build version defaults to `{branch}.*`, but we want to support _all_ future versions, so we set it
-  intellijRepository.set("https://www.jetbrains.com/intellij-repository")
+      // with a null provider (the provider is important).
-  plugins.set(listOf("AceJump:3.8.11"))
+      // By letting the Gradle plugin handle this, the Plugin DevKit IntelliJ plugin cannot help us with the "Usage of
+      // IntelliJ API not available in older IDEs" inspection. However, since our since-build is the version we compile
+      // against, we can never get an API that's newer - it would be an unresolved symbol.
+      untilBuild.set(provider { null })
+    }
   }
 
-tasks {
+  publishing {
-  publishPlugin {
     channels.set(publishChannels.split(","))
     token.set(publishToken)
   }
 
-  signPlugin {
+  signing {
     certificateChain.set(providers.environmentVariable("CERTIFICATE_CHAIN"))
     privateKey.set(providers.environmentVariable("PRIVATE_KEY"))
     password.set(providers.environmentVariable("PRIVATE_KEY_PASSWORD"))
   }
 
-  runPluginVerifier {
+  verifyPlugin {
-    downloadDir.set("${project.buildDir}/pluginVerifier/ides")
+    teamCityOutputFormat = true
-    teamCityOutputFormat.set(true)
+    ides {
+      recommended()
+    }
   }
 
-  patchPluginXml {
+  instrumentCode.set(instrumentPluginCode.toBoolean())
-    // Don't forget to update plugin.xml
-    sinceBuild.set("241.15989.150")
-
-    changeNotes.set(
-      """<a href="https://youtrack.jetbrains.com/issues/VIM?q=State:%20Fixed%20Fix%20versions:%20${version.get()}">Changelog</a>"""
-    )
-  }
 }
 
 ksp {
@@ -891,12 +958,12 @@ fun changes(): List<Change> {
   println("Start changes processing")
   for (message in messages) {
     println("Processing '$message'...")
-    val lowercaseMessage = message.toLowerCase()
+    val lowercaseMessage = message.lowercase()
     val regex = "^fix\\((vim-\\d+)\\):".toRegex()
     val findResult = regex.find(lowercaseMessage)
     if (findResult != null) {
       println("Message matches")
-      val value = findResult.groups[1]!!.value.toUpperCase()
+      val value = findResult.groups[1]!!.value.uppercase()
       val shortMessage = message.drop(findResult.range.last + 1).trim()
       newFixes += Change(value, shortMessage)
     } else {

doc/IdeaVim Plugins.md

@@ -322,6 +322,9 @@ If you want to optimize highlight duration, assign a time in milliseconds:
 If you want to change background color of highlight you can provide the rgba of the color you want e.g.  
       `let g:highlightedyank_highlight_color = "rgba(160, 160, 160, 155)"`
 
+If you want to change text color of highlight you can provide the rgba of the color you want e.g.  
+`let g:highlightedyank_highlight_foreground_color = "rgba(0, 0, 0, 255)"`
+
 https://github.com/machakann/vim-highlightedyank/blob/master/doc/highlightedyank.txt
 
 </details>
@@ -435,3 +438,50 @@ Original plugin: [vim-which-key](https://github.com/liuchengxu/vim-which-key).
 https://github.com/TheBlob42/idea-which-key?tab=readme-ov-file#installation
 
 </details>
+<details>
+<summary><h2>Vim Peekaboo</h2></summary>
+
+By Julien Phalip  
+Original plugin: [vim-peekaboo](https://github.com/junegunn/vim-peekaboo).
+
+### Setup
+
+Add `set peekaboo` to your `~/.ideavimrc` file, then run `:source ~/.ideavimrc`
+or restart the IDE.
+
+### Instructions
+
+https://plugins.jetbrains.com/plugin/25776-vim-peekaboo
+</details>
+
+<details>
+<summary><h2>FunctionTextObj</h2></summary>
+
+By Julien Phalip  
+
+### Setup
+
+Add `set functiontextobj` to your `~/.ideavimrc` file, then run `:source ~/.ideavimrc`
+or restart the IDE.
+
+### Instructions
+
+https://plugins.jetbrains.com/plugin/25897-vim-functiontextobj
+</details>
+
+<details>
+<summary><h2>Switch</h2></summary>
+
+By Julien Phalip  
+Original plugin: [switch.vim](https://github.com/AndrewRadev/switch.vim).
+
+### Setup
+
+Add `set switch` to your `~/.ideavimrc` file, then run `:source ~/.ideavimrc`
+or restart the IDE.
+
+### Instructions
+
+https://plugins.jetbrains.com/plugin/25899-vim-switch
+
+</details>

doc/marketplace-plugin-example.md

@@ -5,7 +5,7 @@ Using actions from external plugins is the same, as tracking and reusing any IDE
 1. Install the plugin via Marketplace
 2. Enable action tracking. You can enable it by one of the following ways:
     * Execute `:set trackactionids` ex command or just `:set tai`
-    * Open the "Find actions" window by pressing `Ctrl-Shift-A` and search for "Track Action Ids" to find the toggle that enables and disables action tracking
+    * Open the "Find actions" window by pressing `Ctrl-Shift-A` and search for "Track Action IDs" to find the toggle that enables and disables action tracking
 3. Execute the plugin action the way intended by plugin author "See Edit menu or use ⇧ + ⌥ + U / Shift + Alt + U" or just find the `Toggle Camel Case` action in the "Find actions" window (`Ctrl-Shift-A`). If you action tracking is on, you will see this notification in your right bottom corner:
    
    <img alt="Notification" src="images/action-id-notification.png"/>

doc/set-commands.md

@@ -8,7 +8,7 @@ Every effort is made to make these options compatible with Vim behaviour.
 However, some differences are inevitable.
 
 ```
-'clipboard'     'cb'    Defines clipboard behavioue
+'clipboard'     'cb'    Defines clipboard behavior
         A comma-separated list of words to control clipboard behaviour:
            unnamed      The clipboard register '*' is used instead of the
                         unnamed register

doc/support-guide.md

@@ -1,7 +1,7 @@
 # Support Guide
 
 This document is created to help our support team.
-It's not intended to be read by the users as it brings to value to them.
+It's not intended to be read by the users as it brings no value to them.
 
 ## Support channels
 
@@ -25,7 +25,7 @@ It's not intended to be read by the users as it brings to value to them.
 IdeaVim has multiple YouTrack statuses, main are:
 
 - Submitted: issue is created by user, but not processed by our team. This is the default status for new tickets.
-- Open: issues is processed by out team, what means that the issues is reproduced and accepted
+- Open: issues is processed by our team, what means that the issues is reproduced and accepted
 - Waiting For Reply: Waiting for further information from the user. These issues are automatically closed if the
      user doesn't reply in 30 days.
 - Ready To Release: Bug is fixed, but not yet released

gradle.properties

@@ -16,26 +16,19 @@
 # https://data.services.jetbrains.com/products?code=IC
 # Maven releases are here: https://www.jetbrains.com/intellij-repository/releases
 # And snapshots: https://www.jetbrains.com/intellij-repository/snapshots
-ideaVersion=2024.1.1
+ideaVersion=2024.2
 # Values for type: https://plugins.jetbrains.com/docs/intellij/tools-gradle-intellij-plugin.html#intellij-extension-type
 ideaType=IC
-downloadIdeaSources=true
 instrumentPluginCode=true
-version=chylex-36
+version=chylex-42
 javaVersion=17
-remoteRobotVersion=0.11.22
+remoteRobotVersion=0.11.23
 antlrVersion=4.10.1
 
-# [VERSION UPDATE] 2024.2 - remove when IdeaVim targets 2024.2
-# Running IdeaVim in split mode requires 242. Update this version once 242 has been released, and remove it completely
-# when IdeaVim targets 242, at which point runIdeSplitMode will run correctly with the target version.
-# See also runIdeSplitMode
-splitModeVersion=242-EAP-SNAPSHOT
-
 
 # Please don't forget to update kotlin version in buildscript section
 # Also update kotlinxSerializationVersion version
-kotlinVersion=1.9.22
+kotlinVersion=2.0.0
 publishToken=token
 publishChannels=eap
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradlew

@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
 #
@@ -55,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -83,7 +85,9 @@ done
 # This is normally unused
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -144,7 +148,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
         # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
+        # shellcheck disable=SC2039,SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
@@ -152,7 +156,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
       '' | soft) :;; #(
       *)
         # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
+        # shellcheck disable=SC2039,SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -201,11 +205,11 @@ fi
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
-# Collect all arguments for the java command;
+# Collect all arguments for the java command:
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
-#     shell script including quotes and variable substitutions, so put them in
+#     and any embedded shellness will be escaped.
-#     double quotes to make sure that they get re-expanded; and
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
-#   * put everything else in single quotes, so that it's not re-expanded.
+#     treated as '${Hostname}' itself on the command line.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \

gradlew.bat

@@ -13,6 +13,8 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
 @if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
@@ -43,11 +45,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute
 
-echo.
+echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo.
+echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation.
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -57,11 +59,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo.
+echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo.
+echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation.
+echo location of your Java installation. 1>&2
 
 goto fail
 

qodana.yaml

@@ -19,9 +19,8 @@ exclude:
       - src/test/java/org/jetbrains/plugins/ideavim/propertybased/samples/JavaText.kt
       - src/test/java/org/jetbrains/plugins/ideavim/propertybased/samples/LoremText.kt
       - src/test/java/org/jetbrains/plugins/ideavim/propertybased/samples/SimpleText.kt
-      - src/main/java/com/maddyhome/idea/vim/vimscript/parser/generated
-      - src/main/java/com/maddyhome/idea/vim/package-info.java
       - vim-engine/src/main/java/com/maddyhome/idea/vim/regexp/parser/generated
+      - vim-engine/src/main/java/com/maddyhome/idea/vim/parser/generated
       - src/main/java/com/maddyhome/idea/vim/group/SearchGroup.java
       - tests/ui-fixtures
 dependencyIgnores:

scripts/build.gradle.kts

@@ -20,17 +20,17 @@ repositories {
 }
 
 dependencies {
-  compileOnly("org.jetbrains.kotlin:kotlin-stdlib:1.9.24")
+  compileOnly("org.jetbrains.kotlin:kotlin-stdlib:2.1.0")
 
-  implementation("io.ktor:ktor-client-core:2.3.12")
+  implementation("io.ktor:ktor-client-core:3.0.2")
-  implementation("io.ktor:ktor-client-cio:2.3.10")
+  implementation("io.ktor:ktor-client-cio:3.0.2")
-  implementation("io.ktor:ktor-client-content-negotiation:2.3.10")
+  implementation("io.ktor:ktor-client-content-negotiation:3.0.2")
-  implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.12")
+  implementation("io.ktor:ktor-serialization-kotlinx-json:3.0.2")
-  implementation("io.ktor:ktor-client-auth:2.3.12")
+  implementation("io.ktor:ktor-client-auth:3.0.2")
   implementation("org.eclipse.jgit:org.eclipse.jgit:6.6.0.202305301015-r")
 
   // This is needed for jgit to connect to ssh
-  implementation("org.eclipse.jgit:org.eclipse.jgit.ssh.apache:6.10.0.202406032230-r")
+  implementation("org.eclipse.jgit:org.eclipse.jgit.ssh.apache:7.1.0.202411261347-r")
   implementation("com.vdurmont:semver4j:3.1.0")
 }
 

scripts/src/main/kotlin/scripts/checkNewPluginDependencies.kt

@@ -40,6 +40,9 @@ val knownPlugins = setOf(
   "com.protoseo.input-source-auto-converter",
 
 //   "cc.implicated.intellij.plugins.bunny", // I don't want to include this plugin in the list of IdeaVim plugins as I don't understand what this is for
+  "com.julienphalip.ideavim.peekaboo", // https://plugins.jetbrains.com/plugin/25776-vim-peekaboo
+  "com.julienphalip.ideavim.switch", // https://plugins.jetbrains.com/plugin/25899-vim-switch
+  "com.julienphalip.ideavim.functiontextobj", // https://plugins.jetbrains.com/plugin/25897-vim-functiontextobj
 )
 
 suspend fun main() {

src/main/java/com/maddyhome/idea/vim/PluginStartup.kt

@@ -8,14 +8,23 @@
 
 package com.maddyhome.idea.vim
 
+import com.intellij.ide.BrowserUtil
+import com.intellij.ide.plugins.IdeaPluginDescriptor
+import com.intellij.ide.plugins.PluginStateListener
+import com.intellij.ide.plugins.PluginStateManager
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.project.ProjectManagerListener
 import com.intellij.openapi.startup.ProjectActivity
+import com.intellij.openapi.updateSettings.impl.UpdateSettings
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.helper.EditorHelper
 import com.maddyhome.idea.vim.newapi.IjVimEditor
 import com.maddyhome.idea.vim.newapi.globalIjOptions
+import com.maddyhome.idea.vim.newapi.initInjector
+import com.maddyhome.idea.vim.ui.JoinEap
+import com.maddyhome.idea.vim.ui.JoinEap.EAP_LINK
 
 /**
  * @author Alex Plate
@@ -24,18 +33,39 @@ internal class PluginStartup : ProjectActivity/*, LightEditCompatible*/ {
 
   private var firstInitializationOccurred = false
 
+  // TODO
+  // We should migrate to some solution from https://plugins.jetbrains.com/docs/intellij/plugin-components.html#application-startup
+  // If you'd like to add a new code here, please consider using one of the things described there.
   override suspend fun execute(project: Project) {
     if (firstInitializationOccurred) return
     firstInitializationOccurred = true
 
+    if (!VimPlugin.getVimState().wasSubscibedToEAPAutomatically && ApplicationManager.getApplication().isEAP && !JoinEap.eapActive()) {
+      VimPlugin.getVimState().wasSubscibedToEAPAutomatically = true
+      UpdateSettings.getInstance().storedPluginHosts += EAP_LINK
+    }
+
     // This code should be executed once
     VimPlugin.getInstance().initialize()
+
+    // Uninstall survey. Should be registered once for all projects
+    PluginStateManager.addStateListener(object : PluginStateListener {
+      override fun install(p0: IdeaPluginDescriptor) {/*Nothing*/
+      }
+
+      override fun uninstall(descriptor: IdeaPluginDescriptor) {
+        if (descriptor.pluginId == VimPlugin.getPluginId()) {
+          BrowserUtil.open("https://surveys.jetbrains.com/s3/ideavim-uninstall-feedback")
+        }
+      }
+    })
   }
 }
 
 // This is a temporal workaround for VIM-2487
 internal class PyNotebooksCloseWorkaround : ProjectManagerListener {
   override fun projectClosingBeforeSave(project: Project) {
+    initInjector()
     // TODO: Confirm context in CWM scenario
     if (injector.globalIjOptions().closenotebooks) {
       injector.editorGroup.getEditors().forEach { vimEditor ->

src/main/java/com/maddyhome/idea/vim/VimPlugin.java

@@ -10,6 +10,7 @@ package com.maddyhome.idea.vim;
 import com.intellij.ide.plugins.IdeaPluginDescriptor;
 import com.intellij.ide.plugins.PluginManagerCore;
 import com.intellij.openapi.Disposable;
+import com.intellij.openapi.application.AccessToken;
 import com.intellij.openapi.application.Application;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.components.PersistentStateComponent;
@@ -24,10 +25,8 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.Messages;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.SystemInfo;
-import com.maddyhome.idea.vim.api.VimEditor;
+import com.intellij.util.SlowOperations;
-import com.maddyhome.idea.vim.api.VimInjectorKt;
+import com.maddyhome.idea.vim.api.*;
-import com.maddyhome.idea.vim.api.VimKeyGroup;
-import com.maddyhome.idea.vim.api.VimOptionGroup;
 import com.maddyhome.idea.vim.config.VimState;
 import com.maddyhome.idea.vim.config.migration.ApplicationConfigurationMigrator;
 import com.maddyhome.idea.vim.extension.VimExtensionRegistrar;
@@ -36,7 +35,7 @@ import com.maddyhome.idea.vim.group.copy.PutGroup;
 import com.maddyhome.idea.vim.group.visual.VisualMotionGroup;
 import com.maddyhome.idea.vim.helper.MacKeyRepeat;
 import com.maddyhome.idea.vim.listener.VimListenerManager;
-import com.maddyhome.idea.vim.newapi.IjVimInjector;
+import com.maddyhome.idea.vim.newapi.IjVimInjectorKt;
 import com.maddyhome.idea.vim.newapi.IjVimSearchGroup;
 import com.maddyhome.idea.vim.ui.StatusBarIconFactory;
 import com.maddyhome.idea.vim.vimscript.services.VariableService;
@@ -67,7 +66,7 @@ public class VimPlugin implements PersistentStateComponent<Element>, Disposable
   private static final Logger LOG = Logger.getInstance(VimPlugin.class);
 
   static {
-    VimInjectorKt.setInjector(new IjVimInjector());
+    IjVimInjectorKt.initInjector();
   }
 
   private final @NotNull VimState state = new VimState();
@@ -140,8 +139,8 @@ public class VimPlugin implements PersistentStateComponent<Element>, Disposable
     return (MacroGroup)VimInjectorKt.getInjector().getMacro();
   }
 
-  public static @NotNull DigraphGroup getDigraph() {
+  public static @NotNull VimDigraphGroup getDigraph() {
-    return (DigraphGroup)VimInjectorKt.getInjector().getDigraphGroup();
+    return VimInjectorKt.getInjector().getDigraphGroup();
   }
 
   public static @NotNull HistoryGroup getHistory() {
@@ -338,7 +337,9 @@ public class VimPlugin implements PersistentStateComponent<Element>, Disposable
 
     // 4) ~/.ideavimrc execution
     // Evaluate in the context of the fallback window, to capture local option state, to copy to the first editor window
+    try (AccessToken ignore = SlowOperations.knownIssue("VIM-3661")) {
       registerIdeavimrc(VimInjectorKt.getInjector().getFallbackWindow());
+    }
 
     // Turing on should be performed after all commands registration
     getSearch().turnOn();

src/main/java/com/maddyhome/idea/vim/VimProjectService.kt

@@ -18,7 +18,7 @@ import com.maddyhome.idea.vim.ui.ex.ExEntryPanel
 internal class VimProjectService(val project: Project) : Disposable {
   override fun dispose() {
     // Not sure if this is a best solution
-    ExEntryPanel.getInstance().editor = null
+    ExEntryPanel.getInstance().setEditor(null)
   }
 
   companion object {

src/main/java/com/maddyhome/idea/vim/action/VimRunLastMacroInOpenFiles.kt

@@ -0,0 +1,52 @@
+package com.maddyhome.idea.vim.action
+
+import com.intellij.openapi.actionSystem.ActionUpdateThread
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.command.UndoConfirmationPolicy
+import com.intellij.openapi.command.WriteCommandAction
+import com.intellij.openapi.fileEditor.TextEditor
+import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx
+import com.intellij.openapi.project.DumbAwareAction
+import com.maddyhome.idea.vim.KeyHandler
+import com.maddyhome.idea.vim.api.injector
+import com.maddyhome.idea.vim.newapi.IjEditorExecutionContext
+import com.maddyhome.idea.vim.newapi.vim
+import com.maddyhome.idea.vim.state.mode.Mode
+
+class VimRunLastMacroInOpenFiles : DumbAwareAction() {
+  override fun update(e: AnActionEvent) {
+    val lastRegister = injector.macro.lastRegister
+    val isEnabled = lastRegister != 0.toChar()
+
+    e.presentation.isEnabled = isEnabled
+    e.presentation.text = if (isEnabled) "Run Macro '${lastRegister}' in Open Files" else "Run Last Macro in Open Files"
+  }
+
+  override fun getActionUpdateThread(): ActionUpdateThread {
+    return ActionUpdateThread.EDT
+  }
+
+  override fun actionPerformed(e: AnActionEvent) {
+    val project = e.project ?: return
+    val fileEditorManager = FileEditorManagerEx.getInstanceExIfCreated(project) ?: return
+    val editors = fileEditorManager.allEditors.filterIsInstance<TextEditor>()
+    
+    WriteCommandAction.writeCommandAction(project)
+      .withName(e.presentation.text)
+      .withGlobalUndo()
+      .withUndoConfirmationPolicy(UndoConfirmationPolicy.REQUEST_CONFIRMATION)
+      .run<RuntimeException> {
+        val reg = injector.macro.lastRegister
+        
+        for (editor in editors) {
+          fileEditorManager.openFile(editor.file, true)
+          
+          val vimEditor = editor.editor.vim
+          vimEditor.mode = Mode.NORMAL()
+          KeyHandler.getInstance().reset(vimEditor)
+          
+          injector.macro.playbackRegister(vimEditor, IjEditorExecutionContext(e.dataContext), reg, 1)
+        }
+      }
+  }
+}

src/main/java/com/maddyhome/idea/vim/action/VimShortcutKeyAction.kt

@@ -43,6 +43,7 @@ import com.maddyhome.idea.vim.key.ShortcutOwnerInfo
 import com.maddyhome.idea.vim.listener.AceJumpService
 import com.maddyhome.idea.vim.listener.AppCodeTemplates.appCodeTemplateCaptured
 import com.maddyhome.idea.vim.newapi.globalIjOptions
+import com.maddyhome.idea.vim.newapi.initInjector
 import com.maddyhome.idea.vim.newapi.vim
 import com.maddyhome.idea.vim.ui.ex.ExEntryPanel
 import com.maddyhome.idea.vim.ui.ex.ExTextField
@@ -61,10 +62,13 @@ import javax.swing.KeyStroke
  *   way to get ideavim keys for this plugin. See VIM-3085
  */
 class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible*/ {
+
+  init {
+    initInjector()
+  }
+
   private val traceTime: Boolean
     get() {
-      // Make sure the injector is initialized
-      VimPlugin.getInstance()
       return injector.globalOptions().ideatracetime
     }
 
@@ -257,7 +261,7 @@ class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible*/ {
   private fun getEditor(e: AnActionEvent): Editor? {
     return e.getData(PlatformDataKeys.EDITOR)
       ?: if (e.getData(PlatformDataKeys.CONTEXT_COMPONENT) is ExTextField) {
-        ExEntryPanel.getInstance().editor
+        ExEntryPanel.getInstance().ijEditor
       } else {
         null
       }
@@ -294,26 +298,10 @@ class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible*/ {
         .addAll(getKeyStrokes(KeyEvent.VK_BACK_SPACE, 0, InputEvent.CTRL_DOWN_MASK))
         .addAll(getKeyStrokes(KeyEvent.VK_INSERT, 0))
         .addAll(getKeyStrokes(KeyEvent.VK_DELETE, 0, InputEvent.CTRL_DOWN_MASK))
-        .addAll(getKeyStrokes(KeyEvent.VK_UP, 0, InputEvent.CTRL_DOWN_MASK, InputEvent.SHIFT_DOWN_MASK))
+        .addAll(getKeyStrokes(KeyEvent.VK_UP, 0))
-        .addAll(getKeyStrokes(KeyEvent.VK_DOWN, 0, InputEvent.CTRL_DOWN_MASK, InputEvent.SHIFT_DOWN_MASK))
+        .addAll(getKeyStrokes(KeyEvent.VK_DOWN, 0))
-        .addAll(
+        .addAll(getKeyStrokes(KeyEvent.VK_LEFT, 0))
-          getKeyStrokes(
+        .addAll(getKeyStrokes(KeyEvent.VK_RIGHT, 0))
-            KeyEvent.VK_LEFT,
-            0,
-            InputEvent.CTRL_DOWN_MASK,
-            InputEvent.SHIFT_DOWN_MASK,
-            InputEvent.CTRL_DOWN_MASK or InputEvent.SHIFT_DOWN_MASK,
-          ),
-        )
-        .addAll(
-          getKeyStrokes(
-            KeyEvent.VK_RIGHT,
-            0,
-            InputEvent.CTRL_DOWN_MASK,
-            InputEvent.SHIFT_DOWN_MASK,
-            InputEvent.CTRL_DOWN_MASK or InputEvent.SHIFT_DOWN_MASK,
-          ),
-        )
         .addAll(
           getKeyStrokes(
             KeyEvent.VK_HOME,

src/main/java/com/maddyhome/idea/vim/action/change/OperatorAction.kt

@@ -28,7 +28,7 @@ import com.maddyhome.idea.vim.group.visual.VimSelection
 import com.maddyhome.idea.vim.handler.VimActionHandler
 import com.maddyhome.idea.vim.handler.VisualOperatorActionHandler
 import com.maddyhome.idea.vim.helper.MessageHelper
-import com.maddyhome.idea.vim.helper.vimStateMachine
+import com.maddyhome.idea.vim.helper.inRepeatMode
 import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.state.mode.SelectionType
 import com.maddyhome.idea.vim.vimscript.model.CommandLineVimLContext
@@ -37,7 +37,7 @@ import com.maddyhome.idea.vim.vimscript.model.expressions.FunctionCallExpression
 import com.maddyhome.idea.vim.vimscript.model.expressions.SimpleExpression
 
 // todo make it multicaret
-private fun doOperatorAction(editor: VimEditor, context: ExecutionContext, textRange: TextRange, selectionType: SelectionType): Boolean {
+private fun doOperatorAction(editor: VimEditor, context: ExecutionContext, textRange: TextRange, motionType: SelectionType): Boolean {
   val func = injector.globalOptions().operatorfunc
   if (func.isEmpty()) {
     VimPlugin.showMessage(MessageHelper.message("E774"))
@@ -57,9 +57,9 @@ private fun doOperatorAction(editor: VimEditor, context: ExecutionContext, textR
         if (value is VimFuncref) {
           handler = value.handler
         }
-      } catch (ex: ExException) {
+      } catch (_: ExException) {
         // Get the argument for function('...') or funcref('...') for the error message
-        val functionName = if (expression is FunctionCallExpression && expression.arguments.size > 0) {
+        val functionName = if (expression is FunctionCallExpression && expression.arguments.isNotEmpty()) {
           expression.arguments[0].evaluate(editor, context, scriptContext).toString()
         }
         else {
@@ -77,7 +77,7 @@ private fun doOperatorAction(editor: VimEditor, context: ExecutionContext, textR
     return false
   }
 
-  val arg = when (selectionType) {
+  val arg = when (motionType) {
     SelectionType.LINE_WISE -> "line"
     SelectionType.CHARACTER_WISE -> "char"
     SelectionType.BLOCK_WISE -> "block"
@@ -101,19 +101,13 @@ internal class OperatorAction : VimActionHandler.SingleExecution() {
   override val argumentType: Argument.Type = Argument.Type.MOTION
 
   override fun execute(editor: VimEditor, context: ExecutionContext, cmd: Command, operatorArguments: OperatorArguments): Boolean {
-    val argument = cmd.argument ?: return false
+    val argument = cmd.argument as? Argument.Motion ?: return false
-    if (!editor.vimStateMachine.isDotRepeatInProgress) {
+    if (!editor.inRepeatMode) {
       argumentCaptured = argument
     }
     val range = getMotionRange(editor, context, argument, operatorArguments)
-
     if (range != null) {
-      val selectionType = if (argument.motion.isLinewiseMotion()) {
+      return doOperatorAction(editor, context, range, argument.getMotionType())
-        SelectionType.LINE_WISE
-      } else {
-        SelectionType.CHARACTER_WISE
-      }
-      return doOperatorAction(editor, context, range, selectionType)
     }
     return false
   }
@@ -121,7 +115,7 @@ internal class OperatorAction : VimActionHandler.SingleExecution() {
   private fun getMotionRange(
     editor: VimEditor,
     context: ExecutionContext,
-    argument: Argument,
+    argument: Argument.Motion,
     operatorArguments: OperatorArguments,
   ): TextRange? {
     // Note that we're using getMotionRange2 in order to avoid normalising the linewise range into line start
@@ -136,7 +130,7 @@ internal class OperatorAction : VimActionHandler.SingleExecution() {
       operatorArguments,
     )?.normalize()?.let {
       // If we're linewise, make sure the end offset isn't just the EOL char
-      if (argument.motion.isLinewiseMotion() && it.endOffset < editor.fileSize()) {
+      if (argument.getMotionType() == SelectionType.LINE_WISE && it.endOffset < editor.fileSize()) {
         TextRange(it.startOffset, it.endOffset + 1)
       } else {
         it

src/main/java/com/maddyhome/idea/vim/action/change/RepeatChangeAction.kt

@@ -17,7 +17,6 @@ import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.command.Command
 import com.maddyhome.idea.vim.command.OperatorArguments
 import com.maddyhome.idea.vim.handler.VimActionHandler
-import com.maddyhome.idea.vim.helper.vimStateMachine
 import com.maddyhome.idea.vim.newapi.ij
 
 @CommandOrMotion(keys = ["."], modes = [Mode.NORMAL])
@@ -25,8 +24,8 @@ internal class RepeatChangeAction : VimActionHandler.SingleExecution() {
   override val type: Command.Type = Command.Type.OTHER_WRITABLE
 
   override fun execute(editor: VimEditor, context: ExecutionContext, cmd: Command, operatorArguments: OperatorArguments): Boolean {
-    val state = editor.vimStateMachine
+    val state = injector.vimState
-    val lastCommand = VimRepeater.lastChangeCommand
+    var lastCommand = VimRepeater.lastChangeCommand
 
     if (lastCommand == null && Extension.lastExtensionHandler == null) return false
 
@@ -58,12 +57,7 @@ internal class RepeatChangeAction : VimActionHandler.SingleExecution() {
       )
     } else if (!repeatHandler && lastCommand != null) {
       if (cmd.rawCount > 0) {
-        lastCommand.rawCount = cmd.count
+        lastCommand = lastCommand.copy(rawCount = cmd.rawCount)
-        val arg = lastCommand.argument
-        if (arg != null) {
-          val mot = arg.motion
-          mot.rawCount = 0
-        }
       }
       state.executingCommand = lastCommand
 

src/main/java/com/maddyhome/idea/vim/action/change/delete/DeleteJoinLinesAction.kt

@@ -40,7 +40,7 @@ class DeleteJoinLinesAction : ChangeEditorActionHandler.ConditionalSingleExecuti
   ): Boolean {
     injector.editorGroup.notifyIdeaJoin(editor)
 
-    return injector.changeGroup.deleteJoinLines(editor, caret, operatorArguments.count1, false, operatorArguments)
+    return injector.changeGroup.deleteJoinLines(editor, context, caret, operatorArguments.count1, false)
   }
 
   override fun execute(

src/main/java/com/maddyhome/idea/vim/action/change/delete/DeleteJoinLinesSpacesAction.kt

@@ -35,7 +35,7 @@ class DeleteJoinLinesSpacesAction : ChangeEditorActionHandler.SingleExecution()
     injector.editorGroup.notifyIdeaJoin(editor)
     var res = true
     editor.nativeCarets().sortedByDescending { it.offset }.forEach { caret ->
-      if (!injector.changeGroup.deleteJoinLines(editor, caret, operatorArguments.count1, true, operatorArguments)) {
+      if (!injector.changeGroup.deleteJoinLines(editor, context, caret, operatorArguments.count1, true)) {
         res = false
       }
     }

src/main/java/com/maddyhome/idea/vim/action/change/delete/DeleteJoinVisualLinesAction.kt

@@ -44,6 +44,7 @@ class DeleteJoinVisualLinesAction : VisualOperatorActionHandler.SingleExecution(
       val range = caretsAndSelections[caret] ?: return@forEach
       if (!injector.changeGroup.deleteJoinRange(
           editor,
+          context,
           caret,
           range.toVimTextRange(true).normalize(),
           false,

src/main/java/com/maddyhome/idea/vim/action/change/delete/DeleteJoinVisualLinesSpacesAction.kt

@@ -44,6 +44,7 @@ class DeleteJoinVisualLinesSpacesAction : VisualOperatorActionHandler.SingleExec
       val range = caretsAndSelections[caret] ?: return@forEach
       if (!injector.changeGroup.deleteJoinRange(
           editor,
+          context,
           caret,
           range.toVimTextRange(true).normalize(),
           true,

src/main/java/com/maddyhome/idea/vim/action/editor/VimEditorActions.kt

@@ -20,13 +20,10 @@ import com.maddyhome.idea.vim.command.OperatorArguments
 import com.maddyhome.idea.vim.handler.IdeActionHandler
 import com.maddyhome.idea.vim.handler.VimActionHandler
 import com.maddyhome.idea.vim.helper.enumSetOf
+import com.maddyhome.idea.vim.undo.VimKeyBasedUndoService
+import com.maddyhome.idea.vim.undo.VimTimestampBasedUndoService
 import java.util.*
 
-@CommandOrMotion(keys = ["<C-H>", "<BS>"], modes = [Mode.INSERT])
-internal class VimEditorBackSpace : IdeActionHandler(IdeActions.ACTION_EDITOR_BACKSPACE) {
-  override val type: Command.Type = Command.Type.DELETE
-}
-
 @CommandOrMotion(keys = ["<Del>"], modes = [Mode.INSERT])
 internal class VimEditorDelete : IdeActionHandler(IdeActions.ACTION_EDITOR_DELETE) {
   override val type: Command.Type = Command.Type.DELETE
@@ -44,8 +41,13 @@ internal class VimEditorDown : IdeActionHandler(IdeActions.ACTION_EDITOR_MOVE_CA
     operatorArguments: OperatorArguments
   ): Boolean {
     val undo = injector.undo
+    when (undo) {
+      is VimKeyBasedUndoService -> undo.setMergeUndoKey()
+      is VimTimestampBasedUndoService -> {
         val nanoTime = System.nanoTime()
         editor.forEachCaret { undo.endInsertSequence(it, it.offset, nanoTime) }
+      }
+    }
     return super.execute(editor, context, cmd, operatorArguments)
   }
 }
@@ -68,8 +70,13 @@ internal class VimEditorUp : IdeActionHandler(IdeActions.ACTION_EDITOR_MOVE_CARE
     operatorArguments: OperatorArguments
   ): Boolean {
     val undo = injector.undo
+    when (undo) {
+      is VimKeyBasedUndoService -> undo.setMergeUndoKey()
+      is VimTimestampBasedUndoService -> {
         val nanoTime = System.nanoTime()
         editor.forEachCaret { undo.endInsertSequence(it, it.offset, nanoTime) }
+      }
+    }
     return super.execute(editor, context, cmd, operatorArguments)
   }
 }
@@ -79,7 +86,7 @@ internal class VimQuickJavaDoc : VimActionHandler.SingleExecution() {
   override val type: Command.Type = Command.Type.OTHER_READONLY
 
   override fun execute(editor: VimEditor, context: ExecutionContext, cmd: Command, operatorArguments: OperatorArguments): Boolean {
-    injector.actionExecutor.executeAction(IdeActions.ACTION_QUICK_JAVADOC, context)
+    injector.actionExecutor.executeAction(editor, IdeActions.ACTION_QUICK_JAVADOC, context)
     return true
   }
 }

src/main/java/com/maddyhome/idea/vim/command/CommandState.kt

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2003-2023 The IdeaVim authors
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE.txt file or at
+ * https://opensource.org/licenses/MIT.
+ */
+
+package com.maddyhome.idea.vim.command
+
+import com.intellij.openapi.editor.Editor
+import com.maddyhome.idea.vim.KeyHandler
+import com.maddyhome.idea.vim.api.injector
+import com.maddyhome.idea.vim.state.VimStateMachine
+
+/**
+ * COMPATIBILITY-LAYER: Additional class
+ * Please see: https://jb.gg/zo8n0r
+ */
+@Deprecated("Use `injector.vimState`")
+class CommandState(private val machine: VimStateMachine) {
+
+  val mode: Mode
+    get() {
+      val myMode = machine.mode
+      return when (myMode) {
+        is com.maddyhome.idea.vim.state.mode.Mode.CMD_LINE -> Mode.CMD_LINE
+        com.maddyhome.idea.vim.state.mode.Mode.INSERT -> Mode.INSERT
+        is com.maddyhome.idea.vim.state.mode.Mode.NORMAL -> Mode.COMMAND
+        is com.maddyhome.idea.vim.state.mode.Mode.OP_PENDING -> Mode.OP_PENDING
+        com.maddyhome.idea.vim.state.mode.Mode.REPLACE -> Mode.REPLACE
+        is com.maddyhome.idea.vim.state.mode.Mode.SELECT -> Mode.SELECT
+        is com.maddyhome.idea.vim.state.mode.Mode.VISUAL -> Mode.VISUAL
+      }
+    }
+
+  @Deprecated("Use `KeyHandler.keyHandlerState.commandBuilder", ReplaceWith(
+    "KeyHandler.getInstance().keyHandlerState.commandBuilder",
+    "com.maddyhome.idea.vim.KeyHandler"
+  )
+  )
+  val commandBuilder: CommandBuilder
+    get() = KeyHandler.getInstance().keyHandlerState.commandBuilder
+
+  @Deprecated("Use `KeyHandler.keyHandlerState.mappingState", ReplaceWith(
+    "KeyHandler.getInstance().keyHandlerState.mappingState",
+    "com.maddyhome.idea.vim.KeyHandler"
+  )
+  )
+  val mappingState: MappingState
+    get() = KeyHandler.getInstance().keyHandlerState.mappingState
+
+  enum class Mode {
+    // Basic modes
+    COMMAND, VISUAL, SELECT, INSERT, CMD_LINE, /*EX*/
+
+    // Additional modes
+    OP_PENDING, REPLACE /*, VISUAL_REPLACE*/, INSERT_NORMAL, INSERT_VISUAL, INSERT_SELECT
+  }
+
+  enum class SubMode {
+    NONE, VISUAL_CHARACTER, VISUAL_LINE, VISUAL_BLOCK
+  }
+
+  companion object {
+    @JvmStatic
+    @Deprecated("Use `injector.vimState`")
+    fun getInstance(editor: Editor): CommandState {
+      return CommandState(injector.vimState)
+    }
+  }
+}

src/main/java/com/maddyhome/idea/vim/common/IndentConfig.kt

@@ -12,17 +12,17 @@ import com.intellij.application.options.CodeStyle
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
 import com.intellij.psi.codeStyle.CommonCodeStyleSettings.IndentOptions
+import com.maddyhome.idea.vim.api.VimIndentConfig
 
-internal class IndentConfig private constructor(indentOptions: IndentOptions) {
+internal class IndentConfig private constructor(indentOptions: IndentOptions): VimIndentConfig {
   private val indentSize = indentOptions.INDENT_SIZE
   private val tabSize = indentOptions.TAB_SIZE
   private val isUseTabs = indentOptions.USE_TAB_CHARACTER
 
-  fun getTotalIndent(count: Int): Int = indentSize * count
+  override fun getIndentSize(depth: Int): Int = indentSize * depth
+  override fun createIndentByDepth(depth: Int): String = createIndentBySize(getIndentSize(depth))
 
-  fun createIndentByCount(count: Int): String = createIndentBySize(getTotalIndent(count))
+  override fun createIndentBySize(size: Int): String {
-
-  fun createIndentBySize(size: Int): String {
     val tabCount: Int
     val spaceCount: Int
     if (isUseTabs) {

src/main/java/com/maddyhome/idea/vim/config/VimState.kt

@@ -18,6 +18,8 @@ import kotlin.reflect.KProperty
 internal class VimState {
   var isIdeaJoinNotified by StateProperty("idea-join")
   var isIdeaPutNotified by StateProperty("idea-put")
+  var isNewUndoNotified by StateProperty("idea-undo")
+  var wasSubscibedToEAPAutomatically by StateProperty("was-automatically-subscribed-to-eap")
 
   fun readData(element: Element) {
     val notifications = element.getChild("notifications")

src/main/java/com/maddyhome/idea/vim/ex/ExOutputModel.kt

@@ -9,51 +9,124 @@ package com.maddyhome.idea.vim.ex
 
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.editor.Editor
-import com.maddyhome.idea.vim.api.VimExOutputPanel
+import com.maddyhome.idea.vim.api.VimOutputPanelBase
+import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.helper.vimExOutput
 import com.maddyhome.idea.vim.ui.ExOutputPanel
+import java.lang.ref.WeakReference
+import javax.swing.KeyStroke
 
 // TODO: We need a nicer way to handle output, especially wrt testing, appending + clearing
-class ExOutputModel private constructor(private val myEditor: Editor) : VimExOutputPanel {
+class ExOutputModel(private val myEditor: WeakReference<Editor>) : VimOutputPanelBase() {
   private var isActiveInTestMode = false
 
-  override val isActive: Boolean
+  val editor get() = myEditor.get()
+
+  val isActive: Boolean
     get() = if (!ApplicationManager.getApplication().isUnitTestMode) {
-      ExOutputPanel.isPanelActive(myEditor)
+      editor?.let { ExOutputPanel.getNullablePanel(it) }?.myActive ?: false
     } else {
       isActiveInTestMode
     }
 
-  override var text: String? = null
+  override fun addText(text: String, isNewLine: Boolean) {
+    if (this.text.isNotEmpty() && isNewLine) this.text += "\n$text" else this.text += text
+  }
+
+  override fun show() {
+    if (editor == null) return
+    val currentPanel = injector.outputPanel.getCurrentOutputPanel()
+    if (currentPanel != null && currentPanel != this) currentPanel.close()
+
+    editor!!.vimExOutput = this
+    val exOutputPanel = ExOutputPanel.getInstance(editor!!)
+    if (!exOutputPanel.myActive) {
+      if (ApplicationManager.getApplication().isUnitTestMode) {
+        isActiveInTestMode = true
+      } else {
+        exOutputPanel.activate()
+      }
+    }
+  }
+
+  override fun scrollPage() {
+    val notNullEditor = editor ?: return
+    val panel = ExOutputPanel.getNullablePanel(notNullEditor) ?: return
+    panel.scrollPage()
+  }
+
+  override fun scrollHalfPage() {
+    val notNullEditor = editor ?: return
+    val panel = ExOutputPanel.getNullablePanel(notNullEditor) ?: return
+    panel.scrollHalfPage()
+  }
+
+  override fun scrollLine() {
+    val notNullEditor = editor ?: return
+    val panel = ExOutputPanel.getNullablePanel(notNullEditor) ?: return
+    panel.scrollLine()
+  }
+
+  override var text: String = ""
     get() = if (!ApplicationManager.getApplication().isUnitTestMode) {
-      ExOutputPanel.getInstance(myEditor).text
+      editor?.let { ExOutputPanel.getInstance(it).text } ?: ""
     } else {
       // ExOutputPanel always returns a non-null string
-      field ?: ""
+      field
     }
     set(value) {
       // ExOutputPanel will strip a trailing newline. We'll do it now so that tests have the same behaviour. We also
       // never pass null to ExOutputPanel, but we do store it for tests, so we know if we're active or not
-      val newValue = value?.removeSuffix("\n")
+      val newValue = value.removeSuffix("\n")
       if (!ApplicationManager.getApplication().isUnitTestMode) {
-        ExOutputPanel.getInstance(myEditor).setText(newValue ?: "")
+        editor?.let { ExOutputPanel.getInstance(it).setText(newValue) }
       } else {
         field = newValue
-        isActiveInTestMode = !newValue.isNullOrEmpty()
+        isActiveInTestMode = newValue.isNotEmpty()
       }
     }
+  override var label: String
+    get() {
+      val notNullEditor = editor ?: return ""
+      val panel = ExOutputPanel.getNullablePanel(notNullEditor) ?: return ""
+      return panel.myLabel.text
+    }
+    set(value) {
+      val notNullEditor = editor ?: return
+      val panel = ExOutputPanel.getNullablePanel(notNullEditor) ?: return
+      panel.myLabel.text = value
+    }
 
-  override fun output(text: String) {
+  fun output(text: String) {
     this.text = text
   }
 
-  override fun clear() {
+  fun clear() {
-    text = null
+    text = ""
+  }
+
+  override val atEnd: Boolean
+    get() {
+      val notNullEditor = editor ?: return false
+      val panel = ExOutputPanel.getNullablePanel(notNullEditor) ?: return false
+      return panel.isAtEnd()
+    }
+
+  override fun onBadKey() {
+    val notNullEditor = editor ?: return
+    val panel = ExOutputPanel.getNullablePanel(notNullEditor) ?: return
+    panel.onBadKey()
+  }
+
+  override fun close(key: KeyStroke?) {
+    val notNullEditor = editor ?: return
+    val panel = ExOutputPanel.getNullablePanel(notNullEditor) ?: return
+    panel.close(key)
   }
 
   override fun close() {
     if (!ApplicationManager.getApplication().isUnitTestMode) {
-      ExOutputPanel.getInstance(myEditor).close()
+      editor?.let { ExOutputPanel.getInstance(it).close() }
     }
     else {
       isActiveInTestMode = false
@@ -65,7 +138,7 @@ class ExOutputModel private constructor(private val myEditor: Editor) : VimExOut
     fun getInstance(editor: Editor): ExOutputModel {
       var model = editor.vimExOutput
       if (model == null) {
-        model = ExOutputModel(editor)
+        model = ExOutputModel(WeakReference(editor))
         editor.vimExOutput = model
       }
       return model

src/main/java/com/maddyhome/idea/vim/extension/VimExtension.java

@@ -27,6 +27,30 @@ public interface VimExtension {
     return MappingOwner.Plugin.Companion.get(getName());
   }
 
+  /**
+   * This method is always called AFTER the full execution of the `.ideavimrc` file.
+   * <p>
+   * During vim initialization process, it firstly loads the .vimrc file, then executes scripts from the plugins folder.
+   * This practically means that the .vimrc file is initialized first; then the plugins are loaded.
+   * See `:h initialization`
+   * <p>
+   * Why does this matter? Because this affects the order of commands are executed. For example,
+   * ```
+   * plug 'tommcdo/vim-exchange'
+   * let g:exchange_no_mappings=1
+   * ```
+   * Here the user will expect that the exchange plugin won't have default mappings. However, if we load vim-exchange
+   *    immediately, this variable won't be initialized at the moment of plugin initialization.
+   * <p>
+   * There is also a tricky case for mappings override:
+   * ```
+   * plug 'tommcdo/vim-exchange'
+   * map X <Plug>(ExchangeLine)
+   * ```
+   * For this case, a plugin with a good implementation detects that there is already a defined mapping for
+   *   `<Plug>(ExchangeLine)` and doesn't register the default cxx mapping. However, such detection requires the mapping
+   *   to be defined before the plugin initialization.
+   */
   void init();
 
   default void dispose() {

src/main/java/com/maddyhome/idea/vim/extension/VimExtensionFacade.kt

@@ -24,13 +24,14 @@ import com.maddyhome.idea.vim.common.CommandAlias
 import com.maddyhome.idea.vim.common.CommandAliasHandler
 import com.maddyhome.idea.vim.common.TextRange
 import com.maddyhome.idea.vim.helper.TestInputModel
+import com.maddyhome.idea.vim.helper.inRepeatMode
 import com.maddyhome.idea.vim.helper.noneOfEnum
-import com.maddyhome.idea.vim.helper.vimStateMachine
 import com.maddyhome.idea.vim.key.MappingOwner
 import com.maddyhome.idea.vim.key.OperatorFunction
 import com.maddyhome.idea.vim.newapi.vim
 import com.maddyhome.idea.vim.state.mode.SelectionType
 import com.maddyhome.idea.vim.ui.ModalEntry
+import com.maddyhome.idea.vim.ui.ex.ExEntryPanelService
 import com.maddyhome.idea.vim.vimscript.model.Executable
 import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
 import com.maddyhome.idea.vim.vimscript.model.VimLContext
@@ -68,8 +69,7 @@ object VimExtensionFacade {
 
 
   @JvmStatic
-  @Deprecated(
+  @Deprecated("Use VimPlugin.getKey().putKeyMapping(modes, fromKeys, pluginOwner, extensionHandler, recursive)",
-    "Use VimPlugin.getKey().putKeyMapping(modes, fromKeys, pluginOwner, extensionHandler, recursive)",
     ReplaceWith(
       "VimPlugin.getKey().putKeyMapping(modes, fromKeys, pluginOwner, extensionHandler, recursive)",
       "com.maddyhome.idea.vim.VimPlugin"
@@ -151,7 +151,7 @@ object VimExtensionFacade {
   /** Returns a single key stroke from the user input similar to 'getchar()'. */
   @JvmStatic
   fun inputKeyStroke(editor: Editor): KeyStroke {
-    if (editor.vim.vimStateMachine.isDotRepeatInProgress) {
+    if (editor.vim.inRepeatMode) {
       val input = Extension.consumeKeystroke()
       LOG.trace("inputKeyStroke: dot repeat in progress. Input: $input")
       return input ?: error("Not enough keystrokes saved: ${Extension.lastExtensionHandler}")
@@ -183,19 +183,27 @@ object VimExtensionFacade {
   /** Returns a string typed in the input box similar to 'input()'. */
   @JvmStatic
   fun inputString(editor: Editor, context: DataContext, prompt: String, finishOn: Char?): String {
-    return injector.commandLine.inputString(editor.vim, context.vim, prompt, finishOn) ?: ""
+    return (injector.commandLine as ExEntryPanelService).inputString(editor.vim, context.vim, prompt, finishOn) ?: ""
   }
 
   /** Get the current contents of the given register similar to 'getreg()'. */
   @JvmStatic
+  @Deprecated("Please use com.maddyhome.idea.vim.extension.VimExtensionFacade.getRegister(com.maddyhome.idea.vim.api.VimEditor, char)")
   fun getRegister(register: Char): List<KeyStroke>? {
     val reg = VimPlugin.getRegister().getRegister(register) ?: return null
     return reg.keys
   }
 
+  /** Get the current contents of the given register similar to 'getreg()'. */
+  @JvmStatic
+  fun getRegister(editor: VimEditor, register: Char): List<KeyStroke>? {
+    val reg = VimPlugin.getRegister().getRegister(editor, injector.executionContextManager.getEditorExecutionContext(editor), register) ?: return null
+    return reg.keys
+  }
+
   @JvmStatic
   fun getRegisterForCaret(register: Char, caret: VimCaret): List<KeyStroke>? {
-    val reg = injector.registerGroup.getRegister(register) ?: return null
+    val reg = caret.registerStorage.getRegister(register) ?: return null
     return reg.keys
   }
 
@@ -208,7 +216,7 @@ object VimExtensionFacade {
   /** Set the current contents of the given register */
   @JvmStatic
   fun setRegisterForCaret(register: Char, caret: ImmutableVimCaret, keys: List<KeyStroke?>?) {
-    injector.registerGroup.setKeys(register, keys?.filterNotNull() ?: emptyList())
+    caret.registerStorage.setKeys(register, keys?.filterNotNull() ?: emptyList())
   }
 
   /** Set the current contents of the given register */

src/main/java/com/maddyhome/idea/vim/extension/VimExtensionRegistrar.kt

@@ -88,29 +88,10 @@ internal object VimExtensionRegistrar : VimExtensionRegistrator {
   }
 
   /**
-   * During vim initialization process, it firstly loads the .vimrc file, then executes scripts from the plugins folder.
+   * See the docs for [VimExtension.init]
-   * This practically means that the .vimrc file is initialized first, then the plugins are loaded.
-   * See `:h initialization`
    *
    * In IdeaVim we don't have a separate plugins folder to load it after .ideavimrc load. However, we can collect
    *   the list of plugins mentioned in the .ideavimrc and load them after .ideavimrc execution is finished.
-   *
-   * Why this matters? Because this affects the order of commands are executed. For example:
-   * ```
-   * plug 'tommcdo/vim-exchange'
-   * let g:exchange_no_mappings=1
-   * ```
-   * Here the user will expect that the exchange plugin won't have default mappings. However, if we load vim-exchange
-   *    immediately, this variable won't be initialized at the moment of plugin initialization.
-   *
-   * There is also a tricky case for mappings override:
-   * ```
-   * plug 'tommcdo/vim-exchange'
-   * map X <Plug>(ExchangeLine)
-   * ```
-   * For this case, a plugin with a good implementation detects that there is already a defined mapping for
-   *   `<Plug>(ExchangeLine)` and doesn't register the default cxx mapping. However, such detection requires the mapping
-   *   to be defined before the plugin initialization.
    */
   @JvmStatic
   fun enableDelayedExtensions() {

src/main/java/com/maddyhome/idea/vim/extension/argtextobj/VimArgTextObjExtension.java

@@ -33,7 +33,6 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayDeque;
 import java.util.Deque;
-import java.util.EnumSet;
 
 import static com.maddyhome.idea.vim.extension.VimExtensionFacade.putExtensionHandlerMapping;
 import static com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMappingIfMissing;
@@ -64,8 +63,8 @@ public class VimArgTextObjExtension implements VimExtension {
    */
   private static class BracketPairs {
     // NOTE: brackets must match by the position, and ordered by rank (highest to lowest).
-    @NotNull private final String openBrackets;
+    private final @NotNull String openBrackets;
-    @NotNull private final String closeBrackets;
+    private final @NotNull String closeBrackets;
 
     static class ParseException extends Exception {
       public ParseException(@NotNull String message) {
@@ -87,8 +86,7 @@ public class VimArgTextObjExtension implements VimExtension {
      * @param bracketPairs comma-separated list of colon-separated bracket pairs.
      * @throws ParseException if a syntax error is detected.
      */
-    @NotNull
+    static @NotNull BracketPairs fromBracketPairList(final @NotNull String bracketPairs) throws ParseException {
-    static BracketPairs fromBracketPairList(@NotNull final String bracketPairs) throws ParseException {
       StringBuilder openBrackets = new StringBuilder();
       StringBuilder closeBrackets = new StringBuilder();
       ParseState state = ParseState.OPEN;
@@ -128,7 +126,7 @@ public class VimArgTextObjExtension implements VimExtension {
       return new BracketPairs(openBrackets.toString(), closeBrackets.toString());
     }
 
-    BracketPairs(@NotNull final String openBrackets, @NotNull final String closeBrackets) {
+    BracketPairs(final @NotNull String openBrackets, final @NotNull String closeBrackets) {
       assert openBrackets.length() == closeBrackets.length();
       this.openBrackets = openBrackets;
       this.closeBrackets = closeBrackets;
@@ -158,10 +156,9 @@ public class VimArgTextObjExtension implements VimExtension {
     }
   }
 
-  public static final BracketPairs DEFAULT_BRACKET_PAIRS = new BracketPairs("(", ")");
+  private static final BracketPairs DEFAULT_BRACKET_PAIRS = new BracketPairs("(", ")");
 
-  @Nullable
+  private static @Nullable String bracketPairsVariable() {
-  private static String bracketPairsVariable() {
     final Object value = VimPlugin.getVariableService().getGlobalVariableValue("argtextobj_pairs");
     if (value instanceof VimString vimValue) {
       return vimValue.getValue();
@@ -192,9 +189,8 @@ public class VimArgTextObjExtension implements VimExtension {
         this.isInner = isInner;
       }
 
-      @Nullable
       @Override
-      public TextRange getRange(@NotNull VimEditor editor,
+      public @Nullable TextRange getRange(@NotNull VimEditor editor,
                                           @NotNull ImmutableVimCaret caret,
                                           @NotNull ExecutionContext context,
                                           int count,
@@ -236,24 +232,22 @@ public class VimArgTextObjExtension implements VimExtension {
         return new TextRange(finder.getLeftBound(), finder.getRightBound());
       }
 
-      @NotNull
       @Override
-      public TextObjectVisualType getVisualType() {
+      public @NotNull TextObjectVisualType getVisualType() {
         return TextObjectVisualType.CHARACTER_WISE;
       }
     }
 
     @Override
     public void execute(@NotNull VimEditor editor, @NotNull ExecutionContext context, @NotNull OperatorArguments operatorArguments) {
-      @NotNull KeyHandler keyHandler = KeyHandler.getInstance();
       @NotNull KeyHandlerState keyHandlerState = KeyHandler.getInstance().getKeyHandlerState();
-      int count = Math.max(1, keyHandlerState.getCommandBuilder().getCount());
 
       final ArgumentTextObjectHandler textObjectHandler = new ArgumentTextObjectHandler(isInner);
       //noinspection DuplicatedCode
-      if (!keyHandler.isOperatorPending(editor.getMode(), keyHandlerState)) {
+      if (!(editor.getMode() instanceof Mode.OP_PENDING)) {
+        int count0 = operatorArguments.getCount0();
         editor.nativeCarets().forEach((VimCaret caret) -> {
-          final TextRange range = textObjectHandler.getRange(editor, caret, context, count, 0);
+          final TextRange range = textObjectHandler.getRange(editor, caret, context, Math.max(1, count0), count0);
           if (range != null) {
             try (VimListenerSuppressor.Locked ignored = SelectionVimListenerSuppressor.INSTANCE.lock()) {
               if (editor.getMode() instanceof Mode.VISUAL) {
@@ -265,8 +259,7 @@ public class VimArgTextObjExtension implements VimExtension {
           }
         });
       } else {
-        keyHandlerState.getCommandBuilder().completeCommandPart(new Argument(new Command(count,
+        keyHandlerState.getCommandBuilder().addAction(textObjectHandler);
-                                                                                         textObjectHandler, Command.Type.MOTION, EnumSet.noneOf(CommandFlags.class))));
       }
     }
   }
@@ -276,9 +269,9 @@ public class VimArgTextObjExtension implements VimExtension {
    * position
    */
   private static class ArgBoundsFinder {
-    @NotNull private final CharSequence text;
+    private final @NotNull CharSequence text;
-    @NotNull private final Document document;
+    private final @NotNull Document document;
-    @NotNull private final BracketPairs brackets;
+    private final @NotNull BracketPairs brackets;
     private int leftBound = Integer.MAX_VALUE;
     private int rightBound = Integer.MIN_VALUE;
     private int leftBracket;
@@ -305,7 +298,7 @@ public class VimArgTextObjExtension implements VimExtension {
      * @param position starting position.
      */
     boolean findBoundsAt(int position) throws IllegalStateException {
-      if (text.length() == 0) {
+      if (text.isEmpty()) {
         error = "empty document";
         return false;
       }

src/main/java/com/maddyhome/idea/vim/extension/commentary/CommentaryExtension.kt

@@ -25,9 +25,6 @@ import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.getLineEndOffset
 import com.maddyhome.idea.vim.api.globalOptions
 import com.maddyhome.idea.vim.api.injector
-import com.maddyhome.idea.vim.command.Argument
-import com.maddyhome.idea.vim.command.Command
-import com.maddyhome.idea.vim.command.CommandFlags
 import com.maddyhome.idea.vim.command.MappingMode
 import com.maddyhome.idea.vim.command.OperatorArguments
 import com.maddyhome.idea.vim.command.TextObjectVisualType
@@ -46,14 +43,12 @@ import com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMappingIfMissin
 import com.maddyhome.idea.vim.extension.exportOperatorFunction
 import com.maddyhome.idea.vim.handler.TextObjectActionHandler
 import com.maddyhome.idea.vim.helper.PsiHelper
-import com.maddyhome.idea.vim.helper.vimStateMachine
 import com.maddyhome.idea.vim.key.OperatorFunction
 import com.maddyhome.idea.vim.newapi.IjVimEditor
 import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.newapi.vim
 import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.state.mode.SelectionType
-import java.util.*
 
 internal class CommentaryExtension : VimExtension {
 
@@ -65,7 +60,7 @@ internal class CommentaryExtension : VimExtension {
       selectionType: SelectionType,
       resetCaret: Boolean = true,
     ): Boolean {
-      val mode = editor.vimStateMachine.mode
+      val mode = editor.mode
       if (mode !is Mode.VISUAL) {
         editor.ij.selectionModel.setSelection(range.startOffset, range.endOffset)
       }
@@ -80,11 +75,12 @@ internal class CommentaryExtension : VimExtension {
 
         val project = editor.ij.project!!
         val callback = { afterCommenting(mode, editor, resetCaret, range) }
-        actions.any { executeActionWithCallbackOnSuccess(it, project, context, callback) }
+        actions.any { executeActionWithCallbackOnSuccess(editor, it, project, context, callback) }
       }
     }
 
     private fun executeActionWithCallbackOnSuccess(
+      editor: VimEditor,
       action: String,
       project: Project,
       context: ExecutionContext,
@@ -93,7 +89,7 @@ internal class CommentaryExtension : VimExtension {
       val res = Ref.create<Boolean>(false)
       AsyncActionExecutionService.getInstance(project).withExecutionAfterAction(
         action,
-        { res.set(injector.actionExecutor.executeAction(action, context)) },
+        { res.set(injector.actionExecutor.executeAction(editor, name = action, context = context)) },
         { if (res.get()) callback() })
       return res.get()
     }
@@ -184,10 +180,8 @@ internal class CommentaryExtension : VimExtension {
     override val isRepeatable = true
 
     override fun execute(editor: VimEditor, context: ExecutionContext, operatorArguments: OperatorArguments) {
-      val command = Command(operatorArguments.count1, CommentaryTextObjectMotionHandler, Command.Type.MOTION, EnumSet.noneOf(CommandFlags::class.java))
-
       val keyState = KeyHandler.getInstance().keyHandlerState
-      keyState.commandBuilder.completeCommandPart(Argument(command))
+      keyState.commandBuilder.addAction(CommentaryTextObjectMotionHandler)
     }
   }
 

src/main/java/com/maddyhome/idea/vim/extension/exchange/VimExchangeExtension.kt

@@ -222,10 +222,10 @@ internal class VimExchangeExtension : VimExtension {
         }
       }
 
-      val zRegText = getRegister('z')
+      val zRegText = getRegister(editor.vim, 'z')
-      val unnRegText = getRegister('"')
+      val unnRegText = getRegister(editor.vim, '"')
-      val startRegText = getRegister('*')
+      val startRegText = getRegister(editor.vim, '*')
-      val plusRegText = getRegister('+')
+      val plusRegText = getRegister(editor.vim, '+')
       runWriteAction {
         // TODO handle:
         // 	" Compare using =~ because "'==' != 0" returns 0
@@ -299,7 +299,7 @@ internal class VimExchangeExtension : VimExtension {
 
     private fun getExchange(editor: Editor, isVisual: Boolean, selectionType: SelectionType): Exchange {
       // TODO: improve KeyStroke list to sting conversion
-      fun getRegisterText(reg: Char): String = getRegister(reg)?.map { it.keyChar }?.joinToString("") ?: ""
+      fun getRegisterText(reg: Char): String = getRegister(editor.vim, reg)?.map { it.keyChar }?.joinToString("") ?: ""
       fun getMarks(isVisual: Boolean): Pair<Mark, Mark> {
         val (startMark, endMark) =
           if (isVisual) {
@@ -313,9 +313,9 @@ internal class VimExchangeExtension : VimExtension {
         return Pair(marks.getMark(vimEditor.primaryCaret(), startMark)!!, marks.getMark(vimEditor.primaryCaret(), endMark)!!)
       }
 
-      val unnRegText = getRegister('"')
+      val unnRegText = getRegister(editor.vim, '"')
-      val starRegText = getRegister('*')
+      val starRegText = getRegister(editor.vim, '*')
-      val plusRegText = getRegister('+')
+      val plusRegText = getRegister(editor.vim, '+')
 
       val (selectionStart, selectionEnd) = getMarks(isVisual)
       if (isVisual) {

src/main/java/com/maddyhome/idea/vim/extension/highlightedyank/VimHighlightedYank.kt

@@ -23,13 +23,15 @@ import com.intellij.util.Alarm
 import com.intellij.util.Alarm.ThreadToUse
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.VimEditor
+import com.maddyhome.idea.vim.api.injector
+import com.maddyhome.idea.vim.common.ModeChangeListener
 import com.maddyhome.idea.vim.common.TextRange
+import com.maddyhome.idea.vim.common.VimYankListener
 import com.maddyhome.idea.vim.extension.VimExtension
 import com.maddyhome.idea.vim.helper.MessageHelper
 import com.maddyhome.idea.vim.helper.VimNlsSafe
-import com.maddyhome.idea.vim.listener.VimInsertListener
-import com.maddyhome.idea.vim.listener.VimYankListener
 import com.maddyhome.idea.vim.newapi.ij
+import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.vimscript.model.datatypes.VimDataType
 import com.maddyhome.idea.vim.vimscript.model.datatypes.VimString
 import org.jetbrains.annotations.NonNls
@@ -43,6 +45,10 @@ private val HIGHLIGHT_DURATION_VARIABLE_NAME = "highlightedyank_highlight_durati
 
 @NonNls
 private val HIGHLIGHT_COLOR_VARIABLE_NAME = "highlightedyank_highlight_color"
+
+@NonNls
+private val HIGHLIGHT_FOREGROUND_COLOR_VARIABLE_NAME = "highlightedyank_highlight_foreground_color"
+
 private var defaultHighlightTextColor: Color? = null
 
 private fun getDefaultHighlightTextColor(): Color {
@@ -73,9 +79,12 @@ internal class HighlightColorResetter : LafManagerListener {
  * if you want to change background color of highlight you can provide the rgba of the color you want e.g.
  * let g:highlightedyank_highlight_color = "rgba(160, 160, 160, 155)"
  *
+ * if you want to change text color of highlight you can provide the rgba of the color you want e.g.
+ * let g:highlightedyank_highlight_foreground_color = "rgba(0, 0, 0, 255)"
+ *
  * When a new text is yanked or user starts editing, the old highlighting would be deleted.
  */
-internal class VimHighlightedYank : VimExtension, VimYankListener, VimInsertListener {
+internal class VimHighlightedYank : VimExtension, VimYankListener, ModeChangeListener {
   private val highlightHandler = HighlightHandler()
   private var initialised = false
 
@@ -83,8 +92,8 @@ internal class VimHighlightedYank : VimExtension, VimYankListener, VimInsertList
 
   override fun init() {
     // Note that these listeners will still be registered when IdeaVim is disabled. However, they'll never get called
-    VimPlugin.getYank().addListener(this)
+    injector.listenersNotifier.modeChangeListeners.add(this)
-    VimPlugin.getChange().addInsertListener(this)
+    injector.listenersNotifier.yankListeners.add(this)
 
     // Register our own disposable to remove highlights when IdeaVim is disabled. Somehow, we need to re-register when
     // IdeaVim is re-enabled. We don't get a call back for that, but because the listeners are active until the
@@ -105,8 +114,8 @@ internal class VimHighlightedYank : VimExtension, VimYankListener, VimInsertList
 
   override fun dispose() {
     // Called when the extension is disabled with `:set no{extension}` or if the plugin owning the extension unloads
-    VimPlugin.getYank().removeListener(this)
+    injector.listenersNotifier.modeChangeListeners.remove(this)
-    VimPlugin.getChange().removeInsertListener(this)
+    injector.listenersNotifier.yankListeners.remove(this)
 
     highlightHandler.clearYankHighlighters()
     initialised = false
@@ -117,7 +126,8 @@ internal class VimHighlightedYank : VimExtension, VimYankListener, VimInsertList
     highlightHandler.highlightYankRange(editor.ij, range)
   }
 
-  override fun insertModeStarted(editor: Editor) {
+  override fun modeChanged(editor: VimEditor, oldMode: Mode) {
+    if (editor.mode !is Mode.INSERT) return
     ensureInitialised()
     highlightHandler.clearYankHighlighters()
   }
@@ -178,13 +188,15 @@ internal class VimHighlightedYank : VimExtension, VimYankListener, VimInsertList
       highlighters.clear()
     }
 
-    private fun getHighlightTextAttributes(editor: Editor) = TextAttributes(
+    private fun getHighlightTextAttributes(editor: Editor): TextAttributes {
-      null,
+      return TextAttributes(
+        extractUserHighlightForegroundColor(),
         extractUsersHighlightColor(),
         editor.colorsScheme.getColor(EditorColors.CARET_COLOR),
         EffectType.SEARCH_MATCH,
         Font.PLAIN,
       )
+    }
 
     private fun extractUsersHighlightDuration(): Int {
       return extractVariable(HIGHLIGHT_DURATION_VARIABLE_NAME, DEFAULT_HIGHLIGHT_DURATION) {
@@ -197,15 +209,52 @@ internal class VimHighlightedYank : VimExtension, VimYankListener, VimInsertList
     }
 
     private fun extractUsersHighlightColor(): Color {
-      return extractVariable(HIGHLIGHT_COLOR_VARIABLE_NAME, getDefaultHighlightTextColor()) { value ->
+      val value = VimPlugin.getVariableService().getGlobalVariableValue(HIGHLIGHT_COLOR_VARIABLE_NAME)
-        val rgba = value.asString()
+      if (value != null) {
+        return try {
+          parseRgbaColor(value.asString())
+        } catch (e: Exception) {
+          @VimNlsSafe val message = MessageHelper.message(
+            "highlightedyank.invalid.value.of.0.1",
+            "g:$HIGHLIGHT_COLOR_VARIABLE_NAME",
+            e.message ?: "",
+          )
+          VimPlugin.showMessage(message)
+          getDefaultHighlightTextColor()
+        }
+      }
+      return getDefaultHighlightTextColor()
+    }
+
+    private fun extractUserHighlightForegroundColor(): Color? {
+      val value = VimPlugin.getVariableService().getGlobalVariableValue(HIGHLIGHT_FOREGROUND_COLOR_VARIABLE_NAME)
+        ?: return null
+
+      return try {
+        parseRgbaColor(value.asString())
+      } catch (e: Exception) {
+        @VimNlsSafe val message = MessageHelper.message(
+          "highlightedyank.invalid.value.of.0.1",
+          "g:$HIGHLIGHT_FOREGROUND_COLOR_VARIABLE_NAME",
+          e.message ?: "",
+        )
+        VimPlugin.showMessage(message)
+        null
+      }
+    }
+
+    private fun parseRgbaColor(colorString: String): Color {
+      val rgba = colorString
         .substring(4)
         .filter { it != '(' && it != ')' && !it.isWhitespace() }
         .split(',')
         .map { it.toInt() }
 
-        Color(rgba[0], rgba[1], rgba[2], rgba[3])
+      if (rgba.size != 4 || rgba.any { it < 0 || it > 255 }) {
+        throw IllegalArgumentException("Invalid RGBA values. Each component must be between 0 and 255")
       }
+
+      return Color(rgba[0], rgba[1], rgba[2], rgba[3])
     }
 
     private fun <T> extractVariable(variable: String, default: T, extractFun: (value: VimDataType) -> T): T {

src/main/java/com/maddyhome/idea/vim/extension/matchit/Matchit.kt

@@ -44,6 +44,7 @@ import com.maddyhome.idea.vim.helper.enumSetOf
 import com.maddyhome.idea.vim.newapi.IjVimEditor
 import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.newapi.vim
+import com.maddyhome.idea.vim.state.mode.Mode
 import java.util.*
 import java.util.regex.Pattern
 
@@ -93,34 +94,29 @@ internal class Matchit : VimExtension {
     override fun execute(editor: VimEditor, context: ExecutionContext, operatorArguments: OperatorArguments) {
       val keyHandler = KeyHandler.getInstance()
       val keyState = keyHandler.keyHandlerState
-      val count = keyState.commandBuilder.count
 
       // Reset the command count so it doesn't transfer onto subsequent commands.
       keyState.commandBuilder.resetCount()
 
       // Normally we want to jump to the start of the matching pair. But when moving forward in operator
       // pending mode, we want to include the entire match. isInOpPending makes that distinction.
-      val isInOpPending = keyHandler.isOperatorPending(editor.mode, keyState)
+      if (editor.mode is Mode.OP_PENDING) {
-
-      if (isInOpPending) {
         val matchitAction = MatchitAction()
         matchitAction.reverse = reverse
         matchitAction.isInOpPending = true
 
-        keyState.commandBuilder.completeCommandPart(
+        keyState.commandBuilder.addAction(matchitAction)
-          Argument(
-            Command(
-              count,
-              matchitAction,
-              Command.Type.MOTION,
-              EnumSet.noneOf(CommandFlags::class.java),
-            ),
-          ),
-        )
       } else {
         editor.sortedCarets().forEach { caret ->
           injector.jumpService.saveJumpLocation(editor)
-          caret.moveToOffset(getMatchitOffset(editor.ij, caret.ij, count, isInOpPending, reverse))
+          caret.moveToOffset(
+            getMatchitOffset(
+              editor.ij,
+              caret.ij,
+              operatorArguments.count0,
+              isInOpPending = false,
+              reverse
+            ))
         }
       }
     }
@@ -354,7 +350,7 @@ private object FileTypePatterns {
 
 private val DEFAULT_PAIRS = setOf('(', ')', '[', ']', '{', '}')
 
-private fun getMatchitOffset(editor: Editor, caret: Caret, count: Int, isInOpPending: Boolean, reverse: Boolean): Int {
+private fun getMatchitOffset(editor: Editor, caret: Caret, count0: Int, isInOpPending: Boolean, reverse: Boolean): Int {
   val virtualFile = EditorHelper.getVirtualFile(editor)
   var caretOffset = caret.offset
 
@@ -367,9 +363,9 @@ private fun getMatchitOffset(editor: Editor, caret: Caret, count: Int, isInOpPen
   val currentChar = editor.document.charsSequence[caretOffset]
   var motionOffset: Int? = null
 
-  if (count > 0) {
+  if (count0 > 0) {
     // Matchit doesn't affect the percent motion, so we fall back to the default behavior.
-    motionOffset = VimPlugin.getMotion().moveCaretToLinePercent(editor.vim, caret.vim, count)
+    motionOffset = VimPlugin.getMotion().moveCaretToLinePercent(editor.vim, caret.vim, count0)
   } else {
     // Check the simplest case first.
     if (DEFAULT_PAIRS.contains(currentChar)) {
@@ -400,8 +396,7 @@ private fun getMatchitOffset(editor: Editor, caret: Caret, count: Int, isInOpPen
 
 private fun getMotionOffset(motion: Motion): Int? {
   return when (motion) {
-    is Motion.AbsoluteOffset -> motion.offset
+    is Motion.AdjustedOffset, is Motion.AbsoluteOffset -> motion.offset
-    is Motion.AdjustedOffset -> motion.offset
     is Motion.Error, is Motion.NoMotion -> null
   }
 }

src/main/java/com/maddyhome/idea/vim/extension/nerdtree/NerdTree.kt

@@ -42,13 +42,10 @@ import com.maddyhome.idea.vim.extension.VimExtension
 import com.maddyhome.idea.vim.group.KeyGroup
 import com.maddyhome.idea.vim.helper.MessageHelper
 import com.maddyhome.idea.vim.helper.runAfterGotFocus
-import com.maddyhome.idea.vim.key.CommandNode
+import com.maddyhome.idea.vim.key.KeyStrokeTrie
-import com.maddyhome.idea.vim.key.CommandPartNode
 import com.maddyhome.idea.vim.key.MappingOwner
-import com.maddyhome.idea.vim.key.Node
 import com.maddyhome.idea.vim.key.RequiredShortcut
-import com.maddyhome.idea.vim.key.RootNode
+import com.maddyhome.idea.vim.key.add
-import com.maddyhome.idea.vim.key.addLeafs
 import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.newapi.vim
 import com.maddyhome.idea.vim.vimscript.model.datatypes.VimString
@@ -198,6 +195,8 @@ internal class NerdTree : VimExtension {
     internal var waitForSearch = false
     internal var speedSearchListenerInstalled = false
 
+    private val keys = mutableListOf<KeyStroke>()
+
     override fun actionPerformed(e: AnActionEvent) {
       var keyStroke = getKeyStroke(e) ?: return
       val keyChar = keyStroke.keyChar
@@ -205,20 +204,14 @@ internal class NerdTree : VimExtension {
         keyStroke = KeyStroke.getKeyStroke(keyChar)
       }
 
-      val nextNode = currentNode[keyStroke]
+      keys.add(keyStroke)
-
+      actionsRoot.getData(keys)?.let { action ->
-      when (nextNode) {
-        null -> currentNode = actionsRoot
-        is CommandNode<NerdAction> -> {
-          currentNode = actionsRoot
-
-          val action = nextNode.actionHolder
         when (action) {
           is NerdAction.ToIj -> Util.callAction(null, action.name, e.dataContext.vim)
           is NerdAction.Code -> e.project?.let { action.action(it, e.dataContext, e) }
         }
-        }
+
-        is CommandPartNode<NerdAction> -> currentNode = nextNode
+        keys.clear()
       }
     }
 
@@ -481,6 +474,9 @@ internal class NerdTree : VimExtension {
     registerCommand("NERDTreeMapNewFile", "n", NerdAction.ToIj("NewFile"))
     registerCommand("NERDTreeMapNewDir", "N", NerdAction.ToIj("NewDir"))
     registerCommand("NERDTreeMapDelete", "d", NerdAction.ToIj("\$Delete"))
+    registerCommand("NERDTreeMapCopy", "y", NerdAction.ToIj("\$Copy"))
+    registerCommand("NERDTreeMapPaste", "v", NerdAction.ToIj("\$Paste"))
+    registerCommand("NERDTreeMapRename", "<C-r>", NerdAction.ToIj("RenameElement"))
     registerCommand("NERDTreeMapRefreshRoot", "R", NerdAction.ToIj("Synchronize"))
     registerCommand("NERDTreeMapMenu", "m", NerdAction.ToIj("ShowPopupMenu"))
     registerCommand("NERDTreeMapQuit", "q", NerdAction.ToIj("HideActiveWindow"))
@@ -537,37 +533,29 @@ private fun addCommand(alias: String, handler: CommandAliasHandler) {
   VimPlugin.getCommand().setAlias(alias, CommandAlias.Call(0, -1, alias, handler))
 }
 
-private fun registerCommand(variable: String, default: String, action: NerdAction) {
+private fun registerCommand(variable: String, defaultMapping: String, action: NerdAction) {
   val variableValue = VimPlugin.getVariableService().getGlobalVariableValue(variable)
-  val mappings = if (variableValue is VimString) {
+  val mapping = if (variableValue is VimString) {
     variableValue.value
   } else {
-    default
+    defaultMapping
   }
-  actionsRoot.addLeafs(mappings, action)
+  registerCommand(mapping, action)
 }
 
-private fun registerCommand(default: String, action: NerdAction) {
+private fun registerCommand(mapping: String, action: NerdAction) {
-  actionsRoot.addLeafs(default, action)
+  actionsRoot.add(mapping, action)
+  injector.parser.parseKeys(mapping).forEach {
+    distinctShortcuts.add(it)
+  }
 }
 
-
+private val actionsRoot: KeyStrokeTrie<NerdAction> = KeyStrokeTrie<NerdAction>("NERDTree")
-private val actionsRoot: RootNode<NerdAction> = RootNode()
+private val distinctShortcuts = mutableSetOf<KeyStroke>()
-private var currentNode: CommandPartNode<NerdAction> = actionsRoot
-private fun collectShortcuts(node: Node<NerdAction>): Set<KeyStroke> {
-  return if (node is CommandPartNode<NerdAction>) {
-    val res = node.keys.toMutableSet()
-    res += node.values.map { collectShortcuts(it) }.flatten()
-    res
-  } else {
-    emptySet()
-  }
-}
 
 private fun installDispatcher(project: Project) {
   val dispatcher = NerdTree.NerdDispatcher.getInstance(project)
-  val shortcuts =
+  val shortcuts = distinctShortcuts.map { RequiredShortcut(it, MappingOwner.Plugin.get(NerdTree.pluginName)) }
-    collectShortcuts(actionsRoot).map { RequiredShortcut(it, MappingOwner.Plugin.get(NerdTree.pluginName)) }
   dispatcher.registerCustomShortcutSet(
     KeyGroup.toShortcutSet(shortcuts),
     (ProjectView.getInstance(project) as ProjectViewImpl).component,

src/main/java/com/maddyhome/idea/vim/extension/paragraphmotion/ParagraphMotion.kt

@@ -62,7 +62,7 @@ internal class ParagraphMotion : VimExtension {
     toKeys: List<KeyStroke>,
     recursive: Boolean,
   ) {
-    val filteredModes = modes.filterNotTo(HashSet()) { VimPlugin.getKey().hasmapfrom(it, fromKeys) }
+    val filteredModes = modes.filterNotTo(HashSet()) { VimPlugin.getKey().getKeyMapping(it).getLayer(fromKeys) != null }
     putKeyMappingIfMissing(filteredModes, fromKeys, pluginOwner, toKeys, recursive)
   }
 }

src/main/java/com/maddyhome/idea/vim/extension/replacewithregister/ReplaceWithRegister.kt

@@ -10,7 +10,6 @@ package com.maddyhome.idea.vim.extension.replacewithregister
 
 import com.intellij.openapi.actionSystem.DataContext
 import com.intellij.openapi.editor.Editor
-import com.maddyhome.idea.vim.KeyHandler
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.ImmutableVimCaret
@@ -144,7 +143,7 @@ internal class ReplaceWithRegister : VimExtension {
 private fun doReplace(editor: Editor, context: DataContext, caret: ImmutableVimCaret, visualSelection: PutData.VisualSelection) {
   val registerGroup = injector.registerGroup
   val lastRegisterChar = if (editor.caretModel.caretCount == 1) registerGroup.currentRegister else registerGroup.getCurrentRegisterForMulticaret()
-  val savedRegister = registerGroup.getRegister(lastRegisterChar) ?: return
+  val savedRegister = caret.registerStorage.getRegister(lastRegisterChar) ?: return
 
   var usedType = savedRegister.type
   var usedText = savedRegister.text
@@ -166,17 +165,11 @@ private fun doReplace(editor: Editor, context: DataContext, caret: ImmutableVimC
     putToLine = -1,
   )
   val vimEditor = editor.vim
-  val keyHandler = KeyHandler.getInstance()
   ClipboardOptionHelper.IdeaputDisabler().use {
     VimPlugin.getPut().putText(
       vimEditor,
       context.vim,
       putData,
-      operatorArguments = OperatorArguments(
-        keyHandler.isOperatorPending(vimEditor.mode, keyHandler.keyHandlerState),
-        0,
-        editor.vim.mode,
-      ),
       saveToRegister = false
     )
   }

src/main/java/com/maddyhome/idea/vim/extension/sneak/IdeaVimSneakExtension.kt

@@ -34,6 +34,7 @@ import com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMapping
 import com.maddyhome.idea.vim.extension.VimExtensionHandler
 import com.maddyhome.idea.vim.helper.StrictMode
 import com.maddyhome.idea.vim.newapi.ij
+import org.jetbrains.annotations.TestOnly
 import java.awt.Font
 import java.awt.event.KeyEvent
 import java.util.*
@@ -45,15 +46,26 @@ private const val DEFAULT_HIGHLIGHT_DURATION_SNEAK = 300
 // By [Mikhail Levchenko](https://github.com/Mishkun)
 // Original repository with the plugin: https://github.com/Mishkun/ideavim-sneak
 internal class IdeaVimSneakExtension : VimExtension {
+  @Suppress("CompanionObjectInExtension")
+  companion object {
+    private var highlightHandler: HighlightHandler? = null
+
+    @TestOnly
+    internal fun stopTimer() {
+      highlightHandler?.stopExistingTimer()
+    }
+  }
+
   override fun getName(): String = "sneak"
 
   override fun init() {
-    val highlightHandler = HighlightHandler()
+    val _highlightHandler = HighlightHandler()
-    mapToFunctionAndProvideKeys("s", SneakHandler(highlightHandler, Direction.FORWARD), MappingMode.NXO)
+    highlightHandler = _highlightHandler
+    mapToFunctionAndProvideKeys("s", SneakHandler(_highlightHandler, Direction.FORWARD), MappingMode.NXO)
 
     // vim-sneak uses `Z` for visual mode because `S` conflict with vim-sneak plugin VIM-3330
-    mapToFunctionAndProvideKeys("S", SneakHandler(highlightHandler, Direction.BACKWARD), MappingMode.NO)
+    mapToFunctionAndProvideKeys("S", SneakHandler(_highlightHandler, Direction.BACKWARD), MappingMode.NO)
-    mapToFunctionAndProvideKeys("Z", SneakHandler(highlightHandler, Direction.BACKWARD), MappingMode.X)
+    mapToFunctionAndProvideKeys("Z", SneakHandler(_highlightHandler, Direction.BACKWARD), MappingMode.X)
 
     // workaround to support ; and , commands
     mapToFunctionAndProvideKeys("f", SneakMemoryHandler("f"), MappingMode.NXO)
@@ -61,8 +73,8 @@ internal class IdeaVimSneakExtension : VimExtension {
     mapToFunctionAndProvideKeys("t", SneakMemoryHandler("t"), MappingMode.NXO)
     mapToFunctionAndProvideKeys("T", SneakMemoryHandler("T"), MappingMode.NXO)
 
-    mapToFunctionAndProvideKeys(";", SneakRepeatHandler(highlightHandler, RepeatDirection.IDENTICAL), MappingMode.NXO)
+    mapToFunctionAndProvideKeys(";", SneakRepeatHandler(_highlightHandler, RepeatDirection.IDENTICAL), MappingMode.NXO)
-    mapToFunctionAndProvideKeys(",", SneakRepeatHandler(highlightHandler, RepeatDirection.REVERSE), MappingMode.NXO)
+    mapToFunctionAndProvideKeys(",", SneakRepeatHandler(_highlightHandler, RepeatDirection.REVERSE), MappingMode.NXO)
   }
 
   private class SneakHandler(
@@ -209,6 +221,7 @@ internal class IdeaVimSneakExtension : VimExtension {
   private class HighlightHandler {
     private var editor: Editor? = null
     private val sneakHighlighters: MutableSet<RangeHighlighter> = mutableSetOf()
+    private var timer: Timer? = null
 
     fun highlightSneakRange(editor: Editor, range: TextRange) {
       clearAllSneakHighlighters()
@@ -254,13 +267,19 @@ internal class IdeaVimSneakExtension : VimExtension {
     }
 
     private fun setClearHighlightRangeTimer(highlighter: RangeHighlighter) {
-      val timer = Timer(DEFAULT_HIGHLIGHT_DURATION_SNEAK) {
+      stopExistingTimer()
+      timer = Timer(DEFAULT_HIGHLIGHT_DURATION_SNEAK) {
         if (editor?.isDisposed != true) {
           editor?.markupModel?.removeHighlighter(highlighter)
         }
       }
-      timer.isRepeats = false
+      timer?.isRepeats = false
-      timer.start()
+      timer?.start()
+    }
+
+    fun stopExistingTimer() {
+      timer?.stop()
+      timer?.actionListeners?.forEach { it.actionPerformed(null) }
     }
 
     private fun getHighlightTextAttributes() = TextAttributes(
@@ -307,7 +326,7 @@ private fun VimExtension.mapToFunctionAndProvideKeys(
     VimPlugin.getKey().hasmapto(it, injector.parser.parseKeys(commandFromOriginalPlugin(keys)))
   }
   val filteredFromModes = mappingModes.filterNotTo(HashSet()) {
-    injector.keyGroup.hasmapfrom(it, fromKeys)
+    injector.keyGroup.getKeyMapping(it).getLayer(fromKeys) != null
   }
 
   val doubleFiltered = mappingModes

src/main/java/com/maddyhome/idea/vim/extension/surround/VimSurroundExtension.kt

@@ -36,6 +36,7 @@ import com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMappingIfMissin
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.setRegisterForCaret
 import com.maddyhome.idea.vim.extension.exportOperatorFunction
 import com.maddyhome.idea.vim.group.findBlockRange
+import com.maddyhome.idea.vim.helper.exitVisualMode
 import com.maddyhome.idea.vim.helper.runWithEveryCaretAndRestore
 import com.maddyhome.idea.vim.key.OperatorFunction
 import com.maddyhome.idea.vim.newapi.IjVimCaret
@@ -46,6 +47,7 @@ import com.maddyhome.idea.vim.options.helpers.ClipboardOptionHelper
 import com.maddyhome.idea.vim.put.PutData
 import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.state.mode.SelectionType
+import com.maddyhome.idea.vim.state.mode.returnTo
 import com.maddyhome.idea.vim.state.mode.selectionType
 import org.jetbrains.annotations.NonNls
 import java.awt.event.KeyEvent
@@ -115,6 +117,9 @@ internal class VimSurroundExtension : VimExtension {
 //        it.moveToOffset(lineStartOffset)
       }
       // Jump back to start
+      if (editor.mode !is Mode.NORMAL) {
+        editor.mode = Mode.NORMAL()
+      }
       executeNormalWithoutMapping(injector.parser.parseKeys("`["), ijEditor)
     }
 
@@ -136,7 +141,7 @@ internal class VimSurroundExtension : VimExtension {
       }
       runWriteAction {
         // Leave visual mode
-        executeNormalWithoutMapping(injector.parser.parseKeys("<Esc>"), editor.ij)
+        editor.exitVisualMode()
       }
     }
   }
@@ -156,17 +161,17 @@ internal class VimSurroundExtension : VimExtension {
     }
 
     companion object {
-      fun change(editor: VimEditor, context: ExecutionContext, charFrom: Char, newSurround: Pair<String, String>?) {
+      fun change(editor: VimEditor, context: ExecutionContext, charFrom: Char, newSurround: SurroundPair?) {
         editor.ij.runWithEveryCaretAndRestore { changeAtCaret(editor, context, charFrom, newSurround) }
       }
       
-      fun changeAtCaret(editor: VimEditor, context: ExecutionContext, charFrom: Char, newSurround: Pair<String, String>?) {
+      fun changeAtCaret(editor: VimEditor, context: ExecutionContext, charFrom: Char, newSurround: SurroundPair?) {
         // Save old register values for carets
         val surroundings = editor.sortedCarets()
           .map {
             val oldValue: List<KeyStroke>? = getRegisterForCaret(REGISTER, it)
             setRegisterForCaret(REGISTER, it, null)
-            SurroundingInfo(it, null, oldValue)
+            SurroundingInfo(it, null, oldValue, false)
           }
 
         // Delete surrounding's content
@@ -182,21 +187,25 @@ internal class VimSurroundExtension : VimExtension {
           }
 
           val registerValue = getRegisterForCaret(REGISTER, it.caret)
-          val innerValue = if (registerValue.isNullOrEmpty()) null else registerValue
+          val innerValue = if (registerValue.isNullOrEmpty()) emptyList() else registerValue
           it.innerText = innerValue
-        }
 
-        surroundings.forEach {
+          // Valid surroundings are only those that:
-          if (it.innerText == null && getRegisterForCaret(REGISTER, it.caret)?.isNotEmpty() == true) {
+          // - are validly wrapping with surround characters (i.e. parenthesis, brackets, tags, quotes, etc.);
-            it.innerText = emptyList()
+          // - or have non-empty inner text (e.g. when we are surrounding words: `csw"`)
+          if (currentSurrounding != null || innerValue.isNotEmpty()) {
+            it.isValidSurrounding = true
           }
         }
 
         surroundings
-          .filter { it.innerText != null } // we do nothing with carets that are not inside the surrounding
+          .filter { it.isValidSurrounding } // we do nothing with carets that are not inside the surrounding
           .map { surrounding ->
             val innerValue = injector.parser.toPrintableString(surrounding.innerText!!)
-            val text = newSurround?.let { it.first + innerValue + it.second } ?: innerValue
+            val text = newSurround?.let {
+              val trimmedValue = if (newSurround.shouldTrim) innerValue.trim() else innerValue
+              it.first + trimmedValue + it.second
+            } ?: innerValue
             val textData = PutData.TextData(text, SelectionType.CHARACTER_WISE, emptyList(), null)
             val putData = PutData(textData, null, 1, insertTextBeforeCaret = true, rawIndent = true, caretAfterInsertedText = false)
 
@@ -249,7 +258,7 @@ internal class VimSurroundExtension : VimExtension {
     }
   }
 
-  private data class SurroundingInfo(val caret: VimCaret, var innerText: List<KeyStroke>?, val oldRegisterContent: List<KeyStroke>?) {
+  private data class SurroundingInfo(val caret: VimCaret, var innerText: List<KeyStroke>?, val oldRegisterContent: List<KeyStroke>?, var isValidSurrounding: Boolean) {
     fun restoreRegister() {
       setRegisterForCaret(REGISTER, caret, oldRegisterContent)
     }
@@ -292,7 +301,7 @@ internal class VimSurroundExtension : VimExtension {
       return true
     }
     
-    private fun applyOnce(editor: Editor, change: VimChangeGroup, pair: Pair<String, String>, count: Int) {
+    private fun applyOnce(editor: Editor, change: VimChangeGroup, pair: SurroundPair, count: Int) {
       // XXX: Will it work with line-wise or block-wise selections?
       val primaryCaret = editor.caretModel.primaryCaret
       val range = getSurroundRange(primaryCaret.vim)
@@ -306,8 +315,10 @@ internal class VimSurroundExtension : VimExtension {
 
     private fun getSurroundRange(caret: VimCaret): TextRange? {
       val editor = caret.editor
-      val ijEditor = editor.ij
+      if (editor.mode is Mode.CMD_LINE) {
-      return when (ijEditor.vim.mode) {
+        editor.mode = (editor.mode as Mode.CMD_LINE).returnTo()
+      }
+      return when (editor.mode) {
         is Mode.NORMAL -> injector.markService.getChangeMarks(caret)
         is Mode.VISUAL -> caret.run { TextRange(selectionStart, selectionEnd) }
         else -> null
@@ -324,37 +335,42 @@ private const val OPERATOR_FUNC = "SurroundOperatorFunc"
 
 private val tagNameAndAttributesCapturePattern = "(\\S+)([^>]*)>".toPattern()
 
+private data class SurroundPair(val first: String, val second: String, val shouldTrim: Boolean)
+
 private val SURROUND_PAIRS = mapOf(
-  'b' to ("(" to ")"),
+  'b' to SurroundPair("(", ")", false),
-  '(' to ("( " to " )"),
+  '(' to SurroundPair("( ", " )", false),
-  ')' to ("(" to ")"),
+  ')' to SurroundPair("(", ")", true),
-  'B' to ("{" to "}"),
+  'B' to SurroundPair("{", "}", false),
-  '{' to ("{ " to " }"),
+  '{' to SurroundPair("{ ", " }", false),
-  '}' to ("{" to "}"),
+  '}' to SurroundPair("{", "}", true),
-  'r' to ("[" to "]"),
+  'r' to SurroundPair("[", "]", false),
-  '[' to ("[ " to " ]"),
+  '[' to SurroundPair("[ ", " ]", false),
-  ']' to ("[" to "]"),
+  ']' to SurroundPair("[", "]", true),
-  'a' to ("<" to ">"),
+  'a' to SurroundPair("<", ">", false),
-  '>' to ("<" to ">"),
+  '>' to SurroundPair("<", ">", false),
-  's' to (" " to ""),
+  's' to SurroundPair(" ", "", false),
 )
 
-private fun getSurroundPair(c: Char): Pair<String, String>? = if (c in SURROUND_PAIRS) {
+private fun getSurroundPair(c: Char): SurroundPair? = if (c in SURROUND_PAIRS) {
   SURROUND_PAIRS[c]
 } else if (!c.isLetter()) {
   val s = c.toString()
-  s to s
+  SurroundPair(s, s, false)
 } else {
   null
 }
 
-private fun inputTagPair(editor: Editor, context: DataContext): Pair<String, String>? {
+private fun inputTagPair(editor: Editor, context: DataContext): SurroundPair? {
   val tagInput = inputString(editor, context, "<", '>')
+  if (editor.vim.mode is Mode.CMD_LINE) {
+    editor.vim.mode = editor.vim.mode.returnTo()
+  }
   val matcher = tagNameAndAttributesCapturePattern.matcher(tagInput)
   return if (matcher.find()) {
     val tagName = matcher.group(1)
     val tagAttributes = matcher.group(2)
-    "<$tagName$tagAttributes>" to "</$tagName>"
+    SurroundPair("<$tagName$tagAttributes>", "</$tagName>", false)
   } else {
     null
   }
@@ -364,13 +380,20 @@ private fun inputFunctionName(
   editor: Editor,
   context: DataContext,
   withInternalSpaces: Boolean,
-): Pair<String, String>? {
+): SurroundPair? {
   val functionNameInput = inputString(editor, context, "function: ", null)
+  if (editor.vim.mode is Mode.CMD_LINE) {
+    editor.vim.mode = editor.vim.mode.returnTo()
+  }
   if (functionNameInput.isEmpty()) return null
-  return if (withInternalSpaces) "$functionNameInput( " to " )" else "$functionNameInput(" to ")"
+  return if (withInternalSpaces) {
+    SurroundPair("$functionNameInput( ", " )", false)
+  } else {
+    SurroundPair("$functionNameInput(", ")", false)
+  }
 }
 
-private fun getOrInputPair(c: Char, editor: Editor, context: DataContext): Pair<String, String>? = when (c) {
+private fun getOrInputPair(c: Char, editor: Editor, context: DataContext): SurroundPair? = when (c) {
   '<', 't' -> inputTagPair(editor, context)
   'f' -> inputFunctionName(editor, context, false)
   'F' -> inputFunctionName(editor, context, true)
@@ -389,7 +412,7 @@ private fun getChar(editor: Editor): Char {
   return res
 }
 
-private fun performSurround(pair: Pair<String, String>, range: TextRange, caret: VimCaret, count: Int, tagsOnNewLines: Boolean = false) {
+private fun performSurround(pair: SurroundPair, range: TextRange, caret: VimCaret, count: Int, tagsOnNewLines: Boolean = false) {
   runWriteAction {
     val editor = caret.editor
     val change = VimPlugin.getChange()

src/main/java/com/maddyhome/idea/vim/extension/textobjentire/VimTextObjEntireExtension.java

@@ -29,14 +29,12 @@ import com.maddyhome.idea.vim.state.mode.Mode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.EnumSet;
-
 import static com.maddyhome.idea.vim.extension.VimExtensionFacade.putExtensionHandlerMapping;
 import static com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMappingIfMissing;
 
 /**
  * Port of vim-entire:
- * https://github.com/kana/vim-textobj-entire
+ * <a href="https://github.com/kana/vim-textobj-entire">vim-textobj-entire</a>
  *
  * <p>
  * vim-textobj-entire provides two text objects:
@@ -51,7 +49,7 @@ import static com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMappingI
  * </ul>
  *
  * See also the reference manual for more details at:
- * https://github.com/kana/vim-textobj-entire/blob/master/doc/textobj-entire.txt
+ * <a href="https://github.com/kana/vim-textobj-entire/blob/master/doc/textobj-entire.txt">text-obj-entire.txt</a>
  *
  * @author Alexandre Grison (@agrison)
  */
@@ -94,9 +92,8 @@ public class VimTextObjEntireExtension implements VimExtension {
         this.ignoreLeadingAndTrailing = ignoreLeadingAndTrailing;
       }
 
-      @Nullable
       @Override
-      public TextRange getRange(@NotNull VimEditor editor,
+      public @Nullable TextRange getRange(@NotNull VimEditor editor,
                                           @NotNull ImmutableVimCaret caret,
                                           @NotNull ExecutionContext context,
                                           int count,
@@ -125,24 +122,22 @@ public class VimTextObjEntireExtension implements VimExtension {
         return new TextRange(start, end);
       }
 
-      @NotNull
       @Override
-      public TextObjectVisualType getVisualType() {
+      public @NotNull TextObjectVisualType getVisualType() {
         return TextObjectVisualType.CHARACTER_WISE;
       }
     }
 
     @Override
     public void execute(@NotNull VimEditor editor, @NotNull ExecutionContext context, @NotNull OperatorArguments operatorArguments) {
-      @NotNull KeyHandler keyHandler = KeyHandler.getInstance();
       @NotNull KeyHandlerState keyHandlerState = KeyHandler.getInstance().getKeyHandlerState();
-      int count = Math.max(1, keyHandlerState.getCommandBuilder().getCount());
 
       final EntireTextObjectHandler textObjectHandler = new EntireTextObjectHandler(ignoreLeadingAndTrailing);
       //noinspection DuplicatedCode
-      if (!keyHandler.isOperatorPending(editor.getMode(), keyHandlerState)) {
+      if (!(editor.getMode() instanceof Mode.OP_PENDING)) {
+        int count0 = operatorArguments.getCount0();
         ((IjVimEditor) editor).getEditor().getCaretModel().runForEachCaret((Caret caret) -> {
-          final TextRange range = textObjectHandler.getRange(editor, new IjVimCaret(caret), context, count, 0);
+          final TextRange range = textObjectHandler.getRange(editor, new IjVimCaret(caret), context, Math.max(1, count0), count0);
           if (range != null) {
             try (VimListenerSuppressor.Locked ignored = SelectionVimListenerSuppressor.INSTANCE.lock()) {
               if (editor.getMode() instanceof Mode.VISUAL) {
@@ -155,9 +150,7 @@ public class VimTextObjEntireExtension implements VimExtension {
 
         });
       } else {
-        keyHandlerState.getCommandBuilder().completeCommandPart(new Argument(new Command(count,
+        keyHandlerState.getCommandBuilder().addAction(textObjectHandler);
-                                                                                         textObjectHandler, Command.Type.MOTION,
-                                                                                         EnumSet.noneOf(CommandFlags.class))));
       }
     }
   }

src/main/java/com/maddyhome/idea/vim/extension/textobjindent/VimIndentObject.java

@@ -30,14 +30,12 @@ import com.maddyhome.idea.vim.state.mode.Mode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.EnumSet;
-
 import static com.maddyhome.idea.vim.extension.VimExtensionFacade.putExtensionHandlerMapping;
 import static com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMapping;
 
 /**
  * Port of vim-indent-object:
- * https://github.com/michaeljsmith/vim-indent-object
+ * <a href="https://github.com/michaeljsmith/vim-indent-object">vim-indent-object</a>
  *
  * <p>
  * vim-indent-object provides these text objects based on the cursor line's indentation:
@@ -49,7 +47,7 @@ import static com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMapping;
  * </ul>
  *
  * See also the reference manual for more details at:
- * https://github.com/michaeljsmith/vim-indent-object/blob/master/doc/indent-object.txt
+ * <a href="https://github.com/michaeljsmith/vim-indent-object/blob/master/doc/indent-object.txt">indent-object.txt</a>
  *
  * @author Shrikant Kandula (@sharat87)
  */
@@ -98,9 +96,8 @@ public class VimIndentObject implements VimExtension {
         this.includeBelow = includeBelow;
       }
 
-      @Nullable
       @Override
-      public TextRange getRange(@NotNull VimEditor editor,
+      public @Nullable TextRange getRange(@NotNull VimEditor editor,
                                           @NotNull ImmutableVimCaret caret,
                                           @NotNull ExecutionContext context,
                                           int count,
@@ -249,9 +246,8 @@ public class VimIndentObject implements VimExtension {
         return new TextRange(upperBoundaryOffset, lowerBoundaryOffset);
       }
 
-      @NotNull
       @Override
-      public TextObjectVisualType getVisualType() {
+      public @NotNull TextObjectVisualType getVisualType() {
         return TextObjectVisualType.LINE_WISE;
       }
 
@@ -264,15 +260,14 @@ public class VimIndentObject implements VimExtension {
     @Override
     public void execute(@NotNull VimEditor editor, @NotNull ExecutionContext context, @NotNull OperatorArguments operatorArguments) {
       IjVimEditor vimEditor = (IjVimEditor)editor;
-      @NotNull KeyHandler keyHandler = KeyHandler.getInstance();
       @NotNull KeyHandlerState keyHandlerState = KeyHandler.getInstance().getKeyHandlerState();
-      int count = Math.max(1, keyHandlerState.getCommandBuilder().getCount());
 
       final IndentObjectHandler textObjectHandler = new IndentObjectHandler(includeAbove, includeBelow);
 
-      if (!keyHandler.isOperatorPending(editor.getMode(), keyHandlerState)) {
+      if (!(editor.getMode() instanceof Mode.OP_PENDING)) {
+        int count0 = operatorArguments.getCount0();
         ((IjVimEditor)editor).getEditor().getCaretModel().runForEachCaret((Caret caret) -> {
-          final TextRange range = textObjectHandler.getRange(vimEditor, new IjVimCaret(caret), context, count, 0);
+          final TextRange range = textObjectHandler.getRange(vimEditor, new IjVimCaret(caret), context, Math.max(1, count0), count0);
           if (range != null) {
             try (VimListenerSuppressor.Locked ignored = SelectionVimListenerSuppressor.INSTANCE.lock()) {
               if (editor.getMode() instanceof Mode.VISUAL) {
@@ -285,9 +280,7 @@ public class VimIndentObject implements VimExtension {
 
         });
       } else {
-        keyHandlerState.getCommandBuilder().completeCommandPart(new Argument(new Command(count,
+        keyHandlerState.getCommandBuilder().addAction(textObjectHandler);
-                                                                                         textObjectHandler, Command.Type.MOTION,
-                                                                                         EnumSet.noneOf(CommandFlags.class))));
       }
     }
   }

src/main/java/com/maddyhome/idea/vim/group/ChangeGroup.kt

@@ -15,77 +15,38 @@ import com.intellij.openapi.command.CommandProcessor
 import com.intellij.openapi.command.UndoConfirmationPolicy
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.editor.Editor
-import com.intellij.openapi.editor.LogicalPosition
 import com.intellij.openapi.editor.actions.EnterAction
 import com.intellij.openapi.editor.event.EditorMouseEvent
 import com.intellij.openapi.editor.event.EditorMouseListener
-import com.intellij.openapi.editor.impl.TextRangeInterval
 import com.intellij.openapi.util.UserDataHolder
-import com.intellij.openapi.util.text.StringUtil
 import com.intellij.psi.codeStyle.CodeStyleManager
 import com.intellij.psi.util.PsiUtilBase
-import com.intellij.util.containers.ContainerUtil
 import com.maddyhome.idea.vim.EventFacade
-import com.maddyhome.idea.vim.api.BufferPosition
 import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.VimCaret
 import com.maddyhome.idea.vim.api.VimChangeGroupBase
 import com.maddyhome.idea.vim.api.VimEditor
-import com.maddyhome.idea.vim.api.VimMotionGroupBase
-import com.maddyhome.idea.vim.api.anyNonWhitespace
 import com.maddyhome.idea.vim.api.getLineEndForOffset
-import com.maddyhome.idea.vim.api.getLineEndOffset
 import com.maddyhome.idea.vim.api.getLineStartForOffset
-import com.maddyhome.idea.vim.api.getText
 import com.maddyhome.idea.vim.api.injector
-import com.maddyhome.idea.vim.api.lineLength
-import com.maddyhome.idea.vim.api.normalizeOffset
-import com.maddyhome.idea.vim.api.options
-import com.maddyhome.idea.vim.command.Argument
-import com.maddyhome.idea.vim.command.OperatorArguments
-import com.maddyhome.idea.vim.common.IndentConfig.Companion.create
 import com.maddyhome.idea.vim.common.TextRange
-import com.maddyhome.idea.vim.ex.ranges.LineRange
-import com.maddyhome.idea.vim.group.MotionGroup.Companion.getMotionRange2
-import com.maddyhome.idea.vim.group.visual.VimSelection
 import com.maddyhome.idea.vim.group.visual.vimSetSystemSelectionSilently
-import com.maddyhome.idea.vim.handler.Motion
-import com.maddyhome.idea.vim.handler.Motion.AbsoluteOffset
 import com.maddyhome.idea.vim.handler.commandContinuation
-import com.maddyhome.idea.vim.helper.CharacterHelper
-import com.maddyhome.idea.vim.helper.CharacterHelper.changeCase
-import com.maddyhome.idea.vim.helper.CharacterHelper.charType
-import com.maddyhome.idea.vim.helper.EditorHelper
-import com.maddyhome.idea.vim.helper.NumberType
-import com.maddyhome.idea.vim.helper.endOffsetInclusive
-import com.maddyhome.idea.vim.helper.findNumberUnderCursor
-import com.maddyhome.idea.vim.helper.findNumbersInRange
 import com.maddyhome.idea.vim.helper.inInsertMode
-import com.maddyhome.idea.vim.helper.moveToInlayAwareLogicalPosition
-import com.maddyhome.idea.vim.helper.moveToInlayAwareOffset
 import com.maddyhome.idea.vim.key.KeyHandlerKeeper.Companion.getInstance
 import com.maddyhome.idea.vim.listener.VimInsertListener
-import com.maddyhome.idea.vim.newapi.IjEditorExecutionContext
 import com.maddyhome.idea.vim.newapi.IjVimCaret
+import com.maddyhome.idea.vim.newapi.IjVimCopiedText
 import com.maddyhome.idea.vim.newapi.IjVimEditor
 import com.maddyhome.idea.vim.newapi.ij
-import com.maddyhome.idea.vim.regexp.VimRegex
-import com.maddyhome.idea.vim.regexp.match.VimMatchResult
 import com.maddyhome.idea.vim.state.mode.Mode
-import com.maddyhome.idea.vim.state.mode.Mode.VISUAL
+import com.maddyhome.idea.vim.undo.VimKeyBasedUndoService
-import com.maddyhome.idea.vim.state.mode.SelectionType
+import com.maddyhome.idea.vim.undo.VimTimestampBasedUndoService
-import com.maddyhome.idea.vim.vimscript.model.commands.SortOption
-import org.jetbrains.annotations.TestOnly
-import java.math.BigInteger
-import java.util.*
-import java.util.function.Consumer
-import kotlin.math.max
 
 /**
  * Provides all the insert/replace related functionality
  */
 class ChangeGroup : VimChangeGroupBase() {
-  private val insertListeners = ContainerUtil.createLockFreeCopyOnWriteList<VimInsertListener>()
   private val listener: EditorMouseListener = object : EditorMouseListener {
     override fun mouseClicked(event: EditorMouseEvent) {
       val editor = event.editor
@@ -103,9 +64,15 @@ class ChangeGroup : VimChangeGroupBase() {
     val editor = (vimEditor as IjVimEditor).editor
     val ijContext = context.ij
     val doc = vimEditor.editor.document
+
     val undo = injector.undo
+    when (undo) {
+      is VimKeyBasedUndoService -> undo.setInsertNonMergeUndoKey()
+      is VimTimestampBasedUndoService -> {
         val nanoTime = System.nanoTime()
         vimEditor.forEachCaret { undo.startInsertSequence(it, it.offset, nanoTime) }
+      }
+    }
     CommandProcessor.getInstance().executeCommand(
       editor.project, {
         ApplicationManager.getApplication()
@@ -145,161 +112,9 @@ class ChangeGroup : VimChangeGroupBase() {
     }
   }
 
-  override fun getDeleteRangeAndType2(
+  override fun processBackspace(editor: VimEditor, context: ExecutionContext) {
-    editor: VimEditor,
+    injector.actionExecutor.executeAction(editor, name = IdeActions.ACTION_EDITOR_BACKSPACE, context = context)
-    caret: VimCaret,
+    injector.scroll.scrollCaretIntoView(editor)
-    context: ExecutionContext,
-    argument: Argument,
-    isChange: Boolean,
-    operatorArguments: OperatorArguments,
-  ): Pair<TextRange, SelectionType>? {
-    val range = getMotionRange2(
-      (editor as IjVimEditor).editor,
-      (caret as IjVimCaret).caret,
-      (context as IjEditorExecutionContext).context,
-      argument,
-      operatorArguments
-    )
-      ?: return null
-
-    // Delete motion commands that are not linewise become linewise if all the following are true:
-    // 1) The range is across multiple lines
-    // 2) There is only whitespace before the start of the range
-    // 3) There is only whitespace after the end of the range
-    var type: SelectionType
-    type = if (argument.motion.isLinewiseMotion()) {
-      SelectionType.LINE_WISE
-    } else {
-      SelectionType.CHARACTER_WISE
-    }
-    val motion = argument.motion
-    if (!isChange && !motion.isLinewiseMotion()) {
-      val start = editor.offsetToBufferPosition(range.startOffset)
-      val end = editor.offsetToBufferPosition(range.endOffset)
-      if (start.line != end.line) {
-        val offset1 = range.startOffset
-        if (!editor.anyNonWhitespace(offset1, -1)) {
-          val offset = range.endOffset
-          if (!editor.anyNonWhitespace(offset, 1)) {
-            type = SelectionType.LINE_WISE
-          }
-        }
-      }
-    }
-    return Pair(range, type)
-  }
-
-  /**
-   * Toggles the case of count characters
-   *
-   * @param editor The editor to change
-   * @param caret  The caret on which the operation is performed
-   * @param count  The number of characters to change
-   * @return true if able to change count characters
-   */
-  override fun changeCaseToggleCharacter(editor: VimEditor, caret: VimCaret, count: Int): Boolean {
-    val allowWrap = injector.options(editor).whichwrap.contains("~")
-    var motion = injector.motion.getHorizontalMotion(editor, caret, count, true, allowWrap)
-    if (motion is Motion.Error) return false
-    changeCase(editor, caret, caret.offset, (motion as AbsoluteOffset).offset, CharacterHelper.CASE_TOGGLE)
-    motion = injector.motion.getHorizontalMotion(
-      editor,
-      caret,
-      count,
-      false,
-      allowWrap
-    ) // same but without allow end because we can change till end, but can't move caret there
-    if (motion is AbsoluteOffset) {
-      caret.moveToOffset(editor.normalizeOffset(motion.offset, false))
-    }
-    return true
-  }
-
-  override fun blockInsert(
-    editor: VimEditor,
-    context: ExecutionContext,
-    range: TextRange,
-    append: Boolean,
-    operatorArguments: OperatorArguments,
-  ): Boolean {
-    val lines = getLinesCountInVisualBlock(editor, range)
-    val startPosition = editor.offsetToBufferPosition(range.startOffset)
-    val mode = operatorArguments.mode
-    val visualBlockMode = mode is VISUAL && mode.selectionType === SelectionType.BLOCK_WISE
-    for (caret in editor.carets()) {
-      val line = startPosition.line
-      var column = startPosition.column
-      if (!visualBlockMode) {
-        column = 0
-      } else if (append) {
-        column += range.maxLength
-        if (caret.vimLastColumn == VimMotionGroupBase.LAST_COLUMN) {
-          column = VimMotionGroupBase.LAST_COLUMN
-        }
-      }
-      val lineLength = editor.lineLength(line)
-      if (column < VimMotionGroupBase.LAST_COLUMN && lineLength < column) {
-        val pad = EditorHelper.pad((editor as IjVimEditor).editor, line, column)
-        val offset = editor.getLineEndOffset(line)
-        insertText(editor, caret, offset, pad)
-      }
-      if (visualBlockMode || !append) {
-        (caret as IjVimCaret).caret.moveToInlayAwareLogicalPosition(LogicalPosition(line, column))
-      }
-      if (visualBlockMode) {
-        setInsertRepeat(lines, column, append)
-      }
-    }
-    if (visualBlockMode || !append) {
-      insertBeforeCursor(editor, context)
-    } else {
-      insertAfterCursor(editor, context)
-    }
-    return true
-  }
-
-  /**
-   * Changes the case of all the characters in the range
-   *
-   * @param editor The editor to change
-   * @param caret  The caret to be moved
-   * @param range  The range to change
-   * @param type   The case change type (TOGGLE, UPPER, LOWER)
-   * @return true if able to delete the text, false if not
-   */
-  override fun changeCaseRange(editor: VimEditor, caret: VimCaret, range: TextRange, type: Char): Boolean {
-    val starts = range.startOffsets
-    val ends = range.endOffsets
-    for (i in ends.indices.reversed()) {
-      changeCase(editor, caret, starts[i], ends[i], type)
-    }
-    caret.moveToOffset(range.startOffset)
-    return true
-  }
-
-  /**
-   * This performs the actual case change.
-   *
-   * @param editor The editor to change
-   * @param start  The start offset to change
-   * @param end    The end offset to change
-   * @param type   The type of change (TOGGLE, UPPER, LOWER)
-   */
-  private fun changeCase(editor: VimEditor, caret: VimCaret, start: Int, end: Int, type: Char) {
-    var start = start
-    var end = end
-    if (start > end) {
-      val t = end
-      end = start
-      start = t
-    }
-    end = editor.normalizeOffset(end, true)
-    val chars = editor.text()
-    val sb = StringBuilder()
-    for (i in start until end) {
-      sb.append(changeCase(chars[i], type))
-    }
-    replaceText(editor, caret, start, end, sb.toString())
   }
 
   private fun restoreCursor(editor: VimEditor, caret: VimCaret, startLine: Int) {
@@ -310,88 +125,13 @@ class ChangeGroup : VimChangeGroupBase() {
     }
   }
 
-  /**
+  override fun reformatCode(editor: VimEditor, start: Int, end: Int) {
-   * Changes the case of all the character moved over by the motion argument.
-   *
-   * @param editor   The editor to change
-   * @param caret    The caret on which motion pretends to be performed
-   * @param context  The data context
-   * @param type     The case change type (TOGGLE, UPPER, LOWER)
-   * @param argument The motion command
-   * @return true if able to delete the text, false if not
-   */
-  override fun changeCaseMotion(
-    editor: VimEditor,
-    caret: VimCaret,
-    context: ExecutionContext?,
-    type: Char,
-    argument: Argument,
-    operatorArguments: OperatorArguments,
-  ): Boolean {
-    val range = injector.motion.getMotionRange(
-      editor, caret, context!!, argument,
-      operatorArguments
-    )
-    return range != null && changeCaseRange(editor, caret, range, type)
-  }
-
-  override fun reformatCodeMotion(
-    editor: VimEditor,
-    caret: VimCaret,
-    context: ExecutionContext,
-    argument: Argument,
-    operatorArguments: OperatorArguments,
-  ): Boolean {
-    val range = injector.motion.getMotionRange(
-      editor, caret, context, argument,
-      operatorArguments
-    )
-    return range != null && reformatCodeRange(editor, caret, range)
-  }
-
-  override fun reformatCodeSelection(editor: VimEditor, caret: VimCaret, range: VimSelection) {
-    val textRange = range.toVimTextRange(true)
-    reformatCodeRange(editor, caret, textRange)
-  }
-
-  private fun reformatCodeRange(editor: VimEditor, caret: VimCaret, range: TextRange): Boolean {
-    val starts = range.startOffsets
-    val ends = range.endOffsets
-    val firstLine = editor.offsetToBufferPosition(range.startOffset).line
-    for (i in ends.indices.reversed()) {
-      val startOffset = editor.getLineStartForOffset(starts[i])
-      val offset = ends[i] - if (startOffset == ends[i]) 0 else 1
-      val endOffset = editor.getLineEndForOffset(offset)
-      reformatCode(editor, startOffset, endOffset)
-    }
-    val newOffset = injector.motion.moveCaretToLineStartSkipLeading(editor, firstLine)
-    caret.moveToOffset(newOffset)
-    return true
-  }
-
-  private fun reformatCode(editor: VimEditor, start: Int, end: Int) {
     val project = (editor as IjVimEditor).editor.project ?: return
     val file = PsiUtilBase.getPsiFileInEditor(editor.editor, project) ?: return
     val textRange = com.intellij.openapi.util.TextRange.create(start, end)
     CodeStyleManager.getInstance(project).reformatText(file, listOf(textRange))
   }
 
-  override fun autoIndentMotion(
-    editor: VimEditor,
-    caret: VimCaret,
-    context: ExecutionContext,
-    argument: Argument,
-    operatorArguments: OperatorArguments,
-  ) {
-    val range = injector.motion.getMotionRange(editor, caret, context, argument, operatorArguments)
-    if (range != null) {
-      autoIndentRange(
-        editor, caret, context,
-        TextRange(range.startOffset, range.endOffsetInclusive)
-      )
-    }
-  }
-
   override fun autoIndentRange(
     editor: VimEditor,
     caret: VimCaret,
@@ -405,10 +145,10 @@ class ChangeGroup : VimChangeGroupBase() {
 
     // FIXME: Here we do selection, and it is not a good idea, because it updates primary selection in Linux
     // FIXME: I'll leave here a dirty fix that restores primary selection, but it would be better to rewrite this method
-    var primaryTextAndTransferableData: Pair<String, List<Any>?>? = null
+    var copiedText: IjVimCopiedText? = null
     try {
       if (injector.registerGroup.isPrimaryRegisterSupported()) {
-        primaryTextAndTransferableData = injector.clipboardManager.getPrimaryTextAndTransferableData()
+        copiedText = injector.clipboardManager.getPrimaryContent(editor, context) as IjVimCopiedText
       }
     } catch (e: Exception) {
       // FIXME: [isPrimaryRegisterSupported()] is not implemented perfectly, so there might be thrown an exception after trying to access the primary selection
@@ -434,373 +174,22 @@ class ChangeGroup : VimChangeGroupBase() {
       afterAction.invoke()
     }
     try {
-      if (primaryTextAndTransferableData != null) {
+      if (copiedText != null) {
-        injector.clipboardManager.setPrimaryText(
+        injector.clipboardManager.setPrimaryContent(editor, context, copiedText)
-          primaryTextAndTransferableData.first,
-          primaryTextAndTransferableData.first,
-          primaryTextAndTransferableData.second ?: emptyList()
-        )
       }
     } catch (e: Exception) {
       // FIXME: [isPrimaryRegisterSupported()] is not implemented perfectly, so there might be thrown an exception after trying to access the primary selection
     }
   }
 
-  override fun indentLines(
+  @Deprecated(message = "Please use listenersNotifier", replaceWith = ReplaceWith("injector.listenersNotifier.modeChangeListeners.add", imports = ["import com.maddyhome.idea.vim.api.injector"]))
-    editor: VimEditor,
-    caret: VimCaret,
-    context: ExecutionContext,
-    lines: Int,
-    dir: Int,
-    operatorArguments: OperatorArguments,
-  ) {
-    val start = caret.offset
-    val end = injector.motion.moveCaretToRelativeLineEnd(editor, caret, lines - 1, true)
-    indentRange(editor, caret, context, TextRange(start, end), 1, dir, operatorArguments)
-  }
-
-  override fun indentMotion(
-    editor: VimEditor,
-    caret: VimCaret,
-    context: ExecutionContext,
-    argument: Argument,
-    dir: Int,
-    operatorArguments: OperatorArguments,
-  ) {
-    val range = injector.motion.getMotionRange(editor, caret, context, argument, operatorArguments)
-    if (range != null) {
-      indentRange(editor, caret, context, range, 1, dir, operatorArguments)
-    }
-  }
-
-  override fun indentRange(
-    editor: VimEditor,
-    caret: VimCaret,
-    context: ExecutionContext,
-    range: TextRange,
-    count: Int,
-    dir: Int,
-    operatorArguments: OperatorArguments,
-  ) {
-    if (logger.isDebugEnabled) {
-      logger.debug("count=$count")
-    }
-
-    // Remember the current caret column
-    val intendedColumn = caret.vimLastColumn
-    val indentConfig = create((editor as IjVimEditor).editor)
-    val sline = editor.offsetToBufferPosition(range.startOffset).line
-    val endLogicalPosition = editor.offsetToBufferPosition(range.endOffset)
-    val eline = if (endLogicalPosition.column == 0) max((endLogicalPosition.line - 1).toDouble(), 0.0)
-      .toInt() else endLogicalPosition.line
-    if (range.isMultiple) {
-      val from = editor.offsetToBufferPosition(range.startOffset).column
-      if (dir == 1) {
-        // Right shift blockwise selection
-        val indent = indentConfig.createIndentByCount(count)
-        for (l in sline..eline) {
-          val len = editor.lineLength(l)
-          if (len > from) {
-            val spos = BufferPosition(l, from, false)
-            insertText(editor, caret, spos, indent)
-          }
-        }
-      } else {
-        // Left shift blockwise selection
-        val chars = editor.text()
-        for (l in sline..eline) {
-          val len = editor.lineLength(l)
-          if (len > from) {
-            val spos = BufferPosition(l, from, false)
-            val epos = BufferPosition(l, from + indentConfig.getTotalIndent(count) - 1, false)
-            val wsoff = editor.bufferPositionToOffset(spos)
-            val weoff = editor.bufferPositionToOffset(epos)
-            var pos: Int
-            pos = wsoff
-            while (pos <= weoff) {
-              if (charType(editor, chars[pos], false) !== CharacterHelper.CharacterType.WHITESPACE) {
-                break
-              }
-              pos++
-            }
-            if (pos > wsoff) {
-              deleteText(editor, TextRange(wsoff, pos), null, caret, operatorArguments, true)
-            }
-          }
-        }
-      }
-    } else {
-      // Shift non-blockwise selection
-      for (l in sline..eline) {
-        val soff = editor.getLineStartOffset(l)
-        val eoff = editor.getLineEndOffset(l, true)
-        val woff = injector.motion.moveCaretToLineStartSkipLeading(editor, l)
-        val col = editor.offsetToBufferPosition(woff).column
-        val limit = max(0.0, (col + dir * indentConfig.getTotalIndent(count)).toDouble())
-          .toInt()
-        if (col > 0 || soff != eoff) {
-          val indent = indentConfig.createIndentBySize(limit)
-          replaceText(editor, caret, soff, woff, indent)
-        }
-      }
-    }
-    if (!editor.editor.inInsertMode) {
-      if (!range.isMultiple) {
-        // The caret has moved, so reset the intended column before trying to get the expected offset
-        val newCaret = caret.setVimLastColumnAndGetCaret(intendedColumn)
-        val offset = injector.motion.moveCaretToLineWithStartOfLineOption(editor, sline, caret)
-        newCaret.moveToOffset(offset)
-      } else {
-        caret.moveToOffset(range.startOffset)
-      }
-    }
-  }
-
-  /**
-   * Sort range of text with a given comparator
-   *
-   * @param editor         The editor to replace text in
-   * @param range          The range to sort
-   * @param lineComparator The comparator to use to sort
-   * @param sortOptions     The option to sort the range
-   * @return true if able to sort the text, false if not
-   */
-  override fun sortRange(
-    editor: VimEditor, caret: VimCaret, range: LineRange, lineComparator: Comparator<String>,
-    sortOptions: SortOption,
-  ): Boolean {
-    val startLine = range.startLine
-    val endLine = range.endLine
-    val count = range.size
-    if (count < 2) {
-      return false
-    }
-    val startOffset = editor.getLineStartOffset(startLine)
-    val endOffset = editor.getLineEndOffset(endLine)
-
-    val selectedText = (editor as IjVimEditor).editor.document.getText(TextRangeInterval(startOffset, endOffset))
-    val lines = selectedText.split("\n")
-    val modifiedLines = sortOptions.pattern?.let {
-      if (sortOptions.sortOnPattern) {
-        extractPatternFromLines(editor, lines, startLine, it)
-      } else {
-        deletePatternFromLines(editor, lines, startLine, it)
-      }
-    } ?: lines
-    val sortedLines = lines.zip(modifiedLines)
-      .sortedWith { l1, l2 -> lineComparator.compare(l1.second, l2.second) }
-      .map {it.first}
-      .toMutableList()
-
-    if (sortOptions.unique) {
-      val iterator = sortedLines.iterator()
-      var previous: String? = null
-      while (iterator.hasNext()) {
-        val current = iterator.next()
-        if (current == previous || sortOptions.ignoreCase && current.equals(previous, ignoreCase = true)) {
-          iterator.remove()
-        } else {
-          previous = current
-        }
-      }
-    }
-    if (sortedLines.isEmpty()) {
-      return false
-    }
-    replaceText(editor, caret, startOffset, endOffset, StringUtil.join(sortedLines, "\n"))
-    return true
-  }
-
-  private fun extractPatternFromLines(editor: VimEditor, lines: List<String>, startLine: Int, pattern: String): List<String> {
-    val regex = VimRegex(pattern)
-    return lines.mapIndexed { i: Int, line: String ->
-      val result = regex.findInLine(editor, startLine + i, 0)
-      when (result) {
-        is VimMatchResult.Success -> result.value
-        is VimMatchResult.Failure -> line
-      }
-    }
-  }
-
-  private fun deletePatternFromLines(editor: VimEditor, lines: List<String>, startLine: Int, pattern: String): List<String> {
-    val regex = VimRegex(pattern)
-    return lines.mapIndexed { i: Int, line: String ->
-      val result = regex.findInLine(editor, startLine + i, 0)
-      when (result) {
-        is VimMatchResult.Success -> line.substring(result.value.length, line.length)
-        is VimMatchResult.Failure -> line
-      }
-    }
-  }
-
-  /**
-   * Perform increment and decrement for numbers in visual mode
-   *
-   *
-   * Flag [avalanche] marks if increment (or decrement) should be performed in avalanche mode
-   * (for v_g_Ctrl-A and v_g_Ctrl-X commands)
-   *
-   * @return true
-   */
-  override fun changeNumberVisualMode(
-    editor: VimEditor,
-    caret: VimCaret,
-    selectedRange: TextRange,
-    count: Int,
-    avalanche: Boolean,
-  ): Boolean {
-
-    val nf: List<String> = injector.options(editor).nrformats
-    val alpha = nf.contains("alpha")
-    val hex = nf.contains("hex")
-    val octal = nf.contains("octal")
-    val numberRanges = findNumbersInRange((editor as IjVimEditor).editor, selectedRange, alpha, hex, octal)
-    val newNumbers: MutableList<String?> = ArrayList()
-    for (i in numberRanges.indices) {
-      val numberRange = numberRanges[i]
-      val iCount = if (avalanche) (i + 1) * count else count
-      val newNumber = changeNumberInRange(editor, numberRange, iCount, alpha, hex, octal)
-      newNumbers.add(newNumber)
-    }
-    for (i in newNumbers.indices.reversed()) {
-      // Replace text bottom up. In other direction ranges will be desynchronized after inc numbers like 99
-      val (first) = numberRanges[i]
-      val newNumber = newNumbers[i]
-      replaceText(editor, caret, first.startOffset, first.endOffset, newNumber!!)
-    }
-    (caret as IjVimCaret).caret.moveToInlayAwareOffset(selectedRange.startOffset)
-    return true
-  }
-
-  override fun changeNumber(editor: VimEditor, caret: VimCaret, count: Int): Boolean {
-    val nf: List<String> = injector.options(editor).nrformats
-    val alpha = nf.contains("alpha")
-    val hex = nf.contains("hex")
-    val octal = nf.contains("octal")
-    val range = findNumberUnderCursor((editor as IjVimEditor).editor, (caret as IjVimCaret).caret, alpha, hex, octal)
-    if (range == null) {
-      logger.debug("no number on line")
-      return false
-    }
-    val newNumber = changeNumberInRange(editor, range, count, alpha, hex, octal)
-    return if (newNumber == null) {
-      false
-    } else {
-      replaceText(editor, caret, range.first.startOffset, range.first.endOffset, newNumber)
-      caret.caret.moveToInlayAwareOffset(range.first.startOffset + newNumber.length - 1)
-      true
-    }
-  }
-
-  override fun reset() {
-    strokes.clear()
-    repeatCharsCount = 0
-    if (lastStrokes != null) {
-      lastStrokes!!.clear()
-    }
-  }
-
-  override fun saveStrokes(newStrokes: String?) {
-    val chars = newStrokes!!.toCharArray()
-    strokes.add(chars)
-  }
-
-  private fun changeNumberInRange(
-    editor: VimEditor,
-    range: Pair<TextRange, NumberType>,
-    count: Int,
-    alpha: Boolean,
-    hex: Boolean,
-    octal: Boolean,
-  ): String? {
-    val text = editor.getText(range.first)
-    val numberType = range.second
-    if (logger.isDebugEnabled) {
-      logger.debug("found range $range")
-      logger.debug("text=$text")
-    }
-    var number = text
-    if (text.isEmpty()) {
-      return null
-    }
-    var ch = text[0]
-    if (hex && NumberType.HEX == numberType) {
-      if (!text.lowercase(Locale.getDefault()).startsWith(HEX_START)) {
-        throw RuntimeException("Hex number should start with 0x: $text")
-      }
-      for (i in text.length - 1 downTo 2) {
-        val index = "abcdefABCDEF".indexOf(text[i])
-        if (index >= 0) {
-          lastLower = index < 6
-          break
-        }
-      }
-      var num = BigInteger(text.substring(2), 16)
-      num = num.add(BigInteger.valueOf(count.toLong()))
-      if (num.compareTo(BigInteger.ZERO) < 0) {
-        num = BigInteger(MAX_HEX_INTEGER, 16).add(BigInteger.ONE).add(num)
-      }
-      number = num.toString(16)
-      number = number.padStart(text.length - 2, '0')
-      if (!lastLower) {
-        number = number.uppercase(Locale.getDefault())
-      }
-      number = text.substring(0, 2) + number
-    } else if (octal && NumberType.OCT == numberType && text.length > 1) {
-      if (!text.startsWith("0")) throw RuntimeException("Oct number should start with 0: $text")
-      var num = BigInteger(text, 8).add(BigInteger.valueOf(count.toLong()))
-      if (num.compareTo(BigInteger.ZERO) < 0) {
-        num = BigInteger("1777777777777777777777", 8).add(BigInteger.ONE).add(num)
-      }
-      number = num.toString(8)
-      number = "0" + number.padStart(text.length - 1, '0')
-    } else if (alpha && NumberType.ALPHA == numberType) {
-      if (!Character.isLetter(ch)) throw RuntimeException("Not alpha number : $text")
-      ch += count.toChar().code
-      if (Character.isLetter(ch)) {
-        number = ch.toString()
-      }
-    } else if (NumberType.DEC == numberType) {
-      if (ch != '-' && !Character.isDigit(ch)) throw RuntimeException("Not dec number : $text")
-      var pad = ch == '0'
-      var len = text.length
-      if (ch == '-' && text[1] == '0') {
-        pad = true
-        len--
-      }
-      var num = BigInteger(text)
-      num = num.add(BigInteger.valueOf(count.toLong()))
-      number = num.toString()
-      if (!octal && pad) {
-        var neg = false
-        if (number[0] == '-') {
-          neg = true
-          number = number.substring(1)
-        }
-        number = number.padStart(len, '0')
-        if (neg) {
-          number = "-$number"
-        }
-      }
-    }
-    return number
-  }
-
   fun addInsertListener(listener: VimInsertListener) {
-    insertListeners.add(listener)
+    injector.listenersNotifier.modeChangeListeners.add(listener)
   }
 
+  @Deprecated(message = "Please use listenersNotifier", replaceWith = ReplaceWith("injector.listenersNotifier.modeChangeListeners.remove", imports = ["import com.maddyhome.idea.vim.api.injector"]))
   fun removeInsertListener(listener: VimInsertListener) {
-    insertListeners.remove(listener)
+    injector.listenersNotifier.modeChangeListeners.remove(listener)
-  }
-
-  override fun notifyListeners(editor: VimEditor) {
-    insertListeners.forEach(Consumer { listener: VimInsertListener -> listener.insertModeStarted((editor as IjVimEditor).editor) })
-  }
-
-  @TestOnly
-  override fun resetRepeat() {
-    setInsertRepeat(0, 0, false)
   }
 
   private companion object {

src/main/java/com/maddyhome/idea/vim/group/DigraphGroup.java

@@ -1,78 +0,0 @@
-/*
- * Copyright 2003-2023 The IdeaVim authors
- *
- * Use of this source code is governed by an MIT-style
- * license that can be found in the LICENSE.txt file or at
- * https://opensource.org/licenses/MIT.
- */
-
-package com.maddyhome.idea.vim.group;
-
-import com.intellij.openapi.diagnostic.Logger;
-import com.maddyhome.idea.vim.api.VimDigraphGroupBase;
-import com.maddyhome.idea.vim.api.VimEditor;
-import com.maddyhome.idea.vim.ex.ExOutputModel;
-import com.maddyhome.idea.vim.helper.EditorHelper;
-import com.maddyhome.idea.vim.newapi.IjVimEditor;
-import org.jetbrains.annotations.NotNull;
-
-public class DigraphGroup extends VimDigraphGroupBase {
-
-  public void showDigraphs(@NotNull VimEditor editor) {
-    int width = EditorHelper.getApproximateScreenWidth(((IjVimEditor) editor).getEditor());
-    if (width < 10) {
-      width = 80;
-    }
-    int colCount = width / 12;
-    int height = (int)Math.ceil((double) getDigraphs().size() / (double)colCount);
-
-    if (logger.isDebugEnabled()) {
-      logger.debug("width=" + width);
-      logger.debug("colCount=" + colCount);
-      logger.debug("height=" + height);
-    }
-
-    StringBuilder res = new StringBuilder();
-    int cnt = 0;
-    for (Character code : getKeys().keySet()) {
-      String key = getKeys().get(code);
-
-      res.append(key);
-      res.append(' ');
-      if (code < 32) {
-        res.append('^');
-        res.append((char)(code + '@'));
-      }
-      else if (code >= 128 && code <= 159) {
-        res.append('~');
-        res.append((char)(code - 128 + '@'));
-      }
-      else {
-        res.append(code);
-        res.append(' ');
-      }
-      res.append(' ');
-      if (code < 0x1000) {
-        res.append('0');
-      }
-      if (code < 0x100) {
-        res.append('0');
-      }
-      if (code < 0x10) {
-        res.append('0');
-      }
-      res.append(Integer.toHexString(code));
-      res.append("  ");
-
-      cnt++;
-      if (cnt == colCount) {
-        res.append('\n');
-        cnt = 0;
-      }
-    }
-
-    ExOutputModel.getInstance(((IjVimEditor) editor).getEditor()).output(res.toString());
-  }
-
-  private static final Logger logger = Logger.getInstance(DigraphGroup.class.getName());
-}

src/main/java/com/maddyhome/idea/vim/group/EditorGroup.java

@@ -8,9 +8,7 @@
 
 package com.maddyhome.idea.vim.group;
 
-import com.intellij.execution.impl.ConsoleViewImpl;
 import com.intellij.find.EditorSearchSession;
-import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.client.ClientAppSession;
 import com.intellij.openapi.client.ClientKind;
 import com.intellij.openapi.client.ClientSessionsManager;
@@ -23,12 +21,10 @@ import com.intellij.openapi.editor.event.CaretListener;
 import com.intellij.openapi.editor.ex.EditorEx;
 import com.intellij.openapi.editor.ex.EditorGutterComponentEx;
 import com.intellij.openapi.project.Project;
-import com.maddyhome.idea.vim.KeyHandler;
 import com.maddyhome.idea.vim.VimPlugin;
 import com.maddyhome.idea.vim.api.*;
 import com.maddyhome.idea.vim.ex.ExOutputModel;
 import com.maddyhome.idea.vim.helper.CaretVisualAttributesHelperKt;
-import com.maddyhome.idea.vim.helper.CommandStateHelper;
 import com.maddyhome.idea.vim.helper.EditorHelper;
 import com.maddyhome.idea.vim.helper.UserDataManager;
 import com.maddyhome.idea.vim.newapi.IjVimDocument;
@@ -218,47 +214,10 @@ public class EditorGroup implements PersistentStateComponent<Element>, VimEditor
       editorEx.addPropertyChangeListener(FontSizeChangeListener.INSTANCE);
     }
 
-    // We add Vim bindings to all opened editors, including editors used as UI controls rather than just project file
+    if (injector.getApplication().isUnitTest()) {
-    // editors. This includes editors used as part of the UI, such as the VCS commit message, or used as read-only
-    // viewers for text output, such as log files in run configurations or the Git Console tab. And editors are used for
-    // interactive stdin/stdout for console-based run configurations.
-    // We want to provide an intuitive experience for working with these additional editors, so we automatically switch
-    // to INSERT mode if they are interactive editors. Recognising these can be a bit tricky.
-    // These additional interactive editors are not file-based, but must have a writable document. However, log output
-    // documents are also writable (the IDE is writing new content as it becomes available) just not user-editable. So
-    // we must also check that the editor is not in read-only "viewer" mode (this includes "rendered" mode, which is
-    // read-only and also hides the caret).
-    // Furthermore, interactive stdin/stdout console output in run configurations is hosted in a read-only editor, but
-    // it can still be edited. The `ConsoleViewImpl` class installs a typing handler that ignores the editor's
-    // `isViewer` property and allows typing if the associated process (if any) is still running. We can get the
-    // editor's console view and check this ourselves, but we have to wait until the editor has finished initialising
-    // before it's available in user data.
-    // Finally, we have a special check for diff windows. If we compare against clipboard, we get a diff editor that is
-    // not file based, is writable, and not a viewer, but we don't want to treat this as an interactive editor.
-    // Note that we need a similar check in `VimEditor.isWritable` to allow Escape to work to exit insert mode. We need
-    // to know that a read-only editor that is hosting a console view with a running process can be treated as writable.
-    Runnable switchToInsertMode = () -> {
-      ExecutionContext context = injector.getExecutionContextManager().getEditorExecutionContext(new IjVimEditor(editor));
-      VimPlugin.getChange().insertBeforeCursor(new IjVimEditor(editor), context);
-      KeyHandler.getInstance().reset(new IjVimEditor(editor));
-    };
-    if (!editor.isViewer() &&
-        !EditorHelper.isFileEditor(editor) &&
-        editor.getDocument().isWritable() &&
-        !CommandStateHelper.inInsertMode(editor) &&
-        editor.getEditorKind() != EditorKind.DIFF) {
-      switchToInsertMode.run();
-    }
-    ApplicationManager.getApplication().invokeLater(
-      () -> {
-        if (editor.isDisposed()) return;
-        ConsoleViewImpl consoleView = editor.getUserData(ConsoleViewImpl.CONSOLE_VIEW_IN_EDITOR_VIEW);
-        if (consoleView != null && consoleView.isRunning() && !CommandStateHelper.inInsertMode(editor)) {
-          switchToInsertMode.run();
-        }
-      });
       updateCaretsVisualAttributes(new IjVimEditor(editor));
     }
+  }
 
   public void editorDeinit(@NotNull Editor editor) {
     deinitLineNumbers(editor);
@@ -279,9 +238,8 @@ public class EditorGroup implements PersistentStateComponent<Element>, VimEditor
     VimPlugin.getNotifications(project).notifyAboutIdeaJoin(editor);
   }
 
-  @Nullable
   @Override
-  public Element getState() {
+  public @Nullable Element getState() {
     Element element = new Element("editor");
     saveData(element);
     return element;
@@ -357,18 +315,16 @@ public class EditorGroup implements PersistentStateComponent<Element>, VimEditor
       .collect(Collectors.toList());
   }
 
-  @NotNull
   @Override
-  public Collection<VimEditor> getEditors() {
+  public @NotNull Collection<VimEditor> getEditors() {
     return getLocalEditors()
       .filter(UserDataManager::getVimInitialised)
       .map(IjVimEditor::new)
       .collect(Collectors.toList());
   }
 
-  @NotNull
   @Override
-  public Collection<VimEditor> getEditors(@NotNull VimDocument buffer) {
+  public @NotNull Collection<VimEditor> getEditors(@NotNull VimDocument buffer) {
     final Document document = ((IjVimDocument)buffer).getDocument();
     return getLocalEditors()
       .filter(editor -> UserDataManager.getVimInitialised(editor) && editor.getDocument().equals(document))
@@ -388,7 +344,7 @@ public class EditorGroup implements PersistentStateComponent<Element>, VimEditor
     // events such as document change (to update search highlights), and these can come from CWM guests, and we'd get
     // the remote editors.
     // This invocation will always get local editors, regardless of the current context.
-    List<ClientAppSession> appSessions = ClientSessionsManager.getAppSessions(ClientKind.ALL);
+    List<ClientAppSession> appSessions = ClientSessionsManager.getAppSessions(ClientKind.LOCAL);
     if (!appSessions.isEmpty()) {
       ClientAppSession localSession = appSessions.get(0);
       return localSession.getService(ClientEditorManager.class).editors();
@@ -416,11 +372,15 @@ public class EditorGroup implements PersistentStateComponent<Element>, VimEditor
           // Note that IDE scale is handled by LafManager.lookAndFeelChanged
           VimCommandLine activeCommandLine = injector.getCommandLine().getActiveCommandLine();
           if (activeCommandLine != null) {
-            injector.getProcessGroup().cancelExEntry(new IjVimEditor(editor), false);
+            activeCommandLine.close(true, false);
           }
-          ExOutputModel exOutputModel = ExOutputModel.tryGetInstance(editor);
+          VimOutputPanel outputPanel = injector.getOutputPanel().getCurrentOutputPanel();
-          if (exOutputModel != null) {
+          if (outputPanel != null) {
-            exOutputModel.close();
+            outputPanel.close();
+          }
+          VimModalInput modalInput = injector.getModalInput().getCurrentModalInput();
+          if (modalInput != null) {
+            modalInput.deactivate(true, false);
           }
         }
       }

src/main/java/com/maddyhome/idea/vim/group/FileGroup.kt

@@ -42,7 +42,6 @@ import com.maddyhome.idea.vim.newapi.IjEditorExecutionContext
 import com.maddyhome.idea.vim.newapi.IjVimEditor
 import com.maddyhome.idea.vim.newapi.execute
 import com.maddyhome.idea.vim.newapi.globalIjOptions
-import com.maddyhome.idea.vim.state.VimStateMachine.Companion.getInstance
 import com.maddyhome.idea.vim.state.mode.Mode.VISUAL
 import java.io.File
 import java.util.*
@@ -173,20 +172,20 @@ class FileGroup : VimFileBase() {
   /**
    * Saves specific file in the project.
    */
-  override fun saveFile(context: ExecutionContext) {
+  override fun saveFile(editor: VimEditor, context: ExecutionContext) {
     val action = if (injector.globalIjOptions().ideawrite.contains(IjOptionConstants.ideawrite_all)) {
       injector.nativeActionManager.saveAll
     } else {
       injector.nativeActionManager.saveCurrent
     }
-    action.execute(context)
+    action.execute(editor, context)
   }
 
   /**
    * Saves all files in the project.
    */
-  override fun saveFiles(context: ExecutionContext) {
+  override fun saveFiles(editor: VimEditor, context: ExecutionContext) {
-    injector.nativeActionManager.saveAll.execute(context)
+    injector.nativeActionManager.saveAll.execute(editor, context)
   }
 
   /**
@@ -271,7 +270,7 @@ class FileGroup : VimFileBase() {
     val msg = StringBuilder()
     val doc = editor.document
 
-    if (getInstance(IjVimEditor(editor)).mode !is VISUAL) {
+    if (injector.vimState.mode !is VISUAL) {
       val lp = editor.caretModel.logicalPosition
       val col = editor.caretModel.offset - doc.getLineStartOffset(lp.line)
       var endoff = doc.getLineEndOffset(lp.line)

src/main/java/com/maddyhome/idea/vim/group/HistoryGroup.java

@@ -14,9 +14,7 @@ import com.intellij.openapi.components.State;
 import com.intellij.openapi.components.Storage;
 import com.intellij.openapi.diagnostic.Logger;
 import com.maddyhome.idea.vim.VimPlugin;
-import com.maddyhome.idea.vim.history.HistoryBlock;
+import com.maddyhome.idea.vim.history.*;
-import com.maddyhome.idea.vim.history.HistoryEntry;
-import com.maddyhome.idea.vim.history.VimHistoryBase;
 import org.jdom.Element;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -35,21 +33,20 @@ public class HistoryGroup extends VimHistoryBase implements PersistentStateCompo
     logger.debug("saveData");
     Element hist = new Element("history");
 
-    saveData(hist, SEARCH);
+    for (Type type : getHistories().keySet()) {
-    saveData(hist, COMMAND);
+      saveData(hist, type);
-    saveData(hist, EXPRESSION);
+    }
-    saveData(hist, INPUT);
 
     element.addContent(hist);
   }
 
-  private void saveData(@NotNull Element element, String key) {
+  private void saveData(@NotNull Element element, VimHistory.Type type) {
-    final HistoryBlock block = getHistories().get(key);
+    final HistoryBlock block = getHistories().get(type);
     if (block == null) {
       return;
     }
 
-    final Element root = new Element("history-" + key);
+    final Element root = new Element("history-" + typeToKey(type));
 
     for (HistoryEntry entry : block.getEntries()) {
       final Element entryElement = new Element("entry");
@@ -67,10 +64,10 @@ public class HistoryGroup extends VimHistoryBase implements PersistentStateCompo
       return;
     }
 
-    readData(hist, SEARCH);
+    for (Element child : hist.getChildren()) {
-    readData(hist, COMMAND);
+      String key = child.getName().replace("history-", "");
-    readData(hist, EXPRESSION);
+      readData(hist, key);
-    readData(hist, INPUT);
+    }
   }
 
   private void readData(@NotNull Element element, String key) {
@@ -80,7 +77,7 @@ public class HistoryGroup extends VimHistoryBase implements PersistentStateCompo
     }
 
     block = new HistoryBlock();
-    getHistories().put(key, block);
+    getHistories().put(getTypeForString(key), block);
 
     final Element root = element.getChild("history-" + key);
     if (root != null) {
@@ -94,6 +91,25 @@ public class HistoryGroup extends VimHistoryBase implements PersistentStateCompo
     }
   }
 
+  private String typeToKey(VimHistory.Type type) {
+    if (type instanceof VimHistory.Type.Search) {
+      return SEARCH;
+    }
+    if (type instanceof VimHistory.Type.Command) {
+      return COMMAND;
+    }
+    if (type instanceof VimHistory.Type.Expression) {
+      return EXPRESSION;
+    }
+    if (type instanceof VimHistory.Type.Input) {
+      return INPUT;
+    }
+    if (type instanceof VimHistory.Type.Custom) {
+      return ((Type.Custom) type).getId();
+    }
+    return "unreachable";
+  }
+
   @Nullable
   @Override
   public Element getState() {

src/main/java/com/maddyhome/idea/vim/group/IjVimPsiService.kt

@@ -26,7 +26,7 @@ class IjVimPsiService: VimPsiService {
     val psiFile = PsiHelper.getFile(editor.ij) ?: return null
     val psiElement = psiFile.findElementAt(pos) ?: return null
     val language = psiElement.language
-    val commenter = LanguageCommenters.INSTANCE.forLanguage(language)
+    val commenter = LanguageCommenters.INSTANCE.forLanguage(language) ?: return null
     val psiComment = PsiTreeUtil.getParentOfType(psiElement, PsiComment::class.java, false) ?: return null
     val commentText = psiComment.text
 

src/main/java/com/maddyhome/idea/vim/group/KeyGroup.java

@@ -8,7 +8,6 @@
 
 package com.maddyhome.idea.vim.group;
 
-import com.google.common.collect.ImmutableList;
 import com.intellij.codeInsight.lookup.impl.LookupImpl;
 import com.intellij.openapi.actionSystem.*;
 import com.intellij.openapi.actionSystem.ex.ActionManagerEx;
@@ -17,21 +16,16 @@ import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.components.PersistentStateComponent;
 import com.intellij.openapi.components.State;
 import com.intellij.openapi.components.Storage;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.keymap.Keymap;
 import com.intellij.openapi.keymap.KeymapManager;
 import com.intellij.openapi.keymap.ex.KeymapManagerEx;
+import com.intellij.util.containers.MultiMap;
 import com.maddyhome.idea.vim.EventFacade;
 import com.maddyhome.idea.vim.VimPlugin;
 import com.maddyhome.idea.vim.action.VimShortcutKeyAction;
 import com.maddyhome.idea.vim.action.change.LazyVimCommand;
-import com.maddyhome.idea.vim.api.NativeAction;
+import com.maddyhome.idea.vim.api.*;
-import com.maddyhome.idea.vim.api.VimEditor;
-import com.maddyhome.idea.vim.api.VimInjectorKt;
-import com.maddyhome.idea.vim.api.VimKeyGroupBase;
 import com.maddyhome.idea.vim.command.MappingMode;
-import com.maddyhome.idea.vim.ex.ExOutputModel;
 import com.maddyhome.idea.vim.key.*;
 import com.maddyhome.idea.vim.newapi.IjNativeAction;
 import com.maddyhome.idea.vim.newapi.IjVimEditor;
@@ -61,8 +55,6 @@ public class KeyGroup extends VimKeyGroupBase implements PersistentStateComponen
   private static final @NonNls String OWNER_ATTRIBUTE = "owner";
   private static final String TEXT_ELEMENT = "text";
 
-  private static final Logger logger = Logger.getInstance(KeyGroup.class);
-
   public void registerRequiredShortcutKeys(@NotNull VimEditor editor) {
     EventFacade.getInstance()
       .registerCustomShortcutSet(VimShortcutKeyAction.getInstance(), toShortcutSet(getRequiredShortcutKeys()),
@@ -80,25 +72,6 @@ public class KeyGroup extends VimKeyGroupBase implements PersistentStateComponen
                                                           ((IjVimEditor)editor).getEditor().getComponent());
   }
 
-  public boolean showKeyMappings(@NotNull Set<? extends MappingMode> modes, @NotNull Editor editor) {
-    List<Pair<EnumSet<MappingMode>, MappingInfo>> rows = getKeyMappingRows(modes);
-    final StringBuilder builder = new StringBuilder();
-    for (Pair<EnumSet<MappingMode>, MappingInfo> row : rows) {
-      MappingInfo mappingInfo = row.getSecond();
-      builder.append(StringsKt.padEnd(getModesStringCode(row.getFirst()), 2, ' '));
-      builder.append(" ");
-      builder.append(StringsKt.padEnd(VimInjectorKt.getInjector().getParser().toKeyNotation(mappingInfo.getFromKeys()), 11, ' '));
-      builder.append(" ");
-      builder.append(mappingInfo.isRecursive() ? " " : "*");
-      builder.append(" ");
-      builder.append(mappingInfo.getPresentableString());
-      builder.append("\n");
-    }
-    ExOutputModel.getInstance(editor).output(builder.toString());
-    return true;
-  }
-
-
   @Override
   public void updateShortcutKeysRegistration() {
     for (VimEditor editor : injector.getEditorGroup().getEditors()) {
@@ -221,8 +194,7 @@ public class KeyGroup extends VimKeyGroupBase implements PersistentStateComponen
       registerRequiredShortcut(keyStrokes, MappingOwner.IdeaVim.System.INSTANCE);
 
       for (MappingMode mappingMode : command.getModes()) {
-        Node<LazyVimCommand> node = getKeyRoot(mappingMode);
+        getBuiltinCommandsTrie(mappingMode).add(keyStrokes, command);
-        NodesKt.addLeafs(node, keyStrokes, command);
       }
     }
   }
@@ -247,53 +219,79 @@ public class KeyGroup extends VimKeyGroupBase implements PersistentStateComponen
     return new CustomShortcutSet(shortcuts.toArray(new Shortcut[0]));
   }
 
-  private static @NotNull List<Pair<EnumSet<MappingMode>, MappingInfo>> getKeyMappingRows(@NotNull Set<? extends MappingMode> modes) {
+  private static @NotNull List<Pair<Set<MappingMode>, MappingInfo>> getKeyMappingRows(@NotNull Set<? extends MappingMode> modes,
-    final Map<ImmutableList<KeyStroke>, EnumSet<MappingMode>> actualModes = new HashMap<>();
+                                                                                      @NotNull List<? extends KeyStroke> prefix) {
+    // Some map commands set a mapping for more than one mode (e.g. `map` sets for Normal, Visual, Select and
+    // Op-pending). Vim treats this as a single mapping, and when listing all maps only lists it once, with the
+    // appropriate mode indicator(s) in the first column (NVO is a space char). If the lhs mapping is changed or cleared
+    // for one of the modes, the original mapping is still a single map for the remaining modes, and the indicator
+    // changes. E.g. `map foo bar` followed by `sunmap foo` would result in `nox foo bar` in the output to `map`.
+    // Vim doesn't do automatic grouping - `nmap foo bar` followed by `omap foo bar` and `vmap foo bar` would result in
+    // 3 lines in the output to `map` - one for `n`, one for `o` and one for `v`.
+    // We store mappings separately per mode (to simplify lookup, especially when matching prefixes), but want to have
+    // the same behaviour as Vim in map output. So we store the original modes with the mapping and check they're still
+    // valid as we collect output
+    final List<Pair<Set<MappingMode>, MappingInfo>> rows = new ArrayList<>();
+    final MultiMap<List<? extends KeyStroke>, Set<MappingMode>> multiModeMappings = MultiMap.create();
+    final List<KeyStroke> fromKeys = new ArrayList<>();
+
     for (MappingMode mode : modes) {
       final KeyMapping mapping = VimPlugin.getKey().getKeyMapping(mode);
-      for (List<? extends KeyStroke> fromKeys : mapping) {
+
-        final ImmutableList<KeyStroke> key = ImmutableList.copyOf(fromKeys);
+      final Iterator<KeyMappingEntry> iterator = mapping.getAll(prefix).iterator();
-        final EnumSet<MappingMode> value = actualModes.get(key);
+      while (iterator.hasNext()) {
-        final EnumSet<MappingMode> newValue;
+        final KeyMappingEntry entry = iterator.next();
-        if (value != null) {
+        final MappingInfo mappingInfo = entry.getMappingInfo();
-          newValue = value.clone();
+
-          newValue.add(mode);
+        final Set<@NotNull MappingMode> originalModes = mappingInfo.getOriginalModes();
+        if (originalModes.size() == 1) {
+          rows.add(new Pair<>(originalModes, mappingInfo));
         }
         else {
-          newValue = EnumSet.of(mode);
+          entry.collectPath(fromKeys);
-        }
+          if (!multiModeMappings.get(fromKeys).contains(originalModes)) {
-        actualModes.put(key, newValue);
+            multiModeMappings.putValue(new ArrayList<>(fromKeys), originalModes);
-      }
+            rows.add(new Pair<>(getModesForMapping(fromKeys, originalModes), mappingInfo));
-    }
-    final List<Pair<EnumSet<MappingMode>, MappingInfo>> rows = new ArrayList<>();
-    for (Map.Entry<ImmutableList<KeyStroke>, EnumSet<MappingMode>> entry : actualModes.entrySet()) {
-      final ArrayList<KeyStroke> fromKeys = new ArrayList<>(entry.getKey());
-      final EnumSet<MappingMode> mappingModes = entry.getValue();
-      if (!mappingModes.isEmpty()) {
-        final MappingMode mode = mappingModes.iterator().next();
-        final KeyMapping mapping = VimPlugin.getKey().getKeyMapping(mode);
-        final MappingInfo mappingInfo = mapping.get(fromKeys);
-        if (mappingInfo != null) {
-          rows.add(new Pair<>(mappingModes, mappingInfo));
           }
         }
       }
-    rows.sort(Comparator.comparing(Pair<EnumSet<MappingMode>, MappingInfo>::getSecond));
+    }
+    rows.sort(Comparator.comparing(Pair<Set<MappingMode>, MappingInfo>::getSecond));
     return rows;
   }
 
+  private static @NotNull Set<MappingMode> getModesForMapping(@NotNull List<? extends KeyStroke> keyStrokes,
+                                                              @NotNull Set<MappingMode> originalMappingModes) {
+    final Set<MappingMode> actualModes = EnumSet.noneOf(MappingMode.class);
+    for (MappingMode mode : originalMappingModes) {
+      final MappingInfo mappingInfo = VimPlugin.getKey().getKeyMapping(mode).get(keyStrokes);
+      if (mappingInfo != null && mappingInfo.getOriginalModes() == originalMappingModes) {
+        actualModes.add(mode);
+      }
+    }
+    return actualModes;
+  }
+
   private static @NotNull @NonNls String getModesStringCode(@NotNull Set<MappingMode> modes) {
-    if (modes.equals(MappingMode.NVO)) {
+    if (modes.equals(MappingMode.IC)) return "!";
-      return "";
+    if (modes.equals(MappingMode.NVO)) return " ";
+    if (modes.equals(MappingMode.C)) return "c";
+    if (modes.equals(MappingMode.I)) return "i";
+    //if (modes.equals(MappingMode.L)) return "l";
+
+    // The following modes are concatenated
+    String mode = "";
+    if (modes.containsAll(MappingMode.N)) mode += "n";
+    if (modes.containsAll(MappingMode.O)) mode += "o";
+
+    if (modes.containsAll(MappingMode.V)) {
+      mode += "v";
     }
-    else if (modes.contains(MappingMode.INSERT)) {
+    else {
-      return "i";
+      if (modes.containsAll(MappingMode.X)) mode += "x";
+      if (modes.containsAll(MappingMode.S)) mode += "s";
     }
-    else if (modes.contains(MappingMode.NORMAL)) {
+    return mode;
-      return "n";
-    }
-    // TODO: Add more codes
-    return "";
   }
 
   private @NotNull List<AnAction> getActions(@NotNull Component component, @NotNull KeyStroke keyStroke) {
@@ -357,7 +355,23 @@ public class KeyGroup extends VimKeyGroupBase implements PersistentStateComponen
   }
 
   @Override
-  public boolean showKeyMappings(@NotNull Set<? extends MappingMode> modes, @NotNull VimEditor editor) {
+  public boolean showKeyMappings(@NotNull Set<? extends MappingMode> modes, @NotNull List<? extends KeyStroke> prefix, @NotNull VimEditor editor) {
-    return showKeyMappings(modes, ((IjVimEditor) editor).getEditor());
+    List<Pair<Set<MappingMode>, MappingInfo>> rows = getKeyMappingRows(modes, prefix);
+
+    final StringBuilder builder = new StringBuilder();
+    for (Pair<Set<MappingMode>, MappingInfo> row : rows) {
+      MappingInfo mappingInfo = row.getSecond();
+      builder.append(StringsKt.padEnd(getModesStringCode(row.getFirst()), 3, ' '));
+      builder.append(StringsKt.padEnd(VimInjectorKt.getInjector().getParser().toKeyNotation(mappingInfo.getFromKeys()) + " ", 12, ' '));
+      builder.append(mappingInfo.isRecursive() ? " " : "*");  // Or `&` if script-local mappings being recursive
+      builder.append(" ");  // Should be `@` if it's a buffer-local mapping
+      builder.append(mappingInfo.getPresentableString());
+      builder.append("\n");
+    }
+
+    VimOutputPanel outputPanel = injector.getOutputPanel().getOrCreate(editor, injector.getExecutionContextManager().getEditorExecutionContext(editor));
+    outputPanel.addText(builder.toString(), true);
+    outputPanel.show();
+    return true;
   }
 }

src/main/java/com/maddyhome/idea/vim/group/MotionGroup.kt

@@ -35,7 +35,7 @@ import com.maddyhome.idea.vim.command.Argument
 import com.maddyhome.idea.vim.command.MotionType
 import com.maddyhome.idea.vim.command.OperatorArguments
 import com.maddyhome.idea.vim.common.TextRange
-import com.maddyhome.idea.vim.ex.ExOutputModel
+import com.maddyhome.idea.vim.handler.ExternalActionHandler
 import com.maddyhome.idea.vim.handler.Motion
 import com.maddyhome.idea.vim.handler.Motion.AbsoluteOffset
 import com.maddyhome.idea.vim.handler.MotionActionHandler
@@ -47,12 +47,14 @@ import com.maddyhome.idea.vim.helper.getNormalizedScrollOffset
 import com.maddyhome.idea.vim.helper.getNormalizedSideScrollOffset
 import com.maddyhome.idea.vim.helper.isEndAllowed
 import com.maddyhome.idea.vim.helper.vimLastColumn
-import com.maddyhome.idea.vim.helper.vimStateMachine
+import com.maddyhome.idea.vim.impl.state.VimStateMachineImpl
 import com.maddyhome.idea.vim.listener.AppCodeTemplates
 import com.maddyhome.idea.vim.newapi.IjEditorExecutionContext
 import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.newapi.vim
 import com.maddyhome.idea.vim.state.mode.Mode
+import com.maddyhome.idea.vim.state.mode.ReturnTo
+import com.maddyhome.idea.vim.state.mode.returnTo
 import org.jetbrains.annotations.Range
 import kotlin.math.max
 import kotlin.math.min
@@ -191,21 +193,16 @@ internal class MotionGroup : VimMotionGroupBase() {
       argument: Argument,
       operatorArguments: OperatorArguments,
     ): TextRange? {
+      if (argument !is Argument.Motion) {
+        throw RuntimeException("Unexpected argument passed to getMotionRange2: $argument")
+      }
+
       var start: Int
       var end: Int
-      if (argument.type === Argument.Type.OFFSETS) {
-        val offsets = argument.offsets[caret.vim] ?: return null
-        val (first, second) = offsets.getNativeStartAndEnd()
-        start = first
-        end = second
-      } else {
-        val cmd = argument.motion
-        // Normalize the counts between the command and the motion argument
-        val cnt = cmd.count * operatorArguments.count1
-        val raw = if (operatorArguments.count0 == 0 && cmd.rawCount == 0) 0 else cnt
-        if (cmd.action is MotionActionHandler) {
-          val action = cmd.action as MotionActionHandler
 
+      val action = argument.motion
+      when (action) {
+        is MotionActionHandler -> {
           // This is where we are now
           start = caret.offset
 
@@ -214,8 +211,8 @@ internal class MotionGroup : VimMotionGroupBase() {
             editor.vim,
             caret.vim,
             IjEditorExecutionContext(context!!),
-            cmd.argument,
+            argument.argument,
-            operatorArguments.withCount0(raw),
+            operatorArguments
           )
 
           // Invalid motion
@@ -231,22 +228,32 @@ internal class MotionGroup : VimMotionGroupBase() {
               end++
             }
           }
-        } else if (cmd.action is TextObjectActionHandler) {
+        }
-          val action = cmd.action as TextObjectActionHandler
+
-          val range =
+        is TextObjectActionHandler -> {
-            action.getRange(editor.vim, caret.vim, IjEditorExecutionContext(context!!), cnt, raw) ?: return null
+          val range = action.getRange(
+            editor.vim,
+            caret.vim,
+            IjEditorExecutionContext(context!!),
+            operatorArguments.count1,
+            operatorArguments.count0
+          ) ?: return null
           start = range.startOffset
           end = range.endOffset
-          if (cmd.isLinewiseMotion()) end--
+          if (argument.isLinewiseMotion()) end--
-        } else {
-          throw RuntimeException(
-            "Commands doesn't take " + cmd.action.javaClass.simpleName + " as an operator",
-          )
         }
+
+        is ExternalActionHandler -> {
+          val range = action.getRange(caret.vim) ?: return null
+          start = range.startOffset
+          end = range.endOffset
+        }
+
+        else -> throw RuntimeException("Commands doesn't take " + action.javaClass.simpleName + " as an operator")
       }
 
       // This is a kludge for dw, dW, and d[w. Without this kludge, an extra newline is operated when it shouldn't be.
-      val id = argument.motion.action.id
+      val id = argument.motion.id
       if (id == VimChangeGroupBase.VIM_MOTION_WORD_RIGHT || id == VimChangeGroupBase.VIM_MOTION_BIG_WORD_RIGHT || id == VimChangeGroupBase.VIM_MOTION_CAMEL_RIGHT) {
         val text = editor.document.charsSequence.subSequence(start, end).toString()
         val lastNewLine = text.lastIndexOf('\n')
@@ -256,6 +263,7 @@ internal class MotionGroup : VimMotionGroupBase() {
           }
         }
       }
+
       return TextRange(start, end)
     }
 
@@ -307,19 +315,32 @@ internal class MotionGroup : VimMotionGroupBase() {
         val editor = fileEditor.editor
         if (!editor.isDisposed) {
           editor.vim.let { vimEditor ->
-            when (vimEditor.vimStateMachine.mode) {
+            when (vimEditor.mode) {
               is Mode.VISUAL -> {
                 vimEditor.exitVisualMode()
                 KeyHandler.getInstance().reset(vimEditor)
               }
               is Mode.CMD_LINE -> {
-                injector.processGroup.cancelExEntry(vimEditor, false)
+                val commandLine = injector.commandLine.getActiveCommandLine() ?: return
-                ExOutputModel.tryGetInstance(editor)?.close()
+                commandLine.close(refocusOwningEditor = false, resetCaret = false)
+                injector.outputPanel.getCurrentOutputPanel()?.close()
               }
               else -> {}
             }
           }
         }
+      } else {
+        val state = injector.vimState as VimStateMachineImpl
+        if (state.mode is Mode.VISUAL) {
+          val returnTo = state.mode.returnTo
+          when (returnTo) {
+            ReturnTo.INSERT -> state.mode = Mode.INSERT
+            ReturnTo.REPLACE -> state.mode = Mode.REPLACE
+            null -> state.mode = Mode.NORMAL()
+          }
+        }
+        val keyHandler = KeyHandler.getInstance()
+        KeyHandler.getInstance().reset(keyHandler.keyHandlerState, state.mode)
       }
     }
   }

src/main/java/com/maddyhome/idea/vim/group/NotificationService.kt

@@ -62,6 +62,25 @@ internal class NotificationService(private val project: Project?) {
   @Suppress("unused")
   constructor() : this(null)
 
+  fun notifyAboutNewUndo() {
+    val notification = Notification(
+      IDEAVIM_NOTIFICATION_ID,
+      "Undo in IdeaVim now works like in Vim",
+      """
+        Caret movement is no longer a separate undo step, and full insert is undoable in one step.
+      """.trimIndent(),
+      NotificationType.INFORMATION,
+    )
+
+    notification.addAction(object : DumbAwareAction("Share Feedback") {
+      override fun actionPerformed(p0: AnActionEvent) {
+        BrowserUtil.browse("https://youtrack.jetbrains.com/issue/VIM-547/Undo-splits-Insert-mode-edits-into-separate-undo-chunks")
+      }
+    })
+
+    notification.notify(project)
+  }
+
   fun notifyAboutIdeaPut() {
     val notification = Notification(
       IDEAVIM_NOTIFICATION_ID,
@@ -182,8 +201,8 @@ internal class NotificationService(private val project: Project?) {
     ).notify(project)
   }
 
-  fun notifyActionId(id: String?) {
+  fun notifyActionId(id: String?, candidates: List<String>? = null) {
-    ActionIdNotifier.notifyActionId(id, project)
+    ActionIdNotifier.notifyActionId(id, project, candidates)
   }
 
   fun notifyKeymapIssues(issues: ArrayList<KeyMapIssue>) {
@@ -259,20 +278,31 @@ internal class NotificationService(private val project: Project?) {
 
   object ActionIdNotifier {
     private var notification: Notification? = null
-    private const val NO_ID = "<i>Cannot detect action id</i>"
 
-    fun notifyActionId(id: String?, project: Project?) {
+    fun notifyActionId(id: String?, project: Project?, candidates: List<String>? = null) {
       notification?.expire()
 
-      val content = if (id != null) "Action id: $id" else NO_ID
+      val possibleIDs = candidates?.distinct()?.sorted()
-      Notification(IDEAVIM_NOTIFICATION_ID, IDEAVIM_NOTIFICATION_TITLE, content, NotificationType.INFORMATION).let {
+      val content = when {
-        notification = it
+        id != null -> "Action ID: <code>$id</code><br><br>"
-        it.whenExpired { notification = null }
+        possibleIDs.isNullOrEmpty() -> "<i>Cannot detect action ID</i><br><br>"
-        it.setContent(it.content + "<br><br><small>Use ${ActionCenter.getToolwindowName()} to see previous ids</small>")
+        possibleIDs.size == 1 -> "Possible action ID: <code>${possibleIDs[0]}</code><br><br>"
+        else -> {
+          buildString {
+            append("<p>Multiple possible action IDs. Candidates include:<ul>")
+            possibleIDs.forEach { append("<li><code>$it</code></li>") }
+            append("</ul></p>")
+          }
+        }
+      } + "<small>See the ${ActionCenter.getToolwindowName()} tool window for previous IDs</small>"
 
+      notification = Notification(IDEAVIM_NOTIFICATION_ID, IDEAVIM_NOTIFICATION_TITLE, content, NotificationType.INFORMATION).also {
+        it.whenExpired { notification = null }
         it.addAction(StopTracking())
 
-        if (id != null) it.addAction(CopyActionId(id, project))
+        if (id != null || possibleIDs?.size == 1) {
+          it.addAction(CopyActionId(id ?: possibleIDs?.get(0), project))
+        }
 
         it.notify(project)
       }

src/main/java/com/maddyhome/idea/vim/group/OptionGroup.kt

@@ -12,6 +12,7 @@ import com.intellij.application.options.CodeStyle
 import com.intellij.codeStyle.AbstractConvertLineSeparatorsAction
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.editor.EditorKind
 import com.intellij.openapi.editor.EditorSettings.LineNumerationType
 import com.intellij.openapi.editor.ScrollPositionCalculator
@@ -19,8 +20,6 @@ import com.intellij.openapi.editor.ex.EditorEx
 import com.intellij.openapi.editor.ex.EditorSettingsExternalizable
 import com.intellij.openapi.editor.impl.softwrap.SoftWrapAppliancePlaces
 import com.intellij.openapi.fileEditor.FileDocumentManager
-import com.intellij.openapi.fileEditor.FileEditorManagerEvent
-import com.intellij.openapi.fileEditor.TextEditor
 import com.intellij.openapi.fileEditor.impl.LoadTextUtil
 import com.intellij.openapi.fileEditor.impl.text.TextEditorImpl
 import com.intellij.openapi.project.Project
@@ -158,25 +157,24 @@ internal class OptionGroup : VimOptionGroupBase(), IjVimOptionGroup, InternalOpt
   }
 
   companion object {
-    fun fileEditorManagerSelectionChangedCallback(event: FileEditorManagerEvent) {
+    fun editorReleased(editor: Editor) {
-      // Vim only has one window, and it's not possible to close it. This means that editing a new file will always
+      // Vim always has at least one window; it's not possible to close it. Editing a new file will open a new buffer in
-      // reuse an existing window (opening a new window will always open from an existing window). More importantly,
+      // the current window, or it's possible to split the current buffer into a new window, or open a new buffer in a
-      // this means that any newly edited file will always get up-to-date local-to-window options. A new window is based
+      // new window. This is important for us because when Vim opens a new window, the new window's local options are
-      // on the opening window (treated as split then edit, so copy local + per-window "global" window values, then
+      // copied from the current window.
-      // apply the per-window "global" values) and an edit reapplies the per-window "global" values.
+      // In detail: splitting the current window gets a complete copy of local and per-window global option values.
-      // If we close all windows, and open a new one, we can only use the per-window "global" values from the fallback
+      // Editing a new file will split the current window and then edit the new buffer in-place.
-      // window, but this is only initialised when we first read `~/.ideavimrc` during startup. Vim would use the values
+      // IntelliJ does not always have an open window. It would be weird to close the last editor tab, and then open
-      // from the current window, so to simulate this, we should update the fallback window with the values from the
+      // the next tab with different options - the user would expect the editor to look like the last one did.
-      // window that was selected at the time that the last window was closed.
+      // Therefore, we have a dummy "fallback" window that captures the options of the last closed editor. When opening
-      // Unfortunately, we can't reliably know if a closing editor is the selected editor. Instead, we rely on selection
+      // an editor and there are no currently open editors, we use the fallback window to initialise the new window.
-      // change events. If an editor is losing selection and there is no new selection, we can assume this means that
+      // This callback tracks when editors are closed, and if the last editor in a project is being closed, updates the
-      // the last editor has been closed, and use the closed editor to update the fallback window
+      // fallback window's options.
-      //
+      val project = editor.project ?: return
-      // XXX: event.oldEditor will must probably return a disposed editor. So, it should be treated with care
+      if (!injector.editorGroup.getEditorsRaw()
-      if (event.newEditor == null) {
+          .any { it.ij != editor && it.ij.project === project && it.ij.editorKind == EditorKind.MAIN_EDITOR }
-        (event.oldEditor as? TextEditor)?.editor?.let {
+      ) {
-          (VimPlugin.getOptionGroup() as OptionGroup).updateFallbackWindow(injector.fallbackWindow, it.vim)
+        (VimPlugin.getOptionGroup() as OptionGroup).updateFallbackWindow(injector.fallbackWindow, editor.vim)
-        }
       }
     }
   }

src/main/java/com/maddyhome/idea/vim/group/ProcessGroup.kt

@@ -95,8 +95,6 @@ class ProcessGroup : VimProcessGroupBase() {
         val progressIndicator = ProgressIndicatorProvider.getInstance().progressIndicator
         val output = handler.runProcessWithProgressIndicator(progressIndicator)
 
-        lastCommand = command
-
         if (output.isCancelled) {
           // TODO: Vim will use whatever text has already been written to stdout
           // For whatever reason, we're not getting any here, so just throw an exception

src/main/java/com/maddyhome/idea/vim/group/RegisterGroup.java

@@ -14,6 +14,7 @@ import com.intellij.openapi.components.State;
 import com.intellij.openapi.components.Storage;
 import com.intellij.openapi.diagnostic.Logger;
 import com.maddyhome.idea.vim.VimPlugin;
+import com.maddyhome.idea.vim.newapi.IjVimInjectorKt;
 import com.maddyhome.idea.vim.register.Register;
 import com.maddyhome.idea.vim.register.VimRegisterGroupBase;
 import com.maddyhome.idea.vim.state.mode.SelectionType;
@@ -35,6 +36,10 @@ import java.util.List;
 })
 public class RegisterGroup extends VimRegisterGroupBase implements PersistentStateComponent<Element> {
 
+  static {
+    IjVimInjectorKt.initInjector();
+  }
+
   private static final Logger logger = Logger.getInstance(RegisterGroup.class);
 
   public RegisterGroup() {

src/main/java/com/maddyhome/idea/vim/group/VimJumpServiceImpl.kt

@@ -25,6 +25,7 @@ import com.maddyhome.idea.vim.mark.Jump
 import com.maddyhome.idea.vim.newapi.IjVimEditor
 import com.maddyhome.idea.vim.newapi.globalIjOptions
 import com.maddyhome.idea.vim.newapi.ij
+import com.maddyhome.idea.vim.newapi.initInjector
 import org.jdom.Element
 
 @State(name = "VimJumpsSettings", storages = [Storage(value = "\$APP_CONFIG$/vim_settings_local.xml", roamingType = RoamingType.DISABLED)])
@@ -65,6 +66,7 @@ internal class VimJumpServiceImpl : VimJumpServiceBase(), PersistentStateCompone
   }
 
   override fun loadState(state: Element) {
+    initInjector()
     val projectElements = state.getChildren("project")
     for (projectElement in projectElements) {
       val jumps = mutableListOf<Jump>()
@@ -89,6 +91,7 @@ internal class VimJumpServiceImpl : VimJumpServiceBase(), PersistentStateCompone
 
 internal class JumpsListener(val project: Project) : RecentPlacesListener {
   override fun recentPlaceAdded(changePlace: PlaceInfo, isChanged: Boolean) {
+    initInjector()
     if (!injector.globalIjOptions().unifyjumps) return
     
     val jumpService = injector.jumpService

src/main/java/com/maddyhome/idea/vim/group/VimMarkServiceImpl.kt

@@ -7,7 +7,6 @@
  */
 package com.maddyhome.idea.vim.group
 
-import com.intellij.codeWithMe.ClientId
 import com.intellij.ide.bookmark.Bookmark
 import com.intellij.ide.bookmark.BookmarkGroup
 import com.intellij.ide.bookmark.BookmarksListener

src/main/java/com/maddyhome/idea/vim/group/copy/PutGroup.kt

@@ -46,10 +46,13 @@ import com.maddyhome.idea.vim.put.PutData
 import com.maddyhome.idea.vim.put.VimPasteProvider
 import com.maddyhome.idea.vim.put.VimPutBase
 import com.maddyhome.idea.vim.register.RegisterConstants
+import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.state.mode.SelectionType
 import com.maddyhome.idea.vim.state.mode.isBlock
 import com.maddyhome.idea.vim.state.mode.isChar
 import com.maddyhome.idea.vim.state.mode.isLine
+import com.maddyhome.idea.vim.undo.VimKeyBasedUndoService
+import com.maddyhome.idea.vim.undo.VimTimestampBasedUndoService
 import java.awt.datatransfer.DataFlavor
 
 @Service
@@ -83,11 +86,17 @@ internal class PutGroup : VimPutBase() {
     val editor = (vimEditor as IjVimEditor).editor
     val context = vimContext.context as DataContext
     val carets: MutableMap<Caret, RangeMarker> = mutableMapOf()
-    if (editor.isInsertMode) {
+    if (injector.vimState.mode is Mode.INSERT) {
-      val undo = injector.undo
       val nanoTime = System.nanoTime()
+
+      val undo = injector.undo
+      when (undo) {
+        is VimKeyBasedUndoService -> undo.setInsertNonMergeUndoKey()
+        is VimTimestampBasedUndoService -> {
           vimEditor.forEachCaret { undo.startInsertSequence(it, it.offset, nanoTime) }
         }
+      }
+    }
     EditorHelper.getOrderedCaretsList(editor).forEach { caret ->
       val startOffset =
         prepareDocumentAndGetStartOffsets(

src/main/java/com/maddyhome/idea/vim/group/visual/IdeaSelectionControl.kt

@@ -8,6 +8,7 @@
 
 package com.maddyhome.idea.vim.group.visual
 
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.diagnostic.trace
 import com.intellij.openapi.editor.Editor
@@ -15,6 +16,8 @@ import com.maddyhome.idea.vim.KeyHandler
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.api.options
+import com.maddyhome.idea.vim.group.visual.IdeaSelectionControl.controlNonVimSelectionChange
+import com.maddyhome.idea.vim.group.visual.IdeaSelectionControl.predictMode
 import com.maddyhome.idea.vim.helper.exitSelectMode
 import com.maddyhome.idea.vim.helper.exitVisualMode
 import com.maddyhome.idea.vim.helper.hasVisualSelection
@@ -63,12 +66,15 @@ internal object IdeaSelectionControl {
       //  - There was no selection and now it is
       //  - There was a selection and now it doesn't exist
       //  - There was a selection and now it exists as well (transforming char selection to line selection, for example)
-      if (initialMode?.hasVisualSelection == false && !editor.selectionModel.hasSelection(true)) {
+      val hasSelection = ApplicationManager.getApplication().runReadAction<Boolean> {
+        editor.selectionModel.hasSelection(true)
+      }
+      if (initialMode?.hasVisualSelection == false && !hasSelection) {
         logger.trace { "Exiting without selection adjusting" }
         return@singleTask
       }
 
-      if (editor.selectionModel.hasSelection(true)) {
+      if (hasSelection) {
         if (editor.vim.inCommandLineMode && editor.vim.mode.returnTo().hasVisualSelection) {
           logger.trace { "Modifying selection while in Command-line mode, most likely incsearch" }
           return@singleTask

src/main/java/com/maddyhome/idea/vim/group/visual/VimVisualTimer.kt

@@ -9,8 +9,6 @@
 package com.maddyhome.idea.vim.group.visual
 
 import com.maddyhome.idea.vim.api.injector
-import com.maddyhome.idea.vim.group.visual.VimVisualTimer.mode
-import com.maddyhome.idea.vim.group.visual.VimVisualTimer.singleTask
 import com.maddyhome.idea.vim.newapi.globalIjOptions
 import com.maddyhome.idea.vim.state.mode.Mode
 import java.awt.event.ActionEvent

src/main/java/com/maddyhome/idea/vim/handler/EditorHandlersChainLogger.kt

@@ -16,6 +16,7 @@ import com.intellij.openapi.keymap.ex.KeymapManagerEx
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.startup.ProjectActivity
 import com.maddyhome.idea.vim.api.key
+import com.maddyhome.idea.vim.newapi.initInjector
 
 /**
  * Logs the chain of handlers for esc and enter
@@ -34,6 +35,8 @@ internal class EditorHandlersChainLogger : ProjectActivity {
   private val editorHandlers = ExtensionPointName<EditorActionHandlerBean>("com.intellij.editorActionHandler")
 
   override suspend fun execute(project: Project) {
+    initInjector()
+
     if (!enableOctopus) return
 
     val escHandlers = editorHandlers.extensionList

src/main/java/com/maddyhome/idea/vim/handler/IdeActionHandler.kt

@@ -19,7 +19,7 @@ import com.maddyhome.idea.vim.command.OperatorArguments
  */
 internal abstract class IdeActionHandler(private val actionName: String) : VimActionHandler.SingleExecution() {
   override fun execute(editor: VimEditor, context: ExecutionContext, cmd: Command, operatorArguments: OperatorArguments): Boolean {
-    injector.actionExecutor.executeAction(actionName, context)
+    injector.actionExecutor.executeAction(editor, name = actionName, context = context)
     injector.scroll.scrollCaretIntoView(editor)
     return true
   }

src/main/java/com/maddyhome/idea/vim/handler/VimEnterHandler.kt

@@ -183,6 +183,7 @@ internal abstract class OctopusHandler(private val nextHandler: EditorActionHand
  * - App code - set handler after
  * - Template - doesn't intersect with enter anymore
  * - rd.client.editor.enter - set handler before. Otherwise, rider will add new line on enter even in normal mode
+ * - inline.completion.enter - set handler before. Otherwise, AI completion is not invoked on enter.
  *
  * This rule is disabled due to VIM-3124
  * - before terminalEnter - not necessary, but terminalEnter causes "file is read-only" tooltip for readonly files VIM-3122
@@ -218,13 +219,17 @@ internal class VimEnterHandler(nextHandler: EditorActionHandler?) : VimKeyHandle
 internal class VimEscHandler(nextHandler: EditorActionHandler) : VimKeyHandler(nextHandler) {
   override val key: String = "<Esc>"
 
-  override fun isHandlerEnabled(editor: Editor, dataContext: DataContext?): Boolean {
+  private val ideaVimSupportDialog
-    val ideaVimSupportDialog =
+    get() = injector.globalIjOptions().ideavimsupport.contains(IjOptionConstants.ideavimsupport_dialog)
-      injector.globalIjOptions().ideavimsupport.contains(IjOptionConstants.ideavimsupport_dialog)
   
+  override fun isHandlerEnabled(editor: Editor, dataContext: DataContext?): Boolean {
     return editor.isPrimaryEditor() ||
-      EditorHelper.isFileEditor(editor) && !editor.vim.mode.inNormalMode ||
+      EditorHelper.isFileEditor(editor) && vimStateNeedsToHandleEscape(editor) ||
-      ideaVimSupportDialog && !editor.vim.mode.inNormalMode
+      ideaVimSupportDialog && vimStateNeedsToHandleEscape(editor)
+  }
+  
+  private fun vimStateNeedsToHandleEscape(editor: Editor): Boolean {
+    return !editor.vim.mode.inNormalMode || KeyHandler.getInstance().keyHandlerState.mappingState.hasKeys
   }
 }
 

src/main/java/com/maddyhome/idea/vim/helper/CaretVisualAttributesHelper.kt

@@ -19,6 +19,7 @@ import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.globalOptions
 import com.maddyhome.idea.vim.api.injector
+import com.maddyhome.idea.vim.common.EditorListener
 import com.maddyhome.idea.vim.common.IsReplaceCharListener
 import com.maddyhome.idea.vim.common.ModeChangeListener
 import com.maddyhome.idea.vim.newapi.IjVimEditor
@@ -73,7 +74,7 @@ internal object GuicursorChangeListener : EffectiveOptionValueChangeListener {
 }
 
 private fun Editor.guicursorMode(): GuiCursorMode {
-  return GuiCursorMode.fromMode(vim.mode, vim.vimStateMachine.isReplaceCharacter)
+  return GuiCursorMode.fromMode(vim.mode, injector.vimState.isReplaceCharacter)
 }
 
 /**
@@ -86,6 +87,7 @@ private fun isBlockCursorOverride() = EditorSettingsExternalizable.getInstance()
 
 private fun Editor.updatePrimaryCaretVisualAttributes() {
   if (VimPlugin.isNotEnabled()) thisLogger().error("The caret attributes should not be updated if the IdeaVim is disabled")
+  if (isIdeaVimDisabledHere) return
   caretModel.primaryCaret.visualAttributes = AttributesCache.getCaretVisualAttributes(this)
 
   // Make sure the caret is visible as soon as it's set. It might be invisible while blinking
@@ -99,6 +101,7 @@ private fun Editor.updatePrimaryCaretVisualAttributes() {
 
 private fun Editor.updateSecondaryCaretsVisualAttributes() {
   if (VimPlugin.isNotEnabled()) thisLogger().error("The caret attributes should not be updated if the IdeaVim is disabled")
+  if (isIdeaVimDisabledHere) return
   // IntelliJ simulates visual block with multiple carets with selections. Do our best to hide them
   val attributes = if (this.vim.inBlockSelection) HIDDEN else AttributesCache.getCaretVisualAttributes(this)
   this.caretModel.allCarets.forEach {
@@ -144,7 +147,7 @@ private object AttributesCache {
 @TestOnly
 internal fun getGuiCursorMode(editor: Editor) = editor.guicursorMode()
 
-class CaretVisualAttributesListener : IsReplaceCharListener, ModeChangeListener {
+class CaretVisualAttributesListener : IsReplaceCharListener, ModeChangeListener, EditorListener {
   override fun isReplaceCharChanged(editor: VimEditor) {
     updateCaretsVisual(editor)
   }
@@ -153,21 +156,19 @@ class CaretVisualAttributesListener : IsReplaceCharListener, ModeChangeListener
     updateCaretsVisual(editor)
   }
 
+  override fun focusGained(editor: VimEditor) {
+    updateCaretsVisual(editor)
+  }
+
   private fun updateCaretsVisual(editor: VimEditor) {
-    if (injector.globalOptions().ideaglobalmode) {
-      updateAllEditorsCaretsVisual()
-    } else {
     val ijEditor = (editor as IjVimEditor).editor
     ijEditor.updateCaretsVisualAttributes()
     ijEditor.updateCaretsVisualPosition()
   }
-  }
 
   fun updateAllEditorsCaretsVisual() {
     injector.editorGroup.getEditors().forEach { editor ->
-      val ijEditor = (editor as IjVimEditor).editor
+      updateCaretsVisual(editor)
-      ijEditor.updateCaretsVisualAttributes()
-      ijEditor.updateCaretsVisualPosition()
     }
   }
 }

src/main/java/com/maddyhome/idea/vim/helper/CommandStateExtensions.kt

@@ -34,4 +34,4 @@ val Editor.inVisualMode: Boolean
 
 @get:JvmName("inExMode")
 internal val Editor.inExMode
-  get() = this.vim.vimStateMachine.mode is Mode.CMD_LINE
+  get() = this.vim.mode is Mode.CMD_LINE

src/main/java/com/maddyhome/idea/vim/helper/EditorHelper.java

@@ -157,6 +157,19 @@ public class EditorHelper {
     return (int)(getVisibleArea(editor).width / getPlainSpaceWidthFloat(editor));
   }
 
+  /**
+   * Gets the number of characters that can be fit inside the output panel for an editor.
+   * <p>
+   * This will be greater than the approximate screen width as it also includes any gutter components in the editor.
+   * </p>
+   *
+   * @param editor The editor
+   * @return The approximate number of columns that can fit in the output panel
+   */
+  public static int getApproximateOutputPanelWidth(final @NotNull Editor editor) {
+    return (int)(editor.getComponent().getWidth() / getPlainSpaceWidthFloat(editor));
+  }
+
   /**
    * Gets the width of the space character in the editor's plain font as a float.
    * <p>
@@ -273,7 +286,7 @@ public class EditorHelper {
 
     // Scroll the given visual line to the caret location, but do not scroll down passed the end of file, or the current
     // virtual space at the bottom of the screen
-    @NotNull final VimEditor editor1 = new IjVimEditor(editor);
+    final @NotNull VimEditor editor1 = new IjVimEditor(editor);
     final int lastVisualLine = EngineEditorHelperKt.getVisualLineCount(editor1) - 1;
     final int yBottomLineOffset = max(getOffsetToScrollVisualLineToBottomOfScreen(editor, lastVisualLine), visibleArea.y);
     scrollVertically(editor, min(yVisualLine - caretScreenOffset - inlayOffset, yBottomLineOffset));
@@ -325,7 +338,7 @@ public class EditorHelper {
     final int lineHeight = editor.getLineHeight();
 
     final int offset = y - ((screenHeight - lineHeight) / lineHeight / 2 * lineHeight);
-    @NotNull final VimEditor editor1 = new IjVimEditor(editor);
+    final @NotNull VimEditor editor1 = new IjVimEditor(editor);
     final int lastVisualLine = EngineEditorHelperKt.getVisualLineCount(editor1) + editor.getSettings().getAdditionalLinesCount();
     final int offsetForLastLineAtBottom = getOffsetToScrollVisualLineToBottomOfScreen(editor, lastVisualLine);
 
@@ -379,7 +392,7 @@ public class EditorHelper {
     return 0;
   }
 
-  private static int getHorizontalScrollbarHeight(@NotNull final Editor editor) {
+  private static int getHorizontalScrollbarHeight(final @NotNull Editor editor) {
     // Horizontal scrollbars on macOS are either transparent AND auto-hide, so we don't need to worry about obscured
     // text, or always visible, opaque and outside the content area, so we don't need to adjust for them
     // Transparent scrollbars on Windows and Linux are overlays on the editor content area, and always visible. That
@@ -462,7 +475,7 @@ public class EditorHelper {
    */
   public static Pair<Boolean, Integer> scrollFullPageDown(final @NotNull Editor editor, int pages) {
     final Rectangle visibleArea = getVisibleArea(editor);
-    @NotNull final VimEditor editor2 = new IjVimEditor(editor);
+    final @NotNull VimEditor editor2 = new IjVimEditor(editor);
     final int lastVisualLine = EngineEditorHelperKt.getVisualLineCount(editor2) - 1;
 
     int y = visibleArea.y + visibleArea.height;
@@ -480,7 +493,7 @@ public class EditorHelper {
           caretVisualLine = lastVisualLine;
         }
         else {
-          @NotNull final VimEditor editor1 = new IjVimEditor(editor);
+          final @NotNull VimEditor editor1 = new IjVimEditor(editor);
           caretVisualLine = EngineEditorHelperKt.getVisualLineCount(editor1) - 1;
           completed = false;
         }
@@ -515,7 +528,7 @@ public class EditorHelper {
   public static Pair<Boolean, Integer> scrollFullPageUp(final @NotNull Editor editor, int pages) {
     final Rectangle visibleArea = getVisibleArea(editor);
     final int lineHeight = editor.getLineHeight();
-    @NotNull final VimEditor editor1 = new IjVimEditor(editor);
+    final @NotNull VimEditor editor1 = new IjVimEditor(editor);
     final int lastVisualLine = EngineEditorHelperKt.getVisualLineCount(editor1) - 1;
 
     int y = visibleArea.y;

src/main/java/com/maddyhome/idea/vim/helper/IjActionExecutor.kt

@@ -13,23 +13,23 @@ import com.intellij.openapi.actionSystem.ActionManager
 import com.intellij.openapi.actionSystem.ActionPlaces
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.AnActionEvent
-import com.intellij.openapi.actionSystem.AnActionResult
 import com.intellij.openapi.actionSystem.DataContextWrapper
 import com.intellij.openapi.actionSystem.EmptyAction
 import com.intellij.openapi.actionSystem.IdeActions
 import com.intellij.openapi.actionSystem.PlatformDataKeys
-import com.intellij.openapi.actionSystem.ex.ActionManagerEx
 import com.intellij.openapi.actionSystem.ex.ActionUtil
+import com.intellij.openapi.actionSystem.ex.ActionUtil.performDumbAwareWithCallbacks
 import com.intellij.openapi.actionSystem.impl.ProxyShortcutSet
 import com.intellij.openapi.actionSystem.impl.Utils
+import com.intellij.openapi.application.ex.ApplicationManagerEx
 import com.intellij.openapi.command.CommandProcessor
 import com.intellij.openapi.command.UndoConfirmationPolicy
 import com.intellij.openapi.components.Service
+import com.intellij.openapi.diagnostic.thisLogger
 import com.intellij.openapi.editor.actionSystem.DocCommandGroupId
-import com.intellij.openapi.project.IndexNotReadyException
+import com.intellij.openapi.progress.util.ProgressIndicatorUtils
 import com.intellij.openapi.ui.popup.JBPopupFactory
 import com.intellij.openapi.util.NlsContexts
-import com.intellij.util.SlowOperations
 import com.maddyhome.idea.vim.RegisterActions
 import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.NativeAction
@@ -61,6 +61,9 @@ internal class IjActionExecutor : VimActionExecutor {
     get() = IdeActions.ACTION_EXPAND_REGION
   override val ACTION_EXPAND_REGION_RECURSIVELY: String
     get() = IdeActions.ACTION_EXPAND_REGION_RECURSIVELY
+  override val ACTION_EXPAND_COLLAPSE_TOGGLE: String
+    // [VERSION UPDATE] 2024.3+ Replace raw "ExpandCollapseToggleAction" with IdeActions.ACTION_EXPAND_COLLAPSE_TOGGLE_REGION from the platform.
+    get() = "ExpandCollapseToggleAction"
 
   /**
    * Execute an action
@@ -69,6 +72,12 @@ internal class IjActionExecutor : VimActionExecutor {
    * @param context The context to run it in
    */
   override fun executeAction(editor: VimEditor?, action: NativeAction, context: ExecutionContext): Boolean {
+    val applicationEx = ApplicationManagerEx.getApplicationEx()
+    if (ProgressIndicatorUtils.isWriteActionRunningOrPending(applicationEx)) {
+      // This is needed for VIM-3376 and it should turn into error at soeme moment
+      thisLogger().warn("Actions cannot be updated when write-action is running or pending")
+    }
+
     val ijAction = (action as IjNativeAction).action
 
     /**
@@ -121,51 +130,15 @@ internal class IjActionExecutor : VimActionExecutor {
     }
   }
 
-  // This is taken directly from ActionUtil.performActionDumbAwareWithCallbacks
-  // But with one check removed. With this check some actions (like `:w` doesn't work)
-  // https://youtrack.jetbrains.com/issue/VIM-2691/File-is-not-saved-on-w
-  private fun performDumbAwareWithCallbacks(
-    action: AnAction,
-    event: AnActionEvent,
-    performRunnable: Runnable,
-  ) {
-    val project = event.project
-    var indexError: IndexNotReadyException? = null
-    val manager = ActionManagerEx.getInstanceEx()
-    manager.fireBeforeActionPerformed(action, event)
-    var result: AnActionResult? = null
-    try {
-      SlowOperations.allowSlowOperations(SlowOperations.ACTION_PERFORM).use {
-        performRunnable.run()
-        result = AnActionResult.PERFORMED
-      }
-    } catch (ex: IndexNotReadyException) {
-      indexError = ex
-      result = AnActionResult.failed(ex)
-    } catch (ex: RuntimeException) {
-      result = AnActionResult.failed(ex)
-      throw ex
-    } catch (ex: Error) {
-      result = AnActionResult.failed(ex)
-      throw ex
-    } finally {
-      if (result == null) result = AnActionResult.failed(Throwable())
-      manager.fireAfterActionPerformed(action, event, result!!)
-    }
-    if (indexError != null) {
-      ActionUtil.showDumbModeWarning(project, action, event)
-    }
-  }
-
   /**
    * Execute an action by name
    *
    * @param name    The name of the action to execute
    * @param context The context to run it in
    */
-  override fun executeAction(name: @NonNls String, context: ExecutionContext): Boolean {
+  override fun executeAction(editor: VimEditor, name: @NonNls String, context: ExecutionContext): Boolean {
     val action = getAction(name, context)
-    return action != null && executeAction(null, IjNativeAction(action), context)
+    return action != null && executeAction(editor, IjNativeAction(action), context)
   }
   
   private fun getAction(name: String, context: ExecutionContext): AnAction? {
@@ -211,8 +184,8 @@ internal class IjActionExecutor : VimActionExecutor {
     CommandProcessor.getInstance().executeCommand(editor?.ij?.project, runnable, name, groupId)
   }
 
-  override fun executeEsc(context: ExecutionContext): Boolean {
+  override fun executeEsc(editor: VimEditor, context: ExecutionContext): Boolean {
-    return executeAction(IdeActions.ACTION_EDITOR_ESCAPE, context)
+    return executeAction(editor, IdeActions.ACTION_EDITOR_ESCAPE, context)
   }
 
   override fun executeVimAction(

src/main/java/com/maddyhome/idea/vim/helper/IjEditorHelper.kt

@@ -13,7 +13,7 @@ import com.intellij.openapi.editor.ReadOnlyFragmentModificationException
 import com.intellij.openapi.editor.VisualPosition
 import com.intellij.openapi.editor.actionSystem.EditorActionManager
 import com.intellij.openapi.editor.ex.util.EditorUtil
-import com.maddyhome.idea.vim.api.EngineEditorHelper
+import com.maddyhome.idea.vim.api.EngineEditorHelperBase
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.VimRangeMarker
 import com.maddyhome.idea.vim.api.VimVisualPosition
@@ -22,7 +22,7 @@ import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.newapi.vim
 
 @Service
-internal class IjEditorHelper : EngineEditorHelper {
+internal class IjEditorHelper : EngineEditorHelperBase() {
   override fun amountOfInlaysBeforeVisualPosition(editor: VimEditor, pos: VimVisualPosition): Int {
     return (editor as IjVimEditor).editor.amountOfInlaysBeforeVisualPosition(
       VisualPosition(
@@ -41,6 +41,10 @@ internal class IjEditorHelper : EngineEditorHelper {
     return EditorHelper.getApproximateScreenWidth(editor.ij)
   }
 
+  override fun getApproximateOutputPanelWidth(editor: VimEditor): Int {
+    return EditorHelper.getApproximateOutputPanelWidth(editor.ij)
+  }
+
   override fun handleWithReadonlyFragmentModificationHandler(editor: VimEditor, exception: Exception) {
     return EditorActionManager.getInstance()
       .getReadonlyFragmentModificationHandler(editor.ij.document)
@@ -51,10 +55,6 @@ internal class IjEditorHelper : EngineEditorHelper {
     return EditorHelper.getVisualLineAtBottomOfScreen(editor.ij)
   }
 
-  override fun pad(editor: VimEditor, line: Int, to: Int): String {
-    return EditorHelper.pad(editor.ij, line, to)
-  }
-
   override fun inlayAwareOffsetToVisualPosition(editor: VimEditor, offset: Int): VimVisualPosition {
     return EditorUtil.inlayAwareOffsetToVisualPosition(editor.ij, offset).vim
   }

src/main/java/com/maddyhome/idea/vim/helper/ModeExtensions.kt

@@ -16,7 +16,6 @@ import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.getLineEndForOffset
 import com.maddyhome.idea.vim.api.getLineStartForOffset
-import com.maddyhome.idea.vim.command.OperatorArguments
 import com.maddyhome.idea.vim.listener.SelectionVimListenerSuppressor
 import com.maddyhome.idea.vim.newapi.IjEditorExecutionContext
 import com.maddyhome.idea.vim.newapi.IjVimCaret
@@ -31,7 +30,7 @@ import com.maddyhome.idea.vim.state.mode.returnTo
 internal fun Editor.exitSelectMode(adjustCaretPosition: Boolean) {
   if (!this.vim.inSelectMode) return
 
-  val returnTo = this.vim.vimStateMachine.mode.returnTo
+  val returnTo = this.vim.mode.returnTo
   when (returnTo) {
     ReturnTo.INSERT -> {
       this.vim.mode = Mode.INSERT
@@ -64,7 +63,7 @@ internal fun Editor.exitSelectMode(adjustCaretPosition: Boolean) {
 internal fun VimEditor.exitSelectMode(adjustCaretPosition: Boolean) {
   if (!this.inSelectMode) return
 
-  val returnTo = this.vimStateMachine.mode.returnTo
+  val returnTo = this.mode.returnTo
   when (returnTo) {
     ReturnTo.INSERT -> {
       this.mode = Mode.INSERT
@@ -94,6 +93,6 @@ internal fun VimEditor.exitSelectMode(adjustCaretPosition: Boolean) {
   }
 }
 
-internal fun Editor.exitInsertMode(context: DataContext, operatorArguments: OperatorArguments) {
+internal fun Editor.exitInsertMode(context: DataContext) {
-  VimPlugin.getChange().processEscape(IjVimEditor(this), IjEditorExecutionContext(context), operatorArguments)
+  VimPlugin.getChange().processEscape(IjVimEditor(this), IjEditorExecutionContext(context))
 }

src/main/java/com/maddyhome/idea/vim/helper/ScrollViewHelper.kt

@@ -29,7 +29,6 @@ import com.maddyhome.idea.vim.helper.EditorHelper.scrollVisualLineToBottomOfScre
 import com.maddyhome.idea.vim.helper.EditorHelper.scrollVisualLineToMiddleOfScreen
 import com.maddyhome.idea.vim.helper.EditorHelper.scrollVisualLineToTopOfScreen
 import com.maddyhome.idea.vim.newapi.vim
-import com.maddyhome.idea.vim.state.VimStateMachine
 import kotlin.math.max
 import kotlin.math.min
 import kotlin.math.roundToInt
@@ -180,7 +179,7 @@ internal object ScrollViewHelper {
   }
 
   private fun getScrollJump(editor: VimEditor, height: Int): Int {
-    val flags = VimStateMachine.getInstance(editor).executingCommandFlags
+    val flags = injector.vimState.executingCommandFlags
     val scrollJump = !flags.contains(CommandFlags.FLAG_IGNORE_SCROLL_JUMP)
 
     // Default value is 1. Zero is a valid value, but we normalise to 1 - we always want to scroll at least one line
@@ -203,7 +202,7 @@ internal object ScrollViewHelper {
     val caretColumn = position.column
     val halfWidth = getApproximateScreenWidth(editor) / 2
     val scrollOffset = getNormalizedSideScrollOffset(editor)
-    val flags = VimStateMachine.getInstance(vimEditor).executingCommandFlags
+    val flags = injector.vimState.executingCommandFlags
     val allowSidescroll = !flags.contains(CommandFlags.FLAG_IGNORE_SIDE_SCROLL_JUMP)
     val sidescroll = injector.options(vimEditor).sidescroll
     val offsetLeft = caretColumn - (currentVisualLeftColumn + scrollOffset)

src/main/java/com/maddyhome/idea/vim/helper/SearchHelperKt.kt

@@ -16,18 +16,15 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.spellchecker.SpellCheckerSeveritiesProvider
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.getLineEndOffset
-import com.maddyhome.idea.vim.api.getText
 import com.maddyhome.idea.vim.api.globalOptions
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.common.TextRange
 import com.maddyhome.idea.vim.helper.CharacterHelper.charType
 import com.maddyhome.idea.vim.newapi.IjVimEditor
-import com.maddyhome.idea.vim.newapi.vim
 import it.unimi.dsi.fastutil.ints.IntComparator
 import it.unimi.dsi.fastutil.ints.IntIterator
 import it.unimi.dsi.fastutil.ints.IntRBTreeSet
 import it.unimi.dsi.fastutil.ints.IntSortedSet
-import java.util.*
 
 /**
  * Check ignorecase and smartcase options to see if a case insensitive search should be performed with the given pattern.
@@ -97,210 +94,6 @@ fun countWords(
   return CountPosition(count, position)
 }
 
-fun findNumbersInRange(
-  editor: Editor,
-  textRange: TextRange,
-  alpha: Boolean,
-  hex: Boolean,
-  octal: Boolean,
-): List<Pair<TextRange, NumberType>> {
-  val result: MutableList<Pair<TextRange, NumberType>> = ArrayList()
-
-
-  for (i in 0 until textRange.size()) {
-    val startOffset = textRange.startOffsets[i]
-    val end = textRange.endOffsets[i]
-    val text: String = editor.vim.getText(startOffset, end)
-    val textChunks = text.split("\\n".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
-    var chunkStart = 0
-    for (chunk in textChunks) {
-      val number = findNumberInText(chunk, 0, alpha, hex, octal)
-
-      if (number != null) {
-        result.add(
-          Pair(
-            TextRange(
-              number.first.startOffset + startOffset + chunkStart,
-              number.first.endOffset + startOffset + chunkStart
-            ),
-            number.second
-          )
-        )
-      }
-      chunkStart += 1 + chunk.length
-    }
-  }
-  return result
-}
-
-fun findNumberUnderCursor(
-  editor: Editor,
-  caret: Caret,
-  alpha: Boolean,
-  hex: Boolean,
-  octal: Boolean,
-): Pair<TextRange, NumberType>? {
-  val lline = caret.logicalPosition.line
-  val text = IjVimEditor(editor).getLineText(lline).lowercase(Locale.getDefault())
-  val startLineOffset = IjVimEditor(editor).getLineStartOffset(lline)
-  val posOnLine = caret.offset - startLineOffset
-
-  val numberTextRange = findNumberInText(text, posOnLine, alpha, hex, octal) ?: return null
-
-  return Pair(
-    TextRange(
-      numberTextRange.first.startOffset + startLineOffset,
-      numberTextRange.first.endOffset + startLineOffset
-    ),
-    numberTextRange.second
-  )
-}
-
-/**
- * Search for number in given text from start position
- *
- * @param textInRange    - text to search in
- * @param startPosOnLine - start offset to search
- * @return - text range with number
- */
-fun findNumberInText(
-  textInRange: String,
-  startPosOnLine: Int,
-  alpha: Boolean,
-  hex: Boolean,
-  octal: Boolean,
-): Pair<TextRange, NumberType>? {
-  if (logger.isDebugEnabled) {
-    logger.debug("text=$textInRange")
-  }
-
-  var pos = startPosOnLine
-  val lineEndOffset = textInRange.length
-
-  while (true) {
-    // Skip over current whitespace if any
-    while (pos < lineEndOffset && !isNumberChar(textInRange[pos], alpha, hex, octal, true)) {
-      pos++
-    }
-
-    if (logger.isDebugEnabled) logger.debug("pos=$pos")
-    if (pos >= lineEndOffset) {
-      logger.debug("no number char on line")
-      return null
-    }
-
-    val isHexChar = "abcdefABCDEF".indexOf(textInRange[pos]) >= 0
-
-    if (hex) {
-      // Ox and OX handling
-      if (textInRange[pos] == '0' && pos < lineEndOffset - 1 && "xX".indexOf(textInRange[pos + 1]) >= 0) {
-        pos += 2
-      } else if ("xX".indexOf(textInRange[pos]) >= 0 && pos > 0 && textInRange[pos - 1] == '0') {
-        pos++
-      }
-
-      logger.debug("checking hex")
-      val range = findRange(textInRange, pos, false, true, false, false)
-      val start = range.first
-      val end = range.second
-
-      // Ox and OX
-      if (start >= 2 && textInRange.substring(start - 2, start).equals("0x", ignoreCase = true)) {
-        logger.debug("found hex")
-        return Pair(TextRange(start - 2, end), NumberType.HEX)
-      }
-
-      if (!isHexChar || alpha) {
-        break
-      } else {
-        pos++
-      }
-    } else {
-      break
-    }
-  }
-
-  if (octal) {
-    logger.debug("checking octal")
-    val range = findRange(textInRange, pos, false, false, true, false)
-    val start = range.first
-    val end = range.second
-
-    if (end - start == 1 && textInRange[start] == '0') {
-      return Pair(TextRange(start, end), NumberType.DEC)
-    }
-    if (textInRange[start] == '0' && end > start &&
-      !(start > 0 && isNumberChar(textInRange[start - 1], false, false, false, true))
-    ) {
-      logger.debug("found octal")
-      return Pair(TextRange(start, end), NumberType.OCT)
-    }
-  }
-
-  if (alpha) {
-    if (logger.isDebugEnabled) logger.debug("checking alpha for " + textInRange[pos])
-    if (isNumberChar(textInRange[pos], true, false, false, false)) {
-      if (logger.isDebugEnabled) logger.debug("found alpha at $pos")
-      return Pair(TextRange(pos, pos + 1), NumberType.ALPHA)
-    }
-  }
-
-  val range = findRange(textInRange, pos, false, false, false, true)
-  var start = range.first
-  val end = range.second
-  if (start > 0 && textInRange[start - 1] == '-') {
-    start--
-  }
-
-  return Pair(TextRange(start, end), NumberType.DEC)
-}
-
-/**
- * Searches for digits block that matches parameters
- */
-private fun findRange(
-  text: String,
-  pos: Int,
-  alpha: Boolean,
-  hex: Boolean,
-  octal: Boolean,
-  decimal: Boolean,
-): Pair<Int, Int> {
-  var end = pos
-  while (end < text.length && isNumberChar(text[end], alpha, hex, octal, decimal || octal)) {
-    end++
-  }
-  var start = pos
-  while (start >= 0 && isNumberChar(text[start], alpha, hex, octal, decimal || octal)) {
-    start--
-  }
-  if (start < end &&
-    (start == -1 ||
-      0 <= start && start < text.length &&
-      !isNumberChar(text[start], alpha, hex, octal, decimal || octal))
-  ) {
-    start++
-  }
-  if (octal) {
-    for (i in start until end) {
-      if (!isNumberChar(text[i], false, false, true, false)) return Pair(0, 0)
-    }
-  }
-  return Pair(start, end)
-}
-
-private fun isNumberChar(ch: Char, alpha: Boolean, hex: Boolean, octal: Boolean, decimal: Boolean): Boolean {
-  return if (alpha && ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))) {
-    true
-  } else if (octal && (ch >= '0' && ch <= '7')) {
-    true
-  } else if (hex && ((ch >= '0' && ch <= '9') || "abcdefABCDEF".indexOf(ch) >= 0)) {
-    true
-  } else {
-    decimal && (ch >= '0' && ch <= '9')
-  }
-}
-
 /**
  * Find the word under the cursor or the next word to the right of the cursor on the current line.
  *