Append changes to history before & after each command

Related to <https://redirect.github.com/helix-editor/helix/pull/7226>

.cargo/config

@@ -1,2 +0,0 @@
-[alias]
-xtask = "run --package xtask --"

.cargo/config.toml

@@ -0,0 +1,17 @@
+# we use tokio_unstable to enable runtime::Handle::id so we can separate
+# globals from multiple parallel tests. If that function ever does get removed
+# its possible to replace (with some additional overhead and effort)
+# Annoyingly build.rustflags doesn't work here because it gets overwritten
+# if people have their own global target.<..> config (for example to enable mold)
+# specifying flags this way is more robust as they get merged
+# This still gets overwritten by RUST_FLAGS though, luckily it shouldn't be necessary
+# to set those most of the time. If downstream does overwrite this its not a huge
+# deal since it will only break tests anyway
+[target."cfg(all())"]
+rustflags = ["--cfg", "tokio_unstable", "-C", "target-feature=-crt-static"]
+
+
+[alias]
+xtask = "run --package xtask --"
+integration-test = "test --features integration --profile integration --workspace --test integration"
+

.envrc

@@ -1,5 +1,6 @@
 watch_file shell.nix
 watch_file flake.lock
+watch_file rust-toolchain.toml
 
 # try to use flakes, if it fails use normal nix (ie. shell.nix)
 use flake || use nix

.gitattributes

@@ -0,0 +1,11 @@
+# Auto detect text files and perform normalization
+*          text=auto
+
+*.rs       text diff=rust
+*.toml     text diff=toml
+
+*.scm      text diff=scheme
+*.md       text diff=markdown
+
+book/theme/highlight.js linguist-vendored
+Cargo.lock text

.github/FUNDING.yml

@@ -0,0 +1 @@
+open_collective: helix-editor

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,29 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: C-bug
-assignees: ''
-
----
-
-<!-- Your issue may already be reported!
-Please search on the issue tracker before creating one. -->
-
-### Reproduction steps
-
-<!-- Ideally provide a key sequence and/or asciinema.org recording. --> 
-
-### Environment
-
-- Platform: <!--  macOS / Windows / Linux -->
-- Terminal emulator: 
-- Helix version: <!--  'hx -V' if using a release, 'git describe' if building from master -->
-
-<details><summary>~/.cache/helix/helix.log</summary>
-
-```
-please provide a copy of `~/.cache/helix/helix.log` here if possible, you may need to redact some of the lines
-```
-
-</details>

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -0,0 +1,78 @@
+name: Bug Report
+description: Create a report to help us improve
+labels: C-bug
+body:
+  - type: markdown
+    attributes:
+      value: Thank you for filing a bug report! 🐛
+  - type: textarea
+    id: problem
+    attributes:
+      label: Summary
+      description: >
+        Please provide a short summary of the bug, along with any information
+        you feel relevant to replicate the bug.
+    validations:
+      required: true
+  - type: textarea
+    id: reproduction-steps
+    attributes:
+      label: Reproduction Steps
+      value: |
+        <!-- Ideally provide a key sequence and/or asciinema.org recording. --> 
+
+        I tried this:
+
+        1. `hx`
+
+        I expected this to happen:
+
+        Instead, this happened:
+  - type: textarea
+    id: helix-log
+    attributes:
+      label: Helix log
+      description: See `hx -h` for log file path. If you can reproduce the issue run `RUST_BACKTRACE=1 hx -vv` to generate a more detailed log file.
+      value: |
+        <details><summary>~/.cache/helix/helix.log</summary>
+
+        ```
+        please provide a copy of `~/.cache/helix/helix.log` here if possible, you may need to redact some of the lines
+        ```
+
+        </details>
+  - type: input
+    id: platform
+    attributes:
+      label: Platform
+      placeholder: Linux / macOS / Windows
+    validations:
+      required: true
+  - type: input
+    id: terminal-emulator
+    attributes:
+      label: Terminal Emulator
+      placeholder: wezterm 20220101-133340-7edc5b5a
+    validations:
+      required: true
+  - type: input
+    id: installation-method
+    attributes:
+      label: Installation Method
+      description: >
+        How you installed Helix - from a package manager like Homebrew or the
+        AUR, built from source, downloaded a binary from the releases page, etc.
+      placeholder: "source / brew / nixpkgs / flake / releases page"
+    validations:
+      required: true
+  - type: input
+    id: helix-version
+    attributes:
+      label: Helix Version
+      description: >
+        Helix version (`hx -V` if using a release, `git describe` if building
+        from master).
+        **Make sure that you are using the [latest helix release](https://github.com/helix-editor/helix/releases) or a newer master build**
+      placeholder: "helix 22.12 (5eaa6d97)"
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/enhancement.md

@@ -0,0 +1,13 @@
+---
+name: Enhancement
+about: Suggest an improvement
+title: ''
+labels: C-enhancement
+assignees: ''
+---
+
+<!--
+Your enhancement may already be reported!
+Please search on the issue tracker before creating a new issue.
+If this is an idea for a feature, please open an "Idea" Discussion instead.
+-->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,13 +0,0 @@
----
-name: Feature request
-about: Suggest a new feature or improvement
-title: ''
-labels: C-enhancement
-assignees: ''
----
-
-<!-- Your feature may already be reported!
-Please search on the issue tracker before creating one. -->
-
-#### Describe your feature request
-

.github/dependabot.yml

@@ -7,6 +7,14 @@ updates:
     directory: "/"
     schedule:
       interval: "weekly"
+    groups:
+      tree-sitter:
+        patterns:
+          - "tree-sitter*"
+      rust-dependencies:
+        update-types:
+          - "minor"
+          - "patch"
 
   - package-ecosystem: "github-actions"
     directory: "/"

.github/workflows/build.yml

@@ -4,194 +4,114 @@ on:
   push:
     branches:
       - master
+  merge_group:
   schedule:
     - cron: '00 01 * * *'
 
 jobs:
   check:
-    name: Check
+    name: Check (msrv)
     runs-on: ubuntu-latest
+    if: github.repository == 'helix-editor/helix' || github.event_name != 'schedule'
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v3
-
+        uses: actions/checkout@v4
       - name: Install stable toolchain
-        uses: actions-rs/toolchain@v1
+        uses: helix-editor/rust-toolchain@v1
         with:
           profile: minimal
-          toolchain: stable
           override: true
 
-      - name: Cache cargo registry
-        uses: actions/cache@v2.1.7
+      - uses: Swatinem/rust-cache@v2
         with:
-          path: ~/.cargo/registry
-          key: ${{ runner.os }}-v2-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-v2-cargo-registry-
-
-      - name: Cache cargo index
-        uses: actions/cache@v2.1.7
-        with:
-          path: ~/.cargo/git
-          key: ${{ runner.os }}-v2-cargo-index-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-v2-cargo-index-
-
-      - name: Cache cargo target dir
-        uses: actions/cache@v2.1.7
-        with:
-          path: target
-          key: ${{ runner.os }}-v2-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-v2-cargo-build-target-
+          shared-key: "build"
 
       - name: Run cargo check
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
+        run: cargo check
 
   test:
     name: Test Suite
     runs-on: ${{ matrix.os }}
+    if: github.repository == 'helix-editor/helix' || github.event_name != 'schedule'
+    env:
+      RUST_BACKTRACE: 1
+      HELIX_LOG_LEVEL: info
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Install stable toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: ${{ matrix.rust }}
-          override: true
+        uses: dtolnay/rust-toolchain@1.70
 
-      - name: Cache cargo registry
-        uses: actions/cache@v2.1.7
+      - uses: Swatinem/rust-cache@v2
         with:
-          path: ~/.cargo/registry
-          key: ${{ runner.os }}-v2-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-v2-cargo-registry-
-
-      - name: Cache cargo index
-        uses: actions/cache@v2.1.7
-        with:
-          path: ~/.cargo/git
-          key: ${{ runner.os }}-v2-cargo-index-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-v2-cargo-index-
-
-      - name: Cache cargo target dir
-        uses: actions/cache@v2.1.7
-        with:
-          path: target
-          key: ${{ runner.os }}-v2-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-v2-cargo-build-target-
-
-      - name: Copy minimal languages config
-        run: cp .github/workflows/languages.toml ./languages.toml
+          shared-key: "build"
 
       - name: Cache test tree-sitter grammar
-        uses: actions/cache@v2.1.7
+        uses: actions/cache@v4
         with:
           path: runtime/grammars
-          key: ${{ runner.os }}-v2-tree-sitter-grammars-${{ hashFiles('languages.toml') }}
-          restore-keys: ${{ runner.os }}-v2-tree-sitter-grammars-
+          key: ${{ runner.os }}-stable-v${{ env.CACHE_VERSION }}-tree-sitter-grammars-${{ hashFiles('languages.toml') }}
+          restore-keys: ${{ runner.os }}-stable-v${{ env.CACHE_VERSION }}-tree-sitter-grammars-
 
       - name: Run cargo test
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --workspace
+        run: cargo test --workspace
+
+      - name: Run cargo integration-test
+        run: cargo integration-test
 
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        rust: [stable]
 
   lints:
     name: Lints
     runs-on: ubuntu-latest
+    if: github.repository == 'helix-editor/helix' || github.event_name != 'schedule'
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Install stable toolchain
-        uses: actions-rs/toolchain@v1
+        uses: dtolnay/rust-toolchain@1.70
         with:
-          profile: minimal
-          toolchain: stable
-          override: true
           components: rustfmt, clippy
 
-      - name: Cache cargo registry
-        uses: actions/cache@v2.1.7
+      - uses: Swatinem/rust-cache@v2
         with:
-          path: ~/.cargo/registry
-          key: ${{ runner.os }}-v2-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-v2-cargo-registry-
-
-      - name: Cache cargo index
-        uses: actions/cache@v2.1.7
-        with:
-          path: ~/.cargo/git
-          key: ${{ runner.os }}-v2-cargo-index-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-v2-cargo-index-
-
-      - name: Cache cargo target dir
-        uses: actions/cache@v2.1.7
-        with:
-          path: target
-          key: ${{ runner.os }}-v2-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-v2-cargo-build-target-
+          shared-key: "build"
 
       - name: Run cargo fmt
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
+        run: cargo fmt --all --check
 
       - name: Run cargo clippy
-        uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: --all-targets -- -D warnings
+        run: cargo clippy --workspace --all-targets -- -D warnings
+
+      - name: Run cargo doc
+        run: cargo doc --no-deps --workspace --document-private-items
+        env:
+          RUSTDOCFLAGS: -D warnings
 
   docs:
     name: Docs
     runs-on: ubuntu-latest
+    if: github.repository == 'helix-editor/helix' || github.event_name != 'schedule'
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Install stable toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
+        uses: dtolnay/rust-toolchain@1.70
 
-      - name: Cache cargo registry
-        uses: actions/cache@v2.1.6
+      - uses: Swatinem/rust-cache@v2
         with:
-          path: ~/.cargo/registry
-          key: ${{ runner.os }}-v2-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-v2-cargo-registry-
+          shared-key: "build"
 
-      - name: Cache cargo index
-        uses: actions/cache@v2.1.6
-        with:
-          path: ~/.cargo/git
-          key: ${{ runner.os }}-v2-cargo-index-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-v2-cargo-index-
-
-      - name: Cache cargo target dir
-        uses: actions/cache@v2.1.6
-        with:
-          path: target
-          key: ${{ runner.os }}-v2-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-v2-cargo-build-target-
+      - name: Validate queries
+        run: cargo xtask query-check
 
       - name: Generate docs
-        uses: actions-rs/cargo@v1
-        with:
-          command: xtask
-          args: docgen
+        run: cargo xtask docgen
 
       - name: Check uncommitted documentation changes
         run: |

.github/workflows/cachix.yml

@@ -11,16 +11,16 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout sources
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
 
     - name: Install nix
-      uses: cachix/install-nix-action@v16
+      uses: cachix/install-nix-action@v26
 
     - name: Authenticate with Cachix
-      uses: cachix/cachix-action@v10
+      uses: cachix/cachix-action@v14
       with:
         name: helix
         authToken: ${{ secrets.CACHIX_AUTH_TOKEN }}
 
     - name: Build nix flake
-      run: nix build
+      run: nix build -L

.github/workflows/gh-pages.yml

@@ -11,10 +11,10 @@ jobs:
   deploy:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup mdBook
-        uses: peaceiris/actions-mdbook@v1
+        uses: peaceiris/actions-mdbook@v2
         with:
           mdbook-version: 'latest'
           # mdbook-version: '0.4.8'
@@ -26,16 +26,16 @@ jobs:
           OUTDIR=$(basename ${{ github.ref }})
           echo "OUTDIR=$OUTDIR" >> $GITHUB_ENV
 
-      - name: Deploy
-        uses: peaceiris/actions-gh-pages@v3
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: ./book/book
-          destination_dir: ./${{ env.OUTDIR }}
-
       - name: Deploy stable
-        uses: peaceiris/actions-gh-pages@v3
+        uses: peaceiris/actions-gh-pages@v4
         if: startswith(github.ref, 'refs/tags/')
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           publish_dir: ./book/book
+
+      - name: Deploy
+        uses: peaceiris/actions-gh-pages@v4
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./book/book
+          destination_dir: ./${{ env.OUTDIR }}

.github/workflows/languages.toml

@@ -11,7 +11,7 @@ indent = { tab-width = 4, unit = "    " }
 
 [[grammar]]
 name = "rust"
-source = { git = "https://github.com/tree-sitter/tree-sitter-rust", rev = "a360da0a29a19c281d08295a35ecd0544d2da211" }
+source = { git = "https://github.com/tree-sitter/tree-sitter-rust", rev = "0431a2c60828731f27491ee9fdefe25e250ce9c9" }
 
 [[language]]
 name = "nix"

.github/workflows/release.yml

@@ -1,46 +1,97 @@
 name: Release
 on:
-  # schedule:
-  # - cron: '0 0 * * *' # midnight UTC
-
   push:
     tags:
-    - 'v[0-9]+.[0-9]+.[0-9]+'
-    ## - release
+    - '[0-9]+.[0-9]+'
+    - '[0-9]+.[0-9]+.[0-9]+'
+    branches:
+    - 'patch/ci-release-*'
+  pull_request:
+    paths:
+    - '.github/workflows/release.yml'
+
+env:
+  # Preview mode: Publishes the build output as a CI artifact instead of creating
+  # a release, allowing for manual inspection of the output. This mode is
+  # activated if the CI run was triggered by events other than pushed tags, or
+  # if the repository is a fork.
+  preview: ${{ !startsWith(github.ref, 'refs/tags/') || github.repository != 'helix-editor/helix' }}
 
 jobs:
+  fetch-grammars:
+    name: Fetch Grammars
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Install stable toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - uses: Swatinem/rust-cache@v2
+
+      - name: Fetch tree-sitter grammars
+        run: cargo run --package=helix-loader --bin=hx-loader
+
+      - name: Bundle grammars
+        run: tar cJf grammars.tar.xz -C runtime/grammars/sources .
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: grammars
+          path: grammars.tar.xz
+
   dist:
     name: Dist
+    needs: [fetch-grammars]
+    env:
+      # For some builds, we use cross to test on 32-bit and big-endian
+      # systems.
+      CARGO: cargo
+      # When CARGO is set to CROSS, this is set to `--target matrix.target`.
+      TARGET_FLAGS:
+      # When CARGO is set to CROSS, TARGET_DIR includes matrix.target.
+      TARGET_DIR: ./target
+      # Emit backtraces on panics.
+      RUST_BACKTRACE: 1
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false # don't fail other jobs if one fails
       matrix:
-        build: [x86_64-linux, aarch64-linux, x86_64-macos, x86_64-windows] #, x86_64-win-gnu, win32-msvc
+        build: [x86_64-linux, x86_64-macos, x86_64-windows] #, x86_64-win-gnu, win32-msvc
         include:
         - build: x86_64-linux
-          os: ubuntu-20.04
+          os: ubuntu-latest
           rust: stable
           target: x86_64-unknown-linux-gnu
           cross: false
         - build: aarch64-linux
-          os: ubuntu-20.04
+          os: ubuntu-latest
           rust: stable
           target: aarch64-unknown-linux-gnu
           cross: true
+        # - build: riscv64-linux
+        #   os: ubuntu-latest
+        #   rust: stable
+        #   target: riscv64gc-unknown-linux-gnu
+        #   cross: true
         - build: x86_64-macos
           os: macos-latest
           rust: stable
           target: x86_64-apple-darwin
           cross: false
         - build: x86_64-windows
-          os: windows-2019
+          os: windows-latest
           rust: stable
           target: x86_64-pc-windows-msvc
           cross: false
-        # - build: aarch64-macos
-        #   os: macos-latest
-        #   rust: stable
-        #   target: aarch64-apple-darwin
+        # 23.03: build issues
+        - build: aarch64-macos
+          os: macos-latest
+          rust: stable
+          target: aarch64-apple-darwin
+          cross: false
+          skip_tests: true  # x86_64 host can't run aarch64 code
         # - build: x86_64-win-gnu
         #   os: windows-2019
         #   rust: stable-x86_64-gnu
@@ -52,55 +103,124 @@ jobs:
 
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
+
+      - name: Download grammars
+        uses: actions/download-artifact@v4
+
+      - name: Move grammars under runtime
+        if: "!startsWith(matrix.os, 'windows')"
+        run: |
+          mkdir -p runtime/grammars/sources
+          tar xJf grammars/grammars.tar.xz -C runtime/grammars/sources
+
+      # The rust-toolchain action ignores rust-toolchain.toml files.
+      # Removing this before building with cargo ensures that the rust-toolchain
+      # is considered the same between installation and usage.
+      - name: Remove the rust-toolchain.toml file
+        run: rm rust-toolchain.toml
 
       - name: Install ${{ matrix.rust }} toolchain
-        uses: actions-rs/toolchain@v1
+        uses: dtolnay/rust-toolchain@master
         with:
-          profile: minimal
           toolchain: ${{ matrix.rust }}
           target: ${{ matrix.target }}
-          override: true
+
+      # Install a pre-release version of Cross
+      # TODO: We need to pre-install Cross because we need cross-rs/cross#591 to
+      #       get a newer C++ compiler toolchain. Remove this step when Cross
+      #       0.3.0, which includes cross-rs/cross#591, is released.
+      - name: Install Cross
+        if: "matrix.cross"
+        run: |
+          cargo install cross --git https://github.com/cross-rs/cross.git --rev 47df5c76e7cba682823a0b6aa6d95c17b31ba63a
+          echo "CARGO=cross" >> $GITHUB_ENV
+        # echo "TARGET_FLAGS=--target ${{ matrix.target }}" >> $GITHUB_ENV
+        # echo "TARGET_DIR=./target/${{ matrix.target }}" >> $GITHUB_ENV
+
+      - name: Show command used for Cargo
+        run: |
+          echo "cargo command is: ${{ env.CARGO }}"
+          echo "target flag is: ${{ env.TARGET_FLAGS }}"
 
       - name: Run cargo test
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: ${{ matrix.cross }}
-          command: test
-          args: --release --locked --target ${{ matrix.target }} --workspace
+        if: "!matrix.skip_tests"
+        run: ${{ env.CARGO }} test --release --locked --target ${{ matrix.target }} --workspace
+
+      - name: Set profile.release.strip = true
+        shell: bash
+        run: |
+          cat >> .cargo/config.toml <<EOF
+          [profile.release]
+          strip = true
+          EOF
 
       - name: Build release binary
-        uses: actions-rs/cargo@v1
-        with:
-          use-cross: ${{ matrix.cross }}
-          command: build
-          args: --release --locked --target ${{ matrix.target }}
+        run: ${{ env.CARGO }} build --release --locked --target ${{ matrix.target }}
 
-      - name: Strip release binary (linux and macos)
-        if: matrix.build == 'x86_64-linux' || matrix.build == 'x86_64-macos'
-        run: strip "target/${{ matrix.target }}/release/hx"
-
-      - name: Strip release binary (arm)
-        if: matrix.build == 'aarch64-linux'
+      - name: Build AppImage
+        shell: bash
+        if: matrix.build == 'x86_64-linux'
         run: |
-          docker run --rm -v \
-            "$PWD/target:/target:Z" \
-            rustembedded/cross:${{ matrix.target }} \
-            aarch64-linux-gnu-strip \
-            /target/${{ matrix.target }}/release/hx
+          # Required as of 22.x https://github.com/AppImage/AppImageKit/wiki/FUSE
+          sudo add-apt-repository universe
+          sudo apt install libfuse2
+
+          mkdir dist
+
+          name=dev
+          if [[ $GITHUB_REF == refs/tags/* ]]; then
+            name=${GITHUB_REF:10}
+          fi
+
+          build="${{ matrix.build }}"
+
+          export VERSION="$name"
+          export ARCH=${build%-linux}
+          export APP=helix
+          export OUTPUT="helix-$VERSION-$ARCH.AppImage"
+          export UPDATE_INFORMATION="gh-releases-zsync|$GITHUB_REPOSITORY_OWNER|helix|latest|$APP-*-$ARCH.AppImage.zsync"
+
+          mkdir -p "$APP.AppDir"/usr/{bin,lib/helix}
+
+          cp "target/${{ matrix.target }}/release/hx" "$APP.AppDir/usr/bin/hx"
+          rm -rf runtime/grammars/sources
+          cp -r runtime "$APP.AppDir/usr/lib/helix/runtime"
+
+          cat << 'EOF' > "$APP.AppDir/AppRun"
+          #!/bin/sh
+
+          APPDIR="$(dirname "$(readlink -f "${0}")")"
+          HELIX_RUNTIME="$APPDIR/usr/lib/helix/runtime" exec "$APPDIR/usr/bin/hx" "$@"
+          EOF
+          chmod 755 "$APP.AppDir/AppRun"
+
+          curl -Lo linuxdeploy-x86_64.AppImage \
+              https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage
+          chmod +x linuxdeploy-x86_64.AppImage
+
+          ./linuxdeploy-x86_64.AppImage \
+              --appdir "$APP.AppDir" -d contrib/Helix.desktop \
+              -i contrib/helix.png --output appimage
+
+          mv "$APP-$VERSION-$ARCH.AppImage" \
+              "$APP-$VERSION-$ARCH.AppImage.zsync" dist
 
       - name: Build archive
         shell: bash
         run: |
-          mkdir dist
+          mkdir -p dist
           if [ "${{ matrix.os }}" = "windows-2019" ]; then
             cp "target/${{ matrix.target }}/release/hx.exe" "dist/"
           else
             cp "target/${{ matrix.target }}/release/hx" "dist/"
           fi
+          if [ -d runtime/grammars/sources ]; then
+            rm -rf runtime/grammars/sources
+          fi
           cp -r runtime dist
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: bins-${{ matrix.build }}
           path: dist
@@ -111,27 +231,22 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
-      - uses: actions/download-artifact@v2
-
-      - name: Calculate tag name
-        run: |
-          name=dev
-          if [[ $GITHUB_REF == refs/tags/v* ]]; then
-            name=${GITHUB_REF:10}
-          fi
-          echo ::set-output name=val::$name
-          echo TAG=$name >> $GITHUB_ENV
-        id: tagname
+      - uses: actions/download-artifact@v4
 
       - name: Build archive
         shell: bash
         run: |
           set -ex
 
-          rm -rf tmp
-          mkdir tmp
+          source="$(pwd)"
+          mkdir -p runtime/grammars/sources
+          tar xJf grammars/grammars.tar.xz -C runtime/grammars/sources
+          rm -rf grammars
+
+          cd "$(mktemp -d)"
+          mv $source/bins-* .
           mkdir dist
 
           for dir in bins-* ; do
@@ -139,25 +254,42 @@ jobs:
               if [[ $platform =~ "windows" ]]; then
                   exe=".exe"
               fi
-              pkgname=helix-$TAG-$platform
-              mkdir tmp/$pkgname
-              cp LICENSE README.md tmp/$pkgname
-              mv bins-$platform/runtime tmp/$pkgname/
-              mv bins-$platform/hx$exe tmp/$pkgname
-              chmod +x tmp/$pkgname/hx$exe
+              pkgname=helix-$GITHUB_REF_NAME-$platform
+              mkdir -p $pkgname
+              cp $source/LICENSE $source/README.md $pkgname
+              mkdir $pkgname/contrib
+              cp -r $source/contrib/completion $pkgname/contrib
+              mv bins-$platform/runtime $pkgname/
+              mv bins-$platform/hx$exe $pkgname
+              chmod +x $pkgname/hx$exe
+
+              if [[ "$platform" = "x86_64-linux" ]]; then
+                  mv bins-$platform/helix-*.AppImage* dist/
+              fi
 
               if [ "$exe" = "" ]; then
-                  tar cJf dist/$pkgname.tar.xz -C tmp $pkgname
+                  tar cJf dist/$pkgname.tar.xz $pkgname
               else
-                  (cd tmp && 7z a -r ../dist/$pkgname.zip $pkgname)
+                  7z a -r dist/$pkgname.zip $pkgname
               fi
           done
 
+          tar cJf dist/helix-$GITHUB_REF_NAME-source.tar.xz -C $source .
+          mv dist $source/
+
       - name: Upload binaries to release
         uses: svenstaro/upload-release-action@v2
+        if: env.preview == 'false'
         with:
           repo_token: ${{ secrets.GITHUB_TOKEN }}
           file: dist/*
           file_glob: true
-          tag: ${{ steps.tagname.outputs.val }}
+          tag: ${{ github.ref_name }}
           overwrite: true
+      
+      - name: Upload binaries as artifact
+        uses: actions/upload-artifact@v4
+        if: env.preview == 'true'
+        with:
+          name: release
+          path: dist/*

.gitignore

@@ -1,6 +1,5 @@
 target
 .direnv
 helix-term/rustfmt.toml
-helix-syntax/languages/
 result
 runtime/grammars

Cargo.toml

@@ -1,12 +1,17 @@
 [workspace]
+resolver = "2"
 members = [
   "helix-core",
   "helix-view",
   "helix-term",
   "helix-tui",
   "helix-lsp",
+  "helix-event",
   "helix-dap",
   "helix-loader",
+  "helix-vcs",
+  "helix-parsec",
+  "helix-stdx",
   "xtask",
 ]
 
@@ -14,9 +19,6 @@ default-members = [
   "helix-term"
 ]
 
-[profile.dev]
-split-debuginfo = "unpacked"
-
 [profile.release]
 lto = "thin"
 # debug = true
@@ -27,3 +29,24 @@ lto = "fat"
 codegen-units = 1
 # strip = "debuginfo" # TODO: or strip = true
 opt-level = 3
+
+[profile.integration]
+inherits = "test"
+package.helix-core.opt-level = 2
+package.helix-tui.opt-level = 2
+package.helix-term.opt-level = 2
+
+[workspace.dependencies]
+tree-sitter = { version = "0.22" }
+nucleo = "0.2.0"
+slotmap = "1.0.7"
+
+[workspace.package]
+version = "24.3.0"
+edition = "2021"
+authors = ["Blaž Hrastnik <blaz@mxxn.io>"]
+categories = ["editor"]
+repository = "https://github.com/helix-editor/helix"
+homepage = "https://helix-editor.com"
+license = "MPL-2.0"
+rust-version = "1.70"

README.md

@@ -1,14 +1,27 @@
-# Helix
+<div align="center">
 
+<h1>
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="logo_dark.svg">
+  <source media="(prefers-color-scheme: light)" srcset="logo_light.svg">
+  <img alt="Helix" height="128" src="logo_light.svg">
+</picture>
+</h1>
 
 [![Build status](https://github.com/helix-editor/helix/actions/workflows/build.yml/badge.svg)](https://github.com/helix-editor/helix/actions)
+[![GitHub Release](https://img.shields.io/github/v/release/helix-editor/helix)](https://github.com/helix-editor/helix/releases/latest)
+[![Documentation](https://shields.io/badge/-documentation-452859)](https://docs.helix-editor.com/)
+[![GitHub contributors](https://img.shields.io/github/contributors/helix-editor/helix)](https://github.com/helix-editor/helix/graphs/contributors)
+[![Matrix Space](https://img.shields.io/matrix/helix-community:matrix.org)](https://matrix.to/#/#helix-community:matrix.org)
+
+</div>
 
 ![Screenshot](./screenshot.png)
 
-A kakoune / neovim inspired editor, written in Rust.
+A [Kakoune](https://github.com/mawww/kakoune) / [Neovim](https://github.com/neovim/neovim) inspired editor, written in Rust.
 
-The editing model is very heavily based on kakoune; during development I found
-myself agreeing with most of kakoune's design decisions.
+The editing model is very heavily based on Kakoune; during development I found
+myself agreeing with most of Kakoune's design decisions.
 
 For more information, see the [website](https://helix-editor.com) or
 [documentation](https://docs.helix-editor.com/).
@@ -25,47 +38,17 @@ All shortcuts/keymaps can be found [in the documentation on the website](https:/
 - Smart, incremental syntax highlighting and code editing via tree-sitter
 
 It's a terminal-based editor first, but I'd like to explore a custom renderer
-(similar to emacs) in wgpu or skulpin.
+(similar to Emacs) in wgpu or skulpin.
 
 Note: Only certain languages have indentation definitions at the moment. Check
-`runtime/queries/<lang>/` for `indents.toml`.
+`runtime/queries/<lang>/` for `indents.scm`.
 
 # Installation
 
-We provide packaging for various distributions, but here's a quick method to
-build from source.
-
-```
-git clone https://github.com/helix-editor/helix
-cd helix
-cargo install --path helix-term
-hx --grammar fetch
-hx --grammar build
-```
-
-This will install the `hx` binary to `$HOME/.cargo/bin` and build tree-sitter grammars.
-
-Helix also needs its runtime files so make sure to copy/symlink the `runtime/` directory into the
-config directory (for example `~/.config/helix/runtime` on Linux/macOS, or `%AppData%/helix/runtime` on Windows).
-This location can be overridden via the `HELIX_RUNTIME` environment variable.
-
-Packages already solve this for you by wrapping the `hx` binary with a wrapper
-that sets the variable to the install dir.
-
-> NOTE: running via cargo also doesn't require setting explicit `HELIX_RUNTIME` path, it will automatically
-> detect the `runtime` directory in the project root.
+[Installation documentation](https://docs.helix-editor.com/install.html).
 
 [![Packaging status](https://repology.org/badge/vertical-allrepos/helix.svg)](https://repology.org/project/helix/versions)
 
-## MacOS
-
-Helix can be installed on MacOS through homebrew via:
-
-```
-brew tap helix-editor/helix
-brew install helix
-```
- 
 # Contributing
 
 Contributing guidelines can be found [here](./docs/CONTRIBUTING.md).
@@ -75,3 +58,7 @@ Contributing guidelines can be found [here](./docs/CONTRIBUTING.md).
 Your question might already be answered on the [FAQ](https://github.com/helix-editor/helix/wiki/FAQ).
 
 Discuss the project on the community [Matrix Space](https://matrix.to/#/#helix-community:matrix.org) (make sure to join `#helix-editor:matrix.org` if you're on a client that doesn't support Matrix Spaces yet).
+
+# Credits
+
+Thanks to [@jakenvac](https://github.com/jakenvac) for designing the logo!

base16_theme.toml

@@ -1,16 +1,16 @@
 # Author: NNB <nnbnh@protonmail.com>
 
-"ui.menu" = "black"
+"ui.menu" = { fg = "black", bg = "white" }
 "ui.menu.selected" = { modifiers = ["reversed"] }
 "ui.linenr" = { fg = "gray", bg = "black" }
 "ui.popup" = { modifiers = ["reversed"] }
 "ui.linenr.selected" = { fg = "white", bg = "black", modifiers = ["bold"] }
 "ui.selection" = { fg = "black", bg = "blue" }
 "ui.selection.primary" = { fg = "white", bg = "blue" }
+"ui.text.inactive" = { fg = "gray" }
 "comment" = { fg = "gray" }
 "ui.statusline" = { fg = "black", bg = "white" }
 "ui.statusline.inactive" = { fg = "gray", bg = "white" }
-"ui.help" = { modifiers = ["reversed"] }
 "ui.cursor" = { fg = "white", modifiers = ["reversed"] }
 "variable" = "red"
 "constant.numeric" = "yellow"
@@ -28,6 +28,8 @@
 "label" = "magenta"
 "namespace" = "magenta"
 "ui.help" = { fg = "white", bg = "black" }
+"ui.virtual.jump-label" = { fg = "blue", modifiers = ["bold", "underlined"] }
+"ui.virtual.ruler" = { bg = "black" }
 
 "markup.heading" = "blue"
 "markup.list" = "red"

book/book.toml

@@ -3,9 +3,14 @@ authors = ["Blaž Hrastnik"]
 language = "en"
 multilingual = false
 src = "src"
-edit-url-template = "https://github.com/helix-editor/helix/tree/master/book/{path}?mode=edit"
 
 [output.html]
 cname = "docs.helix-editor.com"
 default-theme = "colibri"
 preferred-dark-theme = "colibri"
+git-repository-url = "https://github.com/helix-editor/helix"
+edit-url-template = "https://github.com/helix-editor/helix/edit/master/book/{path}"
+additional-css = ["custom.css"]
+
+[output.html.search]
+use-boolean-and = true

book/custom.css

@@ -0,0 +1,231 @@
+html {
+  font-family: "Inter", sans-serif;
+}
+
+.sidebar .sidebar-scrollbox {
+  padding: 0;
+}
+
+.chapter {
+  margin: 0.25rem 0;
+}
+
+.chapter li.chapter-item {
+  line-height: initial;
+  margin: 0;
+  padding: 1rem 1.5rem;
+}
+
+.chapter .section li.chapter-item {
+  line-height: inherit;
+  padding: .5rem .5rem 0 .5rem;
+}
+
+.content {
+  overflow-y: auto;
+  padding: 0 15px;
+  padding-bottom: 50px;
+}
+
+/* 2 1.75 1.5 1.25 1 .875 */
+.content h1 { font-size: 2em }
+.content h2 { font-size: 1.75em }
+.content h3 { font-size: 1.5em }
+.content h4 { font-size: 1.25em }
+.content h5 { font-size: 1em }
+.content h6 { font-size: .875em }
+
+.content h1,
+.content h2,
+.content h3,
+.content h4 {
+  font-weight: 500;
+  margin-top: 1.275em;
+  margin-bottom: .875em;
+}
+
+.content p,
+.content ol,
+.content ul,
+.content table {
+  margin-top: 0;
+  margin-bottom: .875em;
+}
+
+.content ul li {
+  margin-bottom: .25rem;
+}
+
+.content ul {
+  list-style-type: square;
+}
+
+.content ul ul,
+.content ol ul {
+  margin-bottom: .5rem;
+}
+
+.content li p {
+  margin-bottom: .5em;
+}
+
+blockquote {
+  margin: 1.5rem 0;
+  padding: 1rem 1.5rem;
+  color: var(--fg);
+  opacity: .9;
+  background-color: var(--quote-bg);
+  border-left: 4px solid var(--quote-border);
+  border-top: none;
+  border-bottom: none;
+}
+
+blockquote *:last-child {
+  margin-bottom: 0;
+}
+
+table {
+  width: 100%;
+}
+
+table thead th {
+  padding: .75rem;
+  text-align: left;
+  font-weight: 500;
+  line-height: 1.5;
+  width: auto;
+}
+
+table td {
+  padding: .75rem;
+  border: none;
+}
+
+table thead tr {
+  border: none;
+  border-bottom: 2px var(--table-border-color) solid;
+}
+
+table tbody tr {
+  border-bottom: 1px var(--table-border-line) solid;
+}
+
+table tbody tr:nth-child(2n) {
+  background: unset;
+}
+
+pre code.hljs {
+  display: block;
+  overflow-x: auto;
+  padding: 1em;
+}
+
+code.hljs {
+  padding: 3px 5px;
+}
+
+.colibri {
+  --bg: #3b224c;
+  --fg: #bcbdd0;
+  --heading-fg: #fff;
+
+  --sidebar-bg: #281733;
+  --sidebar-fg: #c8c9db;
+  --sidebar-non-existent: #505274;
+  --sidebar-active: #a4a0e8;
+  --sidebar-spacer: #2d334f;
+
+  --scrollbar: var(--sidebar-fg);
+
+  --icons: #737480;
+  --icons-hover: #b7b9cc;
+
+  /* --links: #a4a0e8; */
+  --links: #ECCDBA;
+
+  --inline-code-color: hsl(48.7, 7.8%, 70%);
+
+  --theme-popup-bg: #161923;
+  --theme-popup-border: #737480;
+  --theme-hover: rgba(0, 0, 0, .2);
+
+  --quote-bg: #281733;
+  --quote-border: hsl(226, 15%, 22%);
+
+  --table-border-color: hsl(226, 23%, 76%);
+  --table-header-bg: hsla(226, 23%, 31%, 0);
+  --table-alternate-bg: hsl(226, 23%, 14%);
+  --table-border-line: hsla(201deg, 20%, 92%, 0.2);
+
+  --searchbar-border-color: #aaa;
+  --searchbar-bg: #aeaec6;
+  --searchbar-fg: #000;
+  --searchbar-shadow-color: #aaa;
+  --searchresults-header-fg: #5f5f71;
+  --searchresults-border-color: #5c5c68;
+  --searchresults-li-bg: #242430;
+  --search-mark-bg: #a2cff5;
+}
+
+.colibri .content .header {
+  color: #fff;
+}
+
+/* highlight.js theme, :where() is used to avoid increasing specificity */
+
+:where(.colibri) .hljs {
+  background: #2f1e2e;
+  color: #a39e9b;
+}
+
+:where(.colibri) .hljs-comment,
+:where(.colibri) .hljs-quote {
+  color: #8d8687;
+}
+
+:where(.colibri) .hljs-link,
+:where(.colibri) .hljs-meta,
+:where(.colibri) .hljs-name,
+:where(.colibri) .hljs-regexp,
+:where(.colibri) .hljs-selector-class,
+:where(.colibri) .hljs-selector-id,
+:where(.colibri) .hljs-tag,
+:where(.colibri) .hljs-template-variable,
+:where(.colibri) .hljs-variable {
+  color: #ef6155;
+}
+
+:where(.colibri) .hljs-built_in,
+:where(.colibri) .hljs-deletion,
+:where(.colibri) .hljs-literal,
+:where(.colibri) .hljs-number,
+:where(.colibri) .hljs-params,
+:where(.colibri) .hljs-type {
+  color: #f99b15;
+}
+
+:where(.colibri) .hljs-attribute,
+:where(.colibri) .hljs-section,
+:where(.colibri) .hljs-title {
+  color: #fec418;
+}
+
+:where(.colibri) .hljs-addition,
+:where(.colibri) .hljs-bullet,
+:where(.colibri) .hljs-string,
+:where(.colibri) .hljs-symbol {
+  color: #48b685;
+}
+
+:where(.colibri) .hljs-keyword,
+:where(.colibri) .hljs-selector-tag {
+  color: #815ba4;
+}
+
+:where(.colibri) .hljs-emphasis {
+  font-style: italic;
+}
+
+:where(.colibri) .hljs-strong {
+  font-weight: 700;
+}

book/src/SUMMARY.md

@@ -6,13 +6,14 @@
 - [Usage](./usage.md)
   - [Keymap](./keymap.md)
   - [Commands](./commands.md)
-  - [Language Support](./lang-support.md)
+  - [Language support](./lang-support.md)
 - [Migrating from Vim](./from-vim.md)
 - [Configuration](./configuration.md)
   - [Themes](./themes.md)
-  - [Key Remapping](./remapping.md)
-  - [Hooks](./hooks.md)
+  - [Key remapping](./remapping.md)
   - [Languages](./languages.md)
 - [Guides](./guides/README.md)
-  - [Adding Languages](./guides/adding_languages.md)
-  - [Adding Textobject Queries](./guides/textobject.md)
+  - [Adding languages](./guides/adding_languages.md)
+  - [Adding textobject queries](./guides/textobject.md)
+  - [Adding indent queries](./guides/indent.md)
+  - [Adding injection queries](./guides/injection.md)

book/src/commands.md

@@ -1,5 +1,5 @@
 # Commands
 
-Command mode can be activated by pressing `:`, similar to vim. Built-in commands:
+Command mode can be activated by pressing `:`. The built-in commands are:
 
 {{#include ./generated/typable-cmd.md}}

book/src/configuration.md

@@ -2,10 +2,10 @@
 
 To override global configuration parameters, create a `config.toml` file located in your config directory:
 
-* Linux and Mac: `~/.config/helix/config.toml`
-* Windows: `%AppData%\helix\config.toml`
+- Linux and Mac: `~/.config/helix/config.toml`
+- Windows: `%AppData%\helix\config.toml`
 
-> Note: You may use `hx --edit-config` to create and edit the `config.toml` file.
+> 💡 You can easily open the config file by typing `:config-open` within Helix normal mode.
 
 Example config:
 
@@ -25,28 +25,132 @@ select = "underline"
 hidden = false
 ```
 
+You can use a custom configuration file by specifying it with the `-c` or
+`--config` command line argument, for example `hx -c path/to/custom-config.toml`.
+Additionally, you can reload the configuration file by sending the USR1
+signal to the Helix process on Unix operating systems, such as by using the command `pkill -USR1 hx`.
+
+Finally, you can have a `config.toml` local to a project by putting it under a `.helix` directory in your repository.
+Its settings will be merged with the configuration directory `config.toml` and the built-in configuration.
+
 ## Editor
 
 ### `[editor]` Section
 
 | Key | Description | Default |
 |--|--|---------|
-| `scrolloff` | Number of lines of padding around the edge of the screen when scrolling. | `3` |
-| `mouse` | Enable mouse mode. | `true` |
-| `middle-click-paste` | Middle click paste support. | `true` |
-| `scroll-lines` | Number of lines to scroll per scroll wheel step. | `3` |
-| `shell` | Shell to use when running external commands. | Unix: `["sh", "-c"]`<br/>Windows: `["cmd", "/C"]` |
-| `line-number` | Line number display: `absolute` simply shows each line's number, while `relative` shows the distance from the current line. When unfocused or in insert mode, `relative` will still show absolute line numbers. | `absolute` |
-| `auto-completion` | Enable automatic pop up of auto-completion. | `true` |
-| `idle-timeout` | Time in milliseconds since last keypress before idle timers trigger. Used for autocompletion, set to 0 for instant. | `400` |
+| `scrolloff` | Number of lines of padding around the edge of the screen when scrolling | `5` |
+| `mouse` | Enable mouse mode | `true` |
+| `middle-click-paste` | Middle click paste support | `true` |
+| `scroll-lines` | Number of lines to scroll per scroll wheel step | `3` |
+| `shell` | Shell to use when running external commands | Unix: `["sh", "-c"]`<br/>Windows: `["cmd", "/C"]` |
+| `line-number` | Line number display: `absolute` simply shows each line's number, while `relative` shows the distance from the current line. When unfocused or in insert mode, `relative` will still show absolute line numbers | `absolute` |
+| `cursorline` | Highlight all lines with a cursor | `false` |
+| `cursorcolumn` | Highlight all columns with a cursor | `false` |
+| `gutters` | Gutters to display: Available are `diagnostics` and `diff` and `line-numbers` and `spacer`, note that `diagnostics` also includes other features like breakpoints, 1-width padding will be inserted if gutters is non-empty | `["diagnostics", "spacer", "line-numbers", "spacer", "diff"]` |
+| `auto-completion` | Enable automatic pop up of auto-completion | `true` |
+| `auto-format` | Enable automatic formatting on save | `true` |
+| `auto-save` | Enable automatic saving on the focus moving away from Helix. Requires [focus event support](https://github.com/helix-editor/helix/wiki/Terminal-Support) from your terminal | `false` |
+| `idle-timeout` | Time in milliseconds since last keypress before idle timers trigger. | `250` |
+| `completion-timeout` | Time in milliseconds after typing a word character before completions are shown, set to 5 for instant.  | `250` |
+| `preview-completion-insert` | Whether to apply completion item instantly when selected | `true` |
 | `completion-trigger-len` | The min-length of word under cursor to trigger autocompletion | `2` |
-| `auto-info` | Whether to display infoboxes | `true` |
-| `true-color` | Set to `true` to override automatic detection of terminal truecolor support in the event of a false negative. | `false` |
+| `completion-replace` | Set to `true` to make completions always replace the entire word and not just the part before the cursor | `false` |
+| `auto-info` | Whether to display info boxes | `true` |
+| `true-color` | Set to `true` to override automatic detection of terminal truecolor support in the event of a false negative | `false` |
+| `undercurl` | Set to `true` to override automatic detection of terminal undercurl support in the event of a false negative | `false` |
+| `rulers` | List of column positions at which to display the rulers. Can be overridden by language specific `rulers` in `languages.toml` file | `[]` |
+| `bufferline` | Renders a line at the top of the editor displaying open buffers. Can be `always`, `never` or `multiple` (only shown if more than one buffer is in use) | `never` |
+| `color-modes` | Whether to color the mode indicator with different colors depending on the mode itself | `false` |
+| `text-width` | Maximum line length. Used for the `:reflow` command and soft-wrapping if `soft-wrap.wrap-at-text-width` is set | `80` |
+| `workspace-lsp-roots` | Directories relative to the workspace root that are treated as LSP roots. Should only be set in `.helix/config.toml` | `[]` |
+| `default-line-ending` | The line ending to use for new documents. Can be `native`, `lf`, `crlf`, `ff`, `cr` or `nel`. `native` uses the platform's native line ending (`crlf` on Windows, otherwise `lf`). | `native` |
+| `insert-final-newline` | Whether to automatically insert a trailing line-ending on write if missing | `true` |
+| `popup-border` | Draw border around `popup`, `menu`, `all`, or `none` | `none` |
+| `indent-heuristic` | How the indentation for a newly inserted line is computed: `simple` just copies the indentation level from the previous line, `tree-sitter` computes the indentation based on the syntax tree and `hybrid` combines both approaches. If the chosen heuristic is not available, a different one will be used as a fallback (the fallback order being `hybrid` -> `tree-sitter` -> `simple`). | `hybrid`
+| `jump-label-alphabet` | The characters that are used to generate two character jump labels. Characters at the start of the alphabet are used first. | `"abcdefghijklmnopqrstuvwxyz"`
+
+### `[editor.statusline]` Section
+
+Allows configuring the statusline at the bottom of the editor.
+
+The configuration distinguishes between three areas of the status line:
+
+`[ ... ... LEFT ... ... | ... ... ... CENTER ... ... ... | ... ... RIGHT ... ... ]`
+
+Statusline elements can be defined as follows:
+
+```toml
+[editor.statusline]
+left = ["mode", "spinner"]
+center = ["file-name"]
+right = ["diagnostics", "selections", "position", "file-encoding", "file-line-ending", "file-type"]
+separator = "│"
+mode.normal = "NORMAL"
+mode.insert = "INSERT"
+mode.select = "SELECT"
+```
+The `[editor.statusline]` key takes the following sub-keys:
+
+| Key           | Description | Default |
+| ---           | ---         | ---     |
+| `left`        | A list of elements aligned to the left of the statusline | `["mode", "spinner", "file-name", "read-only-indicator", "file-modification-indicator"]` |
+| `center`      | A list of elements aligned to the middle of the statusline | `[]` |
+| `right`       | A list of elements aligned to the right of the statusline | `["diagnostics", "selections", "register", "position", "file-encoding"]` |
+| `separator`   | The character used to separate elements in the statusline | `"│"` |
+| `mode.normal` | The text shown in the `mode` element for normal mode | `"NOR"` |
+| `mode.insert` | The text shown in the `mode` element for insert mode | `"INS"` |
+| `mode.select` | The text shown in the `mode` element for select mode | `"SEL"` |
+
+The following statusline elements can be configured:
+
+| Key    | Description |
+| ------ | ----------- |
+| `mode` | The current editor mode (`mode.normal`/`mode.insert`/`mode.select`) |
+| `spinner` | A progress spinner indicating LSP activity |
+| `file-name` | The path/name of the opened file |
+| `file-absolute-path` | The absolute path/name of the opened file |
+| `file-base-name` | The basename of the opened file |
+| `file-modification-indicator` | The indicator to show whether the file is modified (a `[+]` appears when there are unsaved changes) |
+| `file-encoding` | The encoding of the opened file if it differs from UTF-8 |
+| `file-line-ending` | The file line endings (CRLF or LF) |
+| `read-only-indicator` | An indicator that shows `[readonly]` when a file cannot be written |
+| `total-line-numbers` | The total line numbers of the opened file |
+| `file-type` | The type of the opened file |
+| `diagnostics` | The number of warnings and/or errors |
+| `workspace-diagnostics` | The number of warnings and/or errors on workspace |
+| `selections` | The number of active selections |
+| `primary-selection-length` | The number of characters currently in primary selection |
+| `position` | The cursor position |
+| `position-percentage` | The cursor position as a percentage of the total number of lines |
+| `separator` | The string defined in `editor.statusline.separator` (defaults to `"│"`) |
+| `spacer` | Inserts a space between elements (multiple/contiguous spacers may be specified) |
+| `version-control` | The current branch name or detached commit hash of the opened workspace |
+| `register` | The current selected register |
+
+### `[editor.lsp]` Section
+
+| Key                   | Description                                                 | Default |
+| ---                   | -----------                                                 | ------- |
+| `enable`              | Enables LSP integration. Setting to false will completely disable language servers regardless of language settings.| `true` |
+| `display-messages`    | Display LSP progress messages below statusline[^1]          | `false` |
+| `auto-signature-help` | Enable automatic popup of signature help (parameter hints)  | `true`  |
+| `display-inlay-hints` | Display inlay hints[^2]                                     | `false` |
+| `display-signature-help-docs` | Display docs under signature help popup             | `true`  |
+| `snippets`      | Enables snippet completions. Requires a server restart (`:lsp-restart`) to take effect after `:config-reload`/`:set`. | `true`  |
+| `goto-reference-include-declaration` | Include declaration in the goto references popup. | `true`  |
+
+[^1]: By default, a progress spinner is shown in the statusline beside the file path.
+
+[^2]: You may also have to activate them in the LSP config for them to appear, not just in Helix. Inlay hints in Helix are still being improved on and may be a little bit laggy/janky under some circumstances. Please report any bugs you see so we can fix them!
 
 ### `[editor.cursor-shape]` Section
 
-Defines the shape of cursor in each mode. Note that due to limitations
-of the terminal environment, only the primary cursor can change shape.
+Defines the shape of cursor in each mode.
+Valid values for these options are `block`, `bar`, `underline`, or `hidden`.
+
+> 💡 Due to limitations of the terminal environment, only the primary cursor can
+> change shape.
 
 | Key      | Description                                | Default |
 | ---      | -----------                                | ------- |
@@ -60,34 +164,52 @@ of the terminal environment, only the primary cursor can change shape.
 
 ### `[editor.file-picker]` Section
 
-Sets options for file picker and global search. All but the last key listed in
-the default file-picker configuration below are IgnoreOptions: whether hidden
-files and files listed within ignore files are ignored by (not visible in) the
-helix file picker and global search. There is also one other key, `max-depth`
-available, which is not defined by default.
+Set options for file picker and global search. Ignoring a file means it is
+not visible in the Helix file picker and global search.
+
+All git related options are only enabled in a git repository.
 
 | Key | Description | Default |
 |--|--|---------|
-|`hidden` | Enables ignoring hidden files. | true
-|`parents` | Enables reading ignore files from parent directories. | true
-|`ignore` | Enables reading `.ignore` files. | true
-|`git-ignore` | Enables reading `.gitignore` files. | true
-|`git-global` | Enables reading global .gitignore, whose path is specified in git's config: `core.excludefile` option. | true
-|`git-exclude` | Enables reading `.git/info/exclude` files. | true
-|`max-depth` | Set with an integer value for maximum depth to recurse. | Defaults to `None`.
+|`hidden` | Enables ignoring hidden files | `true`
+|`follow-symlinks` | Follow symlinks instead of ignoring them | `true`
+|`deduplicate-links` | Ignore symlinks that point at files already shown in the picker | `true`
+|`parents` | Enables reading ignore files from parent directories | `true`
+|`ignore` | Enables reading `.ignore` files | `true`
+|`git-ignore` | Enables reading `.gitignore` files | `true`
+|`git-global` | Enables reading global `.gitignore`, whose path is specified in git's config: `core.excludesfile` option | `true`
+|`git-exclude` | Enables reading `.git/info/exclude` files | `true`
+|`max-depth` | Set with an integer value for maximum depth to recurse | Unset by default
+
+Ignore files can be placed locally as `.ignore` or put in your home directory as `~/.ignore`. They support the usual ignore and negative ignore (unignore) rules used in `.gitignore` files.
+
+Additionally, you can use Helix-specific ignore files by creating a local `.helix/ignore` file in the current workspace or a global `ignore` file located in your Helix config directory:
+- Linux and Mac: `~/.config/helix/ignore`
+- Windows: `%AppData%\helix\ignore`
+
+Example:
+
+```ini
+# unignore in file picker and global search
+!.github/
+!.gitignore
+!.gitattributes
+```
 
 ### `[editor.auto-pairs]` Section
 
-Enable automatic insertion of pairs to parentheses, brackets, etc. Can be
-a simple boolean value, or a specific mapping of pairs of single characters.
+Enables automatic insertion of pairs to parentheses, brackets, etc. Can be a
+simple boolean value, or a specific mapping of pairs of single characters.
 
-| Key | Description |
-| --- | ----------- |
-| `false` | Completely disable auto pairing, regardless of language-specific settings
-| `true` | Use the default pairs: <code>(){}[]''""``</code>
-| Mapping of pairs | e.g. `{ "(" =  ")", "{" = "}", ... }`
+To disable auto-pairs altogether, set `auto-pairs` to `false`:
 
-Example
+```toml
+[editor]
+auto-pairs = false # defaults to `true`
+```
+
+The default pairs are <code>(){}[]''""``</code>, but these can be customized by
+setting `auto-pairs` to a TOML table:
 
 ```toml
 [editor.auto-pairs]
@@ -103,7 +225,7 @@ Additionally, this setting can be used in a language config. Unless
 the editor setting is `false`, this will override the editor config in
 documents with this language.
 
-Example `languages.toml` that adds <> and removes ''
+Example `languages.toml` that adds `<>` and removes `''`
 
 ```toml
 [[language]]
@@ -124,15 +246,159 @@ Search specific options.
 
 | Key | Description | Default |
 |--|--|---------|
-| `smart-case` | Enable smart case regex searching (case insensitive unless pattern contains upper case characters) | `true` |
+| `smart-case` | Enable smart case regex searching (case-insensitive unless pattern contains upper case characters) | `true` |
 | `wrap-around`| Whether the search should wrap after depleting the matches | `true` |
 
+### `[editor.whitespace]` Section
 
-## LSP
+Options for rendering whitespace with visible characters. Use `:set whitespace.render all` to temporarily enable visible whitespace.
 
-To display all language server messages in the status line add the following to your `config.toml`:
+| Key | Description | Default |
+|-----|-------------|---------|
+| `render` | Whether to render whitespace. May either be `all` or `none`, or a table with sub-keys `space`, `nbsp`, `nnbsp`, `tab`, and `newline` | `none` |
+| `characters` | Literal characters to use when rendering whitespace. Sub-keys may be any of `tab`, `space`, `nbsp`, `nnbsp`, `newline` or `tabpad` | See example below |
+
+Example
 
 ```toml
-[lsp]
-display-messages = true
+[editor.whitespace]
+render = "all"
+# or control each character
+[editor.whitespace.render]
+space = "all"
+tab = "all"
+nbsp = "none"
+nnbsp = "none"
+newline = "none"
+
+[editor.whitespace.characters]
+space = "·"
+nbsp = "⍽"
+nnbsp = "␣"
+tab = "→"
+newline = "⏎"
+tabpad = "·" # Tabs will look like "→···" (depending on tab width)
+```
+
+### `[editor.indent-guides]` Section
+
+Options for rendering vertical indent guides.
+
+| Key           | Description                                             | Default |
+| ---           | ---                                                     | ---     |
+| `render`      | Whether to render indent guides                         | `false` |
+| `character`   | Literal character to use for rendering the indent guide | `│`     |
+| `skip-levels` | Number of indent levels to skip                         | `0`     |
+
+Example:
+
+```toml
+[editor.indent-guides]
+render = true
+character = "╎" # Some characters that work well: "▏", "┆", "┊", "⸽"
+skip-levels = 1
+```
+
+### `[editor.gutters]` Section
+
+For simplicity, `editor.gutters` accepts an array of gutter types, which will
+use default settings for all gutter components.
+
+```toml
+[editor]
+gutters = ["diff", "diagnostics", "line-numbers", "spacer"]
+```
+
+To customize the behavior of gutters, the `[editor.gutters]` section must
+be used. This section contains top level settings, as well as settings for
+specific gutter components as subsections.
+
+| Key      | Description                    | Default                                                       |
+| ---      | ---                            | ---                                                           |
+| `layout` | A vector of gutters to display | `["diagnostics", "spacer", "line-numbers", "spacer", "diff"]` |
+
+Example:
+
+```toml
+[editor.gutters]
+layout = ["diff", "diagnostics", "line-numbers", "spacer"]
+```
+
+#### `[editor.gutters.line-numbers]` Section
+
+Options for the line number gutter
+
+| Key         | Description                             | Default |
+| ---         | ---                                     | ---     |
+| `min-width` | The minimum number of characters to use | `3`     |
+
+Example:
+
+```toml
+[editor.gutters.line-numbers]
+min-width = 1
+```
+
+#### `[editor.gutters.diagnostics]` Section
+
+Currently unused
+
+#### `[editor.gutters.diff]` Section
+
+The `diff` gutter option displays colored bars indicating whether a `git` diff represents that a line was added, removed or changed.
+These colors are controlled by the theme attributes `diff.plus`, `diff.minus` and `diff.delta`.
+
+Other diff providers will eventually be supported by a future plugin system.
+
+There are currently no options for this section.
+
+#### `[editor.gutters.spacer]` Section
+
+Currently unused
+
+### `[editor.soft-wrap]` Section
+
+Options for soft wrapping lines that exceed the view width:
+
+| Key                  | Description                                                  | Default |
+| ---                  | ---                                                          | ---     |
+| `enable`             | Whether soft wrapping is enabled.                            | `false` |
+| `max-wrap`           | Maximum free space left at the end of the line.              | `20`    |
+| `max-indent-retain`  | Maximum indentation to carry over when soft wrapping a line. | `40`    |
+| `wrap-indicator`     | Text inserted before soft wrapped lines, highlighted with `ui.virtual.wrap` | `↪ `    |
+| `wrap-at-text-width` | Soft wrap at `text-width` instead of using the full viewport size. | `false` |
+
+Example:
+
+```toml
+[editor.soft-wrap]
+enable = true
+max-wrap = 25 # increase value to reduce forced mid-word wrapping
+max-indent-retain = 0
+wrap-indicator = ""  # set wrap-indicator to "" to hide it
+```
+
+### `[editor.smart-tab]` Section
+
+Options for navigating and editing using tab key.
+
+| Key        | Description | Default |
+|------------|-------------|---------|
+| `enable` | If set to true, then when the cursor is in a position with non-whitespace to its left, instead of inserting a tab, it will run `move_parent_node_end`. If there is only whitespace to the left, then it inserts a tab as normal. With the default bindings, to explicitly insert a tab character, press Shift-tab. | `true` |
+| `supersede-menu` | Normally, when a menu is on screen, such as when auto complete is triggered, the tab key is bound to cycling through the items. This means when menus are on screen, one cannot use the tab key to trigger the `smart-tab` command. If this option is set to true, the `smart-tab` command always takes precedence, which means one cannot use the tab key to cycle through menu items. One of the other bindings must be used instead, such as arrow keys or `C-n`/`C-p`. | `false` |
+
+
+Due to lack of support for S-tab in some terminals, the default keybindings don't fully embrace smart-tab editing experience. If you enjoy smart-tab navigation and a terminal that supports the [Enhanced Keyboard protocol](https://github.com/helix-editor/helix/wiki/Terminal-Support#enhanced-keyboard-protocol), consider setting extra keybindings:
+
+```
+[keys.normal]
+tab = "move_parent_node_end"
+S-tab = "move_parent_node_start"
+
+[keys.insert]
+S-tab = "move_parent_node_start"
+
+[keys.select]
+tab = "extend_parent_node_end"
+S-tab = "extend_parent_node_start"
 ```

book/src/from-vim.md

@@ -1,12 +1,12 @@
 # Migrating from Vim
 
-Helix's editing model is strongly inspired from vim and kakoune, and a notable
-difference from vim (and the most striking similarity to kakoune) is that Helix
-follows the `selection → action` model. This means that the whatever you are
-going to act on (a word, a paragraph, a line, etc) is selected first and the
-action itself (delete, change, yank, etc) comes second. A cursor is simply a
+Helix's editing model is strongly inspired from Vim and Kakoune, and a notable
+difference from Vim (and the most striking similarity to Kakoune) is that Helix
+follows the `selection → action` model. This means that whatever you are
+going to act on (a word, a paragraph, a line, etc.) is selected first and the
+action itself (delete, change, yank, etc.) comes second. A cursor is simply a
 single width selection.
 
-See also Kakoune's [Migrating from Vim](https://github.com/mawww/kakoune/wiki/Migrating-from-Vim).
+See also Kakoune's [Migrating from Vim](https://github.com/mawww/kakoune/wiki/Migrating-from-Vim) and Helix's [Migrating from Vim](https://github.com/helix-editor/helix/wiki/Migrating-from-Vim).
 
-> TODO: Mention texobjects, surround, registers
+> TODO: Mention textobjects, surround, registers

book/src/generated/lang-support.md

@@ -1,66 +1,222 @@
 | Language | Syntax Highlighting | Treesitter Textobjects | Auto Indent | Default LSP |
 | --- | --- | --- | --- | --- |
-| bash | ✓ |  |  | `bash-language-server` |
+| ada | ✓ | ✓ |  | `ada_language_server`, `ada_language_server` |
+| adl | ✓ | ✓ | ✓ |  |
+| agda | ✓ |  |  |  |
+| astro | ✓ |  |  |  |
+| awk | ✓ | ✓ |  | `awk-language-server` |
+| bash | ✓ | ✓ | ✓ | `bash-language-server` |
+| bass | ✓ |  |  | `bass` |
+| beancount | ✓ |  |  |  |
+| bibtex | ✓ |  |  | `texlab` |
+| bicep | ✓ |  |  | `bicep-langserver` |
+| bitbake | ✓ |  |  | `bitbake-language-server` |
+| blade | ✓ |  |  |  |
+| blueprint | ✓ |  |  | `blueprint-compiler` |
 | c | ✓ | ✓ | ✓ | `clangd` |
-| c-sharp | ✓ |  |  | `OmniSharp` |
+| c-sharp | ✓ | ✓ |  | `OmniSharp` |
+| cabal |  |  |  | `haskell-language-server-wrapper` |
+| cairo | ✓ | ✓ | ✓ | `cairo-language-server` |
+| capnp | ✓ |  | ✓ |  |
+| cel | ✓ |  |  |  |
+| clojure | ✓ |  |  | `clojure-lsp` |
 | cmake | ✓ | ✓ | ✓ | `cmake-language-server` |
 | comment | ✓ |  |  |  |
+| common-lisp | ✓ |  | ✓ | `cl-lsp` |
+| cpon | ✓ |  | ✓ |  |
 | cpp | ✓ | ✓ | ✓ | `clangd` |
-| css | ✓ |  |  |  |
-| dart | ✓ |  | ✓ | `dart` |
+| crystal | ✓ | ✓ |  | `crystalline` |
+| css | ✓ |  | ✓ | `vscode-css-language-server` |
+| cue | ✓ |  |  | `cuelsp` |
+| d | ✓ | ✓ | ✓ | `serve-d` |
+| dart | ✓ | ✓ | ✓ | `dart` |
+| dbml | ✓ |  |  |  |
+| devicetree | ✓ |  |  |  |
+| dhall | ✓ | ✓ |  | `dhall-lsp-server` |
+| diff | ✓ |  |  |  |
+| docker-compose | ✓ |  | ✓ | `docker-compose-langserver`, `yaml-language-server` |
 | dockerfile | ✓ |  |  | `docker-langserver` |
-| elixir | ✓ |  |  | `elixir-ls` |
-| elm | ✓ |  |  | `elm-language-server` |
-| erlang | ✓ |  |  |  |
+| dot | ✓ |  |  | `dot-language-server` |
+| dtd | ✓ |  |  |  |
+| earthfile | ✓ | ✓ | ✓ | `earthlyls` |
+| edoc | ✓ |  |  |  |
+| eex | ✓ |  |  |  |
+| ejs | ✓ |  |  |  |
+| elixir | ✓ | ✓ | ✓ | `elixir-ls` |
+| elm | ✓ | ✓ |  | `elm-language-server` |
+| elvish | ✓ |  |  | `elvish` |
+| env | ✓ |  |  |  |
+| erb | ✓ |  |  |  |
+| erlang | ✓ | ✓ |  | `erlang_ls` |
+| esdl | ✓ |  |  |  |
+| fidl | ✓ |  |  |  |
 | fish | ✓ | ✓ | ✓ |  |
-| git-commit | ✓ |  |  |  |
+| forth | ✓ |  |  | `forth-lsp` |
+| fortran | ✓ |  | ✓ | `fortls` |
+| fsharp | ✓ |  |  | `fsautocomplete` |
+| gas | ✓ | ✓ |  |  |
+| gdscript | ✓ | ✓ | ✓ |  |
+| gemini | ✓ |  |  |  |
+| git-attributes | ✓ |  |  |  |
+| git-commit | ✓ | ✓ |  |  |
 | git-config | ✓ |  |  |  |
-| git-diff | ✓ |  |  |  |
+| git-ignore | ✓ |  |  |  |
 | git-rebase | ✓ |  |  |  |
-| glsl | ✓ |  | ✓ |  |
-| go | ✓ | ✓ | ✓ | `gopls` |
-| graphql | ✓ |  |  |  |
-| haskell | ✓ |  |  | `haskell-language-server-wrapper` |
-| hcl | ✓ |  | ✓ | `terraform-ls` |
-| html | ✓ |  |  |  |
+| gleam | ✓ | ✓ |  | `gleam` |
+| glimmer | ✓ |  |  | `ember-language-server` |
+| glsl | ✓ | ✓ | ✓ |  |
+| gn | ✓ |  |  |  |
+| go | ✓ | ✓ | ✓ | `gopls`, `golangci-lint-langserver` |
+| godot-resource | ✓ |  |  |  |
+| gomod | ✓ |  |  | `gopls` |
+| gotmpl | ✓ |  |  | `gopls` |
+| gowork | ✓ |  |  | `gopls` |
+| graphql | ✓ | ✓ |  | `graphql-lsp` |
+| groovy | ✓ |  |  |  |
+| hare | ✓ |  |  |  |
+| haskell | ✓ | ✓ |  | `haskell-language-server-wrapper` |
+| haskell-persistent | ✓ |  |  |  |
+| hcl | ✓ | ✓ | ✓ | `terraform-ls` |
+| heex | ✓ | ✓ |  | `elixir-ls` |
+| helm | ✓ |  |  | `helm_ls` |
+| hocon | ✓ |  | ✓ |  |
+| hoon | ✓ |  |  |  |
+| hosts | ✓ |  |  |  |
+| html | ✓ |  |  | `vscode-html-language-server` |
+| hurl | ✓ |  | ✓ |  |
+| hyprlang | ✓ |  | ✓ |  |
+| idris |  |  |  | `idris2-lsp` |
 | iex | ✓ |  |  |  |
-| java | ✓ |  |  |  |
-| javascript | ✓ |  | ✓ | `typescript-language-server` |
-| json | ✓ |  | ✓ |  |
-| julia | ✓ |  |  | `julia` |
+| ini | ✓ |  |  |  |
+| janet | ✓ |  |  |  |
+| java | ✓ | ✓ | ✓ | `jdtls` |
+| javascript | ✓ | ✓ | ✓ | `typescript-language-server` |
+| jinja | ✓ |  |  |  |
+| jsdoc | ✓ |  |  |  |
+| json | ✓ | ✓ | ✓ | `vscode-json-language-server` |
+| json5 | ✓ |  |  |  |
+| jsonc | ✓ |  | ✓ | `vscode-json-language-server` |
+| jsonnet | ✓ |  |  | `jsonnet-language-server` |
+| jsx | ✓ | ✓ | ✓ | `typescript-language-server` |
+| julia | ✓ | ✓ | ✓ | `julia` |
+| just | ✓ | ✓ | ✓ |  |
+| kdl | ✓ | ✓ | ✓ |  |
+| koka | ✓ |  | ✓ | `koka` |
 | kotlin | ✓ |  |  | `kotlin-language-server` |
-| latex | ✓ |  |  |  |
+| latex | ✓ | ✓ |  | `texlab` |
+| ld | ✓ |  | ✓ |  |
+| ldif | ✓ |  |  |  |
 | lean | ✓ |  |  | `lean` |
 | ledger | ✓ |  |  |  |
 | llvm | ✓ | ✓ | ✓ |  |
 | llvm-mir | ✓ | ✓ | ✓ |  |
 | llvm-mir-yaml | ✓ |  | ✓ |  |
-| lua | ✓ |  | ✓ |  |
-| make | ✓ |  |  |  |
-| markdown | ✓ |  |  |  |
+| log | ✓ |  |  |  |
+| lpf | ✓ |  |  |  |
+| lua | ✓ | ✓ | ✓ | `lua-language-server` |
+| make | ✓ |  | ✓ |  |
+| markdoc | ✓ |  |  | `markdoc-ls` |
+| markdown | ✓ |  |  | `marksman`, `markdown-oxide` |
+| markdown.inline | ✓ |  |  |  |
+| matlab | ✓ | ✓ | ✓ |  |
+| mermaid | ✓ |  |  |  |
+| meson | ✓ |  | ✓ |  |
 | mint |  |  |  | `mint` |
-| nix | ✓ |  | ✓ | `rnix-lsp` |
-| ocaml | ✓ |  | ✓ |  |
-| ocaml-interface | ✓ |  |  |  |
-| perl | ✓ | ✓ | ✓ |  |
-| php | ✓ | ✓ | ✓ |  |
+| move | ✓ |  |  |  |
+| msbuild | ✓ |  | ✓ |  |
+| nasm | ✓ | ✓ |  |  |
+| nickel | ✓ |  | ✓ | `nls` |
+| nim | ✓ | ✓ | ✓ | `nimlangserver` |
+| nix | ✓ | ✓ |  | `nil` |
+| nu | ✓ |  |  | `nu` |
+| nunjucks | ✓ |  |  |  |
+| ocaml | ✓ |  | ✓ | `ocamllsp` |
+| ocaml-interface | ✓ |  |  | `ocamllsp` |
+| odin | ✓ |  | ✓ | `ols` |
+| ohm | ✓ | ✓ | ✓ |  |
+| opencl | ✓ | ✓ | ✓ | `clangd` |
+| openscad | ✓ |  |  | `openscad-lsp` |
+| org | ✓ |  |  |  |
+| pascal | ✓ | ✓ |  | `pasls` |
+| passwd | ✓ |  |  |  |
+| pem | ✓ |  |  |  |
+| perl | ✓ | ✓ | ✓ | `perlnavigator` |
+| php | ✓ | ✓ | ✓ | `intelephense` |
+| php-only | ✓ |  |  |  |
+| pkgbuild | ✓ | ✓ | ✓ | `pkgbuild-language-server`, `bash-language-server` |
+| pkl | ✓ |  | ✓ |  |
+| po | ✓ | ✓ |  |  |
+| pod | ✓ |  |  |  |
+| ponylang | ✓ | ✓ | ✓ |  |
+| powershell | ✓ |  |  |  |
+| prisma | ✓ |  |  | `prisma-language-server` |
 | prolog |  |  |  | `swipl` |
-| protobuf | ✓ |  | ✓ |  |
+| protobuf | ✓ | ✓ | ✓ | `bufls`, `pb` |
+| prql | ✓ |  |  |  |
+| purescript | ✓ | ✓ |  | `purescript-language-server` |
 | python | ✓ | ✓ | ✓ | `pylsp` |
-| racket |  |  |  | `racket` |
+| qml | ✓ |  | ✓ | `qmlls` |
+| r | ✓ |  |  | `R` |
+| racket | ✓ |  | ✓ | `racket` |
 | regex | ✓ |  |  |  |
+| rego | ✓ |  |  | `regols` |
 | rescript | ✓ | ✓ |  | `rescript-language-server` |
-| ruby | ✓ |  | ✓ | `solargraph` |
+| rmarkdown | ✓ |  | ✓ | `R` |
+| robot | ✓ |  |  | `robotframework_ls` |
+| ron | ✓ |  | ✓ |  |
+| rst | ✓ |  |  |  |
+| ruby | ✓ | ✓ | ✓ | `solargraph` |
 | rust | ✓ | ✓ | ✓ | `rust-analyzer` |
-| scala | ✓ |  | ✓ | `metals` |
+| sage | ✓ | ✓ |  |  |
+| scala | ✓ | ✓ | ✓ | `metals` |
+| scheme | ✓ |  | ✓ |  |
+| scss | ✓ |  |  | `vscode-css-language-server` |
+| slint | ✓ | ✓ | ✓ | `slint-lsp` |
+| smali | ✓ |  | ✓ |  |
+| smithy | ✓ |  |  | `cs` |
+| sml | ✓ |  |  |  |
+| solidity | ✓ | ✓ |  | `solc` |
+| spicedb | ✓ |  |  |  |
+| sql | ✓ |  |  |  |
+| sshclientconfig | ✓ |  |  |  |
+| starlark | ✓ | ✓ |  |  |
+| strace | ✓ |  |  |  |
+| supercollider | ✓ |  |  |  |
 | svelte | ✓ |  | ✓ | `svelteserver` |
+| sway | ✓ | ✓ | ✓ | `forc` |
+| swift | ✓ |  |  | `sourcekit-lsp` |
+| t32 | ✓ |  |  |  |
 | tablegen | ✓ | ✓ | ✓ |  |
-| toml | ✓ |  |  |  |
+| tact | ✓ | ✓ | ✓ |  |
+| task | ✓ |  |  |  |
+| tcl | ✓ |  | ✓ |  |
+| templ | ✓ |  |  | `templ` |
+| tfvars | ✓ |  | ✓ | `terraform-ls` |
+| todotxt | ✓ |  |  |  |
+| toml | ✓ | ✓ |  | `taplo` |
 | tsq | ✓ |  |  |  |
-| tsx | ✓ |  |  | `typescript-language-server` |
+| tsx | ✓ | ✓ | ✓ | `typescript-language-server` |
 | twig | ✓ |  |  |  |
-| typescript | ✓ |  | ✓ | `typescript-language-server` |
-| vue | ✓ |  |  |  |
-| wgsl | ✓ |  |  |  |
-| yaml | ✓ |  | ✓ |  |
-| zig | ✓ |  | ✓ | `zls` |
+| typescript | ✓ | ✓ | ✓ | `typescript-language-server` |
+| typst | ✓ |  |  | `tinymist`, `typst-lsp` |
+| ungrammar | ✓ |  |  |  |
+| unison | ✓ |  | ✓ |  |
+| uxntal | ✓ |  |  |  |
+| v | ✓ | ✓ | ✓ | `v-analyzer` |
+| vala | ✓ | ✓ |  | `vala-language-server` |
+| verilog | ✓ | ✓ |  | `svlangserver` |
+| vhdl | ✓ |  |  | `vhdl_ls` |
+| vhs | ✓ |  |  |  |
+| vue | ✓ |  |  | `vue-language-server` |
+| wast | ✓ |  |  |  |
+| wat | ✓ |  |  |  |
+| webc | ✓ |  |  |  |
+| wgsl | ✓ |  |  | `wgsl_analyzer` |
+| wit | ✓ |  | ✓ |  |
+| wren | ✓ | ✓ | ✓ |  |
+| xit | ✓ |  |  |  |
+| xml | ✓ |  | ✓ |  |
+| xtc | ✓ |  |  |  |
+| yaml | ✓ |  | ✓ | `yaml-language-server`, `ansible-language-server` |
+| yuck | ✓ |  |  |  |
+| zig | ✓ | ✓ | ✓ | `zls` |

book/src/generated/typable-cmd.md

@@ -1,31 +1,38 @@
 | Name | Description |
 | --- | --- |
 | `:quit`, `:q` | Close the current view. |
-| `:quit!`, `:q!` | Close the current view forcefully (ignoring unsaved changes). |
+| `:quit!`, `:q!` | Force close the current view, ignoring unsaved changes. |
 | `:open`, `:o` | Open a file from disk into the current view. |
 | `:buffer-close`, `:bc`, `:bclose` | Close the current buffer. |
-| `:buffer-close!`, `:bc!`, `:bclose!` | Close the current buffer forcefully (ignoring unsaved changes). |
+| `:buffer-close!`, `:bc!`, `:bclose!` | Close the current buffer forcefully, ignoring unsaved changes. |
 | `:buffer-close-others`, `:bco`, `:bcloseother` | Close all buffers but the currently focused one. |
-| `:buffer-close-others!`, `:bco!`, `:bcloseother!` | Close all buffers but the currently focused one. |
-| `:buffer-close-all`, `:bca`, `:bcloseall` | Close all buffers, without quiting. |
-| `:buffer-close-all!`, `:bca!`, `:bcloseall!` | Close all buffers forcefully (ignoring unsaved changes), without quiting. |
+| `:buffer-close-others!`, `:bco!`, `:bcloseother!` | Force close all buffers but the currently focused one. |
+| `:buffer-close-all`, `:bca`, `:bcloseall` | Close all buffers without quitting. |
+| `:buffer-close-all!`, `:bca!`, `:bcloseall!` | Force close all buffers ignoring unsaved changes without quitting. |
+| `:buffer-next`, `:bn`, `:bnext` | Goto next buffer. |
+| `:buffer-previous`, `:bp`, `:bprev` | Goto previous buffer. |
 | `:write`, `:w` | Write changes to disk. Accepts an optional path (:write some/path.txt) |
+| `:write!`, `:w!` | Force write changes to disk creating necessary subdirectories. Accepts an optional path (:write! some/path.txt) |
+| `:write-buffer-close`, `:wbc` | Write changes to disk and closes the buffer. Accepts an optional path (:write-buffer-close some/path.txt) |
+| `:write-buffer-close!`, `:wbc!` | Force write changes to disk creating necessary subdirectories and closes the buffer. Accepts an optional path (:write-buffer-close! some/path.txt) |
 | `:new`, `:n` | Create a new scratch buffer. |
 | `:format`, `:fmt` | Format the file using the LSP formatter. |
-| `:indent-style` | Set the indentation style for editing. ('t' for tabs or 1-8 for number of spaces.) |
-| `:line-ending` | Set the document's default line ending. Options: crlf, lf, cr, ff, nel. |
+| `:indent-style` | Set the indentation style for editing. ('t' for tabs or 1-16 for number of spaces.) |
+| `:line-ending` | Set the document's default line ending. Options: crlf, lf. |
 | `:earlier`, `:ear` | Jump back to an earlier point in edit history. Accepts a number of steps or a time span. |
 | `:later`, `:lat` | Jump to a later point in edit history. Accepts a number of steps or a time span. |
 | `:write-quit`, `:wq`, `:x` | Write changes to disk and close the current view. Accepts an optional path (:wq some/path.txt) |
 | `:write-quit!`, `:wq!`, `:x!` | Write changes to disk and close the current view forcefully. Accepts an optional path (:wq! some/path.txt) |
-| `:write-all`, `:wa` | Write changes from all views to disk. |
-| `:write-quit-all`, `:wqa`, `:xa` | Write changes from all views to disk and close all views. |
-| `:write-quit-all!`, `:wqa!`, `:xa!` | Write changes from all views to disk and close all views forcefully (ignoring unsaved changes). |
+| `:write-all`, `:wa` | Write changes from all buffers to disk. |
+| `:write-all!`, `:wa!` | Forcefully write changes from all buffers to disk creating necessary subdirectories. |
+| `:write-quit-all`, `:wqa`, `:xa` | Write changes from all buffers to disk and close all views. |
+| `:write-quit-all!`, `:wqa!`, `:xa!` | Write changes from all buffers to disk and close all views forcefully (ignoring unsaved changes). |
 | `:quit-all`, `:qa` | Close all views. |
-| `:quit-all!`, `:qa!` | Close all views forcefully (ignoring unsaved changes). |
+| `:quit-all!`, `:qa!` | Force close all views ignoring unsaved changes. |
 | `:cquit`, `:cq` | Quit with exit code (default 1). Accepts an optional integer exit code (:cq 2). |
-| `:cquit!`, `:cq!` | Quit with exit code (default 1) forcefully (ignoring unsaved changes). Accepts an optional integer exit code (:cq! 2). |
-| `:theme` | Change the editor theme. |
+| `:cquit!`, `:cq!` | Force quit with exit code (default 1) ignoring unsaved changes. Accepts an optional integer exit code (:cq! 2). |
+| `:theme` | Change the editor theme (show current theme if no name specified). |
+| `:yank-join` | Yank joined selections. A separator can be provided as first argument. Default value is newline. |
 | `:clipboard-yank` | Yank main selection into system clipboard. |
 | `:clipboard-yank-join` | Yank joined selections into system clipboard. A separator can be provided as first argument. Default value is newline. |
 | `:primary-clipboard-yank` | Yank main selection into system primary clipboard. |
@@ -39,9 +46,16 @@
 | `:show-clipboard-provider` | Show clipboard provider name in status bar. |
 | `:change-current-directory`, `:cd` | Change the current working directory. |
 | `:show-directory`, `:pwd` | Show the current working directory. |
-| `:encoding` | Set encoding based on `https://encoding.spec.whatwg.org` |
-| `:reload` | Discard changes and reload from the source file. |
+| `:encoding` | Set encoding. Based on `https://encoding.spec.whatwg.org`. |
+| `:character-info`, `:char` | Get info about the character under the primary cursor. |
+| `:reload`, `:rl` | Discard changes and reload from the source file. |
+| `:reload-all`, `:rla` | Discard changes and reload all documents from the source files. |
+| `:update`, `:u` | Write changes only if the file has been modified. |
+| `:lsp-workspace-command` | Open workspace command picker |
+| `:lsp-restart` | Restarts the language servers used by the current doc |
+| `:lsp-stop` | Stops the language servers that are used by the current doc |
 | `:tree-sitter-scopes` | Display tree sitter scopes, primarily for theming and development. |
+| `:tree-sitter-highlight-name` | Display name of tree-sitter highlight scope under the cursor. |
 | `:debug-start`, `:dbg` | Start a debug session from a given template with given parameters. |
 | `:debug-remote`, `:dbg-tcp` | Connect to a debug adapter by TCP address and start a debugging session from a given template with given parameters. |
 | `:debug-eval` | Evaluate expression in current debug context. |
@@ -50,8 +64,27 @@
 | `:hsplit`, `:hs`, `:sp` | Open the file in a horizontal split. |
 | `:hsplit-new`, `:hnew` | Open a scratch buffer in a horizontal split. |
 | `:tutor` | Open the tutorial. |
-| `:goto`, `:g` | Go to line number. |
-| `:set-option`, `:set` | Set a config option at runtime |
+| `:goto`, `:g` | Goto line number. |
+| `:set-language`, `:lang` | Set the language of current buffer (show current language if no value specified). |
+| `:set-option`, `:set` | Set a config option at runtime.<br>For example to disable smart case search, use `:set search.smart-case false`. |
+| `:toggle-option`, `:toggle` | Toggle a boolean config option at runtime.<br>For example to toggle smart case search, use `:toggle search.smart-case`. |
+| `:get-option`, `:get` | Get the current value of a config option. |
 | `:sort` | Sort ranges in selection. |
 | `:rsort` | Sort ranges in selection in reverse order. |
+| `:reflow` | Hard-wrap the current selection of lines to a given width. |
 | `:tree-sitter-subtree`, `:ts-subtree` | Display tree sitter subtree under cursor, primarily for debugging queries. |
+| `:config-reload` | Refresh user config. |
+| `:config-open` | Open the user config.toml file. |
+| `:config-open-workspace` | Open the workspace config.toml file. |
+| `:log-open` | Open the helix log file. |
+| `:insert-output` | Run shell command, inserting output before each selection. |
+| `:append-output` | Run shell command, appending output after each selection. |
+| `:pipe` | Pipe each selection to the shell command. |
+| `:pipe-to` | Pipe each selection to the shell command, ignoring output. |
+| `:run-shell-command`, `:sh` | Run a shell command |
+| `:reset-diff-change`, `:diffget`, `:diffg` | Reset the diff change at the cursor position. |
+| `:clear-register` | Clear given register. If no argument is provided, clear all registers. |
+| `:redraw` | Clear and re-render the whole UI |
+| `:move` | Move the current buffer and its corresponding file to a different path |
+| `:yank-diagnostic` | Yank diagnostic(s) under primary cursor to register, or clipboard by default |
+| `:read`, `:r` | Load a file into buffer |

book/src/guides/README.md

@@ -1,4 +1,4 @@
 # Guides
 
 This section contains guides for adding new language server configurations,
-tree-sitter grammers, textobject queries, etc.
+tree-sitter grammars, textobject queries, and other similar items.

book/src/guides/adding_languages.md

@@ -1,90 +1,55 @@
-# Adding languages
+# Adding new languages to Helix
+
+In order to add a new language to Helix, you will need to follow the steps
+below.
 
 ## Language configuration
 
-To add a new language, you need to add a `language` entry to the
-[`languages.toml`][languages.toml] found in the root of the repository;
-this `languages.toml` file is included at compilation time, and is
-distinct from the `languages.toml` file in the user's [configuration
-directory](../configuration.md).
+1. Add a new `[[language]]` entry in the `languages.toml` file and provide the
+   necessary configuration for the new language. For more information on
+   language configuration, refer to the
+   [language configuration section](../languages.md) of the documentation.
+   A new language server can be added by extending the `[language-server]` table in the same file.
+2. If you are adding a new language or updating an existing language server
+   configuration, run the command `cargo xtask docgen` to update the
+   [Language Support](../lang-support.md) documentation.
 
-```toml
-[[language]]
-name = "mylang"
-scope = "scope.mylang"
-injection-regex = "^mylang$"
-file-types = ["mylang", "myl"]
-comment-token = "#"
-indent = { tab-width = 2, unit = "  " }
-```
-
-These are the available keys and descriptions for the file.
-
-| Key                   | Description                                                   |
-| ----                  | -----------                                                   |
-| `name`                | The name of the language                                      |
-| `scope`               | A string like `source.js` that identifies the language. Currently, we strive to match the scope names used by popular TextMate grammars and by the Linguist library. Usually `source.<name>` or `text.<name>` in case of markup languages |
-| `injection-regex`     | regex pattern that will be tested against a language name in order to determine whether this language should be used for a potential [language injection][treesitter-language-injection] site. |
-| `file-types`          | The filetypes of the language, for example `["yml", "yaml"]`. Extensions and full file names are supported.  |
-| `shebangs`            | The interpreters from the shebang line, for example `["sh", "bash"]` |
-| `roots`               | A set of marker files to look for when trying to find the workspace root. For example `Cargo.lock`, `yarn.lock` |
-| `auto-format`         | Whether to autoformat this language when saving               |
-| `diagnostic-severity` | Minimal severity of diagnostic for it to be displayed. (Allowed values: `Error`, `Warning`, `Info`, `Hint`) |
-| `comment-token`       | The token to use as a comment-token                           |
-| `indent`              | The indent to use. Has sub keys `tab-width` and `unit`        |
-| `config`              | Language server configuration                                 |
-| `grammar`             | The tree-sitter grammar to use (defaults to the value of `name`) |
+> 💡 If you are adding a new Language Server configuration, make sure to update
+> the
+> [Language Server Wiki](https://github.com/helix-editor/helix/wiki/How-to-install-the-default-language-servers)
+> with the installation instructions.
 
 ## Grammar configuration
 
-If a tree-sitter grammar is available for the language, add a new `grammar`
-entry to `languages.toml`.
-
-```toml
-[[grammar]]
-name = "mylang"
-source = { git = "https://github.com/example/mylang", rev = "a250c4582510ff34767ec3b7dcdd3c24e8c8aa68" }
-```
-
-Grammar configuration takes these keys:
-
-| Key      | Description                                                              |
-| ---      | -----------                                                              |
-| `name`   | The name of the tree-sitter grammar                                      |
-| `source` | The method of fetching the grammar - a table with a schema defined below |
-
-Where `source` is a table with either these keys when using a grammar from a
-git repository:
-
-| Key    | Description                                               |
-| ---    | -----------                                               |
-| `git`  | A git remote URL from which the grammar should be cloned  |
-| `rev`  | The revision (commit hash or tag) which should be fetched |
-| `subpath` | A path within the grammar directory which should be built. Some grammar repositories host multiple grammars (for example `tree-sitter-typescript` and `tree-sitter-ocaml`) in subdirectories. This key is used to point `hx --grammar build` to the correct path for compilation. When omitted, the root of repository is used |
-
-Or a `path` key with an absolute path to a locally available grammar directory.
+1. If a tree-sitter grammar is available for the new language, add a new
+   `[[grammar]]` entry to the `languages.toml` file.
+2. If you are testing the grammar locally, you can use the `source.path` key
+   with an absolute path to the grammar. However, before submitting a pull
+   request, make sure to switch to using `source.git`.
 
 ## Queries
 
-For a language to have syntax-highlighting and indentation among
-other things, you have to add queries. Add a directory for your
-language with the path `runtime/queries/<name>/`. The tree-sitter
-[website](https://tree-sitter.github.io/tree-sitter/syntax-highlighting#queries)
-gives more info on how to write queries.
+1. In order to provide syntax highlighting and indentation for the new language,
+   you will need to add queries.
+2. Create a new directory for the language with the path
+   `runtime/queries/<name>/`.
+3. Refer to the
+   [tree-sitter website](https://tree-sitter.github.io/tree-sitter/syntax-highlighting#queries)
+   for more information on writing queries.
+4. A list of highlight captures can be found [on the themes page](https://docs.helix-editor.com/themes.html#scopes).
 
-> NOTE: When evaluating queries, the first matching query takes
-precedence, which is different from other editors like neovim where
-the last matching query supersedes the ones before it. See
-[this issue][neovim-query-precedence] for an example.
+> 💡 In Helix, the first matching query takes precedence when evaluating
+> queries, which is different from other editors such as Neovim where the last
+> matching query supersedes the ones before it. See
+> [this issue](https://github.com/helix-editor/helix/pull/1170#issuecomment-997294090)
+> for an example.
 
-## Common Issues
+## Common issues
 
-- If you get errors when running after switching branches, you may have to update the tree-sitter grammars. Run `hx --grammar fetch` to fetch the grammars and `hx --grammar build` to build any out-of-date grammars.
-
-- If a parser is segfaulting or you want to remove the parser, make sure to remove the compiled parser in `runtime/grammar/<name>.so`
-
-- The indents query is `indents.toml`, *not* `indents.scm`. See [this](https://github.com/helix-editor/helix/issues/114) issue for more information.
-
-[treesitter-language-injection]: https://tree-sitter.github.io/tree-sitter/syntax-highlighting#language-injection
-[languages.toml]: https://github.com/helix-editor/helix/blob/master/languages.toml
-[neovim-query-precedence]: https://github.com/helix-editor/helix/pull/1170#issuecomment-997294090
+- If you encounter errors when running Helix after switching branches, you may
+  need to update the tree-sitter grammars. Run the command `hx --grammar fetch`
+  to fetch the grammars and `hx --grammar build` to build any out-of-date
+  grammars.
+- If a parser is causing a segfault, or you want to remove it, make sure to
+  remove the compiled parser located at `runtime/grammars/<name>.so`.
+- If you are attempting to add queries and Helix is unable to locate them, ensure that the environment variable `HELIX_RUNTIME` is set to the location of the `runtime` folder you're developing in.

book/src/guides/indent.md

@@ -0,0 +1,373 @@
+# Adding indent queries
+
+Helix uses tree-sitter to correctly indent new lines. This requires a tree-
+sitter grammar and an `indent.scm` query file placed in `runtime/queries/
+{language}/indents.scm`. The indentation for a line is calculated by traversing
+the syntax tree from the lowest node at the beginning of the new line (see
+[Indent queries](#indent-queries)). Each of these nodes contributes to the total
+indent when it is captured by the query (in what way depends on the name of
+the capture.
+
+Note that it matters where these added indents begin. For example,
+multiple indent level increases that start on the same line only increase
+the total indent level by 1. See [Capture types](#capture-types).
+
+By default, Helix uses the `hybrid` indentation heuristic. This means that
+indent queries are not used to compute the expected absolute indentation of a
+line but rather the expected difference in indentation between the new and an
+already existing line. This difference is then added to the actual indentation
+of the already existing line. Since this makes errors in the indent queries
+harder to find, it is recommended to disable it when testing via
+`:set indent-heuristic tree-sitter`. The rest of this guide assumes that
+the `tree-sitter` heuristic is used.
+
+## Indent queries
+
+When Helix is inserting a new line through `o`, `O`, or `<ret>`, to determine
+the indent level for the new line, the query in `indents.scm` is run on the
+document. The starting position of the query is the end of the line above where
+a new line will be inserted.
+
+For `o`, the inserted line is the line below the cursor, so that starting
+position of the query is the end of the current line.
+
+```rust
+fn need_hero(some_hero: Hero, life: Life) -> {
+    matches!(some_hero, Hero { // ←─────────────────╮
+        strong: true,//←╮  ↑  ↑                     │
+        fast: true,  // │  │  ╰── query start       │
+        sure: true,  // │  ╰───── cursor            ├─ traversal 
+        soon: true,  // ╰──────── new line inserted │  start node
+    }) &&            //                             │
+//  ↑                                               │
+//  ╰───────────────────────────────────────────────╯
+    some_hero > life
+}
+```
+
+For `O`, the newly inserted line is the *current* line, so the starting position
+of the query is the end of the line above the cursor.
+
+```rust
+fn need_hero(some_hero: Hero, life: Life) -> { // ←─╮
+    matches!(some_hero, Hero { // ←╮          ↑     │
+        strong: true,//    ↑   ╭───╯          │     │
+        fast: true,  //    │   │ query start ─╯     │
+        sure: true,  //    ╰───┼ cursor             ├─ traversal
+        soon: true,  //        ╰ new line inserted  │  start node
+    }) &&            //                             │
+    some_hero > life //                             │
+} // ←──────────────────────────────────────────────╯
+```
+
+From this starting node, the syntax tree is traversed up until the root node.
+Each indent capture is collected along the way, and then combined according to
+their [capture types](#capture-types) and [scopes](#scopes) to a final indent
+level for the line.
+
+### Capture types
+
+- `@indent` (default scope `tail`):
+  Increase the indent level by 1. Multiple occurrences in the same line *do not*
+  stack. If there is at least one `@indent` and one `@outdent` capture on the
+  same line, the indent level isn't changed at all.
+- `@outdent` (default scope `all`):
+  Decrease the indent level by 1. The same rules as for `@indent` apply.
+- `@indent.always` (default scope `tail`):
+  Increase the indent level by 1. Multiple occurrences on the same line *do*
+  stack. The final indent level is `@indent.always` – `@outdent.always`. If
+  an `@indent` and an `@indent.always` are on the same line, the `@indent` is
+  ignored.
+- `@outdent.always` (default scope `all`):
+  Decrease the indent level by 1. The same rules as for `@indent.always` apply.
+- `@align` (default scope `all`):
+  Align everything inside this node to some anchor. The anchor is given
+  by the start of the node captured by `@anchor` in the same pattern.
+  Every pattern with an `@align` should contain exactly one `@anchor`.
+  Indent (and outdent) for nodes below (in terms of their starting line)
+  the `@align` node is added to the indentation required for alignment.
+- `@extend`:
+  Extend the range of this node to the end of the line and to lines that are
+  indented more than the line that this node starts on. This is useful for
+  languages like Python, where for the purpose of indentation some nodes (like
+  functions or classes) should also contain indented lines that follow them.
+- `@extend.prevent-once`:
+  Prevents the first extension of an ancestor of this node. For example, in Python
+  a return expression always ends the block that it is in. Note that this only
+  stops the extension of the next `@extend` capture. If multiple ancestors are
+  captured, only the extension of the innermost one is prevented. All other
+  ancestors are unaffected (regardless of whether the innermost ancestor would
+  actually have been extended).
+
+#### `@indent` / `@outdent`
+
+Consider this example:
+
+```rust
+fn shout(things: Vec<Thing>) {
+    //                       ↑
+    //                       ├───────────────────────╮ indent level
+    //                    @indent                    ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄
+    //                                               │
+    let it_all = |out| { things.filter(|thing| { //  │      1
+    //                 ↑                       ↑     │
+    //                 ├───────────────────────┼─────┼┄┄┄┄┄┄┄┄┄┄┄┄┄┄
+    //              @indent                 @indent  │
+    //                                               │      2
+        thing.can_do_with(out) //                    │
+    })}; //                                          ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄
+  //↑↑↑                                              │      1
+} //╰┼┴──────────────────────────────────────────────┴┄┄┄┄┄┄┄┄┄┄┄┄┄┄
+// 3x @outdent
+```
+
+```scm
+((block) @indent)
+["}" ")"] @outdent
+```
+
+Note how on the second line, we have two blocks begin on the same line. In this
+case, since both captures occur on the same line, they are combined and only
+result in a net increase of 1. Also note that the closing `}`s are part of the
+`@indent` captures, but the 3 `@outdent`s also combine into 1 and result in that
+line losing one indent level.
+
+#### `@extend` / `@extend.prevent-once`
+
+For an example of where `@extend` can be useful, consider Python, which is
+whitespace-sensitive.
+
+```scm
+]
+  (parenthesized_expression)
+  (function_definition)
+  (class_definition)
+] @indent
+
+```
+
+```python
+class Hero:
+    def __init__(self, strong, fast, sure, soon):#  ←─╮
+        self.is_strong = strong #                     │
+        self.is_fast = fast     # ╭─── query start    │
+        self.is_sure = sure     # │ ╭─ cursor         │
+        self.is_soon = soon     # │ │                 │
+        #     ↑            ↑      │ │                 │
+        #     │            ╰──────╯ │                 │
+        #     ╰─────────────────────╯                 │
+        #                                             ├─ traversal
+    def need_hero(self, life):         #              │  start node
+        return (                       #              │
+            self.is_strong             #              │
+            and self.is_fast           #              │
+            and self.is_sure           #              │
+            and self.is_soon           #              │
+            and self > life            #              │
+        ) # ←─────────────────────────────────────────╯
+```
+
+Without braces to catch the scope of the function, the smallest descendant of
+the cursor on a line feed ends up being the entire inside of the class. Because
+of this, it will miss the entire function node and its indent capture, leading
+to an indent level one too small.
+
+To address this case, `@extend` tells helix to "extend" the captured node's span
+to the line feed and every consecutive line that has a greater indent level than
+the line of the node.
+
+```scm
+(parenthesized_expression) @indent
+
+]
+  (function_definition)
+  (class_definition)
+] @indent @extend
+
+```
+
+```python
+class Hero:
+    def __init__(self, strong, fast, sure, soon):#  ←─╮
+        self.is_strong = strong #                     │
+        self.is_fast = fast     # ╭─── query start    ├─ traversal
+        self.is_sure = sure     # │ ╭─ cursor         │  start node
+        self.is_soon = soon     # │ │ ←───────────────╯
+        #     ↑            ↑      │ │                 
+        #     │            ╰──────╯ │
+        #     ╰─────────────────────╯
+    def need_hero(self, life):
+        return (
+            self.is_strong
+            and self.is_fast
+            and self.is_sure
+            and self.is_soon
+            and self > life
+        )
+```
+
+Furthermore, there are some cases where extending to everything with a greater
+indent level may not be desirable. Consider the `need_hero` function above. If
+our cursor is on the last line of the returned expression.
+
+```python
+class Hero:
+    def __init__(self, strong, fast, sure, soon):
+        self.is_strong = strong
+        self.is_fast = fast
+        self.is_sure = sure
+        self.is_soon = soon
+
+    def need_hero(self, life):
+        return (
+            self.is_strong
+            and self.is_fast
+            and self.is_sure
+            and self.is_soon
+            and self > life
+        ) # ←─── cursor
+    #←────────── where cursor should go on new line
+```
+
+In Python, the are a few tokens that will always end a scope, such as a return
+statement. Since the scope ends, so should the indent level. But because the
+function span is extended to every line with a greater indent level, a new line
+would just continue on the same level. And an `@outdent` would not help us here
+either, since it would cause everything in the parentheses to become outdented
+as well.
+
+To help, we need to signal an end to the extension. We can do this with
+`@extend.prevent-once`.
+
+```scm
+(parenthesized_expression) @indent
+
+]
+  (function_definition)
+  (class_definition)
+] @indent @extend
+
+(return_statement) @extend.prevent-once
+```
+
+#### `@indent.always` / `@outdent.always`
+
+As mentioned before, normally if there is more than one `@indent` or `@outdent`
+capture on the same line, they are combined.
+
+Sometimes, there are cases when you may want to ensure that every indent capture
+is additive, regardless of how many occur on the same line. Consider this
+example in YAML.
+
+```yaml
+  - foo: bar
+# ↑ ↑
+# │ ╰─────────────── start of map
+# ╰───────────────── start of list element
+    baz: quux # ←─── cursor
+    # ←───────────── where the cursor should go on a new line
+    garply: waldo
+  - quux:
+      bar: baz
+    xyzzy: thud
+    fred: plugh
+```
+
+In YAML, you often have lists of maps. In these cases, the syntax is such that
+the list element and the map both start on the same line. But we really do want
+to start an indentation for each of these so that subsequent keys in the map
+hang over the list and align properly. This is where `@indent.always` helps.
+
+```scm
+((block_sequence_item) @item @indent.always @extend
+  (#not-one-line? @item))
+
+((block_mapping_pair
+    key: (_) @key
+    value: (_) @val
+    (#not-same-line? @key @val)
+  ) @indent.always @extend
+)
+```
+
+## Predicates
+
+In some cases, an S-expression cannot express exactly what pattern should be matched.
+For that, tree-sitter allows for predicates to appear anywhere within a pattern,
+similar to how `#set!` declarations work:
+
+```scm
+(some_kind
+  (child_kind) @indent
+  (#predicate? arg1 arg2 ...)
+)
+```
+
+The number of arguments depends on the predicate that's used.
+Each argument is either a capture (`@name`) or a string (`"some string"`).
+The following predicates are supported by tree-sitter:
+
+- `#eq?`/`#not-eq?`:
+The first argument (a capture) must/must not be equal to the second argument
+(a capture or a string).
+
+- `#match?`/`#not-match?`:
+The first argument (a capture) must/must not match the regex given in the
+second argument (a string).
+
+- `#any-of?`/`#not-any-of?`:
+The first argument (a capture) must/must not be one of the other arguments
+(strings).
+
+Additionally, we support some custom predicates for indent queries:
+
+- `#not-kind-eq?`:
+The kind of the first argument (a capture) must not be equal to the second
+argument (a string).
+
+- `#same-line?`/`#not-same-line?`:
+The captures given by the 2 arguments must/must not start on the same line.
+
+- `#one-line?`/`#not-one-line?`:
+The captures given by the fist argument must/must span a total of one line.
+
+### Scopes
+
+Added indents don't always apply to the whole node. For example, in most
+cases when a node should be indented, we actually only want everything
+except for its first line to be indented. For this, there are several
+scopes (more scopes may be added in the future if required):
+
+- `tail`:
+This scope applies to everything except for the first line of the
+captured node.
+- `all`:
+This scope applies to the whole captured node. This is only different from
+`tail` when the captured node is the first node on its line.
+
+For example, imagine we have the following function
+
+```rust
+fn aha() { // ←─────────────────────────────────────╮
+  let take = "on me";  // ←──────────────╮  scope:  │
+  let take = "me on";             //     ├─ "tail"  ├─ (block) @indent
+  let ill = be_gone_days(1 || 2); //     │          │
+} // ←───────────────────────────────────┴──────────┴─ "}" @outdent
+                                         //                scope: "all"
+```
+
+We can write the following query with the `#set!` declaration:
+
+  ```scm
+  ((block) @indent
+   (#set! "scope" "tail"))
+  ("}" @outdent
+   (#set! "scope" "all"))
+  ```
+
+As we can see, the "tail" scope covers the node, except for the first line.
+Everything up to and including the closing brace gets an indent level of 1.
+Then, on the closing brace, we encounter an outdent with a scope of "all", which
+means the first line is included, and the indent level is cancelled out on this
+line. (Note these scopes are the defaults for `@indent` and `@outdent`—they are
+written explicitly for demonstration.)

book/src/guides/injection.md

@@ -0,0 +1,60 @@
+# Adding Injection Queries
+
+Writing language injection queries allows one to highlight a specific node as a different language.
+In addition to the [standard][upstream-docs] language injection options used by tree-sitter, there
+are a few Helix specific extensions that allow for more control.
+
+And example of a simple query that would highlight all strings as bash in Nix:
+```scm
+((string_expression (string_fragment) @injection.content)
+  (#set! injection.language "bash"))
+```
+
+## Capture Types
+
+- `@injection.language` (standard):
+The captured node may contain the language name used to highlight the node captured by
+`@injection.content`.
+
+- `@injection.content` (standard):
+Marks the content to be highlighted as the language captured with `@injection.language` _et al_.
+
+- `@injection.filename` (extension):
+The captured node may contain a filename with a file-extension known to Helix,
+highlighting `@injection.content` as that language. This uses the language extensions defined in
+both the default languages.toml distributed with Helix, as well as user defined languages.
+
+- `@injection.shebang` (extension):
+The captured node may contain a shebang used to choose a language to highlight as. This also uses
+the shebangs defined in the default and user `languages.toml`.
+
+## Settings
+
+- `injection.combined` (standard):
+Indicates that all the matching nodes in the tree should have their content parsed as one
+nested document.
+
+- `injection.language` (standard):
+Forces the captured content to be highlighted as the given language
+
+- `injection.include-children` (standard):
+Indicates that the content node’s entire text should be re-parsed, including the text of its child
+nodes. By default, child nodes’ text will be excluded from the injected document.
+
+- `injection.include-unnamed-children` (extension):
+Same as `injection.include-children` but only for unnamed child nodes.
+
+## Predicates
+
+- `#eq?` (standard):
+The first argument (a capture) must be equal to the second argument
+(a capture or a string).
+
+- `#match?` (standard):
+The first argument (a capture) must match the regex given in the
+second argument (a string).
+
+- `#any-of?` (standard):
+The first argument (a capture) must be one of the other arguments (strings).
+
+[upstream-docs]: http://tree-sitter.github.io/tree-sitter/syntax-highlighting#language-injection

book/src/guides/textobject.md

@@ -1,14 +1,14 @@
-# Adding Textobject Queries
+# Adding textobject queries
 
-Textobjects that are language specific ([like functions, classes, etc][textobjects])
-require an accompanying tree-sitter grammar and a `textobjects.scm` query file
+Helix supports textobjects that are language specific, such as functions, classes, etc.
+These textobjects require an accompanying tree-sitter grammar and a `textobjects.scm` query file
 to work properly. Tree-sitter allows us to query the source code syntax tree
 and capture specific parts of it. The queries are written in a lisp dialect.
 More information on how to write queries can be found in the [official tree-sitter
 documentation][tree-sitter-queries].
 
 Query files should be placed in `runtime/queries/{language}/textobjects.scm`
-when contributing. Note that to test the query files locally you should put
+when contributing to Helix. Note that to test the query files locally you should put
 them under your local runtime directory (`~/.config/helix/runtime` on Linux
 for example).
 
@@ -20,15 +20,19 @@ The following [captures][tree-sitter-captures] are recognized:
 | `function.around`  |
 | `class.inside`     |
 | `class.around`     |
+| `test.inside`      |
+| `test.around`      |
 | `parameter.inside` |
 | `comment.inside`   |
 | `comment.around`   |
+| `entry.inside`     |
+| `entry.around`     |
 
 [Example query files][textobject-examples] can be found in the helix GitHub repository.
 
-## Queries for Textobject Based Navigation
+## Queries for textobject based navigation
 
-[Tree-sitter based navigation][textobjects-nav] is done using captures in the
+Tree-sitter based navigation in Helix is done using captures in the
 following order:
 
 - `object.movement`
@@ -36,12 +40,10 @@ following order:
 - `object.inside`
 
 For example if a `function.around` capture has been already defined for a language
-in it's `textobjects.scm` file, function navigation should also work automatically.
+in its `textobjects.scm` file, function navigation should also work automatically.
 `function.movement` should be defined only if the node captured by `function.around`
 doesn't make sense in a navigation context.
 
-[textobjects]: ../usage.md#textobjects
-[textobjects-nav]: ../usage.md#tree-sitter-textobject-based-navigation
 [tree-sitter-queries]: https://tree-sitter.github.io/tree-sitter/using-parsers#query-syntax
 [tree-sitter-captures]: https://tree-sitter.github.io/tree-sitter/using-parsers#capturing-nodes
-[textobject-examples]: https://github.com/search?q=repo%3Ahelix-editor%2Fhelix+filename%3Atextobjects.scm&type=Code&ref=advsearch&l=&l=
+[textobject-examples]: https://github.com/search?q=repo%3Ahelix-editor%2Fhelix+path%3A%2A%2A/textobjects.scm&type=Code&ref=advsearch&l=&l=

book/src/hooks.md

@@ -1 +0,0 @@
-# Hooks

book/src/install.md

@@ -1,62 +1,331 @@
-# Installation
+# Installing Helix
 
-We provide pre-built binaries on the [GitHub Releases page](https://github.com/helix-editor/helix/releases).
+<!--toc:start-->
+- [Pre-built binaries](#pre-built-binaries)
+- [Linux, macOS, Windows and OpenBSD packaging status](#linux-macos-windows-and-openbsd-packaging-status)
+- [Linux](#linux)
+  - [Ubuntu](#ubuntu)
+  - [Fedora/RHEL](#fedorarhel)
+  - [Arch Linux extra](#arch-linux-extra)
+  - [NixOS](#nixos)
+  - [Flatpak](#flatpak)
+  - [Snap](#snap)
+  - [AppImage](#appimage)
+- [macOS](#macos)
+  - [Homebrew Core](#homebrew-core)
+  - [MacPorts](#macports)
+- [Windows](#windows)
+  - [Winget](#winget)
+  - [Scoop](#scoop)
+  - [Chocolatey](#chocolatey)
+  - [MSYS2](#msys2)
+- [Building from source](#building-from-source)
+  - [Configuring Helix's runtime files](#configuring-helixs-runtime-files)
+    - [Linux and macOS](#linux-and-macos)
+    - [Windows](#windows)
+    - [Multiple runtime directories](#multiple-runtime-directories)
+  - [Validating the installation](#validating-the-installation)
+  - [Configure the desktop shortcut](#configure-the-desktop-shortcut)
+<!--toc:end-->
+
+To install Helix, follow the instructions specific to your operating system.
+Note that:
+
+- To get the latest nightly version of Helix, you need to
+  [build from source](#building-from-source).
+
+- To take full advantage of Helix, install the language servers for your
+  preferred programming languages. See the
+  [wiki](https://github.com/helix-editor/helix/wiki/How-to-install-the-default-language-servers)
+  for instructions.
+
+## Pre-built binaries
+
+Download pre-built binaries from the
+[GitHub Releases page](https://github.com/helix-editor/helix/releases). Add the binary to your system's `$PATH` to use it from the command
+line.
+
+## Linux, macOS, Windows and OpenBSD packaging status
 
 [![Packaging status](https://repology.org/badge/vertical-allrepos/helix.svg)](https://repology.org/project/helix/versions)
 
-## OSX
-
-A Homebrew tap is available:
-
-```
-brew tap helix-editor/helix
-brew install helix
-```
-
 ## Linux
 
-### NixOS
+The following third party repositories are available:
 
-A [flake](https://nixos.wiki/wiki/Flakes) containing the package is available in
-the project root. The flake can also be used to spin up a reproducible development
-shell for working on Helix with `nix develop`.
+### Ubuntu
 
-Flake outputs are cached for each push to master using
-[Cachix](https://www.cachix.org/). With Cachix
-[installed](https://docs.cachix.org/installation), `cachix use helix` will
-configure Nix to use cached outputs when possible.
-
-### Arch Linux
-
-Releases are available in the `community` repository.
-
-A [helix-git](https://aur.archlinux.org/packages/helix-git/) package is also available on the AUR, which builds the master branch.
-
-### Fedora Linux
-
-You can install the COPR package for Helix via
+Add the `PPA` for Helix:
 
+```sh
+sudo add-apt-repository ppa:maveonair/helix-editor
+sudo apt update
+sudo apt install helix
 ```
-sudo dnf copr enable varlad/helix
+
+### Fedora/RHEL
+
+```sh
 sudo dnf install helix
 ```
 
-## Build from source
+### Arch Linux extra
 
-```
-git clone https://github.com/helix-editor/helix
-cd helix
-cargo install --path helix-term
+Releases are available in the `extra` repository:
+
+```sh
+sudo pacman -S helix
 ```
 
-This will install the `hx` binary to `$HOME/.cargo/bin`.
+> 💡 When installed from the `extra` repository, run Helix with `helix` instead of `hx`.
+>
+> For example:
+> ```sh
+> helix --health
+> ```
+> to check health
 
-Helix also needs it's runtime files so make sure to copy/symlink the `runtime/` directory into the
-config directory (for example `~/.config/helix/runtime` on Linux/macOS). This location can be overriden
-via the `HELIX_RUNTIME` environment variable.
+Additionally, a [helix-git](https://aur.archlinux.org/packages/helix-git/) package is available
+in the AUR, which builds the master branch.
 
-## Building tree-sitter grammars
+### NixOS
 
-Tree-sitter grammars must be fetched and compiled if not pre-packaged.
-Fetch grammars with `hx --grammar fetch` (requires `git`) and compile them
-with `hx --grammar build` (requires a C compiler).
+Helix is available in [nixpkgs](https://github.com/nixos/nixpkgs) through the `helix` attribute,
+the unstable channel usually carries the latest release.
+
+Helix is also available as a [flake](https://nixos.wiki/wiki/Flakes) in the project
+root. Use `nix develop` to spin up a reproducible development shell. Outputs are
+cached for each push to master using [Cachix](https://www.cachix.org/). The
+flake is configured to automatically make use of this cache assuming the user
+accepts the new settings on first use.
+
+If you are using a version of Nix without flakes enabled,
+[install Cachix CLI](https://docs.cachix.org/installation) and use
+`cachix use helix` to configure Nix to use cached outputs when possible.
+
+### Flatpak
+
+Helix is available on [Flathub](https://flathub.org/en-GB/apps/com.helix_editor.Helix):
+
+```sh
+flatpak install flathub com.helix_editor.Helix
+flatpak run com.helix_editor.Helix
+```
+
+### Snap
+
+Helix is available on [Snapcraft](https://snapcraft.io/helix) and can be installed with:
+
+```sh
+snap install --classic helix
+```
+
+This will install Helix as both `/snap/bin/helix` and `/snap/bin/hx`, so make sure `/snap/bin` is in your `PATH`.
+
+### AppImage
+
+Install Helix using the Linux [AppImage](https://appimage.org/) format.
+Download the official Helix AppImage from the [latest releases](https://github.com/helix-editor/helix/releases/latest) page.
+
+```sh
+chmod +x helix-*.AppImage # change permission for executable mode
+./helix-*.AppImage # run helix
+```
+ 
+## macOS
+
+### Homebrew Core
+
+```sh
+brew install helix
+```
+
+### MacPorts
+
+```sh
+port install helix
+```
+
+## Windows
+
+Install on Windows using [Winget](https://learn.microsoft.com/en-us/windows/package-manager/winget/), [Scoop](https://scoop.sh/), [Chocolatey](https://chocolatey.org/)
+or [MSYS2](https://msys2.org/).
+
+### Winget
+Windows Package Manager winget command-line tool is by default available on Windows 11 and modern versions of Windows 10 as a part of the App Installer.
+You can get [App Installer from the Microsoft Store](https://www.microsoft.com/p/app-installer/9nblggh4nns1#activetab=pivot:overviewtab). If it's already installed, make sure it is updated with the latest version.
+
+```sh
+winget install Helix.Helix
+```
+
+### Scoop
+
+```sh
+scoop install helix
+```
+
+### Chocolatey
+
+```sh
+choco install helix
+```
+
+### MSYS2
+
+For 64-bit Windows 8.1 or above:
+
+```sh
+pacman -S mingw-w64-ucrt-x86_64-helix
+```
+
+## Building from source
+
+Requirements:
+
+Clone the Helix GitHub repository into a directory of your choice. The
+examples in this documentation assume installation into either `~/src/` on
+Linux and macOS, or `%userprofile%\src\` on Windows.
+
+- The [Rust toolchain](https://www.rust-lang.org/tools/install)
+- The [Git version control system](https://git-scm.com/)
+- A C++14 compatible compiler to build the tree-sitter grammars, for example GCC or Clang
+
+If you are using the `musl-libc` standard library instead of `glibc` the following environment variable must be set during the build to ensure tree-sitter grammars can be loaded correctly:
+
+```sh
+RUSTFLAGS="-C target-feature=-crt-static"
+```
+
+1. Clone the repository:
+
+   ```sh
+   git clone https://github.com/helix-editor/helix
+   cd helix
+   ```
+
+2. Compile from source:
+
+   ```sh
+   cargo install --path helix-term --locked
+   ```
+
+   This command will create the `hx` executable and construct the tree-sitter
+   grammars in the local `runtime` folder.
+
+> 💡 If you do not want to fetch or build grammars, set an environment variable `HELIX_DISABLE_AUTO_GRAMMAR_BUILD`
+
+> 💡 Tree-sitter grammars can be fetched and compiled if not pre-packaged. Fetch
+> grammars with `hx --grammar fetch` and compile them with
+> `hx --grammar build`. This will install them in
+> the `runtime` directory within the user's helix config directory (more
+> [details below](#multiple-runtime-directories)).
+
+### Configuring Helix's runtime files
+
+#### Linux and macOS
+
+The **runtime** directory is one below the Helix source, so either export a
+`HELIX_RUNTIME` environment variable to point to that directory and add it to
+your `~/.bashrc` or equivalent:
+
+```sh
+export HELIX_RUNTIME=~/src/helix/runtime
+```
+
+Or, create a symbolic link:
+
+```sh
+ln -Ts $PWD/runtime ~/.config/helix/runtime
+```
+
+If the above command fails to create a symbolic link because the file exists either move `~/.config/helix/runtime` to a new location or delete it, then run the symlink command above again.
+
+#### Windows
+
+Either set the `HELIX_RUNTIME` environment variable to point to the runtime files using the Windows setting (search for
+`Edit environment variables for your account`) or use the `setx` command in
+Cmd:
+
+```sh
+setx HELIX_RUNTIME "%userprofile%\source\repos\helix\runtime"
+```
+
+> 💡 `%userprofile%` resolves to your user directory like
+> `C:\Users\Your-Name\` for example.
+
+Or, create a symlink in `%appdata%\helix\` that links to the source code directory:
+
+| Method     | Command                                                                                |
+| ---------- | -------------------------------------------------------------------------------------- |
+| PowerShell | `New-Item -ItemType Junction -Target "runtime" -Path "$Env:AppData\helix\runtime"`     |
+| Cmd        | `cd %appdata%\helix` <br/> `mklink /D runtime "%userprofile%\src\helix\runtime"`       |
+
+> 💡 On Windows, creating a symbolic link may require running PowerShell or
+> Cmd as an administrator.
+
+#### Multiple runtime directories
+
+When Helix finds multiple runtime directories it will search through them for files in the
+following order:
+
+1. `runtime/` sibling directory to `$CARGO_MANIFEST_DIR` directory (this is intended for
+  developing and testing helix only).
+2. `runtime/` subdirectory of OS-dependent helix user config directory.
+3. `$HELIX_RUNTIME`
+4. Distribution-specific fallback directory (set at compile time—not run time—
+   with the `HELIX_DEFAULT_RUNTIME` environment variable)
+5. `runtime/` subdirectory of path to Helix executable.
+
+This order also sets the priority for selecting which file will be used if multiple runtime
+directories have files with the same name.
+
+#### Note to packagers
+
+If you are making a package of Helix for end users, to provide a good out of
+the box experience, you should set the `HELIX_DEFAULT_RUNTIME` environment
+variable at build time (before invoking `cargo build`) to a directory which
+will store the final runtime files after installation. For example, say you want
+to package the runtime into `/usr/lib/helix/runtime`. The rough steps a build
+script could follow are:
+
+1. `export HELIX_DEFAULT_RUNTIME=/usr/lib/helix/runtime`
+1. `cargo build --profile opt --locked --path helix-term`
+1. `cp -r runtime $BUILD_DIR/usr/lib/helix/`
+1. `cp target/opt/hx $BUILD_DIR/usr/bin/hx`
+
+This way the resulting `hx` binary will always look for its runtime directory in
+`/usr/lib/helix/runtime` if the user has no custom runtime in `~/.config/helix`
+or `HELIX_RUNTIME`.
+
+### Validating the installation
+
+To make sure everything is set up as expected you should run the Helix health
+check:
+
+```sh
+hx --health
+```
+
+For more information on the health check results refer to
+[Health check](https://github.com/helix-editor/helix/wiki/Healthcheck).
+
+### Configure the desktop shortcut
+
+If your desktop environment supports the
+[XDG desktop menu](https://specifications.freedesktop.org/menu-spec/menu-spec-latest.html)
+you can configure Helix to show up in the application menu by copying the
+provided `.desktop` and icon files to their correct folders:
+
+```sh
+cp contrib/Helix.desktop ~/.local/share/applications
+cp contrib/helix.png ~/.icons # or ~/.local/share/icons
+```
+
+To use another terminal than the system default, you can modify the `.desktop`
+file. For example, to use `kitty`:
+
+```sh
+sed -i "s|Exec=hx %F|Exec=kitty hx %F|g" ~/.local/share/applications/Helix.desktop
+sed -i "s|Terminal=true|Terminal=false|g" ~/.local/share/applications/Helix.desktop
+```

book/src/keymap.md

@@ -1,19 +1,44 @@
 # Keymap
 
-- Mappings marked (**LSP**) require an active language server for the file.
-- Mappings marked (**TS**) require a tree-sitter grammar for the filetype.
+- [Normal mode](#normal-mode)
+  - [Movement](#movement)
+  - [Changes](#changes)
+    - [Shell](#shell)
+  - [Selection manipulation](#selection-manipulation)
+  - [Search](#search)
+  - [Minor modes](#minor-modes)
+    - [View mode](#view-mode)
+    - [Goto mode](#goto-mode)
+    - [Match mode](#match-mode)
+    - [Window mode](#window-mode)
+    - [Space mode](#space-mode)
+      - [Comment mode](#comment-mode)
+      - [Popup](#popup)
+    - [Unimpaired](#unimpaired)
+- [Insert mode](#insert-mode)
+- [Select / extend mode](#select--extend-mode)
+- [Picker](#picker)
+- [Prompt](#prompt)
+
+> 💡 Mappings marked (**LSP**) require an active language server for the file.
+
+> 💡 Mappings marked (**TS**) require a tree-sitter grammar for the file type.
+
+> ⚠️ Some terminals' default key mappings conflict with Helix's. If any of the mappings described on this page do not work as expected, check your terminal's mappings to ensure they do not conflict. See the (wiki)[https://github.com/helix-editor/helix/wiki/Terminal-Support] for known conflicts.
 
 ## Normal mode
 
+Normal mode is the default mode when you launch helix. You can return to it from other modes by pressing the `Escape` key.
+
 ### Movement
 
-> NOTE: Unlike vim, `f`, `F`, `t` and `T` are not confined to the current line.
+> NOTE: Unlike Vim, `f`, `F`, `t` and `T` are not confined to the current line.
 
 | Key                   | Description                                        | Command                     |
 | -----                 | -----------                                        | -------                     |
 | `h`, `Left`           | Move left                                          | `move_char_left`            |
-| `j`, `Down`           | Move down                                          | `move_line_down`            |
-| `k`, `Up`             | Move up                                            | `move_line_up`              |
+| `j`, `Down`           | Move down                                          | `move_visual_line_down`     |
+| `k`, `Up`             | Move up                                            | `move_visual_line_up`       |
 | `l`, `Right`          | Move right                                         | `move_char_right`           |
 | `w`                   | Move next word start                               | `move_next_word_start`      |
 | `b`                   | Move previous word start                           | `move_prev_word_start`      |
@@ -26,13 +51,13 @@
 | `T`                   | Find 'till previous char                           | `till_prev_char`            |
 | `F`                   | Find previous char                                 | `find_prev_char`            |
 | `G`                   | Go to line number `<n>`                            | `goto_line`                 |
-| `Alt-.`               | Repeat last motion (`f`, `t` or `m`)               | `repeat_last_motion`        |
+| `Alt-.`               | Repeat last motion (`f`, `t`, `m`, `[` or `]`)     | `repeat_last_motion`        |
 | `Home`                | Move to the start of the line                      | `goto_line_start`           |
 | `End`                 | Move to the end of the line                        | `goto_line_end`             |
 | `Ctrl-b`, `PageUp`    | Move page up                                       | `page_up`                   |
 | `Ctrl-f`, `PageDown`  | Move page down                                     | `page_down`                 |
-| `Ctrl-u`              | Move half page up                                  | `half_page_up`              |
-| `Ctrl-d`              | Move half page down                                | `half_page_down`            |
+| `Ctrl-u`              | Move cursor and page half page up                  | `page_cursor_half_up`       |
+| `Ctrl-d`              | Move cursor and page half page down                | `page_cursor_half_down`     |
 | `Ctrl-i`              | Jump forward on the jumplist                       | `jump_forward`              |
 | `Ctrl-o`              | Jump backward on the jumplist                      | `jump_backward`             |
 | `Ctrl-s`              | Save the current selection to the jumplist         | `save_selection`            |
@@ -48,11 +73,11 @@
 | `` Alt-` `` | Set the selected text to upper case                                  | `switch_to_uppercase`     |
 | `i`         | Insert before selection                                              | `insert_mode`             |
 | `a`         | Insert after selection (append)                                      | `append_mode`             |
-| `I`         | Insert at the start of the line                                      | `prepend_to_line`         |
-| `A`         | Insert at the end of the line                                        | `append_to_line`          |
+| `I`         | Insert at the start of the line                                      | `insert_at_line_start`    |
+| `A`         | Insert at the end of the line                                        | `insert_at_line_end`      |
 | `o`         | Open new line below selection                                        | `open_below`              |
 | `O`         | Open new line above selection                                        | `open_above`              |
-| `.`         | Repeat last change                                                   | N/A                       |
+| `.`         | Repeat last insert                                                   | N/A                       |
 | `u`         | Undo change                                                          | `undo`                    |
 | `U`         | Redo change                                                          | `redo`                    |
 | `Alt-u`     | Move backward in history                                             | `earlier`                 |
@@ -89,8 +114,10 @@
 | Key                   | Description                                                       | Command                              |
 | -----                 | -----------                                                       | -------                              |
 | `s`                   | Select all regex matches inside selections                        | `select_regex`                       |
-| `S`                   | Split selection into subselections on regex matches               | `split_selection`                    |
+| `S`                   | Split selection into sub selections on regex matches              | `split_selection`                    |
 | `Alt-s`               | Split selection on newlines                                       | `split_selection_on_newline`         |
+| `Alt-minus`           | Merge selections                                                  | `merge_selections`                   |
+| `Alt-_`               | Merge consecutive selections                                      | `merge_consecutive_selections`       |
 | `&`                   | Align selection in columns                                        | `align_selections`                   |
 | `_`                   | Trim whitespace from the selection                                | `trim_selections`                    |
 | `;`                   | Collapse selection onto a single cursor                           | `collapse_selection`                 |
@@ -105,20 +132,22 @@
 | `Alt-(`               | Rotate selection contents backward                                | `rotate_selection_contents_backward` |
 | `Alt-)`               | Rotate selection contents forward                                 | `rotate_selection_contents_forward`  |
 | `%`                   | Select entire file                                                | `select_all`                         |
-| `x`                   | Select current line, if already selected, extend to next line     | `extend_line`                        |
+| `x`                   | Select current line, if already selected, extend to next line     | `extend_line_below`                  |
 | `X`                   | Extend selection to line bounds (line-wise selection)             | `extend_to_line_bounds`              |
+| `Alt-x`               | Shrink selection to line bounds (line-wise selection)             | `shrink_to_line_bounds`              |
 | `J`                   | Join lines inside selection                                       | `join_selections`                    |
+| `Alt-J`               | Join lines inside selection and select the inserted space         | `join_selections_space`              |
 | `K`                   | Keep selections matching the regex                                | `keep_selections`                    |
 | `Alt-K`               | Remove selections matching the regex                              | `remove_selections`                  |
 | `Ctrl-c`              | Comment/uncomment the selections                                  | `toggle_comments`                    |
-| `Alt-k`, `Alt-up`     | Expand selection to parent syntax node (**TS**)                   | `expand_selection`                   |
-| `Alt-j`, `Alt-down`   | Shrink syntax tree object selection (**TS**)                      | `shrink_selection`                   |
-| `Alt-h`, `Alt-left`   | Select previous sibling node in syntax tree (**TS**)              | `select_prev_sibling`                |
-| `Alt-l`, `Alt-right`  | Select next sibling node in syntax tree (**TS**)                  | `select_next_sibling`                |
+| `Alt-o`, `Alt-up`     | Expand selection to parent syntax node (**TS**)                   | `expand_selection`                   |
+| `Alt-i`, `Alt-down`   | Shrink syntax tree object selection (**TS**)                      | `shrink_selection`                   |
+| `Alt-p`, `Alt-left`   | Select previous sibling node in syntax tree (**TS**)              | `select_prev_sibling`                |
+| `Alt-n`, `Alt-right`  | Select next sibling node in syntax tree (**TS**)                  | `select_next_sibling`                |
 
 ### Search
 
-Search commands all operate on the `/` register by default. Use `"<char>` to operate on a different one.
+Search commands all operate on the `/` register by default. To use a different register, use `"<char>`.
 
 | Key   | Description                                 | Command              |
 | ----- | -----------                                 | -------              |
@@ -143,36 +172,43 @@ These sub-modes are accessible from normal mode and typically switch back to nor
 | `Ctrl-w` | Enter [window mode](#window-mode)                  | N/A            |
 | `Space`  | Enter [space mode](#space-mode)                    | N/A            |
 
+These modes (except command mode) can be configured by
+[remapping keys](https://docs.helix-editor.com/remapping.html#minor-modes).
+
 #### View mode
 
+Accessed by typing `z` in [normal mode](#normal-mode).
+
 View mode is intended for scrolling and manipulating the view without changing
-the selection. The "sticky" variant of this mode is persistent; use the Escape
-key to return to normal mode after usage (useful when you're simply looking
-over text and not actively editing it).
+the selection. The "sticky" variant of this mode (accessed by typing `Z` in
+normal mode) is persistent and can be exited using the escape key. This is
+useful when you're simply looking over text and not actively editing it.
 
 
-| Key                  | Description                                               | Command             |
-| -----                | -----------                                               | -------             |
-| `z`, `c`             | Vertically center the line                                | `align_view_center` |
-| `t`                  | Align the line to the top of the screen                   | `align_view_top`    |
-| `b`                  | Align the line to the bottom of the screen                | `align_view_bottom` |
-| `m`                  | Align the line to the middle of the screen (horizontally) | `align_view_middle` |
-| `j`, `down`          | Scroll the view downwards                                 | `scroll_down`       |
-| `k`, `up`            | Scroll the view upwards                                   | `scroll_up`         |
-| `Ctrl-f`, `PageDown` | Move page down                                            | `page_down`         |
-| `Ctrl-b`, `PageUp`   | Move page up                                              | `page_up`           |
-| `Ctrl-d`             | Move half page down                                       | `half_page_down`    |
-| `Ctrl-u`             | Move half page up                                         | `half_page_up`      |
+| Key                  | Description                                               | Command                 |
+| -----                | -----------                                               | -------                 |
+| `z`, `c`             | Vertically center the line                                | `align_view_center`     |
+| `t`                  | Align the line to the top of the screen                   | `align_view_top`        |
+| `b`                  | Align the line to the bottom of the screen                | `align_view_bottom`     |
+| `m`                  | Align the line to the middle of the screen (horizontally) | `align_view_middle`     |
+| `j`, `down`          | Scroll the view downwards                                 | `scroll_down`           |
+| `k`, `up`            | Scroll the view upwards                                   | `scroll_up`             |
+| `Ctrl-f`, `PageDown` | Move page down                                            | `page_down`             |
+| `Ctrl-b`, `PageUp`   | Move page up                                              | `page_up`               |
+| `Ctrl-u`             | Move cursor and page half page up                         | `page_cursor_half_up`   |
+| `Ctrl-d`             | Move cursor and page half page down                       | `page_cursor_half_down` |
 
 #### Goto mode
 
+Accessed by typing `g` in [normal mode](#normal-mode).
+
 Jumps to various locations.
 
 | Key   | Description                                      | Command                    |
 | ----- | -----------                                      | -------                    |
 | `g`   | Go to line number `<n>` else start of file       | `goto_file_start`          |
 | `e`   | Go to the end of the file                        | `goto_last_line`           |
-| `f`   | Go to files in the selection                     | `goto_file`                |
+| `f`   | Go to files in the selections                    | `goto_file`                |
 | `h`   | Go to the start of the line                      | `goto_line_start`          |
 | `l`   | Go to the end of the line                        | `goto_line_end`            |
 | `s`   | Go to first non-whitespace character of the line | `goto_first_nonwhitespace` |
@@ -188,12 +224,16 @@ Jumps to various locations.
 | `n`   | Go to next buffer                                | `goto_next_buffer`         |
 | `p`   | Go to previous buffer                            | `goto_previous_buffer`     |
 | `.`   | Go to last modification in current file          | `goto_last_modification`   |
+| `j`   | Move down textual (instead of visual) line       | `move_line_down`           |
+| `k`   | Move up textual (instead of visual) line         | `move_line_up`             |
+| `w`   | Show labels at each word and select the word that belongs to the entered labels | `goto_word` |
 
 #### Match mode
 
-Enter this mode using `m` from normal mode. See the relavant section
-in [Usage](./usage.md) for an explanation about [surround](./usage.md#surround)
-and [textobject](./usage.md#textobject) usage.
+Accessed by typing `m` in [normal mode](#normal-mode).
+
+See the relevant section in [Usage](./usage.md) for an explanation about
+[surround](./usage.md#surround) and [textobject](./usage.md#navigating-using-tree-sitter-textobjects) usage.
 
 | Key              | Description                                     | Command                    |
 | -----            | -----------                                     | -------                    |
@@ -208,47 +248,64 @@ TODO: Mappings for selecting syntax nodes (a superset of `[`).
 
 #### Window mode
 
-This layer is similar to vim keybindings as kakoune does not support window.
+Accessed by typing `Ctrl-w` in [normal mode](#normal-mode).
+
+This layer is similar to Vim keybindings as Kakoune does not support windows.
 
 | Key                    | Description                                          | Command           |
 | -----                  | -------------                                        | -------           |
 | `w`, `Ctrl-w`          | Switch to next window                                | `rotate_view`     |
 | `v`, `Ctrl-v`          | Vertical right split                                 | `vsplit`          |
 | `s`, `Ctrl-s`          | Horizontal bottom split                              | `hsplit`          |
-| `f`                    | Go to files in the selection in horizontal splits    | `goto_file`       |
-| `F`                    | Go to files in the selection in vertical splits      | `goto_file`       |
+| `f`                    | Go to files in the selections in horizontal splits   | `goto_file`       |
+| `F`                    | Go to files in the selections in vertical splits     | `goto_file`       |
 | `h`, `Ctrl-h`, `Left`  | Move to left split                                   | `jump_view_left`  |
 | `j`, `Ctrl-j`, `Down`  | Move to split below                                  | `jump_view_down`  |
 | `k`, `Ctrl-k`, `Up`    | Move to split above                                  | `jump_view_up`    |
 | `l`, `Ctrl-l`, `Right` | Move to right split                                  | `jump_view_right` |
 | `q`, `Ctrl-q`          | Close current window                                 | `wclose`          |
 | `o`, `Ctrl-o`          | Only keep the current window, closing all the others | `wonly`           |
+| `H`                    | Swap window to the left                              | `swap_view_left`  |
+| `J`                    | Swap window downwards                                | `swap_view_down`  |
+| `K`                    | Swap window upwards                                  | `swap_view_up`    |
+| `L`                    | Swap window to the right                             | `swap_view_right` |
 
 #### Space mode
 
+Accessed by typing `Space` in [normal mode](#normal-mode).
+
 This layer is a kludge of mappings, mostly pickers.
 
+| Key     | Description                                                             | Command                                    |
+| -----   | -----------                                                             | -------                                    |
+| `f`     | Open file picker                                                        | `file_picker`                              |
+| `F`     | Open file picker at current working directory                           | `file_picker_in_current_directory`         |
+| `b`     | Open buffer picker                                                      | `buffer_picker`                            |
+| `j`     | Open jumplist picker                                                    | `jumplist_picker`                          |
+| `g`     | Open changed file picker                                                | `changed_file_picker`                      |
+| `G`     | Debug (experimental)                                                    | N/A                                        |
+| `k`     | Show documentation for item under cursor in a [popup](#popup) (**LSP**) | `hover`                                    |
+| `s`     | Open document symbol picker (**LSP**)                                   | `symbol_picker`                            |
+| `S`     | Open workspace symbol picker (**LSP**)                                  | `workspace_symbol_picker`                  |
+| `d`     | Open document diagnostics picker (**LSP**)                              | `diagnostics_picker`                       |
+| `D`     | Open workspace diagnostics picker (**LSP**)                             | `workspace_diagnostics_picker`             |
+| `r`     | Rename symbol (**LSP**)                                                 | `rename_symbol`                            |
+| `a`     | Apply code action (**LSP**)                                             | `code_action`                              |
+| `h`     | Select symbol references (**LSP**)                                      | `select_references_to_symbol_under_cursor` |
+| `'`     | Open last fuzzy picker                                                  | `last_picker`                              |
+| `w`     | Enter [window mode](#window-mode)                                       | N/A                                        |
+| `c`     | Comment/uncomment selections                                            | `toggle_comments`                          |
+| `C`     | Block comment/uncomment selections                                      | `toggle_block_comments`                    |
+| `Alt-c` | Line comment/uncomment selections                                       | `toggle_line_comments`                     |
+| `p`     | Paste system clipboard after selections                                 | `paste_clipboard_after`                    |
+| `P`     | Paste system clipboard before selections                                | `paste_clipboard_before`                   |
+| `y`     | Yank selections to clipboard                                            | `yank_to_clipboard`                        |
+| `Y`     | Yank main selection to clipboard                                        | `yank_main_selection_to_clipboard`         |
+| `R`     | Replace selections by clipboard contents                                | `replace_selections_with_clipboard`        |
+| `/`     | Global search in workspace folder                                       | `global_search`                            |
+| `?`     | Open command palette                                                    | `command_palette`                          |
 
-| Key     | Description                                                             | Command                             |
-| -----   | -----------                                                             | -------                             |
-| `f`     | Open file picker                                                        | `file_picker`                       |
-| `b`     | Open buffer picker                                                      | `buffer_picker`                     |
-| `k`     | Show documentation for item under cursor in a [popup](#popup) (**LSP**) | `hover`                             |
-| `s`     | Open document symbol picker (**LSP**)                                   | `symbol_picker`                     |
-| `S`     | Open workspace symbol picker (**LSP**)                                  | `workspace_symbol_picker`           |
-| `r`     | Rename symbol (**LSP**)                                                 | `rename_symbol`                     |
-| `a`     | Apply code action  (**LSP**)                                            | `code_action`                       |
-| `'`     | Open last fuzzy picker                                                  | `last_picker`                       |
-| `w`     | Enter [window mode](#window-mode)                                       | N/A                                 |
-| `p`     | Paste system clipboard after selections                                 | `paste_clipboard_after`             |
-| `P`     | Paste system clipboard before selections                                | `paste_clipboard_before`            |
-| `y`     | Join and yank selections to clipboard                                   | `yank_joined_to_clipboard`          |
-| `Y`     | Yank main selection to clipboard                                        | `yank_main_selection_to_clipboard`  |
-| `R`     | Replace selections by clipboard contents                                | `replace_selections_with_clipboard` |
-| `/`     | Global search in workspace folder                                       | `global_search`                     |
-| `?`     | Open command palette                                                    | `command_palette`                   |
-
-> TIP: Global search displays results in a fuzzy picker, use `space + '` to bring it back up after opening a file.
+> 💡 Global search displays results in a fuzzy picker, use `Space + '` to bring it back up after opening a file.
 
 ##### Popup
 
@@ -261,62 +318,95 @@ Displays documentation for item under cursor.
 
 #### Unimpaired
 
-Mappings in the style of [vim-unimpaired](https://github.com/tpope/vim-unimpaired).
+These mappings are in the style of [vim-unimpaired](https://github.com/tpope/vim-unimpaired).
 
 | Key      | Description                                  | Command               |
 | -----    | -----------                                  | -------               |
-| `[d`     | Go to previous diagnostic (**LSP**)          | `goto_prev_diag`      |
 | `]d`     | Go to next diagnostic (**LSP**)              | `goto_next_diag`      |
-| `[D`     | Go to first diagnostic in document (**LSP**) | `goto_first_diag`     |
+| `[d`     | Go to previous diagnostic (**LSP**)          | `goto_prev_diag`      |
 | `]D`     | Go to last diagnostic in document (**LSP**)  | `goto_last_diag`      |
+| `[D`     | Go to first diagnostic in document (**LSP**) | `goto_first_diag`     |
 | `]f`     | Go to next function (**TS**)                 | `goto_next_function`  |
 | `[f`     | Go to previous function (**TS**)             | `goto_prev_function`  |
-| `]c`     | Go to next class (**TS**)                    | `goto_next_class`     |
-| `[c`     | Go to previous class (**TS**)                | `goto_prev_class`     |
+| `]t`     | Go to next type definition (**TS**)          | `goto_next_class`     |
+| `[t`     | Go to previous type definition (**TS**)      | `goto_prev_class`     |
 | `]a`     | Go to next argument/parameter (**TS**)       | `goto_next_parameter` |
 | `[a`     | Go to previous argument/parameter (**TS**)   | `goto_prev_parameter` |
-| `]o`     | Go to next comment (**TS**)                  | `goto_next_comment`   |
-| `[o`     | Go to previous comment (**TS**)              | `goto_prev_comment`   |
-| `[space` | Add newline above                            | `add_newline_above`   |
-| `]space` | Add newline below                            | `add_newline_below`   |
+| `]c`     | Go to next comment (**TS**)                  | `goto_next_comment`   |
+| `[c`     | Go to previous comment (**TS**)              | `goto_prev_comment`   |
+| `]T`     | Go to next test (**TS**)                     | `goto_next_test`      |
+| `[T`     | Go to previous test (**TS**)                 | `goto_prev_test`      |
+| `]p`     | Go to next paragraph                         | `goto_next_paragraph` |
+| `[p`     | Go to previous paragraph                     | `goto_prev_paragraph` |
+| `]g`     | Go to next change                            | `goto_next_change`    |
+| `[g`     | Go to previous change                        | `goto_prev_change`    |
+| `]G`     | Go to last change                            | `goto_last_change`    |
+| `[G`     | Go to first change                           | `goto_first_change`   |
+| `]Space` | Add newline below                            | `add_newline_below`   |
+| `[Space` | Add newline above                            | `add_newline_above`   |
 
-## Insert Mode
+## Insert mode
 
-We support many readline/emacs style bindings in insert mode for
-convenience. These can be helpful for making simple modifications
-without escaping to normal mode, but beware that you will not have an
-undo-able "save point" until you return to normal mode.
+Accessed by typing `i` in [normal mode](#normal-mode).
 
-| Key                       | Description                 | Command                 |
-| -----                     | -----------                 | -------                 |
-| `Escape`                  | Switch to normal mode       | `normal_mode`           |
-| `Ctrl-x`                  | Autocomplete                | `completion`            |
-| `Ctrl-r`                  | Insert a register content   | `insert_register`       |
-| `Ctrl-w`, `Alt-Backspace` | Delete previous word        | `delete_word_backward`  |
-| `Alt-d`                   | Delete next word            | `delete_word_forward`   |
-| `Alt-b`, `Alt-Left`       | Backward a word             | `move_prev_word_end`    |
-| `Ctrl-b`, `Left`          | Backward a char             | `move_char_left`        |
-| `Alt-f`, `Alt-Right`      | Forward a word              | `move_next_word_start`  |
-| `Ctrl-f`, `Right`         | Forward a char              | `move_char_right`       |
-| `Ctrl-e`, `End`           | Move to line end            | `goto_line_end_newline` |
-| `Ctrl-a`, `Home`          | Move to line start          | `goto_line_start`       |
-| `Ctrl-u`                  | Delete to start of line     | `kill_to_line_start`    |
-| `Ctrl-k`                  | Delete to end of line       | `kill_to_line_end`      |
-| `Ctrl-j`, `Enter`         | Insert new line             | `insert_newline`        |
-| `Backspace`, `Ctrl-h`     | Delete previous char        | `delete_char_backward`  |
-| `Delete`, `Ctrl-d`        | Delete previous char        | `delete_char_forward`   |
-| `Ctrl-p`, `Up`            | Move to previous line       | `move_line_up`          |
-| `Ctrl-n`, `Down`          | Move to next line           | `move_line_down`        |
-| `PageUp`                  | Move one page up            | `page_up`               |
-| `PageDown`                | Move one page down          | `page_down`             |
-| `Alt->`                   | Go to end of buffer         | `goto_file_end`         |
-| `Alt-<`                   | Go to start of buffer       | `goto_file_start`       |
+Insert mode bindings are minimal by default. Helix is designed to
+be a modal editor, and this is reflected in the user experience and internal
+mechanics. Changes to the text are only saved for undos when
+escaping from insert mode to normal mode.
+
+> 💡 New users are strongly encouraged to learn the modal editing paradigm
+> to get the smoothest experience.
+
+| Key                                         | Description                 | Command                  |
+| -----                                       | -----------                 | -------                  |
+| `Escape`                                    | Switch to normal mode       | `normal_mode`            |
+| `Ctrl-s`                                    | Commit undo checkpoint      | `commit_undo_checkpoint` |
+| `Ctrl-x`                                    | Autocomplete                | `completion`             |
+| `Ctrl-r`                                    | Insert a register content   | `insert_register`        |
+| `Ctrl-w`, `Alt-Backspace`                   | Delete previous word        | `delete_word_backward`   |
+| `Alt-d`, `Alt-Delete`                       | Delete next word            | `delete_word_forward`    |
+| `Ctrl-u`                                    | Delete to start of line     | `kill_to_line_start`     |
+| `Ctrl-k`                                    | Delete to end of line       | `kill_to_line_end`       |
+| `Ctrl-h`, `Backspace`, `Shift-Backspace`    | Delete previous char        | `delete_char_backward`   |
+| `Ctrl-d`, `Delete`                          | Delete next char            | `delete_char_forward`    |
+| `Ctrl-j`, `Enter`                           | Insert new line             | `insert_newline`         |
+
+These keys are not recommended, but are included for new users less familiar
+with modal editors.
+
+| Key                                         | Description                 | Command                  |
+| -----                                       | -----------                 | -------                  |
+| `Up`                                        | Move to previous line       | `move_line_up`           |
+| `Down`                                      | Move to next line           | `move_line_down`         |
+| `Left`                                      | Backward a char             | `move_char_left`         |
+| `Right`                                     | Forward a char              | `move_char_right`        |
+| `PageUp`                                    | Move one page up            | `page_up`                |
+| `PageDown`                                  | Move one page down          | `page_down`              |
+| `Home`                                      | Move to line start          | `goto_line_start`        |
+| `End`                                       | Move to line end            | `goto_line_end_newline`  |
+
+As you become more comfortable with modal editing, you may want to disable some
+insert mode bindings. You can do this by editing your `config.toml` file.
+
+```toml
+[keys.insert]
+up = "no_op"
+down = "no_op"
+left = "no_op"
+right = "no_op"
+pageup = "no_op"
+pagedown = "no_op"
+home = "no_op"
+end = "no_op"
+```
 
 ## Select / extend mode
 
-This mode echoes Normal mode, but changes any movements to extend
+Accessed by typing `v` in [normal mode](#normal-mode).
+
+Select mode echoes Normal mode, but changes any movements to extend
 selections rather than replace them. Goto motions are also changed to
-extend, so that `vgl` for example extends the selection to the end of
+extend, so that `vgl`, for example, extends the selection to the end of
 the line.
 
 Search is also affected. By default, `n` and `N` will remove the current
@@ -325,47 +415,48 @@ mode before pressing `n` or `N` makes it possible to keep the current
 selection. Toggling it on and off during your iterative searching allows
 you to selectively add search terms to your selections.
 
-# Picker
+## Picker
 
 Keys to use within picker. Remapping currently not supported.
 
-| Key                          | Description       |
-| -----                        | -------------     |
-| `Up`, `Ctrl-k`, `Ctrl-p`     | Previous entry    |
-| `PageUp`, `Ctrl-b`           | Page up           |
-| `Down`, `Ctrl-j`, `Ctrl-n`   | Next entry        |
-| `PageDown`, `Ctrl-f`         | Page down         |
-| `Home`                       | Go to first entry |
-| `End`                        | Go to last entry  |
-| `Ctrl-space`                 | Filter options    |
-| `Enter`                      | Open selected     |
-| `Ctrl-s`                     | Open horizontally |
-| `Ctrl-v`                     | Open vertically   |
-| `Escape`, `Ctrl-c`           | Close picker      |
+| Key                          | Description                                                |
+| -----                        | -------------                                              |
+| `Shift-Tab`, `Up`, `Ctrl-p`  | Previous entry                                             |
+| `Tab`, `Down`, `Ctrl-n`      | Next entry                                                 |
+| `PageUp`, `Ctrl-u`           | Page up                                                    |
+| `PageDown`, `Ctrl-d`         | Page down                                                  |
+| `Home`                       | Go to first entry                                          |
+| `End`                        | Go to last entry                                           |
+| `Enter`                      | Open selected                                              |
+| `Alt-Enter`                  | Open selected in the background without closing the picker |
+| `Ctrl-s`                     | Open horizontally                                          |
+| `Ctrl-v`                     | Open vertically                                            |
+| `Ctrl-t`                     | Toggle preview                                             |
+| `Escape`, `Ctrl-c`           | Close picker                                               |
 
-# Prompt
+## Prompt
 
 Keys to use within prompt, Remapping currently not supported.
 
-| Key                     | Description                                                             |
-| -----                   | -------------                                                           |
-| `Escape`, `Ctrl-c`      | Close prompt                                                            |
-| `Alt-b`, `Alt-Left`     | Backward a word                                                         |
-| `Ctrl-b`, `Left`        | Backward a char                                                         |
-| `Alt-f`, `Alt-Right`    | Forward a word                                                          |
-| `Ctrl-f`, `Right`       | Forward a char                                                          |
-| `Ctrl-e`, `End`         | Move prompt end                                                         |
-| `Ctrl-a`, `Home`        | Move prompt start                                                       |
-| `Ctrl-w`                | Delete previous word                                                    |
-| `Alt-d`                 | Delete next word                                                        |
-| `Ctrl-u`                | Delete to start of line                                                 |
-| `Ctrl-k`                | Delete to end of line                                                   |
-| `backspace`, `Ctrl-h`   | Delete previous char                                                    |
-| `delete`, `Ctrl-d`      | Delete next char                                                        |
-| `Ctrl-s`                | Insert a word under doc cursor, may be changed to Ctrl-r Ctrl-w later   |
-| `Ctrl-p`, `Up`          | Select previous history                                                 |
-| `Ctrl-n`, `Down`        | Select next history                                                     |
-| `Tab`                   | Select next completion item                                             |
-| `BackTab`               | Select previous completion item                                         |
-| `Enter`                 | Open selected                                                           |
-
+| Key                                         | Description                                                             |
+| -----                                       | -------------                                                           |
+| `Escape`, `Ctrl-c`                          | Close prompt                                                            |
+| `Alt-b`, `Ctrl-Left`                        | Backward a word                                                         |
+| `Ctrl-b`, `Left`                            | Backward a char                                                         |
+| `Alt-f`, `Ctrl-Right`                       | Forward a word                                                          |
+| `Ctrl-f`, `Right`                           | Forward a char                                                          |
+| `Ctrl-e`, `End`                             | Move prompt end                                                         |
+| `Ctrl-a`, `Home`                            | Move prompt start                                                       |
+| `Ctrl-w`, `Alt-Backspace`, `Ctrl-Backspace` | Delete previous word                                                    |
+| `Alt-d`, `Alt-Delete`, `Ctrl-Delete`        | Delete next word                                                        |
+| `Ctrl-u`                                    | Delete to start of line                                                 |
+| `Ctrl-k`                                    | Delete to end of line                                                   |
+| `Backspace`, `Ctrl-h`, `Shift-Backspace`    | Delete previous char                                                    |
+| `Delete`, `Ctrl-d`                          | Delete next char                                                        |
+| `Ctrl-s`                                    | Insert a word under doc cursor, may be changed to Ctrl-r Ctrl-w later   |
+| `Ctrl-p`, `Up`                              | Select previous history                                                 |
+| `Ctrl-n`, `Down`                            | Select next history                                                     |
+| `Ctrl-r`                                    | Insert the content of the register selected by following input char     |
+| `Tab`                                       | Select next completion item                                             |
+| `BackTab`                                   | Select previous completion item                                         |
+| `Enter`                                     | Open selected                                                           |

book/src/lang-support.md

@@ -1,10 +1,16 @@
 # Language Support
 
-For more information like arguments passed to default LSP server,
-extensions assosciated with a filetype, custom LSP settings, filetype
-specific indent settings, etc see the default
-[`languages.toml`][languages.toml] file.
+The following languages and Language Servers are supported. To use
+Language Server features, you must first [configure][lsp-config-wiki] the
+appropriate Language Server.
+
+You can check the language support in your installed helix version with `hx --health`.
+
+Also see the [Language Configuration][lang-config] docs and the [Adding
+Languages][adding-languages] guide for more language configuration information.
 
 {{#include ./generated/lang-support.md}}
 
-[languages.toml]: https://github.com/helix-editor/helix/blob/master/languages.toml
+[lsp-config-wiki]: https://github.com/helix-editor/helix/wiki/Language-Server-Configurations
+[lang-config]: ./languages.md
+[adding-languages]: ./guides/adding_languages.md

book/src/languages.md

@@ -1,34 +1,235 @@
 # Languages
 
-Language-specific settings and settings for particular language servers can be configured in a `languages.toml` file placed in your [configuration directory](./configuration.md). Helix actually uses two `languages.toml` files, the [first one](https://github.com/helix-editor/helix/blob/master/languages.toml) is in the main helix repository; it contains the default settings for each language and is included in the helix binary at compile time. Users who want to see the available settings and options can either reference the helix repo's `languages.toml` file, or consult the table in the [adding languages](./guides/adding_languages.md) section.
+Language-specific settings and settings for language servers are configured
+in `languages.toml` files.
 
-Changes made to the `languages.toml` file in a user's [configuration directory](./configuration.md) are merged with helix's defaults on start-up, such that a user's settings will take precedence over defaults in the event of a collision. For example, the default `languages.toml` sets rust's `auto-format` to `true`. If a user wants to disable auto-format, they can change the `languages.toml` in their [configuration directory](./configuration.md) to make the rust entry read like the example below; the new key/value pair `auto-format = false` will override the default when the two sets of settings are merged on start-up:
+## `languages.toml` files
+
+There are three possible locations for a `languages.toml` file:
+
+1. In the Helix source code, which lives in the
+   [Helix repository](https://github.com/helix-editor/helix/blob/master/languages.toml).
+   It provides the default configurations for languages and language servers.
+
+2. In your [configuration directory](./configuration.md). This overrides values
+   from the built-in language configuration. For example, to disable
+   auto-LSP-formatting in Rust:
+
+   ```toml
+   # in <config_dir>/helix/languages.toml
+
+   [language-server.mylang-lsp]
+   command = "mylang-lsp"
+
+   [[language]]
+   name = "rust"
+   auto-format = false
+   ```
+
+3. In a `.helix` folder in your project. Language configuration may also be
+   overridden local to a project by creating a `languages.toml` file in a
+   `.helix` folder. Its settings will be merged with the language configuration
+   in the configuration directory and the built-in configuration.
+
+## Language configuration
+
+Each language is configured by adding a `[[language]]` section to a
+`languages.toml` file. For example:
 
 ```toml
-# in <config_dir>/helix/languages.toml
-
 [[language]]
-name = "rust"
-auto-format = false
+name = "mylang"
+scope = "source.mylang"
+injection-regex = "mylang"
+file-types = ["mylang", "myl"]
+comment-tokens = "#"
+indent = { tab-width = 2, unit = "  " }
+formatter = { command = "mylang-formatter" , args = ["--stdin"] }
+language-servers = [ "mylang-lsp" ]
 ```
 
-## Tree-sitter grammars
+These configuration keys are available:
 
-Tree-sitter grammars can also be configured in `languages.toml`:
+| Key                   | Description                                                   |
+| ----                  | -----------                                                   |
+| `name`                | The name of the language                                      |
+| `language-id`         | The language-id for language servers, checkout the table at [TextDocumentItem](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocumentItem) for the right id |
+| `scope`               | A string like `source.js` that identifies the language. Currently, we strive to match the scope names used by popular TextMate grammars and by the Linguist library. Usually `source.<name>` or `text.<name>` in case of markup languages |
+| `injection-regex`     | regex pattern that will be tested against a language name in order to determine whether this language should be used for a potential [language injection][treesitter-language-injection] site. |
+| `file-types`          | The filetypes of the language, for example `["yml", "yaml"]`. See the file-type detection section below. |
+| `shebangs`            | The interpreters from the shebang line, for example `["sh", "bash"]` |
+| `roots`               | A set of marker files to look for when trying to find the workspace root. For example `Cargo.lock`, `yarn.lock` |
+| `auto-format`         | Whether to autoformat this language when saving               |
+| `diagnostic-severity` | Minimal severity of diagnostic for it to be displayed. (Allowed values: `Error`, `Warning`, `Info`, `Hint`) |
+| `comment-tokens`      | The tokens to use as a comment token, either a single token `"//"` or an array `["//", "///", "//!"]` (the first token will be used for commenting). Also configurable as `comment-token` for backwards compatibility|
+| `block-comment-tokens`| The start and end tokens for a multiline comment either an array or single table of `{ start = "/*", end = "*/"}`. The first set of tokens will be used for commenting, any pairs in the array can be uncommented |
+| `indent`              | The indent to use. Has sub keys `unit` (the text inserted into the document when indenting; usually set to N spaces or `"\t"` for tabs) and `tab-width` (the number of spaces rendered for a tab) |
+| `language-servers`    | The Language Servers used for this language. See below for more information in the section [Configuring Language Servers for a language](#configuring-language-servers-for-a-language)   |
+| `grammar`             | The tree-sitter grammar to use (defaults to the value of `name`) |
+| `formatter`           | The formatter for the language, it will take precedence over the lsp when defined. The formatter must be able to take the original file as input from stdin and write the formatted file to stdout |
+| `soft-wrap` | [editor.softwrap](./configuration.md#editorsoft-wrap-section)
+| `text-width`          |  Maximum line length. Used for the `:reflow` command and soft-wrapping if `soft-wrap.wrap-at-text-width` is set, defaults to `editor.text-width`   |
+| `workspace-lsp-roots`     | Directories relative to the workspace root that are treated as LSP roots. Should only be set in `.helix/config.toml`. Overwrites the setting of the same name in `config.toml` if set. |
+| `persistent-diagnostic-sources` | An array of LSP diagnostic sources assumed unchanged when the language server resends the same set of diagnostics. Helix can track the position for these diagnostics internally instead. Useful for diagnostics that are recomputed on save.
+
+### File-type detection and the `file-types` key
+
+Helix determines which language configuration to use based on the `file-types` key
+from the above section. `file-types` is a list of strings or tables, for
+example:
 
 ```toml
-# in <config_dir>/helix/languages.toml
-
-[[grammar]]
-name = "rust"
-source = { git = "https://github.com/tree-sitter/tree-sitter-rust", rev = "a250c4582510ff34767ec3b7dcdd3c24e8c8aa68" }
-
-[[grammar]]
-name = "c"
-source = { path = "/path/to/tree-sitter-c" }
+file-types = ["toml", { glob = "Makefile" }, { glob = ".git/config" }, { glob = ".github/workflows/*.yaml" } ]
 ```
 
-You may use a top-level `use-grammars` key to control which grammars are fetched and built.
+When determining a language configuration to use, Helix searches the file-types
+with the following priorities:
+
+1. Glob: values in `glob` tables are checked against the full path of the given
+   file. Globs are standard Unix-style path globs (e.g. the kind you use in Shell)
+   and can be used to match paths for a specific prefix, suffix, directory, etc.
+   In the above example, the `{ glob = "Makefile" }` config would match files
+   with the name `Makefile`, the `{ glob = ".git/config" }` config would match
+   `config` files in `.git` directories, and the `{ glob = ".github/workflows/*.yaml" }`
+   config would match any `yaml` files in `.github/workflow` directories. Note
+   that globs should always use the Unix path separator `/` even on Windows systems;
+   the matcher will automatically take the machine-specific separators into account.
+   If the glob isn't an absolute path or doesn't already start with a glob prefix,
+   `*/` will automatically be added to ensure it matches for any subdirectory.
+2. Extension: if there are no glob matches, any `file-types` string that matches
+   the file extension of a given file wins. In the example above, the `"toml"`
+   config matches files like `Cargo.toml` or `languages.toml`.
+
+## Language Server configuration
+
+Language servers are configured separately in the table `language-server` in the same file as the languages `languages.toml`
+
+For example:
+
+```toml
+[language-server.mylang-lsp]
+command = "mylang-lsp"
+args = ["--stdio"]
+config = { provideFormatter = true }
+environment = { "ENV1" = "value1", "ENV2" = "value2" }
+
+[language-server.efm-lsp-prettier]
+command = "efm-langserver"
+
+[language-server.efm-lsp-prettier.config]
+documentFormatting = true
+languages = { typescript = [ { formatCommand ="prettier --stdin-filepath ${INPUT}", formatStdin = true } ] }
+```
+
+These are the available options for a language server.
+
+| Key                        | Description                                                                                                                       |
+| ----                       | -----------                                                                                                                       |
+| `command`                  | The name or path of the language server binary to execute. Binaries must be in `$PATH`                                            |
+| `args`                     | A list of arguments to pass to the language server binary                                                                         |
+| `config`                   | LSP initialization options                                                                                                        |
+| `timeout`                  | The maximum time a request to the language server may take, in seconds. Defaults to `20`                                          |
+| `environment`              | Any environment variables that will be used when starting the language server `{ "KEY1" = "Value1", "KEY2" = "Value2" }`          |
+| `required-root-patterns`   | A list of `glob` patterns to look for in the working directory. The language server is started if at least one of them is found.  |
+
+A `format` sub-table within `config` can be used to pass extra formatting options to
+[Document Formatting Requests](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_formatting).
+For example, with typescript:
+
+```toml
+[language-server.typescript-language-server]
+# pass format options according to https://github.com/typescript-language-server/typescript-language-server#workspacedidchangeconfiguration omitting the "[language].format." prefix.
+config = { format = { "semicolons" = "insert", "insertSpaceBeforeFunctionParenthesis" = true } }
+```
+
+### Configuring Language Servers for a language
+
+The `language-servers` attribute in a language tells helix which language servers are used for this language.
+
+They have to be defined in the `[language-server]` table as described in the previous section.
+
+Different languages can use the same language server instance, e.g. `typescript-language-server` is used for javascript, jsx, tsx and typescript by default.
+
+The definition order of language servers affects the order in the results list of code action menu.
+
+In case multiple language servers are specified in the `language-servers` attribute of a `language`,
+it's often useful to only enable/disable certain language-server features for these language servers.
+
+As an example, `efm-lsp-prettier` of the previous example is used only with a formatting command `prettier`,
+so everything else should be handled by the `typescript-language-server` (which is configured by default).
+The language configuration for typescript could look like this:
+
+```toml
+[[language]]
+name = "typescript"
+language-servers = [ { name = "efm-lsp-prettier", only-features = [ "format" ] }, "typescript-language-server" ]
+```
+
+or equivalent:
+
+```toml
+[[language]]
+name = "typescript"
+language-servers = [ { name = "typescript-language-server", except-features = [ "format" ] }, "efm-lsp-prettier" ]
+```
+
+Each requested LSP feature is prioritized in the order of the `language-servers` array.
+For example, the first `goto-definition` supported language server (in this case `typescript-language-server`) will be taken for the relevant LSP request (command `goto_definition`).
+The features `diagnostics`, `code-action`, `completion`, `document-symbols` and `workspace-symbols` are an exception to that rule, as they are working for all language servers at the same time and are merged together, if enabled for the language.
+If no `except-features` or `only-features` is given, all features for the language server are enabled.
+If a language server itself doesn't support a feature, the next language server array entry will be tried (and so on).
+
+The list of supported features is:
+
+- `format`
+- `goto-definition`
+- `goto-declaration`
+- `goto-type-definition`
+- `goto-reference`
+- `goto-implementation`
+- `signature-help`
+- `hover`
+- `document-highlight`
+- `completion`
+- `code-action`
+- `workspace-command`
+- `document-symbols`
+- `workspace-symbols`
+- `diagnostics`
+- `rename-symbol`
+- `inlay-hints`
+
+## Tree-sitter grammar configuration
+
+The source for a language's tree-sitter grammar is specified in a `[[grammar]]`
+section in `languages.toml`. For example:
+
+```toml
+[[grammar]]
+name = "mylang"
+source = { git = "https://github.com/example/mylang", rev = "a250c4582510ff34767ec3b7dcdd3c24e8c8aa68" }
+```
+
+Grammar configuration takes these keys:
+
+| Key      | Description                                                              |
+| ---      | -----------                                                              |
+| `name`   | The name of the tree-sitter grammar                                      |
+| `source` | The method of fetching the grammar - a table with a schema defined below |
+
+Where `source` is a table with either these keys when using a grammar from a
+git repository:
+
+| Key    | Description                                               |
+| ---    | -----------                                               |
+| `git`  | A git remote URL from which the grammar should be cloned  |
+| `rev`  | The revision (commit hash or tag) which should be fetched |
+| `subpath` | A path within the grammar directory which should be built. Some grammar repositories host multiple grammars (for example `tree-sitter-typescript` and `tree-sitter-ocaml`) in subdirectories. This key is used to point `hx --grammar build` to the correct path for compilation. When omitted, the root of repository is used |
+
+### Choosing grammars
+
+You may use a top-level `use-grammars` key to control which grammars are
+fetched and built when using `hx --grammar fetch` and `hx --grammar build`.
 
 ```toml
 # Note: this key must come **before** the [[language]] and [[grammar]] sections
@@ -38,3 +239,5 @@ use-grammars = { except = [ "yaml", "json" ] }
 ```
 
 When omitted, all grammars are fetched and built.
+
+[treesitter-language-injection]: https://tree-sitter.github.io/tree-sitter/syntax-highlighting#language-injection

book/src/remapping.md

@@ -1,31 +1,56 @@
-# Key Remapping
+# Key remapping
 
-One-way key remapping is temporarily supported via a simple TOML configuration
+Helix currently supports one-way key remapping through a simple TOML configuration
 file. (More powerful solutions such as rebinding via commands will be
 available in the future).
 
-To remap keys, write a `config.toml` file in your `helix` configuration
-directory (default `~/.config/helix` in Linux systems) with a structure like
+To remap keys, create a `config.toml` file in your `helix` configuration
+directory (default `~/.config/helix` on Linux systems) with a structure like
 this:
 
 ```toml
 # At most one section each of 'keys.normal', 'keys.insert' and 'keys.select'
 [keys.normal]
-C-s = ":w" # Maps the Control-s to the typable command :w which is an alias for :write (save file)
-C-o = ":open ~/.config/helix/config.toml" # Maps the Control-o to opening of the helix config file
+C-s = ":w" # Maps Ctrl-s to the typable command :w which is an alias for :write (save file)
+C-o = ":open ~/.config/helix/config.toml" # Maps Ctrl-o to opening of the helix config file
 a = "move_char_left" # Maps the 'a' key to the move_char_left command
 w = "move_line_up" # Maps the 'w' key move_line_up
-"C-S-esc" = "extend_line" # Maps Control-Shift-Escape to extend_line
+"C-S-esc" = "extend_line" # Maps Ctrl-Shift-Escape to extend_line
 g = { a = "code_action" } # Maps `ga` to show possible code actions
 "ret" = ["open_below", "normal_mode"] # Maps the enter key to open_below then re-enter normal mode
 
 [keys.insert]
-"A-x" = "normal_mode" # Maps Alt-X to enter normal mode
+"A-x" = "normal_mode"     # Maps Alt-X to enter normal mode
 j = { k = "normal_mode" } # Maps `jk` to exit insert mode
 ```
-> NOTE: Typable commands can also be remapped, remember to keep the `:` prefix to indicate it's a typable command.
 
-Control, Shift and Alt modifiers are encoded respectively with the prefixes
+## Minor modes
+
+Minor modes are accessed by pressing a key (usually from normal mode), giving access to dedicated bindings. Bindings
+can be modified or added by nesting definitions.
+
+```toml
+[keys.insert.j]
+k = "normal_mode" # Maps `jk` to exit insert mode
+
+[keys.normal.g]
+a = "code_action" # Maps `ga` to show possible code actions
+
+# invert `j` and `k` in view mode
+[keys.normal.z]
+j = "scroll_up"
+k = "scroll_down"
+
+# create a new minor mode bound to `+`
+[keys.normal."+"]
+m = ":run-shell-command make"
+c = ":run-shell-command cargo build"
+t = ":run-shell-command cargo test"
+```
+
+## Special keys and modifiers
+
+Ctrl, Shift and Alt modifiers are encoded respectively with the prefixes
 `C-`, `S-` and `A-`. Special keys are encoded as follows:
 
 | Key name     | Representation |
@@ -33,12 +58,7 @@ Control, Shift and Alt modifiers are encoded respectively with the prefixes
 | Backspace    | `"backspace"`  |
 | Space        | `"space"`      |
 | Return/Enter | `"ret"`        |
-| <            | `"lt"`         |
-| \>           | `"gt"`         |
-| \+           | `"plus"`       |
 | \-           | `"minus"`      |
-| ;            | `"semicolon"`  |
-| %            | `"percent"`    |
 | Left         | `"left"`       |
 | Right        | `"right"`      |
 | Up           | `"up"`         |
@@ -55,5 +75,5 @@ Control, Shift and Alt modifiers are encoded respectively with the prefixes
 
 Keys can be disabled by binding them to the `no_op` command.
 
-Commands can be found at [Keymap](https://docs.helix-editor.com/keymap.html) Commands.
-> Commands can also be found in the source code at [`helix-term/src/commands.rs`](https://github.com/helix-editor/helix/blob/master/helix-term/src/commands.rs) at the invocation of `static_commands!` macro and the `TypableCommandList`.
+A list of commands is available in the [Keymap](https://docs.helix-editor.com/keymap.html) documentation
+ and in the source code at [`helix-term/src/commands.rs`](https://github.com/helix-editor/helix/blob/master/helix-term/src/commands.rs) at the invocation of `static_commands!` macro and the `TypableCommandList`.

book/src/themes.md

@@ -1,22 +1,23 @@
 # Themes
 
-To use a theme add `theme = "<name>"` to your [`config.toml`](./configuration.md) at the very top of the file before the first section or select it during runtime using `:theme <name>`.
+To use a theme add `theme = "<name>"` to the top of your [`config.toml`](./configuration.md) file, or select it during runtime using `:theme <name>`.
 
 ## Creating a theme
 
-Create a file with the name of your theme as file name (i.e `mytheme.toml`) and place it in your `themes` directory (i.e `~/.config/helix/themes`). The directory might have to be created beforehand.
+Create a file with the name of your theme as the file name (i.e `mytheme.toml`) and place it in your `themes` directory (i.e `~/.config/helix/themes` or `%AppData%\helix\themes` on Windows). The directory might have to be created beforehand.
 
-The names "default" and "base16_default" are reserved for the builtin themes and cannot be overridden by user defined themes.
+> 💡 The names "default" and "base16_default" are reserved for built-in themes
+> and cannot be overridden by user-defined themes.
 
-The default theme.toml can be found [here](https://github.com/helix-editor/helix/blob/master/theme.toml), and user submitted themes [here](https://github.com/helix-editor/helix/blob/master/runtime/themes). 
+### Overview
 
 Each line in the theme file is specified as below:
 
 ```toml
-key = { fg = "#ffffff", bg = "#000000", modifiers = ["bold", "italic"] }
+key = { fg = "#ffffff", bg = "#000000", underline = { color = "#ff0000", style = "curl"}, modifiers = ["bold", "italic"] }
 ```
 
-where `key` represents what you want to style, `fg` specifies the foreground color, `bg` the background color, and `modifiers` is a list of style modifiers. `bg` and `modifiers` can be omitted to defer to the defaults.
+Where `key` represents what you want to style, `fg` specifies the foreground color, `bg` the background color, `underline` the underline `style`/`color`, and `modifiers` is a list of style modifiers. `bg`, `underline` and `modifiers` can be omitted to defer to the defaults.
 
 To specify only the foreground color:
 
@@ -24,29 +25,37 @@ To specify only the foreground color:
 key = "#ffffff"
 ```
 
-if the key contains a dot `'.'`, it must be quoted to prevent it being parsed as a [dotted key](https://toml.io/en/v1.0.0#keys).
+If the key contains a dot `'.'`, it must be quoted to prevent it being parsed as a [dotted key](https://toml.io/en/v1.0.0#keys).
 
 ```toml
 "key.key" = "#ffffff"
 ```
 
+For inspiration, you can find the default `theme.toml`
+[here](https://github.com/helix-editor/helix/blob/master/theme.toml) and
+user-submitted themes
+[here](https://github.com/helix-editor/helix/blob/master/runtime/themes).
+
+
+## The details of theme creation
+
 ### Color palettes
 
-It's recommended define a palette of named colors, and refer to them from the
+It's recommended to define a palette of named colors, and refer to them in the
 configuration values in your theme. To do this, add a table called
 `palette` to your theme file:
 
 ```toml
-ui.background = "white"
-ui.text = "black"
+"ui.background" = "white"
+"ui.text" = "black"
 
 [palette]
 white = "#ffffff"
 black = "#000000"
 ```
 
-Remember that the `[palette]` table includes all keys after its header,
-so you should define the palette after normal theme options.
+Keep in mind that the `[palette]` table includes all keys after its header,
+so it should be defined after the normal theme options.
 
 The default palette uses the terminal's default 16 colors, and the colors names
 are listed below. The `[palette]` section in the config file takes precedence
@@ -54,6 +63,7 @@ over it and is merged into the default palette.
 
 | Color Name      |
 | ---             |
+| `default`       |
 | `black`         |
 | `red`           |
 | `green`         |
@@ -73,41 +83,77 @@ over it and is merged into the default palette.
 
 ### Modifiers
 
-The following values may be used as modifiers. 
+The following values may be used as modifier, provided they are supported by
+your terminal emulator.
 
-Less common modifiers might not be supported by your terminal emulator.
+| Modifier             |
+| ---                  |
+| `bold`               |
+| `dim`                |
+| `italic`             |
+| `underlined`         |
+| `slow_blink`         |
+| `rapid_blink`        |
+| `reversed`           |
+| `hidden`             |
+| `crossed_out`        |
+
+> 💡 The `underlined` modifier is deprecated and only available for backwards compatibility.
+> Its behavior is equivalent to setting `underline.style="line"`.
+
+### Underline style
+
+One of the following values may be used as a value for `underline.style`, providing it is
+supported by your terminal emulator.
 
 | Modifier       |
 | ---            |
-| `bold`         |
-| `dim`          |
-| `italic`       |
-| `underlined`   |
-| `slow_blink`   |
-| `rapid_blink`  |
-| `reversed`     |
-| `hidden`       |
-| `crossed_out`  |
+| `line`         |
+| `curl`         |
+| `dashed`       |
+| `dotted`       |
+| `double_line`  |
+
+
+### Inheritance
+
+Extend other themes by setting the `inherits` property to an existing theme.
+
+```toml
+inherits = "boo_berry"
+
+# Override the theming for "keyword"s:
+"keyword" = { fg = "gold" }
+
+# Override colors in the palette:
+[palette]
+berry = "#2A2A4D"
+```
 
 ### Scopes
 
-The following is a list of scopes available to use for styling.
+The following is a list of scopes available to use for styling:
 
 #### Syntax highlighting
 
 These keys match [tree-sitter scopes](https://tree-sitter.github.io/tree-sitter/syntax-highlighting#theme).
 
-For a given highlight produced, styling will be determined based on the longest matching theme key. For example, the highlight `function.builtin.static` would match the key `function.builtin` rather than `function`.
+When determining styling for a highlight, the longest matching theme key will be used. For example, if the highlight is `function.builtin.static`, the key `function.builtin` will be used instead of `function`.
 
 We use a similar set of scopes as
-[SublimeText](https://www.sublimetext.com/docs/scope_naming.html). See also
+[Sublime Text](https://www.sublimetext.com/docs/scope_naming.html). See also
 [TextMate](https://macromates.com/manual/en/language_grammars) scopes.
 
+- `attribute` - Class attributes, HTML tag attributes
+
 - `type` - Types
   - `builtin` - Primitive types provided by the language (`int`, `usize`)
+  - `parameter` - Generic type parameters (`T`)
+  - `enum`
+    - `variant`
 - `constructor`
 
-- `constant` (TODO: constant.other.placeholder for %v)
+- `constant` (TODO: constant.other.placeholder for `%v`)
   - `builtin` Special constants provided by the language (`true`, `false`, `nil` etc)
     - `boolean`
   - `character`
@@ -125,21 +171,21 @@ We use a similar set of scopes as
 
 - `comment` - Code comments
   - `line` - Single line comments (`//`)
-  - `block` - Block comments (e.g. (`/*     */`)
+  - `block` - Block comments (e.g. (`/* */`)
     - `documentation` - Documentation comments (e.g. `///` in Rust)
 
 - `variable` - Variables
-  - `builtin` - Reserved language variables (`self`, `this`, `super`, etc)
+  - `builtin` - Reserved language variables (`self`, `this`, `super`, etc.)
   - `parameter` - Function parameters
   - `other`
     - `member` - Fields of composite data types (e.g. structs, unions)
-  - `function` (TODO: ?)
 
 - `label`
 
 - `punctuation`
   - `delimiter` - Commas, colons
   - `bracket` - Parentheses, angle brackets, etc.
+  - `special` - String interpolation brackets.
 
 - `keyword`
   - `control`
@@ -151,6 +197,9 @@ We use a similar set of scopes as
   - `operator` - `or`, `in`
   - `directive` - Preprocessor directives (`#if` in C)
   - `function` - `fn`, `func`
+  - `storage` - Keywords describing how things are stored
+    - `type` - The type of something, `class`, `function`, `var`, `let`, etc.
+    - `modifier` - Storage modifiers like `static`, `mut`, `const`, `ref`, etc.
 
 - `operator` - `||`, `+=`, `>`
 
@@ -158,12 +207,15 @@ We use a similar set of scopes as
   - `builtin`
   - `method`
   - `macro`
-  - `special` (preprocesor in C)
+  - `special` (preprocessor in C)
 
 - `tag` - Tags (e.g. `<body>` in HTML)
+  - `builtin`
 
 - `namespace`
 
+- `special`
+
 - `markup`
   - `heading`
     - `marker`
@@ -171,12 +223,15 @@ We use a similar set of scopes as
   - `list`
     - `unnumbered`
     - `numbered`
+    - `checked`
+    - `unchecked`
   - `bold`
   - `italic`
+  - `strikethrough`
   - `link`
-    - `url` - urls pointed to by links
-    - `label` - non-url link references
-    - `text` - url and image descriptions in links
+    - `url` - URLs pointed to by links
+    - `label` - non-URL link references
+    - `text` - URL and image descriptions in links
   - `quote`
   - `raw`
     - `inline`
@@ -184,53 +239,96 @@ We use a similar set of scopes as
 
 - `diff` - version control changes
   - `plus` - additions
+    - `gutter` - gutter indicator
   - `minus` - deletions
+    - `gutter` - gutter indicator
   - `delta` - modifications
     - `moved` - renamed or moved files/changes
+    - `conflict` - merge conflicts
+    - `gutter` - gutter indicator
 
 #### Interface
 
-These scopes are used for theming the editor interface.
+These scopes are used for theming the editor interface:
 
 - `markup`
   - `normal`
-    - `completion` - for completion doc popup ui
-    - `hover` - for hover popup ui
+    - `completion` - for completion doc popup UI
+    - `hover` - for hover popup UI
   - `heading`
-    - `completion` - for completion doc popup ui
-    - `hover` - for hover popup ui
+    - `completion` - for completion doc popup UI
+    - `hover` - for hover popup UI
   - `raw`
     - `inline`
-      - `completion` - for completion doc popup ui
-      - `hover` - for hover popup ui
+      - `completion` - for completion doc popup UI
+      - `hover` - for hover popup UI
 
 
-| Key                      | Notes                               |
-| ---                      | ---                                 |
-| `ui.background`          |                                     |
-| `ui.cursor`              |                                     |
-| `ui.cursor.insert`       |                                     |
-| `ui.cursor.select`       |                                     |
-| `ui.cursor.match`        | Matching bracket etc.               |
-| `ui.cursor.primary`      | Cursor with primary selection       |
-| `ui.linenr`              |                                     |
-| `ui.linenr.selected`     |                                     |
-| `ui.statusline`          | Statusline                          |
-| `ui.statusline.inactive` | Statusline (unfocused document)     |
-| `ui.popup`               |                                     |
-| `ui.popup.info`          |                                     |
-| `ui.window`              |                                     |
-| `ui.help`                |                                     |
-| `ui.text`                |                                     |
-| `ui.text.focus`          |                                     |
-| `ui.text.info`           |                                     |
-| `ui.menu`                |                                     |
-| `ui.menu.selected`       |                                     |
-| `ui.selection`           | For selections in the editing area  |
-| `ui.selection.primary`   |                                     |
-| `warning`                | Diagnostics warning (gutter)        |
-| `error`                  | Diagnostics error (gutter)          |
-| `info`                   | Diagnostics info (gutter)           |
-| `hint`                   | Diagnostics hint (gutter)           |
-| `diagnostic`             | For text in editing area            |
+| Key                               | Notes                                                                                          |
+| ---                               | ---                                                                                            |
+| `ui.background`                   |                                                                                                |
+| `ui.background.separator`         | Picker separator below input line                                                              |
+| `ui.cursor`                       |                                                                                                |
+| `ui.cursor.normal`                |                                                                                                |
+| `ui.cursor.insert`                |                                                                                                |
+| `ui.cursor.select`                |                                                                                                |
+| `ui.cursor.match`                 | Matching bracket etc.                                                                          |
+| `ui.cursor.primary`               | Cursor with primary selection                                                                  |
+| `ui.cursor.primary.normal`        |                                                                                                |
+| `ui.cursor.primary.insert`        |                                                                                                |
+| `ui.cursor.primary.select`        |                                                                                                |
+| `ui.debug.breakpoint`             | Breakpoint indicator, found in the gutter                                                      |
+| `ui.debug.active`                 | Indicator for the line at which debugging execution is paused at, found in the gutter          |
+| `ui.gutter`                       | Gutter                                                                                         |
+| `ui.gutter.selected`              | Gutter for the line the cursor is on                                                           |
+| `ui.highlight.frameline`          | Line at which debugging execution is paused at                                                 |
+| `ui.linenr`                       | Line numbers                                                                                   |
+| `ui.linenr.selected`              | Line number for the line the cursor is on                                                      |
+| `ui.statusline`                   | Statusline                                                                                     |
+| `ui.statusline.inactive`          | Statusline (unfocused document)                                                                |
+| `ui.statusline.normal`            | Statusline mode during normal mode ([only if `editor.color-modes` is enabled][editor-section]) |
+| `ui.statusline.insert`            | Statusline mode during insert mode ([only if `editor.color-modes` is enabled][editor-section]) |
+| `ui.statusline.select`            | Statusline mode during select mode ([only if `editor.color-modes` is enabled][editor-section]) |
+| `ui.statusline.separator`         | Separator character in statusline                                                              |
+| `ui.bufferline`                   | Style for the buffer line                                                                      |
+| `ui.bufferline.active`            | Style for the active buffer in buffer line                                                        |
+| `ui.bufferline.background`        | Style for bufferline background                                                                |
+| `ui.popup`                        | Documentation popups (e.g. Space + k)                                                          |
+| `ui.popup.info`                   | Prompt for multiple key options                                                                |
+| `ui.window`                       | Borderlines separating splits                                                                  |
+| `ui.help`                         | Description box for commands                                                                   |
+| `ui.text`                         | Default text style, command prompts, popup text, etc.                                          |
+| `ui.text.focus`                   | The currently selected line in the picker                                                      |
+| `ui.text.inactive`                | Same as `ui.text` but when the text is inactive (e.g. suggestions)                             |
+| `ui.text.info`                    | The key: command text in `ui.popup.info` boxes                                                 |
+| `ui.virtual.ruler`                | Ruler columns (see the [`editor.rulers` config][editor-section])                               |
+| `ui.virtual.whitespace`           | Visible whitespace characters                                                                  |
+| `ui.virtual.indent-guide`         | Vertical indent width guides                                                                   |
+| `ui.virtual.inlay-hint`           | Default style for inlay hints of all kinds                                                     |
+| `ui.virtual.inlay-hint.parameter` | Style for inlay hints of kind `parameter` (LSPs are not required to set a kind)                |
+| `ui.virtual.inlay-hint.type`      | Style for inlay hints of kind `type` (LSPs are not required to set a kind)                     |
+| `ui.virtual.wrap`                 | Soft-wrap indicator (see the [`editor.soft-wrap` config][editor-section])                      |
+| `ui.virtual.jump-label`           | Style for virtual jump labels                                                                  |
+| `ui.menu`                         | Code and command completion menus                                                              |
+| `ui.menu.selected`                | Selected autocomplete item                                                                     |
+| `ui.menu.scroll`                  | `fg` sets thumb color, `bg` sets track color of scrollbar                                      |
+| `ui.selection`                    | For selections in the editing area                                                             |
+| `ui.selection.primary`            |                                                                                                |
+| `ui.highlight`                    | Highlighted lines in the picker preview                                                        |
+| `ui.cursorline.primary`           | The line of the primary cursor ([if cursorline is enabled][editor-section])                    |
+| `ui.cursorline.secondary`         | The lines of any other cursors ([if cursorline is enabled][editor-section])                    |
+| `ui.cursorcolumn.primary`         | The column of the primary cursor ([if cursorcolumn is enabled][editor-section])                |
+| `ui.cursorcolumn.secondary`       | The columns of any other cursors ([if cursorcolumn is enabled][editor-section])                |
+| `warning`                         | Diagnostics warning (gutter)                                                                   |
+| `error`                           | Diagnostics error (gutter)                                                                     |
+| `info`                            | Diagnostics info (gutter)                                                                      |
+| `hint`                            | Diagnostics hint (gutter)                                                                      |
+| `diagnostic`                      | Diagnostics fallback style (editing area)                                                      |
+| `diagnostic.hint`                 | Diagnostics hint (editing area)                                                                |
+| `diagnostic.info`                 | Diagnostics info (editing area)                                                                |
+| `diagnostic.warning`              | Diagnostics warning (editing area)                                                             |
+| `diagnostic.error`                | Diagnostics error (editing area)                                                               |
+| `diagnostic.unnecessary`          | Diagnostics with unnecessary tag (editing area)                                                |
+| `diagnostic.deprecated`           | Diagnostics with deprecated tag (editing area)                                                 |
 
+[editor-section]: ./configuration.md#editor-section

book/src/title-page.md

@@ -6,6 +6,7 @@ Docs for bleeding edge master can be found at
 See the [usage] section for a quick overview of the editor, [keymap]
 section for all available keybindings and the [configuration] section
 for defining custom keybindings, setting themes, etc.
+For everything else (e.g., how to install supported language servers), see the [Helix Wiki].
 
 Refer the [FAQ] for common questions.
 
@@ -13,3 +14,4 @@ Refer the [FAQ] for common questions.
 [usage]: ./usage.md
 [keymap]: ./keymap.md
 [configuration]: ./configuration.md
+[Helix Wiki]: https://github.com/helix-editor/helix/wiki

book/src/usage.md

@@ -1,95 +1,207 @@
-# Usage
+# Using Helix
 
-(Currently not fully documented, see the [keymappings](./keymap.md) list for more.)
+<!--toc:start-->
+- [Registers](#registers)
+  - [User-defined registers](#user-defined-registers)
+  - [Special registers](#special-registers)
+- [Surround](#surround)
+- [Selecting and manipulating text with textobjects](#selecting-and-manipulating-text-with-textobjects)
+- [Navigating using tree-sitter textobjects](#navigating-using-tree-sitter-textobjects)
+- [Moving the selection with syntax-aware motions](#moving-the-selection-with-syntax-aware-motions)
+<!--toc:end-->
 
-See [tutor.txt](https://github.com/helix-editor/helix/blob/master/runtime/tutor.txt) (accessible via `hx --tutor` or `:tutor`) for a vimtutor-like introduction.
+For a full interactive introduction to Helix, refer to the
+[tutor](https://github.com/helix-editor/helix/blob/master/runtime/tutor) which
+can be accessed via the command `hx --tutor` or `:tutor`.
+
+> 💡 Currently, not all functionality is fully documented, please refer to the
+> [key mappings](./keymap.md) list.
 
 ## Registers
 
-Vim-like registers can be used to yank and store text to be pasted later. Usage is similar, with `"` being used to select a register:
+In Helix, registers are storage locations for text and other data, such as the
+result of a search. Registers can be used to cut, copy, and paste text, similar
+to the clipboard in other text editors. Usage is similar to Vim, with `"` being
+used to select a register.
+
+### User-defined registers
+
+Helix allows you to create your own named registers for storing text, for
+example:
 
 - `"ay` - Yank the current selection to register `a`.
 - `"op` - Paste the text in register `o` after the selection.
 
-If there is a selected register before invoking a change or delete command, the selection will be stored in the register and the action will be carried out:
+If a register is selected before invoking a change or delete command, the selection will be stored in the register and the action will be carried out:
 
 - `"hc` - Store the selection in register `h` and then change it (delete and enter insert mode).
 - `"md` - Store the selection in register `m` and delete it.
 
-### Special Registers
+### Default registers
+
+Commands that use registers, like yank (`y`), use a default register if none is specified.
+These registers are used as defaults:
 
 | Register character | Contains              |
 | ---                | ---                   |
 | `/`                | Last search           |
 | `:`                | Last executed command |
 | `"`                | Last yanked text      |
-| `_`                | Black hole            |
+| `@`                | Last recorded macro   |
 
-> There is no special register for copying to system clipboard, instead special commands and keybindings are provided. See the [keymap](keymap.md#space-mode) for the specifics.
-> The black hole register works as a no-op register, meaning no data will be written to / read from it.
+### Special registers
+
+Some registers have special behavior when read from and written to.
+
+| Register character | When read              | When written             |
+| ---                | ---                    | ---                      |
+| `_`                | No values are returned | All values are discarded |
+| `#`                | Selection indices (first selection is `1`, second is `2`, etc.) | This register is not writable |
+| `.`                | Contents of the current selections | This register is not writable |
+| `%`                | Name of the current file | This register is not writable |
+| `+`                | Reads from the system clipboard | Joins and yanks to the system clipboard |
+| `*`                | Reads from the primary clipboard | Joins and yanks to the primary clipboard |
+
+When yanking multiple selections to the clipboard registers, the selections
+are joined with newlines. Pasting from these registers will paste multiple
+selections if the clipboard was last yanked to by the Helix session. Otherwise
+the clipboard contents are pasted as one selection.
 
 ## Surround
 
-Functionality similar to [vim-surround](https://github.com/tpope/vim-surround) is built into
-helix. The keymappings have been inspired from [vim-sandwich](https://github.com/machakann/vim-sandwich):
+Helix includes built-in functionality similar to [vim-surround](https://github.com/tpope/vim-surround).
+The keymappings have been inspired from [vim-sandwich](https://github.com/machakann/vim-sandwich):
 
-![surround demo](https://user-images.githubusercontent.com/23398472/122865801-97073180-d344-11eb-8142-8f43809982c6.gif)
+![Surround demo](https://user-images.githubusercontent.com/23398472/122865801-97073180-d344-11eb-8142-8f43809982c6.gif)
 
-- `ms` - Add surround characters
-- `mr` - Replace surround characters
-- `md` - Delete surround characters
+| Key Sequence                      | Action                                  |
+| --------------------------------- | --------------------------------------- |
+| `ms<char>` (after selecting text) | Add surround characters to selection    |
+| `mr<char_to_replace><new_char>`   | Replace the closest surround characters |
+| `md<char_to_delete>`              | Delete the closest surround characters  |
 
-`ms` acts on a selection, so select the text first and use `ms<char>`. `mr` and `md` work
-on the closest pairs found and selections are not required; use counts to act in outer pairs.
+You can use counts to act on outer pairs.
 
-It can also act on multiple selections (yay!). For example, to change every occurrence of `(use)` to `[use]`:
+Surround can also act on multiple selections. For example, to change every occurrence of `(use)` to `[use]`:
 
-- `%` to select the whole file
-- `s` to split the selections on a search term
-- Input `use` and hit Enter
-- `mr([` to replace the parens with square brackets
+1. `%` to select the whole file
+2. `s` to split the selections on a search term
+3. Input `use` and hit Enter
+4. `mr([` to replace the parentheses with square brackets
 
-Multiple characters are currently not supported, but planned.
+Multiple characters are currently not supported, but planned for future release.
 
-## Textobjects
+## Selecting and manipulating text with textobjects
 
-Currently supported: `word`, `surround`, `function`, `class`, `parameter`.
+In Helix, textobjects are a way to select, manipulate and operate on a piece of
+text in a structured way. They allow you to refer to blocks of text based on
+their structure or purpose, such as a word, sentence, paragraph, or even a
+function or block of code.
 
-![textobject-demo](https://user-images.githubusercontent.com/23398472/124231131-81a4bb00-db2d-11eb-9d10-8e577ca7b177.gif)
-![textobject-treesitter-demo](https://user-images.githubusercontent.com/23398472/132537398-2a2e0a54-582b-44ab-a77f-eb818942203d.gif)
+![Textobject demo](https://user-images.githubusercontent.com/23398472/124231131-81a4bb00-db2d-11eb-9d10-8e577ca7b177.gif)
+![Textobject tree-sitter demo](https://user-images.githubusercontent.com/23398472/132537398-2a2e0a54-582b-44ab-a77f-eb818942203d.gif)
 
-- `ma` - Select around the object (`va` in vim, `<alt-a>` in kakoune)
-- `mi` - Select inside the object (`vi` in vim, `<alt-i>` in kakoune)
+- `ma` - Select around the object (`va` in Vim, `<alt-a>` in Kakoune)
+- `mi` - Select inside the object (`vi` in Vim, `<alt-i>` in Kakoune)
 
 | Key after `mi` or `ma` | Textobject selected      |
 | ---                    | ---                      |
 | `w`                    | Word                     |
 | `W`                    | WORD                     |
-| `(`, `[`, `'`, etc     | Specified surround pairs |
+| `p`                    | Paragraph                |
+| `(`, `[`, `'`, etc.    | Specified surround pairs |
+| `m`                    | The closest surround pair    |
 | `f`                    | Function                 |
-| `c`                    | Class                    |
+| `t`                    | Type (or Class)          |
 | `a`                    | Argument/parameter       |
-| `o`                    | Comment                  |
+| `c`                    | Comment                  |
+| `T`                    | Test                     |
+| `g`                    | Change                   |
 
-> NOTE: `f`, `c`, etc need a tree-sitter grammar active for the current
+> 💡 `f`, `t`, etc. need a tree-sitter grammar active for the current
 document and a special tree-sitter query file to work properly. [Only
 some grammars][lang-support] currently have the query file implemented.
 Contributions are welcome!
 
-## Tree-sitter Textobject Based Navigation
+## Navigating using tree-sitter textobjects
 
-Navigating between functions, classes, parameters, etc is made
-possible by leveraging tree-sitter and textobjects queries. For
+Navigating between functions, classes, parameters, and other elements is
+possible using tree-sitter and textobject queries. For
 example to move to the next function use `]f`, to move to previous
-class use `[c`, and so on.
+type use `[t`, and so on.
 
-![tree-sitter-nav-demo][tree-sitter-nav-demo]
+![Tree-sitter-nav-demo][tree-sitter-nav-demo]
 
-See the [unimpaired][unimpaired-keybinds] section of the keybind
-documentation for the full reference.
+For the full reference see the [unimpaired][unimpaired-keybinds] section of the key bind
+documentation.
 
-> NOTE: This feature is dependent on tree-sitter based textobjects
-and therefore requires the corresponding query file to work properly.
+> 💡 This feature relies on tree-sitter textobjects
+> and requires the corresponding query file to work properly.
+
+## Moving the selection with syntax-aware motions
+
+`Alt-p`, `Alt-o`, `Alt-i`, and `Alt-n` (or `Alt` and arrow keys) allow you to move the 
+selection according to its location in the syntax tree. For example, many languages have the
+following syntax for function calls:
+
+```js
+func(arg1, arg2, arg3);
+```
+
+A function call might be parsed by tree-sitter into a tree like the following.
+
+```tsq
+(call
+  function: (identifier) ; func
+  arguments:
+    (arguments           ; (arg1, arg2, arg3)
+      (identifier)       ; arg1
+      (identifier)       ; arg2
+      (identifier)))     ; arg3
+```
+
+Use `:tree-sitter-subtree` to view the syntax tree of the primary selection. In
+a more intuitive tree format:
+
+```
+            ┌────┐
+            │call│
+      ┌─────┴────┴─────┐
+      │                │
+┌─────▼────┐      ┌────▼────┐
+│identifier│      │arguments│
+│  "func"  │ ┌────┴───┬─────┴───┐
+└──────────┘ │        │         │
+             │        │         │
+   ┌─────────▼┐  ┌────▼─────┐  ┌▼─────────┐
+   │identifier│  │identifier│  │identifier│
+   │  "arg1"  │  │  "arg2"  │  │  "arg3"  │
+   └──────────┘  └──────────┘  └──────────┘
+```
+
+If you have a selection that wraps `arg1` (see the tree above), and you use
+`Alt-n`, it will select the next sibling in the syntax tree: `arg2`.
+
+```js
+// before
+func([arg1], arg2, arg3)
+// after
+func(arg1, [arg2], arg3);
+```
+
+Similarly, `Alt-o` will expand the selection to the parent node, in this case, the
+arguments node.
+
+```js
+func[(arg1, arg2, arg3)];
+```
+
+There is also some nuanced behavior that prevents you from getting stuck on a
+node with no sibling. When using `Alt-p` with a selection on `arg1`, the previous
+child node will be selected. In the event that `arg1` does not have a previous
+sibling, the selection will move up the syntax tree and select the previous
+element. As a result, using `Alt-p` with a selection on `arg1` will move the
+selection to the "func" `identifier`.
 
 [lang-support]: ./lang-support.md
 [unimpaired-keybinds]: ./keymap.md#unimpaired

book/theme/book.js

@@ -1,660 +0,0 @@
-"use strict";
-
-// Fix back button cache problem
-window.onunload = function () { };
-
-// Global variable, shared between modules
-function playground_text(playground) {
-    let code_block = playground.querySelector("code");
-
-    if (window.ace && code_block.classList.contains("editable")) {
-        let editor = window.ace.edit(code_block);
-        return editor.getValue();
-    } else {
-        return code_block.textContent;
-    }
-}
-
-(function codeSnippets() {
-    function fetch_with_timeout(url, options, timeout = 6000) {
-        return Promise.race([
-            fetch(url, options),
-            new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), timeout))
-        ]);
-    }
-
-    var playgrounds = Array.from(document.querySelectorAll(".playground"));
-    if (playgrounds.length > 0) {
-        fetch_with_timeout("https://play.rust-lang.org/meta/crates", {
-            headers: {
-                'Content-Type': "application/json",
-            },
-            method: 'POST',
-            mode: 'cors',
-        })
-        .then(response => response.json())
-        .then(response => {
-            // get list of crates available in the rust playground
-            let playground_crates = response.crates.map(item => item["id"]);
-            playgrounds.forEach(block => handle_crate_list_update(block, playground_crates));
-        });
-    }
-
-    function handle_crate_list_update(playground_block, playground_crates) {
-        // update the play buttons after receiving the response
-        update_play_button(playground_block, playground_crates);
-
-        // and install on change listener to dynamically update ACE editors
-        if (window.ace) {
-            let code_block = playground_block.querySelector("code");
-            if (code_block.classList.contains("editable")) {
-                let editor = window.ace.edit(code_block);
-                editor.addEventListener("change", function (e) {
-                    update_play_button(playground_block, playground_crates);
-                });
-                // add Ctrl-Enter command to execute rust code
-                editor.commands.addCommand({
-                    name: "run",
-                    bindKey: {
-                        win: "Ctrl-Enter",
-                        mac: "Ctrl-Enter"
-                    },
-                    exec: _editor => run_rust_code(playground_block)
-                });
-            }
-        }
-    }
-
-    // updates the visibility of play button based on `no_run` class and
-    // used crates vs ones available on http://play.rust-lang.org
-    function update_play_button(pre_block, playground_crates) {
-        var play_button = pre_block.querySelector(".play-button");
-
-        // skip if code is `no_run`
-        if (pre_block.querySelector('code').classList.contains("no_run")) {
-            play_button.classList.add("hidden");
-            return;
-        }
-
-        // get list of `extern crate`'s from snippet
-        var txt = playground_text(pre_block);
-        var re = /extern\s+crate\s+([a-zA-Z_0-9]+)\s*;/g;
-        var snippet_crates = [];
-        var item;
-        while (item = re.exec(txt)) {
-            snippet_crates.push(item[1]);
-        }
-
-        // check if all used crates are available on play.rust-lang.org
-        var all_available = snippet_crates.every(function (elem) {
-            return playground_crates.indexOf(elem) > -1;
-        });
-
-        if (all_available) {
-            play_button.classList.remove("hidden");
-        } else {
-            play_button.classList.add("hidden");
-        }
-    }
-
-    function run_rust_code(code_block) {
-        var result_block = code_block.querySelector(".result");
-        if (!result_block) {
-            result_block = document.createElement('code');
-            result_block.className = 'result hljs language-bash';
-
-            code_block.append(result_block);
-        }
-
-        let text = playground_text(code_block);
-        let classes = code_block.querySelector('code').classList;
-        let has_2018 = classes.contains("edition2018");
-        let edition = has_2018 ? "2018" : "2015";
-
-        var params = {
-            version: "stable",
-            optimize: "0",
-            code: text,
-            edition: edition
-        };
-
-        if (text.indexOf("#![feature") !== -1) {
-            params.version = "nightly";
-        }
-
-        result_block.innerText = "Running...";
-
-        fetch_with_timeout("https://play.rust-lang.org/evaluate.json", {
-            headers: {
-                'Content-Type': "application/json",
-            },
-            method: 'POST',
-            mode: 'cors',
-            body: JSON.stringify(params)
-        })
-        .then(response => response.json())
-        .then(response => result_block.innerText = response.result)
-        .catch(error => result_block.innerText = "Playground Communication: " + error.message);
-    }
-
-    // Syntax highlighting Configuration
-    hljs.configure({
-        tabReplace: '    ', // 4 spaces
-        languages: [],      // Languages used for auto-detection
-    });
-
-    let code_nodes = Array
-        .from(document.querySelectorAll('code'))
-        // Don't highlight `inline code` blocks in headers.
-        .filter(function (node) {return !node.parentElement.classList.contains("header"); });
-
-    if (window.ace) {
-        // language-rust class needs to be removed for editable
-        // blocks or highlightjs will capture events
-        Array
-            .from(document.querySelectorAll('code.editable'))
-            .forEach(function (block) { block.classList.remove('language-rust'); });
-
-        Array
-            .from(document.querySelectorAll('code:not(.editable)'))
-            .forEach(function (block) { hljs.highlightBlock(block); });
-    } else {
-        code_nodes.forEach(function (block) { hljs.highlightBlock(block); });
-    }
-
-    // Adding the hljs class gives code blocks the color css
-    // even if highlighting doesn't apply
-    code_nodes.forEach(function (block) { block.classList.add('hljs'); });
-
-    Array.from(document.querySelectorAll("code.language-rust")).forEach(function (block) {
-
-        var lines = Array.from(block.querySelectorAll('.boring'));
-        // If no lines were hidden, return
-        if (!lines.length) { return; }
-        block.classList.add("hide-boring");
-
-        var buttons = document.createElement('div');
-        buttons.className = 'buttons';
-        buttons.innerHTML = "<button class=\"fa fa-eye\" title=\"Show hidden lines\" aria-label=\"Show hidden lines\"></button>";
-
-        // add expand button
-        var pre_block = block.parentNode;
-        pre_block.insertBefore(buttons, pre_block.firstChild);
-
-        pre_block.querySelector('.buttons').addEventListener('click', function (e) {
-            if (e.target.classList.contains('fa-eye')) {
-                e.target.classList.remove('fa-eye');
-                e.target.classList.add('fa-eye-slash');
-                e.target.title = 'Hide lines';
-                e.target.setAttribute('aria-label', e.target.title);
-
-                block.classList.remove('hide-boring');
-            } else if (e.target.classList.contains('fa-eye-slash')) {
-                e.target.classList.remove('fa-eye-slash');
-                e.target.classList.add('fa-eye');
-                e.target.title = 'Show hidden lines';
-                e.target.setAttribute('aria-label', e.target.title);
-
-                block.classList.add('hide-boring');
-            }
-        });
-    });
-
-    if (window.playground_copyable) {
-        Array.from(document.querySelectorAll('pre code')).forEach(function (block) {
-            var pre_block = block.parentNode;
-            if (!pre_block.classList.contains('playground')) {
-                var buttons = pre_block.querySelector(".buttons");
-                if (!buttons) {
-                    buttons = document.createElement('div');
-                    buttons.className = 'buttons';
-                    pre_block.insertBefore(buttons, pre_block.firstChild);
-                }
-
-                var clipButton = document.createElement('button');
-                clipButton.className = 'fa fa-copy clip-button';
-                clipButton.title = 'Copy to clipboard';
-                clipButton.setAttribute('aria-label', clipButton.title);
-                clipButton.innerHTML = '<i class=\"tooltiptext\"></i>';
-
-                buttons.insertBefore(clipButton, buttons.firstChild);
-            }
-        });
-    }
-
-    // Process playground code blocks
-    Array.from(document.querySelectorAll(".playground")).forEach(function (pre_block) {
-        // Add play button
-        var buttons = pre_block.querySelector(".buttons");
-        if (!buttons) {
-            buttons = document.createElement('div');
-            buttons.className = 'buttons';
-            pre_block.insertBefore(buttons, pre_block.firstChild);
-        }
-
-        var runCodeButton = document.createElement('button');
-        runCodeButton.className = 'fa fa-play play-button';
-        runCodeButton.hidden = true;
-        runCodeButton.title = 'Run this code';
-        runCodeButton.setAttribute('aria-label', runCodeButton.title);
-
-        buttons.insertBefore(runCodeButton, buttons.firstChild);
-        runCodeButton.addEventListener('click', function (e) {
-            run_rust_code(pre_block);
-        });
-
-        if (window.playground_copyable) {
-            var copyCodeClipboardButton = document.createElement('button');
-            copyCodeClipboardButton.className = 'fa fa-copy clip-button';
-            copyCodeClipboardButton.innerHTML = '<i class="tooltiptext"></i>';
-            copyCodeClipboardButton.title = 'Copy to clipboard';
-            copyCodeClipboardButton.setAttribute('aria-label', copyCodeClipboardButton.title);
-
-            buttons.insertBefore(copyCodeClipboardButton, buttons.firstChild);
-        }
-
-        let code_block = pre_block.querySelector("code");
-        if (window.ace && code_block.classList.contains("editable")) {
-            var undoChangesButton = document.createElement('button');
-            undoChangesButton.className = 'fa fa-history reset-button';
-            undoChangesButton.title = 'Undo changes';
-            undoChangesButton.setAttribute('aria-label', undoChangesButton.title);
-
-            buttons.insertBefore(undoChangesButton, buttons.firstChild);
-
-            undoChangesButton.addEventListener('click', function () {
-                let editor = window.ace.edit(code_block);
-                editor.setValue(editor.originalCode);
-                editor.clearSelection();
-            });
-        }
-    });
-})();
-
-(function themes() {
-    var html = document.querySelector('html');
-    var themeToggleButton = document.getElementById('theme-toggle');
-    var themePopup = document.getElementById('theme-list');
-    var themeColorMetaTag = document.querySelector('meta[name="theme-color"]');
-    var stylesheets = {
-        ayuHighlight: document.querySelector("[href$='ayu-highlight.css']"),
-        tomorrowNight: document.querySelector("[href$='tomorrow-night.css']"),
-        highlight: document.querySelector("[href$='highlight.css']"),
-    };
-
-    function showThemes() {
-        themePopup.style.display = 'block';
-        themeToggleButton.setAttribute('aria-expanded', true);
-        themePopup.querySelector("button#" + get_theme()).focus();
-    }
-
-    function hideThemes() {
-        themePopup.style.display = 'none';
-        themeToggleButton.setAttribute('aria-expanded', false);
-        themeToggleButton.focus();
-    }
-
-    function get_theme() {
-        var theme;
-        try { theme = localStorage.getItem('mdbook-theme'); } catch (e) { }
-        if (theme === null || theme === undefined) {
-            return default_theme;
-        } else {
-            return theme;
-        }
-    }
-
-    function set_theme(theme, store = true) {
-        let ace_theme;
-
-        if (theme == 'coal' || theme == 'navy') {
-            stylesheets.ayuHighlight.disabled = true;
-            stylesheets.tomorrowNight.disabled = false;
-            stylesheets.highlight.disabled = true;
-
-            ace_theme = "ace/theme/tomorrow_night";
-        } else if (theme == 'ayu') {
-            stylesheets.ayuHighlight.disabled = false;
-            stylesheets.tomorrowNight.disabled = true;
-            stylesheets.highlight.disabled = true;
-            ace_theme = "ace/theme/tomorrow_night";
-        } else {
-            stylesheets.ayuHighlight.disabled = true;
-            stylesheets.tomorrowNight.disabled = true;
-            stylesheets.highlight.disabled = false;
-            ace_theme = "ace/theme/dawn";
-        }
-
-        setTimeout(function () {
-            themeColorMetaTag.content = getComputedStyle(document.body).backgroundColor;
-        }, 1);
-
-        if (window.ace && window.editors) {
-            window.editors.forEach(function (editor) {
-                editor.setTheme(ace_theme);
-            });
-        }
-
-        var previousTheme = get_theme();
-
-        if (store) {
-            try { localStorage.setItem('mdbook-theme', theme); } catch (e) { }
-        }
-
-        html.classList.remove(previousTheme);
-        html.classList.add(theme);
-    }
-
-    // Set theme
-    var theme = get_theme();
-
-    set_theme(theme, false);
-
-    themeToggleButton.addEventListener('click', function () {
-        if (themePopup.style.display === 'block') {
-            hideThemes();
-        } else {
-            showThemes();
-        }
-    });
-
-    themePopup.addEventListener('click', function (e) {
-        var theme = e.target.id || e.target.parentElement.id;
-        set_theme(theme);
-    });
-
-    themePopup.addEventListener('focusout', function(e) {
-        // e.relatedTarget is null in Safari and Firefox on macOS (see workaround below)
-        if (!!e.relatedTarget && !themeToggleButton.contains(e.relatedTarget) && !themePopup.contains(e.relatedTarget)) {
-            hideThemes();
-        }
-    });
-
-    // Should not be needed, but it works around an issue on macOS & iOS: https://github.com/rust-lang/mdBook/issues/628
-    document.addEventListener('click', function(e) {
-        if (themePopup.style.display === 'block' && !themeToggleButton.contains(e.target) && !themePopup.contains(e.target)) {
-            hideThemes();
-        }
-    });
-
-    document.addEventListener('keydown', function (e) {
-        if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) { return; }
-        if (!themePopup.contains(e.target)) { return; }
-
-        switch (e.key) {
-            case 'Escape':
-                e.preventDefault();
-                hideThemes();
-                break;
-            case 'ArrowUp':
-                e.preventDefault();
-                var li = document.activeElement.parentElement;
-                if (li && li.previousElementSibling) {
-                    li.previousElementSibling.querySelector('button').focus();
-                }
-                break;
-            case 'ArrowDown':
-                e.preventDefault();
-                var li = document.activeElement.parentElement;
-                if (li && li.nextElementSibling) {
-                    li.nextElementSibling.querySelector('button').focus();
-                }
-                break;
-            case 'Home':
-                e.preventDefault();
-                themePopup.querySelector('li:first-child button').focus();
-                break;
-            case 'End':
-                e.preventDefault();
-                themePopup.querySelector('li:last-child button').focus();
-                break;
-        }
-    });
-})();
-
-(function sidebar() {
-    var html = document.querySelector("html");
-    var sidebar = document.getElementById("sidebar");
-    var sidebarLinks = document.querySelectorAll('#sidebar a');
-    var sidebarToggleButton = document.getElementById("sidebar-toggle");
-    var sidebarResizeHandle = document.getElementById("sidebar-resize-handle");
-    var firstContact = null;
-
-    function showSidebar() {
-        html.classList.remove('sidebar-hidden')
-        html.classList.add('sidebar-visible');
-        Array.from(sidebarLinks).forEach(function (link) {
-            link.setAttribute('tabIndex', 0);
-        });
-        sidebarToggleButton.setAttribute('aria-expanded', true);
-        sidebar.setAttribute('aria-hidden', false);
-        try { localStorage.setItem('mdbook-sidebar', 'visible'); } catch (e) { }
-    }
-
-
-    var sidebarAnchorToggles = document.querySelectorAll('#sidebar a.toggle');
-
-    function toggleSection(ev) {
-        ev.currentTarget.parentElement.classList.toggle('expanded');
-    }
-
-    Array.from(sidebarAnchorToggles).forEach(function (el) {
-        el.addEventListener('click', toggleSection);
-    });
-
-    function hideSidebar() {
-        html.classList.remove('sidebar-visible')
-        html.classList.add('sidebar-hidden');
-        Array.from(sidebarLinks).forEach(function (link) {
-            link.setAttribute('tabIndex', -1);
-        });
-        sidebarToggleButton.setAttribute('aria-expanded', false);
-        sidebar.setAttribute('aria-hidden', true);
-        try { localStorage.setItem('mdbook-sidebar', 'hidden'); } catch (e) { }
-    }
-
-    // Toggle sidebar
-    sidebarToggleButton.addEventListener('click', function sidebarToggle() {
-        if (html.classList.contains("sidebar-hidden")) {
-            var current_width = parseInt(
-                document.documentElement.style.getPropertyValue('--sidebar-width'), 10);
-            if (current_width < 150) {
-                document.documentElement.style.setProperty('--sidebar-width', '150px');
-            }
-            showSidebar();
-        } else if (html.classList.contains("sidebar-visible")) {
-            hideSidebar();
-        } else {
-            if (getComputedStyle(sidebar)['transform'] === 'none') {
-                hideSidebar();
-            } else {
-                showSidebar();
-            }
-        }
-    });
-
-    sidebarResizeHandle.addEventListener('mousedown', initResize, false);
-
-    function initResize(e) {
-        window.addEventListener('mousemove', resize, false);
-        window.addEventListener('mouseup', stopResize, false);
-        html.classList.add('sidebar-resizing');
-    }
-    function resize(e) {
-        var pos = (e.clientX - sidebar.offsetLeft);
-        if (pos < 20) {
-            hideSidebar();
-        } else {
-            if (html.classList.contains("sidebar-hidden")) {
-                showSidebar();
-            }
-            pos = Math.min(pos, window.innerWidth - 100);
-            document.documentElement.style.setProperty('--sidebar-width', pos + 'px');
-        }
-    }
-    //on mouseup remove windows functions mousemove & mouseup
-    function stopResize(e) {
-        html.classList.remove('sidebar-resizing');
-        window.removeEventListener('mousemove', resize, false);
-        window.removeEventListener('mouseup', stopResize, false);
-    }
-
-    document.addEventListener('touchstart', function (e) {
-        firstContact = {
-            x: e.touches[0].clientX,
-            time: Date.now()
-        };
-    }, { passive: true });
-
-    document.addEventListener('touchmove', function (e) {
-        if (!firstContact)
-            return;
-
-        var curX = e.touches[0].clientX;
-        var xDiff = curX - firstContact.x,
-            tDiff = Date.now() - firstContact.time;
-
-        if (tDiff < 250 && Math.abs(xDiff) >= 150) {
-            if (xDiff >= 0 && firstContact.x < Math.min(document.body.clientWidth * 0.25, 300))
-                showSidebar();
-            else if (xDiff < 0 && curX < 300)
-                hideSidebar();
-
-            firstContact = null;
-        }
-    }, { passive: true });
-
-    // Scroll sidebar to current active section
-    var activeSection = document.getElementById("sidebar").querySelector(".active");
-    if (activeSection) {
-        // https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoView
-        activeSection.scrollIntoView({ block: 'center' });
-    }
-})();
-
-(function chapterNavigation() {
-    document.addEventListener('keydown', function (e) {
-        if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) { return; }
-        if (window.search && window.search.hasFocus()) { return; }
-
-        switch (e.key) {
-            case 'ArrowRight':
-                e.preventDefault();
-                var nextButton = document.querySelector('.nav-chapters.next');
-                if (nextButton) {
-                    window.location.href = nextButton.href;
-                }
-                break;
-            case 'ArrowLeft':
-                e.preventDefault();
-                var previousButton = document.querySelector('.nav-chapters.previous');
-                if (previousButton) {
-                    window.location.href = previousButton.href;
-                }
-                break;
-        }
-    });
-})();
-
-(function clipboard() {
-    var clipButtons = document.querySelectorAll('.clip-button');
-
-    function hideTooltip(elem) {
-        elem.firstChild.innerText = "";
-        elem.className = 'fa fa-copy clip-button';
-    }
-
-    function showTooltip(elem, msg) {
-        elem.firstChild.innerText = msg;
-        elem.className = 'fa fa-copy tooltipped';
-    }
-
-    var clipboardSnippets = new ClipboardJS('.clip-button', {
-        text: function (trigger) {
-            hideTooltip(trigger);
-            let playground = trigger.closest("pre");
-            return playground_text(playground);
-        }
-    });
-
-    Array.from(clipButtons).forEach(function (clipButton) {
-        clipButton.addEventListener('mouseout', function (e) {
-            hideTooltip(e.currentTarget);
-        });
-    });
-
-    clipboardSnippets.on('success', function (e) {
-        e.clearSelection();
-        showTooltip(e.trigger, "Copied!");
-    });
-
-    clipboardSnippets.on('error', function (e) {
-        showTooltip(e.trigger, "Clipboard error!");
-    });
-})();
-
-(function scrollToTop () {
-    var menuTitle = document.querySelector('.menu-title');
-
-    menuTitle.addEventListener('click', function () {
-        document.scrollingElement.scrollTo({ top: 0, behavior: 'smooth' });
-    });
-})();
-
-(function controllMenu() {
-    var menu = document.getElementById('menu-bar');
-
-    (function controllPosition() {
-        var scrollTop = document.scrollingElement.scrollTop;
-        var prevScrollTop = scrollTop;
-        var minMenuY = -menu.clientHeight - 50;
-        // When the script loads, the page can be at any scroll (e.g. if you reforesh it).
-        menu.style.top = scrollTop + 'px';
-        // Same as parseInt(menu.style.top.slice(0, -2), but faster
-        var topCache = menu.style.top.slice(0, -2);
-        menu.classList.remove('sticky');
-        var stickyCache = false; // Same as menu.classList.contains('sticky'), but faster
-        document.addEventListener('scroll', function () {
-            scrollTop = Math.max(document.scrollingElement.scrollTop, 0);
-            // `null` means that it doesn't need to be updated
-            var nextSticky = null;
-            var nextTop = null;
-            var scrollDown = scrollTop > prevScrollTop;
-            var menuPosAbsoluteY = topCache - scrollTop;
-            if (scrollDown) {
-                nextSticky = false;
-                if (menuPosAbsoluteY > 0) {
-                    nextTop = prevScrollTop;
-                }
-            } else {
-                if (menuPosAbsoluteY > 0) {
-                    nextSticky = true;
-                } else if (menuPosAbsoluteY < minMenuY) {
-                    nextTop = prevScrollTop + minMenuY;
-                }
-            }
-            if (nextSticky === true && stickyCache === false) {
-                menu.classList.add('sticky');
-                stickyCache = true;
-            } else if (nextSticky === false && stickyCache === true) {
-                menu.classList.remove('sticky');
-                stickyCache = false;
-            }
-            if (nextTop !== null) {
-                menu.style.top = nextTop + 'px';
-                topCache = nextTop;
-            }
-            prevScrollTop = scrollTop;
-        }, { passive: true });
-    })();
-    (function controllBorder() {
-        menu.classList.remove('bordered');
-        document.addEventListener('scroll', function () {
-            if (menu.offsetTop === 0) {
-                menu.classList.remove('bordered');
-            } else {
-                menu.classList.add('bordered');
-            }
-        }, { passive: true });
-    })();
-})();

book/theme/css/chrome.css

@@ -1,499 +0,0 @@
-/* CSS for UI elements (a.k.a. chrome) */
-
-@import 'variables.css';
-
-::-webkit-scrollbar {
-    background: var(--bg);
-}
-::-webkit-scrollbar-thumb {
-    background: var(--scrollbar);
-}
-html {
-    scrollbar-color: var(--scrollbar) var(--bg);
-}
-#searchresults a,
-.content a:link,
-a:visited,
-a > .hljs {
-    color: var(--links);
-}
-.content a:hover {
-    text-decoration: underline;
-}
-
-/* Menu Bar */
-
-#menu-bar,
-#menu-bar-hover-placeholder {
-    z-index: 101;
-    margin: auto calc(0px - var(--page-padding));
-}
-#menu-bar {
-    position: relative;
-    display: flex;
-    flex-wrap: wrap;
-    background-color: var(--bg);
-    border-bottom-color: var(--bg);
-    border-bottom-width: 1px;
-    border-bottom-style: solid;
-}
-#menu-bar.sticky,
-.js #menu-bar-hover-placeholder:hover + #menu-bar,
-.js #menu-bar:hover,
-.js.sidebar-visible #menu-bar {
-    position: -webkit-sticky;
-    position: sticky;
-    top: 0 !important;
-}
-#menu-bar-hover-placeholder {
-    position: sticky;
-    position: -webkit-sticky;
-    top: 0;
-    height: var(--menu-bar-height);
-}
-#menu-bar.bordered {
-    border-bottom-color: var(--table-border-color);
-}
-#menu-bar i, #menu-bar .icon-button {
-    position: relative;
-    padding: 0 8px;
-    z-index: 10;
-    line-height: var(--menu-bar-height);
-    cursor: pointer;
-    transition: color 0.5s;
-}
-@media only screen and (max-width: 420px) {
-    #menu-bar i, #menu-bar .icon-button {
-        padding: 0 5px;
-    }
-}
-
-.icon-button {
-    border: none;
-    background: none;
-    padding: 0;
-    color: inherit;
-}
-.icon-button i {
-    margin: 0;
-}
-
-.right-buttons {
-    margin: 0 15px;
-}
-.right-buttons a {
-    text-decoration: none;
-}
-
-.left-buttons {
-    display: flex;
-    margin: 0 5px;
-}
-.no-js .left-buttons {
-    display: none;
-}
-
-.menu-title {
-    display: inline-block;
-    font-weight: 200;
-    font-size: 2.4rem;
-    line-height: var(--menu-bar-height);
-    text-align: center;
-    margin: 0;
-    flex: 1;
-    white-space: nowrap;
-    overflow: hidden;
-    text-overflow: ellipsis;
-}
-.js .menu-title {
-    cursor: pointer;
-}
-
-.menu-bar,
-.menu-bar:visited,
-.nav-chapters,
-.nav-chapters:visited,
-.mobile-nav-chapters,
-.mobile-nav-chapters:visited,
-.menu-bar .icon-button,
-.menu-bar a i {
-    color: var(--icons);
-}
-
-.menu-bar i:hover,
-.menu-bar .icon-button:hover,
-.nav-chapters:hover,
-.mobile-nav-chapters i:hover {
-    color: var(--icons-hover);
-}
-
-/* Nav Icons */
-
-.nav-chapters {
-    font-size: 2.5em;
-    text-align: center;
-    text-decoration: none;
-
-    position: fixed;
-    top: 0;
-    bottom: 0;
-    margin: 0;
-    max-width: 150px;
-    min-width: 90px;
-
-    display: flex;
-    justify-content: center;
-    align-content: center;
-    flex-direction: column;
-
-    transition: color 0.5s, background-color 0.5s;
-}
-
-.nav-chapters:hover {
-    text-decoration: none;
-    background-color: var(--theme-hover);
-    transition: background-color 0.15s, color 0.15s;
-}
-
-.nav-wrapper {
-    margin-top: 50px;
-    display: none;
-}
-
-.mobile-nav-chapters {
-    font-size: 2.5em;
-    text-align: center;
-    text-decoration: none;
-    width: 90px;
-    border-radius: 5px;
-    background-color: var(--sidebar-bg);
-}
-
-.previous {
-    float: left;
-}
-
-.next {
-    float: right;
-    right: var(--page-padding);
-}
-
-@media only screen and (max-width: 1080px) {
-    .nav-wide-wrapper { display: none; }
-    .nav-wrapper { display: block; }
-}
-
-@media only screen and (max-width: 1380px) {
-    .sidebar-visible .nav-wide-wrapper { display: none; }
-    .sidebar-visible .nav-wrapper { display: block; }
-}
-
-/* Inline code */
-
-:not(pre) > .hljs {
-    display: inline;
-    padding: 0.1em 0.3em;
-    border-radius: 3px;
-}
-
-:not(pre):not(a):not(td):not(p) > .hljs {
-    color: var(--inline-code-color);
-    overflow-x: initial;
-}
-
-a:hover > .hljs {
-    text-decoration: underline;
-}
-
-pre {
-    position: relative;
-}
-pre > .buttons {
-    position: absolute;
-    z-index: 100;
-    right: 5px;
-    top: 5px;
-
-    color: var(--sidebar-fg);
-    cursor: pointer;
-}
-pre > .buttons :hover {
-    color: var(--sidebar-active);
-}
-pre > .buttons i {
-    margin-left: 8px;
-}
-pre > .buttons button {
-    color: inherit;
-    background: transparent;
-    border: none;
-    cursor: inherit;
-}
-pre > .result {
-    margin-top: 10px;
-}
-
-/* Search */
-
-#searchresults a {
-    text-decoration: none;
-}
-
-mark {
-    border-radius: 2px;
-    padding: 0 3px 1px 3px;
-    margin: 0 -3px -1px -3px;
-    background-color: var(--search-mark-bg);
-    transition: background-color 300ms linear;
-    cursor: pointer;
-}
-
-mark.fade-out {
-    background-color: rgba(0,0,0,0) !important;
-    cursor: auto;
-}
-
-.searchbar-outer {
-    margin-left: auto;
-    margin-right: auto;
-    max-width: var(--content-max-width);
-}
-
-#searchbar {
-    width: 100%;
-    margin: 5px auto 0px auto;
-    padding: 10px 16px;
-    transition: box-shadow 300ms ease-in-out;
-    border: 1px solid var(--searchbar-border-color);
-    border-radius: 3px;
-    background-color: var(--searchbar-bg);
-    color: var(--searchbar-fg);
-}
-#searchbar:focus,
-#searchbar.active {
-    box-shadow: 0 0 3px var(--searchbar-shadow-color);
-}
-
-.searchresults-header {
-    font-weight: bold;
-    font-size: 1em;
-    padding: 18px 0 0 5px;
-    color: var(--searchresults-header-fg);
-}
-
-.searchresults-outer {
-    margin-left: auto;
-    margin-right: auto;
-    max-width: var(--content-max-width);
-    border-bottom: 1px dashed var(--searchresults-border-color);
-}
-
-ul#searchresults {
-    list-style: none;
-    padding-left: 20px;
-}
-ul#searchresults li {
-    margin: 10px 0px;
-    padding: 2px;
-    border-radius: 2px;
-}
-ul#searchresults li.focus {
-    background-color: var(--searchresults-li-bg);
-}
-ul#searchresults span.teaser {
-    display: block;
-    clear: both;
-    margin: 5px 0 0 20px;
-    font-size: 0.8em;
-}
-ul#searchresults span.teaser em {
-    font-weight: bold;
-    font-style: normal;
-}
-
-/* Sidebar */
-
-.sidebar {
-    position: fixed;
-    left: 0;
-    top: 0;
-    bottom: 0;
-    width: var(--sidebar-width);
-    font-size: 0.875em;
-    box-sizing: border-box;
-    -webkit-overflow-scrolling: touch;
-    overscroll-behavior-y: contain;
-    background-color: var(--sidebar-bg);
-    color: var(--sidebar-fg);
-}
-.sidebar-resizing {
-    -moz-user-select: none;
-    -webkit-user-select: none;
-    -ms-user-select: none;
-    user-select: none;
-}
-.js:not(.sidebar-resizing) .sidebar {
-    transition: transform 0.3s; /* Animation: slide away */
-}
-.sidebar code {
-    line-height: 2em;
-}
-.sidebar .sidebar-scrollbox {
-    overflow-y: auto;
-    position: absolute;
-    top: 0;
-    bottom: 0;
-    left: 0;
-    right: 0;
-}
-.sidebar .sidebar-resize-handle {
-    position: absolute;
-    cursor: col-resize;
-    width: 0;
-    right: 0;
-    top: 0;
-    bottom: 0;
-}
-.js .sidebar .sidebar-resize-handle {
-    cursor: col-resize;
-    width: 5px;
-}
-.sidebar-hidden .sidebar {
-    transform: translateX(calc(0px - var(--sidebar-width)));
-}
-.sidebar::-webkit-scrollbar {
-    background: var(--sidebar-bg);
-}
-.sidebar::-webkit-scrollbar-thumb {
-    background: var(--scrollbar);
-}
-
-.sidebar-visible .page-wrapper {
-    transform: translateX(var(--sidebar-width));
-}
-@media only screen and (min-width: 620px) {
-    .sidebar-visible .page-wrapper {
-        transform: none;
-        margin-left: var(--sidebar-width);
-    }
-}
-
-.chapter {
-    list-style: none outside none;
-    padding-left: 0;
-    margin: .25rem 0;
-}
-
-.chapter ol {
-    width: 100%;
-}
-
-.chapter li {
-    display: flex;
-    color: var(--sidebar-non-existant);
-}
-.chapter li a {
-    display: block;
-    text-decoration: none;
-    color: var(--sidebar-fg);
-}
-
-.chapter li a:hover {
-    color: var(--sidebar-active);
-}
-
-.chapter li a.active {
-    color: var(--sidebar-active);
-}
-
-.chapter li > a.toggle {
-    cursor: pointer;
-    display: block;
-    margin-left: auto;
-    padding: 0 10px;
-    user-select: none;
-    opacity: 0.68;
-}
-
-.chapter li > a.toggle div {
-    transition: transform 0.5s;
-}
-
-/* collapse the section */
-.chapter li:not(.expanded) + li > ol {
-    display: none;
-}
-
-.chapter li.chapter-item {
-    padding: 1rem 1.5rem;
-}
-
-.chapter .section li.chapter-item {
-    padding: .5rem .5rem 0 .5rem;
-}
-
-.chapter li.expanded > a.toggle div {
-    transform: rotate(90deg);
-}
-
-.spacer {
-    width: 100%;
-    height: 3px;
-    margin: 5px 0px;
-}
-.chapter .spacer {
-    background-color: var(--sidebar-spacer);
-}
-
-@media (-moz-touch-enabled: 1), (pointer: coarse) {
-    .chapter li a { padding: 5px 0; }
-    .spacer { margin: 10px 0; }
-}
-
-.section {
-    list-style: none outside none;
-    padding-left: 2rem;
-    line-height: 1.9em;
-}
-
-/* Theme Menu Popup */
-
-.theme-popup {
-    position: absolute;
-    left: 10px;
-    top: var(--menu-bar-height);
-    z-index: 1000;
-    border-radius: 4px;
-    font-size: 0.7em;
-    color: var(--fg);
-    background: var(--theme-popup-bg);
-    border: 1px solid var(--theme-popup-border);
-    margin: 0;
-    padding: 0;
-    list-style: none;
-    display: none;
-}
-.theme-popup .default {
-    color: var(--icons);
-}
-.theme-popup .theme {
-    width: 100%;
-    border: 0;
-    margin: 0;
-    padding: 2px 10px;
-    line-height: 25px;
-    white-space: nowrap;
-    text-align: left;
-    cursor: pointer;
-    color: inherit;
-    background: inherit;
-    font-size: inherit;
-}
-.theme-popup .theme:hover {
-    background-color: var(--theme-hover);
-}
-.theme-popup .theme:hover:first-child,
-.theme-popup .theme:hover:last-child {
-    border-top-left-radius: inherit;
-    border-top-right-radius: inherit;
-}

book/theme/css/general.css

@@ -1,233 +0,0 @@
-/* Base styles and content styles */
-
-@import 'variables.css';
-
-:root {
-    /* Browser default font-size is 16px, this way 1 rem = 10px */
-    font-size: 62.5%;
-}
-
-/* TODO: replace with self hosted fonts */
-
-html {
-    font-family: "Inter", sans-serif;
-    color: var(--fg);
-    background-color: var(--bg);
-    text-size-adjust: none;
-}
-
-/* @supports (font-variation-settings: normal) { */
-/*   html { font-family: 'Inter var', sans-serif; } */
-/* } */
-
-body {
-    margin: 0;
-    font-size: 1.6rem;
-    overflow-x: hidden;
-}
-
-code {
-    font-family: "Source Code Pro", Consolas, "Ubuntu Mono", Menlo, "DejaVu Sans Mono", monospace, monospace !important;
-    font-size: 0.875em; /* please adjust the ace font size accordingly in editor.js */
-}
-
-/* Don't change font size in headers. */
-h1 code, h2 code, h3 code, h4 code, h5 code, h6 code {
-    font-size: unset;
-}
-
-.left { float: left; }
-.right { float: right; }
-.boring { opacity: 0.6; }
-.hide-boring .boring { display: none; }
-.hidden { display: none !important; }
-
-h2, h3 { margin-top: 2.5em; }
-h4, h5 { margin-top: 2em; }
-
-.header + .header h3,
-.header + .header h4,
-.header + .header h5 {
-    margin-top: 1em;
-}
-
-h1:target::before,
-h2:target::before,
-h3:target::before,
-h4:target::before,
-h5:target::before,
-h6:target::before {
-    display: inline-block;
-    content: "»";
-    margin-left: -30px;
-    width: 30px;
-}
-
-/* This is broken on Safari as of version 14, but is fixed
-   in Safari Technology Preview 117 which I think will be Safari 14.2.
-   https://bugs.webkit.org/show_bug.cgi?id=218076
-*/
-:target {
-    scroll-margin-top: calc(var(--menu-bar-height) + 0.5em);
-}
-
-.page {
-    outline: 0;
-    padding: 0 var(--page-padding);
-    margin-top: calc(0px - var(--menu-bar-height)); /* Compensate for the #menu-bar-hover-placeholder */
-}
-.page-wrapper {
-    box-sizing: border-box;
-}
-.js:not(.sidebar-resizing) .page-wrapper {
-    transition: margin-left 0.3s ease, transform 0.3s ease; /* Animation: slide away */
-}
-
-.content {
-    overflow-y: auto;
-    padding: 0 15px;
-    padding-bottom: 50px;
-}
-.content main {
-    margin-left: auto;
-    margin-right: auto;
-    max-width: var(--content-max-width);
-}
-
-
-/* 2 1.75 1.5 1.25 1 .875 */
-
-.content h1 { font-size: 2em }
-.content h2 { font-size: 1.75em }
-.content h3 { font-size: 1.5em }
-.content h4 { font-size: 1.25em }
-.content h5 { font-size: 1em }
-.content h6 { font-size: .875em }
-
-.content h1, .content h2, .content h3, .content h4 {
-    font-weight: 500;
-    margin-top: 1.275em;
-    margin-bottom: .875em;
-}
-.content p, .content ol, .content ul, .content table {
-    margin-top: 0;
-    margin-bottom: .875em;
-}
-
-.content ul li {
-margin-bottom: .25rem;
-}
-.content ul {
-    list-style-type: square;
-}
-.content ul ul, .content ol ul {
-    margin-bottom: .5rem;
-}
-.content li p {
-    margin-bottom: .5em;
-}
-
-.content p { line-height: 1.45em; }
-.content ol { line-height: 1.45em; }
-.content ul { line-height: 1.45em; }
-.content a { text-decoration: none; }
-.content a:hover { text-decoration: underline; }
-.content img { max-width: 100%; }
-.content .header:link,
-.content .header:visited {
-    color: var(--fg);
-    color: var(--heading-fg);
-}
-.content .header:link,
-.content .header:visited:hover {
-    text-decoration: none;
-}
-
-table {
-    margin: 0 auto;
-    border-collapse: collapse;
-    width: 100%;
-}
-table td {
-    padding: .75rem;
-    width: auto;
-}
-table thead {
-    background: var(--table-header-bg);
-}
-table thead td {
-    font-weight: 700;
-    border: none;
-}
-table thead th {
-    padding: .75rem;
-    text-align: left;
-    font-weight: 500;
-    line-height: 1.5;
-    width: auto;
-}
-table thead tr {
-    border-bottom: 2px var(--table-border-color) solid;
-}
-table tbody tr {
-    border-bottom: 1px var(--table-border-line) solid;
-}
-/* Alternate background colors for rows */
-table tbody tr:nth-child(2n) {
-    /* background: var(--table-alternate-bg); */
-}
-
-
-blockquote {
-    margin: 1.5rem 0;
-    padding: 1rem 1.5rem;
-    color: var(--fg);
-    opacity: .9;
-    background-color: var(--quote-bg);
-    border-left: 4px solid var(--quote-border);
-}
-blockquote *:last-child {
-  margin-bottom: 0;
-}
-
-
-:not(.footnote-definition) + .footnote-definition,
-.footnote-definition + :not(.footnote-definition) {
-    margin-top: 2em;
-}
-.footnote-definition {
-    font-size: 0.9em;
-    margin: 0.5em 0;
-}
-.footnote-definition p {
-    display: inline;
-}
-
-.tooltiptext {
-    position: absolute;
-    visibility: hidden;
-    color: #fff;
-    background-color: #333;
-    transform: translateX(-50%); /* Center by moving tooltip 50% of its width left */
-    left: -8px; /* Half of the width of the icon */
-    top: -35px;
-    font-size: 0.8em;
-    text-align: center;
-    border-radius: 6px;
-    padding: 5px 8px;
-    margin: 5px;
-    z-index: 1000;
-}
-.tooltipped .tooltiptext {
-    visibility: visible;
-}
-
-.chapter li.part-title {
-    color: var(--sidebar-fg);
-    margin: 5px 0px;
-    font-weight: bold;
-}
-
-.result-no-output {
-    font-style: italic;
-}

book/theme/css/print.css

@@ -1,54 +0,0 @@
-
-#sidebar,
-#menu-bar,
-.nav-chapters,
-.mobile-nav-chapters {
-    display: none;
-}
-
-#page-wrapper.page-wrapper {
-    transform: none;
-    margin-left: 0px;
-    overflow-y: initial;
-}
-
-#content {
-    max-width: none;
-    margin: 0;
-    padding: 0;
-}
-
-.page {
-    overflow-y: initial;
-}
-
-code {
-    background-color: #666666;
-    border-radius: 5px;
-
-    /* Force background to be printed in Chrome */
-    -webkit-print-color-adjust: exact;
-}
-
-pre > .buttons {
-    z-index: 2;
-}
-
-a, a:visited, a:active, a:hover {
-    color: #4183c4;
-    text-decoration: none;
-}
-
-h1, h2, h3, h4, h5, h6 {
-    page-break-inside: avoid;
-    page-break-after: avoid;
-}
-
-pre, code {
-    page-break-inside: avoid;
-    white-space: pre-wrap;
-}
-
-.fa {
-    display: none !important;
-}

book/theme/css/variables.css

@@ -1,342 +0,0 @@
-
-/* Globals */
-
-:root {
-    --sidebar-width: 300px;
-    --page-padding: 15px;
-    --content-max-width: 750px;
-    --menu-bar-height: 50px;
-}
-
-/* Themes */
-
-.ayu {
-    --bg: hsl(210, 25%, 8%);
-    --fg: #c5c5c5;
-
-    --sidebar-bg: #14191f;
-    --sidebar-fg: #c8c9db;
-    --sidebar-non-existant: #5c6773;
-    --sidebar-active: #ffb454;
-    --sidebar-spacer: #2d334f;
-
-    --scrollbar: var(--sidebar-fg);
-
-    --icons: #737480;
-    --icons-hover: #b7b9cc;
-
-    --links: #0096cf;
-
-    --inline-code-color: #ffb454;
-
-    --theme-popup-bg: #14191f;
-    --theme-popup-border: #5c6773;
-    --theme-hover: #191f26;
-
-    --quote-bg: hsl(226, 15%, 17%);
-    --quote-border: hsl(226, 15%, 22%);
-
-    --table-border-color: hsl(210, 25%, 13%);
-    --table-header-bg: hsl(210, 25%, 28%);
-    --table-alternate-bg: hsl(210, 25%, 11%);
-
-    --searchbar-border-color: #848484;
-    --searchbar-bg: #424242;
-    --searchbar-fg: #fff;
-    --searchbar-shadow-color: #d4c89f;
-    --searchresults-header-fg: #666;
-    --searchresults-border-color: #888;
-    --searchresults-li-bg: #252932;
-    --search-mark-bg: #e3b171;
-}
-
-.coal {
-    --bg: hsl(200, 7%, 8%);
-    --fg: #98a3ad;
-
-    --sidebar-bg: #292c2f;
-    --sidebar-fg: #a1adb8;
-    --sidebar-non-existant: #505254;
-    --sidebar-active: #3473ad;
-    --sidebar-spacer: #393939;
-
-    --scrollbar: var(--sidebar-fg);
-
-    --icons: #43484d;
-    --icons-hover: #b3c0cc;
-
-    --links: #2b79a2;
-
-    --inline-code-color: #c5c8c6;
-
-    --theme-popup-bg: #141617;
-    --theme-popup-border: #43484d;
-    --theme-hover: #1f2124;
-
-    --quote-bg: hsl(234, 21%, 18%);
-    --quote-border: hsl(234, 21%, 23%);
-
-    --table-border-color: hsl(200, 7%, 13%);
-    --table-header-bg: hsl(200, 7%, 28%);
-    --table-alternate-bg: hsl(200, 7%, 11%);
-
-    --searchbar-border-color: #aaa;
-    --searchbar-bg: #b7b7b7;
-    --searchbar-fg: #000;
-    --searchbar-shadow-color: #aaa;
-    --searchresults-header-fg: #666;
-    --searchresults-border-color: #98a3ad;
-    --searchresults-li-bg: #2b2b2f;
-    --search-mark-bg: #355c7d;
-}
-
-.light {
-    --bg: hsl(0, 0%, 100%);
-    --fg: hsl(0, 0%, 0%);
-
-    --sidebar-bg: #fafafa;
-    --sidebar-fg: hsl(0, 0%, 0%);
-    --sidebar-non-existant: #aaaaaa;
-    --sidebar-active: #1f1fff;
-    --sidebar-spacer: #f4f4f4;
-
-    --scrollbar: #8F8F8F;
-
-    --icons: #747474;
-    --icons-hover: #000000;
-
-    --links: #20609f;
-
-    --inline-code-color: #301900;
-
-    --theme-popup-bg: #fafafa;
-    --theme-popup-border: #cccccc;
-    --theme-hover: #e6e6e6;
-
-    --quote-bg: hsl(197, 37%, 96%);
-    --quote-border: hsl(197, 37%, 91%);
-
-    --table-border-color: hsl(0, 0%, 95%);
-    --table-header-bg: hsl(0, 0%, 80%);
-    --table-alternate-bg: hsl(0, 0%, 97%);
-
-    --searchbar-border-color: #aaa;
-    --searchbar-bg: #fafafa;
-    --searchbar-fg: #000;
-    --searchbar-shadow-color: #aaa;
-    --searchresults-header-fg: #666;
-    --searchresults-border-color: #888;
-    --searchresults-li-bg: #e4f2fe;
-    --search-mark-bg: #a2cff5;
-}
-
-.navy {
-    --bg: hsl(226, 23%, 11%);
-    --fg: #bcbdd0;
-
-    --sidebar-bg: #282d3f;
-    --sidebar-fg: #c8c9db;
-    --sidebar-non-existant: #505274;
-    --sidebar-active: #2b79a2;
-    --sidebar-spacer: #2d334f;
-
-    --scrollbar: var(--sidebar-fg);
-
-    --icons: #737480;
-    --icons-hover: #b7b9cc;
-
-    --links: #2b79a2;
-
-    --inline-code-color: #c5c8c6;
-
-    --theme-popup-bg: #161923;
-    --theme-popup-border: #737480;
-    --theme-hover: #282e40;
-
-    --quote-bg: hsl(226, 15%, 17%);
-    --quote-border: hsl(226, 15%, 22%);
-
-    --table-border-color: hsl(226, 23%, 16%);
-    --table-header-bg: hsl(226, 23%, 31%);
-    --table-alternate-bg: hsl(226, 23%, 14%);
-
-    --searchbar-border-color: #aaa;
-    --searchbar-bg: #aeaec6;
-    --searchbar-fg: #000;
-    --searchbar-shadow-color: #aaa;
-    --searchresults-header-fg: #5f5f71;
-    --searchresults-border-color: #5c5c68;
-    --searchresults-li-bg: #242430;
-    --search-mark-bg: #a2cff5;
-}
-
-.rust {
-    --bg: hsl(60, 9%, 87%);
-    --fg: #262625;
-
-    --sidebar-bg: #3b2e2a;
-    --sidebar-fg: #c8c9db;
-    --sidebar-non-existant: #505254;
-    --sidebar-active: #e69f67;
-    --sidebar-spacer: #45373a;
-
-    --scrollbar: var(--sidebar-fg);
-
-    --icons: #737480;
-    --icons-hover: #262625;
-
-    --links: #2b79a2;
-
-    --inline-code-color: #6e6b5e;
-
-    --theme-popup-bg: #e1e1db;
-    --theme-popup-border: #b38f6b;
-    --theme-hover: #99908a;
-
-    --quote-bg: hsl(60, 5%, 75%);
-    --quote-border: hsl(60, 5%, 70%);
-
-    --table-border-color: hsl(60, 9%, 82%);
-    --table-header-bg: #b3a497;
-    --table-alternate-bg: hsl(60, 9%, 84%);
-
-    --searchbar-border-color: #aaa;
-    --searchbar-bg: #fafafa;
-    --searchbar-fg: #000;
-    --searchbar-shadow-color: #aaa;
-    --searchresults-header-fg: #666;
-    --searchresults-border-color: #888;
-    --searchresults-li-bg: #dec2a2;
-    --search-mark-bg: #e69f67;
-}
-
-@media (prefers-color-scheme: dark) {
-    .light.no-js {
-        --bg: hsl(200, 7%, 8%);
-        --fg: #98a3ad;
-
-        --sidebar-bg: #292c2f;
-        --sidebar-fg: #a1adb8;
-        --sidebar-non-existant: #505254;
-        --sidebar-active: #3473ad;
-        --sidebar-spacer: #393939;
-
-        --scrollbar: var(--sidebar-fg);
-
-        --icons: #43484d;
-        --icons-hover: #b3c0cc;
-
-        --links: #2b79a2;
-
-        --inline-code-color: #c5c8c6;
-
-        --theme-popup-bg: #141617;
-        --theme-popup-border: #43484d;
-        --theme-hover: #1f2124;
-
-        --quote-bg: hsl(234, 21%, 18%);
-        --quote-border: hsl(234, 21%, 23%);
-
-        --table-border-color: hsl(200, 7%, 13%);
-        --table-header-bg: hsl(200, 7%, 28%);
-        --table-alternate-bg: hsl(200, 7%, 11%);
-
-        --searchbar-border-color: #aaa;
-        --searchbar-bg: #b7b7b7;
-        --searchbar-fg: #000;
-        --searchbar-shadow-color: #aaa;
-        --searchresults-header-fg: #666;
-        --searchresults-border-color: #98a3ad;
-        --searchresults-li-bg: #2b2b2f;
-        --search-mark-bg: #355c7d;
-    }
-}
-
-.colibri {
-    --bg: #3b224c;
-    --fg: #bcbdd0;
-    --heading-fg: #fff;
-
-    --sidebar-bg: #281733;
-    --sidebar-fg: #c8c9db;
-    --sidebar-non-existant: #505274;
-    --sidebar-active: #a4a0e8;
-    --sidebar-spacer: #2d334f;
-
-    --scrollbar: var(--sidebar-fg);
-
-    --icons: #737480;
-    --icons-hover: #b7b9cc;
-
-    /* --links: #a4a0e8; */
-    --links: #ECCDBA;
-
-    --inline-code-color: hsl(48.7, 7.8%, 70%);
-
-    --theme-popup-bg: #161923;
-    --theme-popup-border: #737480;
-    --theme-hover: rgba(0,0,0, .2);
-
-    --quote-bg: #281733;
-    --quote-border: hsl(226, 15%, 22%);
-
-    --table-border-color: hsl(226, 23%, 76%);
-    --table-header-bg: hsla(226, 23%, 31%, 0);
-    --table-alternate-bg: hsl(226, 23%, 14%);
-    --table-border-line: hsla(201deg, 20%, 92%, 0.2);
-
-    --searchbar-border-color: #aaa;
-    --searchbar-bg: #aeaec6;
-    --searchbar-fg: #000;
-    --searchbar-shadow-color: #aaa;
-    --searchresults-header-fg: #5f5f71;
-    --searchresults-border-color: #5c5c68;
-    --searchresults-li-bg: #242430;
-    --search-mark-bg: #a2cff5;
-}
-
-.colibri {
-/*
-    --bg: #ffffff;
-    --fg: #452859;
-    --fg: #5a5977;
-    --heading-fg: #281733;
-
-    --sidebar-bg: #281733;
-    --sidebar-fg: #c8c9db;
-    --sidebar-non-existant: #505274;
-    --sidebar-active: #a4a0e8;
-    --sidebar-spacer: #2d334f;
-
-    --scrollbar: var(--sidebar-fg);
-
-    --icons: #737480;
-    --icons-hover: #b7b9cc;
-
-    --links: #6F44F0;
-
-    --inline-code-color: #a39e9b;
-
-    --theme-popup-bg: #161923;
-    --theme-popup-border: #737480;
-    --theme-hover: rgba(0,0,0, .2);
-
-    --quote-bg: rgba(0, 0, 0, 0);
-    --quote-border: hsl(226, 15%, 75%);
-
-    --table-border-color: #5a5977;
-    --table-border-color: hsl(201deg 10% 67%);
-    --table-header-bg: hsl(0, 0%, 100%);
-    --table-alternate-bg: hsl(0, 0%, 97%);
-    --table-border-line: hsl(201deg, 20%, 92%);
-
-    --searchbar-border-color: #aaa;
-    --searchbar-bg: #aeaec6;
-    --searchbar-fg: #000;
-    --searchbar-shadow-color: #aaa;
-    --searchresults-header-fg: #5f5f71;
-    --searchresults-border-color: #5c5c68;
-    --searchresults-li-bg: #242430;
-    --search-mark-bg: #a2cff5;
-*/
-}

book/theme/favicon.svg

@@ -1,22 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 199.7 184.2">
-  <style>
-    @media (prefers-color-scheme: dark) {
-      svg { fill: white; }
-    }
-  </style>
-<path d="M189.5,36.8c0.2,2.8,0,5.1-0.6,6.8L153,162c-0.6,2.1-2,3.7-4.2,5c-2.2,1.2-4.4,1.9-6.7,1.9H31.4c-9.6,0-15.3-2.8-17.3-8.4
-  c-0.8-2.2-0.8-3.9,0.1-5.2c0.9-1.2,2.4-1.8,4.6-1.8H123c7.4,0,12.6-1.4,15.4-4.1s5.7-8.9,8.6-18.4l32.9-108.6
-  c1.8-5.9,1-11.1-2.2-15.6S169.9,0,164,0H72.7c-1,0-3.1,0.4-6.1,1.1l0.1-0.4C64.5,0.2,62.6,0,61,0.1s-3,0.5-4.3,1.4
-  c-1.3,0.9-2.4,1.8-3.2,2.8S52,6.5,51.2,8.1c-0.8,1.6-1.4,3-1.9,4.3s-1.1,2.7-1.8,4.2c-0.7,1.5-1.3,2.7-2,3.7c-0.5,0.6-1.2,1.5-2,2.5
-  s-1.6,2-2.2,2.8s-0.9,1.5-1.1,2.2c-0.2,0.7-0.1,1.8,0.2,3.2c0.3,1.4,0.4,2.4,0.4,3.1c-0.3,3-1.4,6.9-3.3,11.6
-  c-1.9,4.7-3.6,8.1-5.1,10.1c-0.3,0.4-1.2,1.3-2.6,2.7c-1.4,1.4-2.3,2.6-2.6,3.7c-0.3,0.4-0.3,1.5-0.1,3.4c0.3,1.8,0.4,3.1,0.3,3.8
-  c-0.3,2.7-1.3,6.3-3,10.8c-1.7,4.5-3.4,8.2-5,11c-0.2,0.5-0.9,1.4-2,2.8c-1.1,1.4-1.8,2.5-2,3.4c-0.2,0.6-0.1,1.8,0.1,3.4
-  c0.2,1.6,0.2,2.8-0.1,3.6c-0.6,3-1.8,6.7-3.6,11c-1.8,4.3-3.6,7.9-5.4,11c-0.5,0.8-1.1,1.7-2,2.8c-0.8,1.1-1.5,2-2,2.8
-  s-0.8,1.6-1,2.5c-0.1,0.5,0,1.3,0.4,2.3c0.3,1.1,0.4,1.9,0.4,2.6c-0.1,1.1-0.2,2.6-0.5,4.4c-0.2,1.8-0.4,2.9-0.4,3.2
-  c-1.8,4.8-1.7,9.9,0.2,15.2c2.2,6.2,6.2,11.5,11.9,15.8c5.7,4.3,11.7,6.4,17.8,6.4h110.7c5.2,0,10.1-1.7,14.7-5.2s7.7-7.8,9.2-12.9
-  l33-108.6c1.8-5.8,1-10.9-2.2-15.5C194.9,39.7,192.6,38,189.5,36.8z M59.6,122.8L73.8,80c0,0,7,0,10.8,0s28.8-1.7,25.4,17.5
-  c-3.4,19.2-18.8,25.2-36.8,25.4S59.6,122.8,59.6,122.8z M78.6,116.8c4.7-0.1,18.9-2.9,22.1-17.1S89.2,86.3,89.2,86.3l-8.9,0
-  l-10.2,30.5C70.2,116.9,74,116.9,78.6,116.8z M75.3,68.7L89,26.2h9.8l0.8,34l23.6-34h9.9l-13.6,42.5h-7.1l12.5-35.4l-24.5,35.4h-6.8
-  l-0.8-35L82,68.7H75.3z"/>
-</svg>
-<!-- Original image Copyright Dave Gandy — CC BY 4.0 License -->
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;" viewBox="663.38 37.57 575.35 903.75">     <g transform="matrix(1,0,0,1,-31352.7,-1817.25)">                  <g transform="matrix(1,0,0,1,31062.7,-20.8972)">             <g transform="matrix(1,0,0,1,-130.173,0.00185558)">                 <path d="M1083.58,1875.72L1635.06,2194.12C1649.8,2202.63 1658.88,2218.37 1658.88,2235.39C1658.88,2264.98 1658.88,2311.74 1658.88,2341.33C1658.88,2349.84 1656.61,2358.03 1652.5,2365.16C1652.5,2365.16 1214.7,2112.4 1107.2,2050.33C1092.58,2041.89 1083.58,2026.29 1083.58,2009.41C1083.58,1963.5 1083.58,1875.72 1083.58,1875.72Z" style="fill:#706bc8;"></path>             </g>             <g transform="matrix(1,0,0,1,-130.173,0.00185558)">                 <path d="M1635.26,2604.84C1649.88,2613.28 1658.88,2628.87 1658.88,2645.75C1658.88,2691.67 1658.88,2779.44 1658.88,2779.44L1107.41,2461.05C1092.66,2452.53 1083.58,2436.8 1083.58,2419.78C1083.58,2390.19 1083.58,2343.42 1083.58,2313.84C1083.58,2305.32 1085.85,2297.13 1089.96,2290.01C1089.96,2290.01 1527.76,2542.77 1635.26,2604.84Z" style="fill:#55c5e4;"></path>             </g>             <g transform="matrix(1,0,0,1,216.062,984.098)">                 <path d="M790.407,1432.56C785.214,1435.55 780.717,1439.9 777.509,1445.46C767.862,1462.16 773.473,1483.76 790.004,1493.59L789.998,1493.59L761.173,1476.95C746.427,1468.44 737.344,1452.71 737.344,1435.68C737.344,1406.09 737.344,1359.33 737.344,1329.74C737.344,1312.71 746.427,1296.98 761.173,1288.47L1259.59,1000.74L1259.83,1000.6C1264.92,997.617 1269.33,993.314 1272.48,987.844C1282.13,971.136 1276.52,949.544 1259.99,939.707L1260,939.707L1288.82,956.349C1303.57,964.862 1312.65,980.595 1312.65,997.622C1312.65,1027.21 1312.65,1073.97 1312.65,1103.56C1312.65,1120.59 1303.57,1136.32 1288.82,1144.83L1259.19,1161.94L1259.59,1161.68L790.407,1432.56Z" style="fill:#84ddea;"></path>             </g>             <g transform="matrix(1,0,0,1,216.062,984.098)">                 <path d="M790.407,1686.24C785.214,1689.23 780.717,1693.58 777.509,1699.13C767.862,1715.84 773.473,1737.43 790.004,1747.27L789.998,1747.27L761.173,1730.63C746.427,1722.12 737.344,1706.38 737.344,1689.36C737.344,1659.77 737.344,1613.01 737.344,1583.42C737.344,1566.39 746.427,1550.66 761.173,1542.15L1259.59,1254.42L1259.83,1254.28C1264.92,1251.29 1269.33,1246.99 1272.48,1241.52C1282.13,1224.81 1276.52,1203.22 1259.99,1193.38L1260,1193.38L1288.82,1210.03C1303.57,1218.54 1312.65,1234.27 1312.65,1251.3C1312.65,1280.89 1312.65,1327.65 1312.65,1357.24C1312.65,1374.26 1303.57,1390 1288.82,1398.51L1259.19,1415.61L1259.59,1415.36L790.407,1686.24Z" style="fill:#997bc8;"></path></g></g></g> </svg>

book/theme/highlight.css

@@ -1,56 +0,0 @@
-pre code.hljs {
- display:block;
- overflow-x:auto;
- padding:1em
-}
-code.hljs {
- padding:3px 5px
-}
-.hljs {
- background:#2f1e2e;
- color:#a39e9b
-}
-.hljs-comment,
-.hljs-quote {
- color:#8d8687
-}
-.hljs-link,
-.hljs-meta,
-.hljs-name,
-.hljs-regexp,
-.hljs-selector-class,
-.hljs-selector-id,
-.hljs-tag,
-.hljs-template-variable,
-.hljs-variable {
- color:#ef6155
-}
-.hljs-built_in,
-.hljs-deletion,
-.hljs-literal,
-.hljs-number,
-.hljs-params,
-.hljs-type {
- color:#f99b15
-}
-.hljs-attribute,
-.hljs-section,
-.hljs-title {
- color:#fec418
-}
-.hljs-addition,
-.hljs-bullet,
-.hljs-string,
-.hljs-symbol {
- color:#48b685
-}
-.hljs-keyword,
-.hljs-selector-tag {
- color:#815ba4
-}
-.hljs-emphasis {
- font-style:italic
-}
-.hljs-strong {
- font-weight:700
-}

book/theme/index.hbs

@@ -1,11 +1,11 @@
 <!DOCTYPE HTML>
-<html lang="{{ language }}" class="sidebar-visible no-js {{ default_theme }}">
+<html lang="{{ language }}" class="{{ default_theme }}" dir="{{ text_direction }}">
     <head>
         <!-- Book generated using mdBook -->
         <meta charset="UTF-8">
         <title>{{ title }}</title>
         {{#if is_print }}
-        <meta name="robots" content="noindex" />
+        <meta name="robots" content="noindex">
         {{/if}}
         {{#if base_url}}
         <base href="{{ base_url }}">
@@ -15,10 +15,9 @@
         <!-- Custom HTML head -->
         {{> head}}
 
-        <meta content="text/html; charset=utf-8" http-equiv="Content-Type">
         <meta name="description" content="{{ description }}">
         <meta name="viewport" content="width=device-width, initial-scale=1">
-        <meta name="theme-color" content="#ffffff" />
+        <meta name="theme-color" content="#ffffff">
 
         {{#if favicon_svg}}
         <link rel="icon" href="{{ path_to_root }}favicon.svg">
@@ -35,8 +34,6 @@
 
         <!-- Fonts -->
         <link rel="stylesheet" href="{{ path_to_root }}FontAwesome/css/font-awesome.css">
-        <link rel="preconnect" href="https://fonts.gstatic.com">
-        <link href="https://fonts.googleapis.com/css2?family=Inter:wght@200;400;500;700&display=swap" rel="stylesheet">
         {{#if copy_fonts}}
         <link rel="stylesheet" href="{{ path_to_root }}fonts/fonts.css">
         {{/if}}
@@ -53,18 +50,19 @@
 
         {{#if mathjax_support}}
         <!-- MathJax -->
-        <script async type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+        <script async src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
         {{/if}}
     </head>
-    <body>
+    <body class="sidebar-visible no-js">
+    <div id="body-container">
         <!-- Provide site root to javascript -->
-        <script type="text/javascript">
+        <script>
             var path_to_root = "{{ path_to_root }}";
             var default_theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "{{ preferred_dark_theme }}" : "{{ default_theme }}";
         </script>
 
         <!-- Work around some values being stored in localStorage wrapped in quotes -->
-        <script type="text/javascript">
+        <script>
             try {
                 var theme = localStorage.getItem('mdbook-theme');
                 var sidebar = localStorage.getItem('mdbook-sidebar');
@@ -80,27 +78,34 @@
         </script>
 
         <!-- Set the theme before any content is loaded, prevents flash -->
-        <script type="text/javascript">
+        <script>
             var theme;
             try { theme = localStorage.getItem('mdbook-theme'); } catch(e) { }
             if (theme === null || theme === undefined) { theme = default_theme; }
             var html = document.querySelector('html');
-            html.classList.remove('no-js')
             html.classList.remove('{{ default_theme }}')
             html.classList.add(theme);
-            html.classList.add('js');
+            var body = document.querySelector('body');
+            body.classList.remove('no-js')
+            body.classList.add('js');
         </script>
 
+        <input type="checkbox" id="sidebar-toggle-anchor" class="hidden">
+
         <!-- Hide / unhide sidebar before it is displayed -->
-        <script type="text/javascript">
-            var html = document.querySelector('html');
-            var sidebar = 'hidden';
+        <script>
+            var body = document.querySelector('body');
+            var sidebar = null;
+            var sidebar_toggle = document.getElementById("sidebar-toggle-anchor");
             if (document.body.clientWidth >= 1080) {
                 try { sidebar = localStorage.getItem('mdbook-sidebar'); } catch(e) { }
                 sidebar = sidebar || 'visible';
+            } else {
+                sidebar = 'hidden';
             }
-            html.classList.remove('sidebar-visible');
-            html.classList.add("sidebar-" + sidebar);
+            sidebar_toggle.checked = sidebar === 'visible';
+            body.classList.remove('sidebar-visible');
+            body.classList.add("sidebar-" + sidebar);
         </script>
 
         <nav id="sidebar" class="sidebar" aria-label="Table of contents">
@@ -110,26 +115,48 @@
             <div id="sidebar-resize-handle" class="sidebar-resize-handle"></div>
         </nav>
 
+        <!-- Track and set sidebar scroll position -->
+        <script>
+            var sidebarScrollbox = document.querySelector('#sidebar .sidebar-scrollbox');
+            sidebarScrollbox.addEventListener('click', function(e) {
+                if (e.target.tagName === 'A') {
+                    sessionStorage.setItem('sidebar-scroll', sidebarScrollbox.scrollTop);
+                }
+            }, { passive: true });
+            var sidebarScrollTop = sessionStorage.getItem('sidebar-scroll');
+            sessionStorage.removeItem('sidebar-scroll');
+            if (sidebarScrollTop) {
+                // preserve sidebar scroll position when navigating via links within sidebar
+                sidebarScrollbox.scrollTop = sidebarScrollTop;
+            } else {
+                // scroll sidebar to current active section when navigating via "next/previous chapter" buttons
+                var activeSection = document.querySelector('#sidebar .active');
+                if (activeSection) {
+                    activeSection.scrollIntoView({ block: 'center' });
+                }
+            }
+        </script>
+
         <div id="page-wrapper" class="page-wrapper">
 
             <div class="page">
                 {{> header}}
                 <div id="menu-bar-hover-placeholder"></div>
-                <div id="menu-bar" class="menu-bar sticky bordered">
+                <div id="menu-bar" class="menu-bar sticky">
                     <div class="left-buttons">
-                        <button id="sidebar-toggle" class="icon-button" type="button" title="Toggle Table of Contents" aria-label="Toggle Table of Contents" aria-controls="sidebar">
+                        <label id="sidebar-toggle" class="icon-button" for="sidebar-toggle-anchor" title="Toggle Table of Contents" aria-label="Toggle Table of Contents" aria-controls="sidebar">
                             <i class="fa fa-bars"></i>
-                        </button>
+                        </label>
                         <button id="theme-toggle" class="icon-button" type="button" title="Change theme" aria-label="Change theme" aria-haspopup="true" aria-expanded="false" aria-controls="theme-list">
                             <i class="fa fa-paint-brush"></i>
                         </button>
                         <ul id="theme-list" class="theme-popup" aria-label="Themes" role="menu">
-                            <li role="none"><button role="menuitem" class="theme" id="light">{{ theme_option "Light" }}</button></li>
-                            <li role="none"><button role="menuitem" class="theme" id="rust">{{ theme_option "Rust" }}</button></li>
-                            <li role="none"><button role="menuitem" class="theme" id="coal">{{ theme_option "Coal" }}</button></li>
-                            <li role="none"><button role="menuitem" class="theme" id="navy">{{ theme_option "Navy" }}</button></li>
-                            <li role="none"><button role="menuitem" class="theme" id="ayu">{{ theme_option "Ayu" }}</button></li>
-                            <li role="none"><button role="menuitem" class="theme" id="colibri">{{ theme_option "Colibri" }}</button></li>
+                            <li role="none"><button role="menuitem" class="theme" id="light">Light</button></li>
+                            <li role="none"><button role="menuitem" class="theme" id="rust">Rust</button></li>
+                            <li role="none"><button role="menuitem" class="theme" id="coal">Coal</button></li>
+                            <li role="none"><button role="menuitem" class="theme" id="navy">Navy</button></li>
+                            <li role="none"><button role="menuitem" class="theme" id="ayu">Ayu</button></li>
+                            <li role="none"><button role="menuitem" class="theme" id="colibri">Colibri</button></li>
                         </ul>
                         {{#if search_enabled}}
                         <button id="search-toggle" class="icon-button" type="button" title="Search. (Shortkey: s)" aria-label="Toggle Searchbar" aria-expanded="false" aria-keyshortcuts="S" aria-controls="searchbar">
@@ -151,13 +178,19 @@
                             <i id="git-repository-button" class="fa {{git_repository_icon}}"></i>
                         </a>
                         {{/if}}
+                        {{#if git_repository_edit_url}}
+                        <a href="{{git_repository_edit_url}}" title="Suggest an edit" aria-label="Suggest an edit">
+                            <i id="git-edit-button" class="fa fa-edit"></i>
+                        </a>
+                        {{/if}}
+
                     </div>
                 </div>
 
                 {{#if search_enabled}}
                 <div id="search-wrapper" class="hidden">
                     <form id="searchbar-outer" class="searchbar-outer">
-                        <input type="search" name="search" id="searchbar" name="searchbar" placeholder="Search this book ..." aria-controls="searchresults-outer" aria-describedby="searchresults-header">
+                        <input type="search" id="searchbar" name="searchbar" placeholder="Search this book ..." aria-controls="searchresults-outer" aria-describedby="searchresults-header">
                     </form>
                     <div id="searchresults-outer" class="searchresults-outer hidden">
                         <div id="searchresults-header" class="searchresults-header"></div>
@@ -168,7 +201,7 @@
                 {{/if}}
 
                 <!-- Apply ARIA attributes after the sidebar and the sidebar toggle button are added to the DOM -->
-                <script type="text/javascript">
+                <script>
                     document.getElementById('sidebar-toggle').setAttribute('aria-expanded', sidebar === 'visible');
                     document.getElementById('sidebar').setAttribute('aria-hidden', sidebar !== 'visible');
                     Array.from(document.querySelectorAll('#sidebar a')).forEach(function(link) {
@@ -190,7 +223,7 @@
                         {{/previous}}
 
                         {{#next}}
-                            <a rel="next" href="{{ path_to_root }}{{link}}" class="mobile-nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
+                            <a rel="next prefetch" href="{{ path_to_root }}{{link}}" class="mobile-nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
                                 <i class="fa fa-angle-right"></i>
                             </a>
                         {{/next}}
@@ -208,7 +241,7 @@
                 {{/previous}}
 
                 {{#next}}
-                    <a rel="next" href="{{ path_to_root }}{{link}}" class="nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
+                    <a rel="next prefetch" href="{{ path_to_root }}{{link}}" class="nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
                         <i class="fa fa-angle-right"></i>
                     </a>
                 {{/next}}
@@ -216,10 +249,12 @@
 
         </div>
 
-        {{#if livereload}}
+        {{#if live_reload_endpoint}}
         <!-- Livereload script (if served using the cli tool) -->
-        <script type="text/javascript">
-            var socket = new WebSocket("{{{livereload}}}");
+        <script>
+            const wsProtocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
+            const wsAddress = wsProtocol + "//" + location.host + "/" + "{{{live_reload_endpoint}}}";
+            const socket = new WebSocket(wsAddress);
             socket.onmessage = function (event) {
                 if (event.data === "reload") {
                     socket.close();
@@ -235,7 +270,7 @@
 
         {{#if google_analytics}}
         <!-- Google Analytics Tag -->
-        <script type="text/javascript">
+        <script>
             var localAddrs = ["localhost", "127.0.0.1", ""];
 
             // make sure we don't activate google analytics if the developer is
@@ -253,43 +288,43 @@
         {{/if}}
 
         {{#if playground_line_numbers}}
-        <script type="text/javascript">
+        <script>
             window.playground_line_numbers = true;
         </script>
         {{/if}}
 
         {{#if playground_copyable}}
-        <script type="text/javascript">
+        <script>
             window.playground_copyable = true;
         </script>
         {{/if}}
 
         {{#if playground_js}}
-        <script src="{{ path_to_root }}ace.js" type="text/javascript" charset="utf-8"></script>
-        <script src="{{ path_to_root }}editor.js" type="text/javascript" charset="utf-8"></script>
-        <script src="{{ path_to_root }}mode-rust.js" type="text/javascript" charset="utf-8"></script>
-        <script src="{{ path_to_root }}theme-dawn.js" type="text/javascript" charset="utf-8"></script>
-        <script src="{{ path_to_root }}theme-tomorrow_night.js" type="text/javascript" charset="utf-8"></script>
+        <script src="{{ path_to_root }}ace.js"></script>
+        <script src="{{ path_to_root }}editor.js"></script>
+        <script src="{{ path_to_root }}mode-rust.js"></script>
+        <script src="{{ path_to_root }}theme-dawn.js"></script>
+        <script src="{{ path_to_root }}theme-tomorrow_night.js"></script>
         {{/if}}
 
         {{#if search_js}}
-        <script src="{{ path_to_root }}elasticlunr.min.js" type="text/javascript" charset="utf-8"></script>
-        <script src="{{ path_to_root }}mark.min.js" type="text/javascript" charset="utf-8"></script>
-        <script src="{{ path_to_root }}searcher.js" type="text/javascript" charset="utf-8"></script>
+        <script src="{{ path_to_root }}elasticlunr.min.js"></script>
+        <script src="{{ path_to_root }}mark.min.js"></script>
+        <script src="{{ path_to_root }}searcher.js"></script>
         {{/if}}
 
-        <script src="{{ path_to_root }}clipboard.min.js" type="text/javascript" charset="utf-8"></script>
-        <script src="{{ path_to_root }}highlight.js" type="text/javascript" charset="utf-8"></script>
-        <script src="{{ path_to_root }}book.js" type="text/javascript" charset="utf-8"></script>
+        <script src="{{ path_to_root }}clipboard.min.js"></script>
+        <script src="{{ path_to_root }}highlight.js"></script>
+        <script src="{{ path_to_root }}book.js"></script>
 
         <!-- Custom JS scripts -->
         {{#each additional_js}}
-        <script type="text/javascript" src="{{ ../path_to_root }}{{this}}"></script>
+        <script src="{{ ../path_to_root }}{{this}}"></script>
         {{/each}}
 
         {{#if is_print}}
         {{#if mathjax_support}}
-        <script type="text/javascript">
+        <script>
         window.addEventListener('load', function() {
             MathJax.Hub.Register.StartupHook('End', function() {
                 window.setTimeout(window.print, 100);
@@ -297,7 +332,7 @@
         });
         </script>
         {{else}}
-        <script type="text/javascript">
+        <script>
         window.addEventListener('load', function() {
             window.setTimeout(window.print, 100);
         });
@@ -305,5 +340,6 @@
         {{/if}}
         {{/if}}
 
+    </div>
     </body>
 </html>

contrib/Helix.appdata.xml

@@ -0,0 +1,110 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<component type="desktop-application">
+  <id>com.helix_editor.Helix</id>
+  <metadata_license>CC0-1.0</metadata_license>
+  <project_license>MPL-2.0</project_license>
+  <name>Helix</name>
+  <summary>A post-modern text editor</summary>
+  <summary xml:lang="ar">مُحَرِّرُ نُصُوصٍ سَابِقٌ لِعَهدِه</summary>
+  <developer id="com.helix_editor">
+    <name>Blaž Hrastnik</name>
+  </developer>
+
+  <description>
+    <p>
+      Helix is a terminal-based text editor inspired by Kakoune / Neovim and written in Rust.
+    </p>
+    <p xml:lang="ar">
+      مُحَرِّرُ نُصُوصٍ يَعمَلُ فِي الطَّرَفِيَّة، مُستَلهَمٌ مِن Kakoune وَ Neovim وَمَكتُوبٌ بِلُغَةِ رَست البَرمَجِيَّة.
+    </p>
+    <ul>
+      <li>Vim-like modal editing</li>
+      <li xml:lang="ar">تَحرِيرٌ وَضعِيٌّ شَبيهٌ بِـVim</li>
+      <li>Multiple selections</li>
+      <li xml:lang="ar">تَحدِيدَاتٌ لِلنَّصِ مُتَعَدِّدَة</li>
+      <li>Built-in language server support</li>
+      <li xml:lang="ar">دَعْمٌ مُدمَجٌ لِخَوادِمِ اللُّغَات</li>
+      <li>Smart, incremental syntax highlighting and code editing via tree-sitter</li>
+      <li xml:lang="ar">تَحرِيرُ التَّعلِيمَاتِ البَّرمَجِيَّةِ مَعَ تَمييزٍ لِلتَّركِيبِ النَّحُويِّ بِواسِطَةِ tree-sitter</li>
+    </ul>
+  </description>
+
+  <launchable type="desktop-id">Helix.desktop</launchable>
+
+  <screenshots>
+    <screenshot type="default">
+      <caption>Helix with default theme</caption>
+      <image>https://github.com/helix-editor/helix/raw/d4565b4404cabc522bd60822abd374755581d751/screenshot.png</image>
+    </screenshot>
+  </screenshots>
+
+  <url type="homepage">https://helix-editor.com/</url>
+  <url type="donation">https://opencollective.com/helix-editor</url>
+  <url type="help">https://docs.helix-editor.com/</url>
+  <url type="vcs-browser">https://github.com/helix-editor/helix</url>
+  <url type="bugtracker">https://github.com/helix-editor/helix/issues</url>
+
+  <content_rating type="oars-1.1" />
+
+  <releases>
+    <release version="24.03" date="2024-03-30">
+      <url>https://helix-editor.com/news/release-24-03-highlights/</url>
+    </release>
+    <release version="23.10" date="2023-10-24">
+      <url>https://helix-editor.com/news/release-23-10-highlights/</url>
+    </release>
+    <release version="23.05" date="2023-05-18">
+      <url>https://github.com/helix-editor/helix/releases/tag/23.05</url>
+    </release>
+    <release version="23.03" date="2023-03-31">
+      <url>https://helix-editor.com/news/release-23-03-highlights/</url>
+    </release>
+    <release version="22.12" date="2022-12-6">
+      <url>https://helix-editor.com/news/release-22-12-highlights/</url>
+    </release>
+    <release version="22.08" date="2022-8-31">
+      <url>https://helix-editor.com/news/release-22-08-highlights/</url>
+    </release>
+    <release version="22.05" date="2022-5-28">
+      <url>https://helix-editor.com/news/release-22-05-highlights/</url>
+    </release>
+    <release version="22.03" date="2022-3-28">
+      <url>https://helix-editor.com/news/release-22-03-highlights/</url>
+    </release>
+  </releases>
+
+  <recommends>
+    <control>keyboard</control>
+  </recommends>
+
+  <categories>
+    <category>Utility</category>
+    <category>TextEditor</category>
+  </categories>
+
+  <keywords>
+    <keyword>text</keyword>
+    <keyword>editor</keyword>
+    <keyword>development</keyword>
+    <keyword>programming</keyword>
+  </keywords>
+
+  <provides>
+    <binary>hx</binary>
+    <mediatype>text/english</mediatype>
+    <mediatype>text/plain</mediatype>
+    <mediatype>text/x-makefile</mediatype>
+    <mediatype>text/x-c++hdr</mediatype>
+    <mediatype>text/x-c++src</mediatype>
+    <mediatype>text/x-chdr</mediatype>
+    <mediatype>text/x-csrc</mediatype>
+    <mediatype>text/x-java</mediatype>
+    <mediatype>text/x-moc</mediatype>
+    <mediatype>text/x-pascal</mediatype>
+    <mediatype>text/x-tcl</mediatype>
+    <mediatype>text/x-tex</mediatype>
+    <mediatype>application/x-shellscript</mediatype>
+    <mediatype>text/x-c</mediatype>
+    <mediatype>text/x-c++</mediatype>
+  </provides>
+</component>

contrib/Helix.desktop

@@ -0,0 +1,91 @@
+[Desktop Entry]
+Name=Helix
+GenericName=Text Editor
+GenericName[ar]=مُحَرِّرُ نُصُوص
+GenericName[de]=Texteditor
+GenericName[fr]=Éditeur de texte
+GenericName[ru]=Текстовый редактор
+GenericName[sr]=Едитор текст
+GenericName[tr]=Metin Düzenleyici
+Comment=Edit text files
+Comment[af]=Redigeer tekslêers
+Comment[am]=የጽሑፍ ፋይሎች ያስተካክሉ
+Comment[ar]=مُحَرِّرُ مِلَفَّاتٍ نَصِّيَّة
+Comment[az]=Mətn fayllarını redaktə edin
+Comment[be]=Рэдагаваньне тэкставых файлаў
+Comment[bg]=Редактиране на текстови файлове
+Comment[bn]=টেক্স্ট ফাইল এডিট করুন
+Comment[bs]=Izmijeni tekstualne datoteke
+Comment[ca]=Edita fitxers de text
+Comment[cs]=Úprava textových souborů
+Comment[cy]=Golygu ffeiliau testun
+Comment[da]=Redigér tekstfiler
+Comment[de]=Textdateien bearbeiten
+Comment[el]=Επεξεργασία αρχείων κειμένου
+Comment[en_CA]=Edit text files
+Comment[en_GB]=Edit text files
+Comment[es]=Edita archivos de texto
+Comment[et]=Redigeeri tekstifaile
+Comment[eu]=Editatu testu-fitxategiak
+Comment[fa]=ویرایش پرونده‌های متنی
+Comment[fi]=Muokkaa tekstitiedostoja
+Comment[fr]=Éditer des fichiers texte
+Comment[ga]=Eagar comhad Téacs
+Comment[gu]=લખાણ ફાઇલોમાં ફેરફાર કરો
+Comment[he]=ערוך קבצי טקסט
+Comment[hi]=पाठ फ़ाइलें संपादित करें
+Comment[hr]=Uređivanje tekstualne datoteke
+Comment[hu]=Szövegfájlok szerkesztése
+Comment[id]=Edit file teks
+Comment[it]=Modifica file di testo
+Comment[ja]=テキストファイルを編集します
+Comment[kn]=ಪಠ್ಯ ಕಡತಗಳನ್ನು ಸಂಪಾದಿಸು
+Comment[ko]=텍스트 파일을 편집합니다
+Comment[lt]=Redaguoti tekstines bylas
+Comment[lv]=Rediģēt teksta failus
+Comment[mk]=Уреди текстуални фајлови
+Comment[ml]=വാചക രചനകള് തിരുത്തുക
+Comment[mn]=Текст файл боловсруулах
+Comment[mr]=गद्य फाइल संपादित करा
+Comment[ms]=Edit fail teks
+Comment[nb]=Rediger tekstfiler
+Comment[ne]=पाठ फाइललाई संशोधन गर्नुहोस्
+Comment[nl]=Tekstbestanden bewerken
+Comment[nn]=Rediger tekstfiler
+Comment[no]=Rediger tekstfiler
+Comment[or]=ପାଠ୍ଯ ଫାଇଲଗୁଡ଼ିକୁ ସମ୍ପାଦନ କରନ୍ତୁ
+Comment[pa]=ਪਾਠ ਫਾਇਲਾਂ ਸੰਪਾਦਨ
+Comment[pl]=Edytor plików tekstowych
+Comment[pt]=Editar ficheiros de texto
+Comment[pt_BR]=Edite arquivos de texto
+Comment[ro]=Editare fişiere text
+Comment[ru]=Редактирование текстовых файлов
+Comment[sk]=Úprava textových súborov
+Comment[sl]=Urejanje datotek z besedili
+Comment[sq]=Përpuno files teksti
+Comment[sr]=Уређујте текст фајлове
+Comment[sr@Latn]=Izmeni tekstualne datoteke
+Comment[sv]=Redigera textfiler
+Comment[ta]=உரை கோப்புகளை தொகுக்கவும்
+Comment[th]=แก้ไขแฟ้มข้อความ
+Comment[tk]=Metin faýllary editle
+Comment[tr]=Metin dosyaları düzenleyin
+Comment[uk]=Редактор текстових файлів
+Comment[vi]=Soạn thảo tập tin văn bản
+Comment[wa]=Asspougnî des fitchîs tecses
+Comment[zh_CN]=编辑文本文件
+Comment[zh_TW]=編輯文字檔
+TryExec=hx
+Exec=hx %F
+Terminal=true
+Type=Application
+Keywords=Text;editor;
+Keywords[ar]=نص;نصوص;محرر;
+Keywords[fr]=Texte;éditeur;
+Keywords[ru]=текст;текстовый редактор;
+Keywords[sr]=Текст;едитор;
+Keywords[tr]=Metin;düzenleyici;
+Icon=helix
+Categories=Utility;TextEditor;
+StartupNotify=false
+MimeType=text/english;text/plain;text/x-makefile;text/x-c++hdr;text/x-c++src;text/x-chdr;text/x-csrc;text/x-java;text/x-moc;text/x-pascal;text/x-tcl;text/x-tex;application/x-shellscript;text/x-c;text/x-c++;

contrib/completion/hx.bash

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# Bash completion script for Helix editor
+
+_hx() {
+	# $1 command name
+	# $2 word being completed
+	# $3 word preceding
+
+	case "$3" in
+	-g | --grammar)
+		COMPREPLY="$(compgen -W 'fetch build' -- $2)"
+		;;
+	--health)
+		local languages=$(hx --health |tail -n '+7' |awk '{print $1}' |sed 's/\x1b\[[0-9;]*m//g')
+		COMPREPLY="$(compgen -W """$languages""" -- $2)"
+		;;
+	*)
+		COMPREPLY="$(compgen -fd -W "-h --help --tutor -V --version -v -vv -vvv --health -g --grammar --vsplit --hsplit -c --config --log" -- """$2""")"
+		;;
+	esac
+
+	local IFS=$'\n'
+	COMPREPLY=($COMPREPLY)
+} && complete -o filenames -F _hx hx

contrib/completion/hx.elv

@@ -0,0 +1,55 @@
+# You can move it here ~/.config/elvish/lib/hx.elv
+# Or add `eval (slurp < ~/$REPOS/helix/contrib/completion/hx.elv)`
+# Be sure to replace `$REPOS` with something that makes sense for you!
+
+### Renders a pretty completion candidate
+var candidate = { | _stem  _desc | 
+  edit:complex-candidate $_stem &display=(styled $_stem bold)(styled " "$_desc dim)
+}
+
+### These commands will invalidate further input (i.e. not react to them)
+var skips = [ "--tutor" "--help" "--version" "-V" "--health" ]
+
+### Grammar commands
+var grammar = [ "--grammar" "-g" ]
+
+### Config commands
+var config = [ "--config" "-c" ]
+
+### Set an arg-completer for the `hx` binary
+set edit:completion:arg-completer[hx] = {|@args|
+  var n = (count $args)
+  if (>= $n 3) {
+    # Stop completions if passed arg will take presedence
+    # and invalidate further input
+    if (has-value $skips $args[-2]) {
+      return
+    } 
+    # If the previous arg == --grammar, then only suggest:
+    if (has-value $grammar $args[-2]) {
+      $candidate "fetch" "Fetch the tree-sitter grammars"
+      $candidate "build" "Build the tree-sitter grammars"
+      return
+    } 
+    # When we have --config, we need a file
+    if (has-values $config $args[-2]) {
+      edit:complete-filename $args[-1] | each { |v| put $v[stem] }
+      return
+    } 
+    # When we have --log, we need a file
+    if (has-values "log" $args[-2]) {
+      edit:complete-filename $args[-1] | each { |v| put $v[stem] }
+      return
+    } 
+  } 
+  edit:complete-filename $args[-1] | each { |v| put $v[stem]}
+  $candidate "--help" "(Prints help information)"
+  $candidate "--version" "(Prints version information)"
+  $candidate "--tutor" "(Loads the tutorial)"
+  $candidate "--health" "(Checks for errors in editor setup)"
+  $candidate "--grammar" "(Fetch or build the tree-sitter grammars)"
+  $candidate "--vsplit" "(Splits all given files vertically)"
+  $candidate "--hsplit" "(Splits all given files horizontally)"
+  $candidate "--config" "(Specifies a file to use for configuration)"
+  $candidate "--log" "(Specifies a file to write log data into)"
+}

contrib/completion/hx.fish

@@ -0,0 +1,15 @@
+#!/usr/bin/env fish
+# Fish completion script for Helix editor
+
+set -l langs (hx --health |tail -n '+7' |awk '{print $1}' |sed 's/\x1b\[[0-9;]*m//g')
+
+complete -c hx -s h -l help -d "Prints help information"
+complete -c hx -l tutor -d "Loads the tutorial"
+complete -c hx -l health -x -a "$langs" -d "Checks for errors in editor setup"
+complete -c hx -s g -l grammar -x -a "fetch build" -d "Fetches or builds tree-sitter grammars"
+complete -c hx -s v -o vv -o vvv -d "Increases logging verbosity"
+complete -c hx -s V -l version -d "Prints version information"
+complete -c hx -l vsplit -d "Splits all given files vertically into different windows"
+complete -c hx -l hsplit -d "Splits all given files horizontally into different windows"
+complete -c hx -s c -l config -r -d "Specifies a file to use for completion"
+complete -c hx -l log -r -d "Specifies a file to write log data into"

contrib/completion/hx.zsh

@@ -0,0 +1,34 @@
+#compdef _hx hx
+# Zsh completion script for Helix editor
+
+_hx() {
+	_arguments -C \
+		"-h[Prints help information]" \
+		"--help[Prints help information]" \
+		"-v[Increase logging verbosity]" \
+		"-vv[Increase logging verbosity]" \
+		"-vvv[Increase logging verbosity]" \
+		"-V[Prints version information]" \
+		"--version[Prints version information]" \
+		"--tutor[Loads the tutorial]" \
+		"--health[Checks for errors in editor setup]:language:->health" \
+		"-g[Fetches or builds tree-sitter grammars]:action:->grammar" \
+		"--grammar[Fetches or builds tree-sitter grammars]:action:->grammar" \
+		"--vsplit[Splits all given files vertically into different windows]" \
+		"--hsplit[Splits all given files horizontally into different windows]" \
+		"-c[Specifies a file to use for configuration]" \
+		"--config[Specifies a file to use for configuration]" \
+		"--log[Specifies a file to write log data into]" \
+		"*:file:_files"
+
+	case "$state" in
+	health)
+		local languages=($(hx --health |tail -n '+7' |awk '{print $1}' |sed 's/\x1b\[[0-9;]*m//g'))
+		_values 'language' $languages
+		;;
+	grammar)
+		_values 'action' fetch build
+		;;
+	esac
+}
+

default.nix

@@ -0,0 +1,8 @@
+# Flake's default package for non-flake-enabled nix instances
+let
+  compat = builtins.fetchTarball {
+    url = "https://github.com/edolstra/flake-compat/archive/b4a34015c698c7793d592d66adbab377907a2be8.tar.gz";
+    sha256 = "sha256:1qc703yg0babixi6wshn5wm2kgl5y1drcswgszh4xxzbrwkk9sv7";
+  };
+in
+  (import compat {src = ./.;}).defaultNix.default

docs/CONTRIBUTING.md

@@ -8,7 +8,10 @@ Some suggestions to get started:
 - Help with packaging on various distributions needed!
 - To use print debugging to the [Helix log file][log-file], you must:
   * Print using `log::info!`, `warn!`, or `error!`. (`log::info!("helix!")`)
-  * Pass the appropriate verbosity level option for the desired log level. (`hx -v <file>` for info, more `v`s for higher severity inclusive)
+  * Pass the appropriate verbosity level option for the desired log level. (`hx -v <file>` for info, more `v`s for higher verbosity)
+  * Want to display the logs in a separate file instead of using the `:log-open` command in your compiled Helix editor? Start your debug version with `cargo run -- --log foo.log` and in a new terminal use `tail -f foo.log`
+- Instead of running a release version of Helix, while developing you may want to run in debug mode with `cargo run` which is way faster to compile
+- Looking for even faster compile times? Give a try to [mold](https://github.com/rui314/mold)
 - If your preferred language is missing, integrating a tree-sitter grammar for
     it and defining syntax highlight queries for it is straight forward and
     doesn't require much knowledge of the internals.
@@ -26,12 +29,40 @@ files, run
 cargo xtask docgen
 ```
 
-inside the project. We use [xtask][xtask] as an ad-hoc task runner and
-thus do not require any dependencies other than `cargo` (You don't have
-to `cargo install` anything either).
+inside the project. We use [xtask][xtask] as an ad-hoc task runner.
 
+To preview the book itself, install [mdbook][mdbook]. Then, run
+
+```shell
+mdbook serve book
+```
+
+and visit [http://localhost:3000](http://localhost:3000).
+
+# Testing
+
+## Unit tests/Documentation tests
+
+Run `cargo test --workspace` to run unit tests and documentation tests in all packages.
+
+## Integration tests
+
+Integration tests for helix-term can be run with `cargo integration-test`. Code
+contributors are strongly encouraged to write integration tests for their code.
+Existing tests can be used as examples. Helpers can be found in
+[helpers.rs][helpers.rs]. The log level can be set with the `HELIX_LOG_LEVEL`
+environment variable, e.g. `HELIX_LOG_LEVEL=debug cargo integration-test`.
+
+## Minimum Stable Rust Version (MSRV) Policy
+
+Helix follows the MSRV of Firefox.
+The current MSRV and future changes to the MSRV are listed in the [Firefox documentation].
+
+[Firefox documentation]: https://firefox-source-docs.mozilla.org/writing-rust-code/update-policy.html
 [good-first-issue]: https://github.com/helix-editor/helix/labels/E-easy
 [log-file]: https://github.com/helix-editor/helix/wiki/FAQ#access-the-log-file
 [architecture.md]: ./architecture.md
 [docs]: https://docs.helix-editor.com/
 [xtask]: https://github.com/matklad/cargo-xtask
+[mdbook]: https://rust-lang.github.io/mdBook/guide/installation.html
+[helpers.rs]: ../helix-term/tests/test/helpers.rs

docs/architecture.md

@@ -32,7 +32,7 @@ represented by a `Selection`. Each `Range` in the selection consists of a moving
 a selection with a single range, with the head and the anchor in the same
 position.
 
-Ropes are modified by constructing an OT-like `Transaction`. It's represents
+Ropes are modified by constructing an OT-like `Transaction`. It represents
 a single coherent change to the document and can be applied to the rope.
 A transaction can be inverted to produce an undo. Selections and marks can be
 mapped over a transaction to translate to a position in the new text state after
@@ -42,7 +42,7 @@ applying the transaction.
 > interface used to generate text edits.
 
 `Syntax` is the interface used to interact with tree-sitter ASTs for syntax
-highling and other features.
+highlighting and other features.
 
 ## View
 

docs/releases.md

@@ -0,0 +1,67 @@
+## Checklist
+
+Helix releases are versioned in the Calendar Versioning scheme:
+`YY.0M(.MICRO)`, for example, `22.05` for May of 2022, or in a patch release,
+`22.05.1`. In these instructions we'll use `<tag>` as a placeholder for the tag
+being published.
+
+* Merge the changelog PR
+* Add new `<release>` entry in `contrib/Helix.appdata.xml` with release information according to the [AppStream spec](https://www.freedesktop.org/software/appstream/docs/sect-Metadata-Releases.html)
+* Tag and push
+    * `git tag -s -m "<tag>" -a <tag> && git push`
+    * Make sure to switch to master and pull first
+* Edit the `Cargo.toml` file and change the date in the `version` field to the next planned release
+    * Due to Cargo having a strict requirement on SemVer with 3 or more version
+      numbers, a `0` is required in the micro version; however, unless we are
+      publishing a patch release after a major release, the `.0` is dropped in
+      the user facing version.
+    * Releases are planned to happen every two months, so `22.05.0` would change to `22.07.0`
+    * If we are pushing a patch/bugfix release in the same month as the previous
+      release, bump the micro version, e.g. `22.07.0` to `22.07.1`
+* Wait for the Release CI to finish
+    * It will automatically turn the git tag into a GitHub release when it uploads artifacts
+* Edit the new release
+    * Use `<tag>` as the title
+    * Link to the changelog and release notes
+* Merge the release notes PR
+* Download the macos and linux binaries and update the `sha256`s in the [homebrew formula]
+    * Use `sha256sum` on the downloaded `.tar.xz` files to determine the hash
+* Link to the release notes in this-week-in-rust
+    * [Example PR](https://github.com/rust-lang/this-week-in-rust/pull/3300)
+* Post to reddit
+    * [Example post](https://www.reddit.com/r/rust/comments/uzp5ze/helix_editor_2205_released/)
+
+[homebrew formula]: https://github.com/Homebrew/homebrew-core/blob/master/Formula/helix.rb
+
+## Changelog Curation
+
+The changelog is currently created manually by reading through commits in the
+log since the last release. GitHub's compare view is a nice way to approach
+this. For example, when creating the 22.07 release notes, this compare link
+may be used
+
+```
+https://github.com/helix-editor/helix/compare/22.05...master
+```
+
+Either side of the triple-dot may be replaced with an exact revision, so if
+you wish to incrementally compile the changelog, you can tackle a weeks worth
+or so, record the revision where you stopped, and use that as a starting point
+next week:
+
+```
+https://github.com/helix-editor/helix/compare/7706a4a0d8b67b943c31d0c5f7b00d357b5d838d...master
+```
+
+A work-in-progress commit for a changelog might look like
+[this example](https://github.com/helix-editor/helix/commit/831adfd4c709ca16b248799bfef19698d5175e55).
+
+Not every PR or commit needs a blurb in the changelog. Each release section
+tends to have a blurb that links to a GitHub comparison between release
+versions for convenience:
+
+> As usual, the following is a summary of each of the changes since the last
+> release. For the full log, check out the git log.
+
+Typically, small changes like dependencies or documentation updates, refactors,
+or meta changes like GitHub Actions work are left out.

docs/vision.md

@@ -20,5 +20,5 @@ Vision statements are all well and good, but are also vague and subjective.  Her
 * **Built-in tools** for working with code bases efficiently.  Most projects aren't a single file, and an editor should handle that as a first-class use case.  In Helix's case, this means (among other things) a fuzzy-search file navigator and LSP support.
 * **Edit anything** that comes up when coding, within reason.  Whether it's a 200 MB XML file, a megabyte of minified javascript on a single line, or Japanese text encoded in ShiftJIS, you should be able to open it and edit it without problems.  (Note: this doesn't mean handle every esoteric use case.  Sometimes you do just need a specialized tool, and Helix isn't that.)
 * **Configurable**, within reason.  Although the defaults should be good, not everyone will agree on what "good" is.  Within the bounds of Helix's core interaction models, it should be reasonably configurable so that it can be "good" for more people.  This means, for example, custom key maps among other things.
-* **Extensible**, within reason.  Although we want Helix to be productive out-of-the-box, it's not practical or desirable to cram every useful feature and use case into the core editor.  The basics should be built-in, but you should be able to extend it with additional functionality as needed.  Right now we're thinking Wasm-based plugins.
+* **Extensible**, within reason.  Although we want Helix to be productive out-of-the-box, it's not practical or desirable to cram every useful feature and use case into the core editor.  The basics should be built-in, but you should be able to extend it with additional functionality as needed.
 * **Clean code base.**  Sometimes other factors (e.g. significant performance gains, important features, correctness, etc.) will trump strict readability, but we nevertheless want to keep the code base straightforward and easy to understand to the extent we can.

flake.lock

@@ -1,13 +1,17 @@
 {
   "nodes": {
     "crane": {
-      "flake": false,
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
       "locked": {
-        "lastModified": 1644785799,
-        "narHash": "sha256-VpAJO1L0XeBvtCuNGK4IDKp6ENHIpTrlaZT7yfBCvwo=",
+        "lastModified": 1709610799,
+        "narHash": "sha256-5jfLQx0U9hXbi2skYMGodDJkIgffrjIOgMRjZqms2QE=",
         "owner": "ipetkov",
         "repo": "crane",
-        "rev": "fc7a94f841347c88f2cb44217b2a3faa93e2a0b2",
+        "rev": "81c393c776d5379c030607866afef6406ca1be57",
         "type": "github"
       },
       "original": {
@@ -16,141 +20,31 @@
         "type": "github"
       }
     },
-    "devshell": {
-      "inputs": {
-        "flake-utils": "flake-utils",
-        "nixpkgs": [
-          "nixCargoIntegration",
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1646667754,
-        "narHash": "sha256-LahZHvCC3UVzGQ55iWDRZkuDssXl1rYgqgScrPV9S38=",
-        "owner": "numtide",
-        "repo": "devshell",
-        "rev": "59fbe1dfc0de8c3332957c16998a7d16dff365d8",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "devshell",
-        "type": "github"
-      }
-    },
-    "dream2nix": {
-      "inputs": {
-        "alejandra": [
-          "nixCargoIntegration",
-          "nixpkgs"
-        ],
-        "crane": "crane",
-        "flake-utils-pre-commit": [
-          "nixCargoIntegration",
-          "nixpkgs"
-        ],
-        "gomod2nix": [
-          "nixCargoIntegration",
-          "nixpkgs"
-        ],
-        "mach-nix": [
-          "nixCargoIntegration",
-          "nixpkgs"
-        ],
-        "nixpkgs": [
-          "nixCargoIntegration",
-          "nixpkgs"
-        ],
-        "node2nix": [
-          "nixCargoIntegration",
-          "nixpkgs"
-        ],
-        "poetry2nix": [
-          "nixCargoIntegration",
-          "nixpkgs"
-        ],
-        "pre-commit-hooks": [
-          "nixCargoIntegration",
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1646710334,
-        "narHash": "sha256-eLBcDgcbOUfeH4k6SEW5a5v0PTp2KNCn+5ZXIoWGYww=",
-        "owner": "nix-community",
-        "repo": "dream2nix",
-        "rev": "5dcfbfd3b60ce0208b894c1bdea00e2bdf80ca6a",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "ref": "main",
-        "repo": "dream2nix",
-        "type": "github"
-      }
-    },
     "flake-utils": {
-      "locked": {
-        "lastModified": 1642700792,
-        "narHash": "sha256-XqHrk7hFb+zBvRg6Ghl+AZDq03ov6OshJLiSWOoX5es=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "846b2ae0fc4cc943637d3d1def4454213e203cba",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "flake-utils_2": {
-      "locked": {
-        "lastModified": 1637014545,
-        "narHash": "sha256-26IZAc5yzlD9FlDT54io1oqG/bBoyka+FJk5guaX4x4=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "bba5dcc8e0b20ab664967ad83d24d64cb64ec4f4",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "nixCargoIntegration": {
       "inputs": {
-        "devshell": "devshell",
-        "dream2nix": "dream2nix",
-        "nixpkgs": [
-          "nixpkgs"
-        ],
-        "rustOverlay": [
-          "rust-overlay"
-        ]
+        "systems": "systems"
       },
       "locked": {
-        "lastModified": 1646766572,
-        "narHash": "sha256-DV3+zxvAIKsMHsHedJKYFsracvFyLKpFQqurUBR86oY=",
-        "owner": "yusdacra",
-        "repo": "nix-cargo-integration",
-        "rev": "3a3f47f43ba486b7554164a698c8dfc5a38624ce",
+        "lastModified": 1709126324,
+        "narHash": "sha256-q6EQdSeUZOG26WelxqkmR7kArjgWCdw5sfJVHPH/7j8=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "d465f4819400de7c8d874d50b982301f28a84605",
         "type": "github"
       },
       "original": {
-        "owner": "yusdacra",
-        "repo": "nix-cargo-integration",
+        "owner": "numtide",
+        "repo": "flake-utils",
         "type": "github"
       }
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1646497237,
-        "narHash": "sha256-Ccpot1h/rV8MgcngDp5OrdmLTMaUTbStZTR5/sI7zW0=",
+        "lastModified": 1709479366,
+        "narHash": "sha256-n6F0n8UV6lnTZbYPl1A9q1BS0p4hduAv1mGAP17CVd0=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "062a0c5437b68f950b081bbfc8a699d57a4ee026",
+        "rev": "b8697e57f10292a6165a20f03d2f42920dfaf973",
         "type": "github"
       },
       "original": {
@@ -162,24 +56,27 @@
     },
     "root": {
       "inputs": {
-        "nixCargoIntegration": "nixCargoIntegration",
+        "crane": "crane",
+        "flake-utils": "flake-utils",
         "nixpkgs": "nixpkgs",
         "rust-overlay": "rust-overlay"
       }
     },
     "rust-overlay": {
       "inputs": {
-        "flake-utils": "flake-utils_2",
+        "flake-utils": [
+          "flake-utils"
+        ],
         "nixpkgs": [
           "nixpkgs"
         ]
       },
       "locked": {
-        "lastModified": 1646792695,
-        "narHash": "sha256-2drCXIKIQnJMlTZbcCfuHZAh+iPcdlRkCqtZnA6MHLY=",
+        "lastModified": 1709604635,
+        "narHash": "sha256-le4fwmWmjGRYWwkho0Gr7mnnZndOOe4XGbLw68OvF40=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "7f599870402c8d2a5806086c8ee0f2d92b175c54",
+        "rev": "e86c0fb5d3a22a5f30d7f64ecad88643fe26449d",
         "type": "github"
       },
       "original": {
@@ -187,6 +84,21 @@
         "repo": "rust-overlay",
         "type": "github"
       }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
     }
   },
   "root": "root",

flake.nix

@@ -3,63 +3,198 @@
 
   inputs = {
     nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
     rust-overlay = {
       url = "github:oxalica/rust-overlay";
-      inputs.nixpkgs.follows = "nixpkgs";
+      inputs = {
+        nixpkgs.follows = "nixpkgs";
+        flake-utils.follows = "flake-utils";
+      };
     };
-    nixCargoIntegration = {
-      url = "github:yusdacra/nix-cargo-integration";
+    crane = {
+      url = "github:ipetkov/crane";
       inputs.nixpkgs.follows = "nixpkgs";
-      inputs.rustOverlay.follows = "rust-overlay";
     };
   };
 
-  outputs = inputs@{ nixCargoIntegration, ... }:
-    nixCargoIntegration.lib.makeOutputs {
-      root = ./.;
-      renameOutputs = { "helix-term" = "helix"; };
-      # Set default app to hx (binary is from helix-term release build)
-      # Set default package to helix-term release build
-      defaultOutputs = {
-        app = "hx";
-        package = "helix";
+  outputs = {
+    self,
+    nixpkgs,
+    crane,
+    flake-utils,
+    rust-overlay,
+    ...
+  }:
+    flake-utils.lib.eachDefaultSystem (system: let
+      pkgs = import nixpkgs {
+        inherit system;
+        overlays = [(import rust-overlay)];
       };
-      overrides = {
-        crateOverrides = common: _: {
-          helix-term = prev:
-            let
-              inherit (common) pkgs;
-              grammars = pkgs.callPackage ./grammars.nix { };
-              runtimeDir = pkgs.runCommand "helix-runtime" { } ''
-                mkdir -p $out
-                ln -s ${common.root}/runtime/* $out
-                rm -r $out/grammars
-                ln -s ${grammars} $out/grammars
-              '';
-            in
-            {
-              # disable fetching and building of tree-sitter grammars in the helix-term build.rs
-              HELIX_DISABLE_AUTO_GRAMMAR_BUILD = "1";
-              # link languages and theme toml files since helix-term expects them (for tests)
-              preConfigure = "ln -s ${common.root}/{languages.toml,theme.toml,base16_theme.toml} ..";
-              buildInputs = (prev.buildInputs or [ ]) ++ [ common.cCompiler.cc.lib ];
-              nativeBuildInputs = [ pkgs.makeWrapper ];
-
-              postFixup = ''
-                if [ -f "$out/bin/hx" ]; then
-                  wrapProgram "$out/bin/hx" --set HELIX_RUNTIME "${runtimeDir}"
-                fi
-              '';
+      mkRootPath = rel:
+        builtins.path {
+          path = "${toString ./.}/${rel}";
+          name = rel;
+        };
+      filteredSource = let
+        pathsToIgnore = [
+          ".envrc"
+          ".ignore"
+          ".github"
+          ".gitignore"
+          "logo_dark.svg"
+          "logo_light.svg"
+          "rust-toolchain.toml"
+          "rustfmt.toml"
+          "runtime"
+          "screenshot.png"
+          "book"
+          "docs"
+          "README.md"
+          "CHANGELOG.md"
+          "shell.nix"
+          "default.nix"
+          "grammars.nix"
+          "flake.nix"
+          "flake.lock"
+        ];
+        ignorePaths = path: type: let
+          inherit (nixpkgs) lib;
+          # split the nix store path into its components
+          components = lib.splitString "/" path;
+          # drop off the `/nix/hash-source` section from the path
+          relPathComponents = lib.drop 4 components;
+          # reassemble the path components
+          relPath = lib.concatStringsSep "/" relPathComponents;
+        in
+          lib.all (p: ! (lib.hasPrefix p relPath)) pathsToIgnore;
+      in
+        builtins.path {
+          name = "helix-source";
+          path = toString ./.;
+          # filter out unnecessary paths
+          filter = ignorePaths;
+        };
+      makeOverridableHelix = old: config: let
+        grammars = pkgs.callPackage ./grammars.nix config;
+        runtimeDir = pkgs.runCommand "helix-runtime" {} ''
+          mkdir -p $out
+          ln -s ${mkRootPath "runtime"}/* $out
+          rm -r $out/grammars
+          ln -s ${grammars} $out/grammars
+        '';
+        helix-wrapped =
+          pkgs.runCommand
+          old.name
+          {
+            inherit (old) pname version;
+            meta = old.meta or {};
+            passthru =
+              (old.passthru or {})
+              // {
+                unwrapped = old;
+              };
+            nativeBuildInputs = [pkgs.makeWrapper];
+            makeWrapperArgs = config.makeWrapperArgs or [];
+          }
+          ''
+            cp -rs --no-preserve=mode,ownership ${old} $out
+            wrapProgram "$out/bin/hx" ''${makeWrapperArgs[@]} --set HELIX_RUNTIME "${runtimeDir}"
+          '';
+      in
+        helix-wrapped
+        // {
+          override = makeOverridableHelix old;
+          passthru =
+            helix-wrapped.passthru
+            // {
+              wrapper = old: makeOverridableHelix old config;
             };
         };
-        shell = common: prev: {
-          packages = prev.packages ++ (with common.pkgs; [ lld_13 lldb cargo-tarpaulin cargo-flamegraph ]);
-          env = prev.env ++ [
-            { name = "HELIX_RUNTIME"; eval = "$PWD/runtime"; }
-            { name = "RUST_BACKTRACE"; value = "1"; }
-            { name = "RUSTFLAGS"; value = "-C link-arg=-fuse-ld=lld -C target-cpu=native -Clink-arg=-Wl,--no-rosegment"; }
-          ];
-        };
+      stdenv =
+        if pkgs.stdenv.isLinux
+        then pkgs.stdenv
+        else pkgs.clangStdenv;
+      rustFlagsEnv =
+        if stdenv.isLinux
+        then ''$RUSTFLAGS -C link-arg=-fuse-ld=lld -C target-cpu=native -Clink-arg=-Wl,--no-rosegment''
+        else "$RUSTFLAGS";
+      rustToolchain = pkgs.pkgsBuildHost.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml;
+      craneLibMSRV = (crane.mkLib pkgs).overrideToolchain rustToolchain;
+      craneLibStable = (crane.mkLib pkgs).overrideToolchain pkgs.pkgsBuildHost.rust-bin.stable.latest.default;
+      commonArgs = {
+        inherit stdenv;
+        inherit (craneLibMSRV.crateNameFromCargoToml {cargoToml = ./helix-term/Cargo.toml;}) pname;
+        inherit (craneLibMSRV.crateNameFromCargoToml {cargoToml = ./Cargo.toml;}) version;
+        src = filteredSource;
+        # disable fetching and building of tree-sitter grammars in the helix-term build.rs
+        HELIX_DISABLE_AUTO_GRAMMAR_BUILD = "1";
+        buildInputs = [stdenv.cc.cc.lib];
+        # disable tests
+        doCheck = false;
+        meta.mainProgram = "hx";
+      };
+      cargoArtifacts = craneLibMSRV.buildDepsOnly commonArgs;
+    in {
+      packages = {
+        helix-unwrapped = craneLibStable.buildPackage (commonArgs
+          // {
+            cargoArtifacts = craneLibStable.buildDepsOnly commonArgs;
+            postInstall = ''
+              mkdir -p $out/share/applications $out/share/icons/hicolor/scalable/apps $out/share/icons/hicolor/256x256/apps
+              cp contrib/Helix.desktop $out/share/applications
+              cp logo.svg $out/share/icons/hicolor/scalable/apps/helix.svg
+              cp contrib/helix.png $out/share/icons/hicolor/256x256/apps
+            '';
+          });
+        helix = makeOverridableHelix self.packages.${system}.helix-unwrapped {};
+        default = self.packages.${system}.helix;
+      };
+
+      checks = {
+        # Build the crate itself
+        inherit (self.packages.${system}) helix;
+
+        clippy = craneLibMSRV.cargoClippy (commonArgs
+          // {
+            inherit cargoArtifacts;
+            cargoClippyExtraArgs = "--all-targets -- --deny warnings";
+          });
+
+        fmt = craneLibMSRV.cargoFmt commonArgs;
+
+        doc = craneLibMSRV.cargoDoc (commonArgs
+          // {
+            inherit cargoArtifacts;
+          });
+
+        test = craneLibMSRV.cargoTest (commonArgs
+          // {
+            inherit cargoArtifacts;
+          });
+      };
+
+      devShells.default = pkgs.mkShell {
+        inputsFrom = builtins.attrValues self.checks.${system};
+        nativeBuildInputs = with pkgs;
+          [lld_13 cargo-flamegraph rust-analyzer]
+          ++ (lib.optional (stdenv.isx86_64 && stdenv.isLinux) pkgs.cargo-tarpaulin)
+          ++ (lib.optional stdenv.isLinux pkgs.lldb)
+          ++ (lib.optional stdenv.isDarwin pkgs.darwin.apple_sdk.frameworks.CoreFoundation);
+        shellHook = ''
+          export HELIX_RUNTIME="$PWD/runtime"
+          export RUST_BACKTRACE="1"
+          export RUSTFLAGS="${rustFlagsEnv}"
+        '';
+      };
+    })
+    // {
+      overlays.default = final: prev: {
+        inherit (self.packages.${final.system}) helix;
       };
     };
+
+  nixConfig = {
+    extra-substituters = ["https://helix.cachix.org"];
+    extra-trusted-public-keys = ["helix.cachix.org-1:ejp9KQpR1FBI2onstMQ34yogDm4OgU2ru6lIwPvuCVs="];
+  };
 }

grammars.nix

@@ -1,41 +1,80 @@
-{ stdenv, lib, runCommand, yj }:
-let
+{
+  stdenv,
+  lib,
+  runCommandLocal,
+  runCommand,
+  yj,
+  includeGrammarIf ? _: true,
+  grammarOverlays ? [],
+  ...
+}: let
   # HACK: nix < 2.6 has a bug in the toml parser, so we convert to JSON
   # before parsing
-  languages-json = runCommand "languages-toml-to-json" { } ''
+  languages-json = runCommandLocal "languages-toml-to-json" {} ''
     ${yj}/bin/yj -t < ${./languages.toml} > $out
   '';
   languagesConfig =
-    builtins.fromJSON (builtins.readFile (builtins.toPath languages-json));
-  isGitGrammar = (grammar:
-    builtins.hasAttr "source" grammar && builtins.hasAttr "git" grammar.source
-    && builtins.hasAttr "rev" grammar.source);
-  gitGrammars = builtins.filter isGitGrammar languagesConfig.grammar;
-  buildGrammar = grammar:
-    let
-      source = builtins.fetchTree {
-        type = "git";
-        url = grammar.source.git;
-        rev = grammar.source.rev;
-        ref = grammar.source.ref or "HEAD";
-        shallow = true;
-      };
-    in stdenv.mkDerivation rec {
+    if lib.versionAtLeast builtins.nixVersion "2.6.0"
+    then builtins.fromTOML (builtins.readFile ./languages.toml)
+    else builtins.fromJSON (builtins.readFile (builtins.toPath languages-json));
+  isGitGrammar = grammar:
+    builtins.hasAttr "source" grammar
+    && builtins.hasAttr "git" grammar.source
+    && builtins.hasAttr "rev" grammar.source;
+  isGitHubGrammar = grammar: lib.hasPrefix "https://github.com" grammar.source.git;
+  toGitHubFetcher = url: let
+    match = builtins.match "https://github\.com/([^/]*)/([^/]*)/?" url;
+  in {
+    owner = builtins.elemAt match 0;
+    repo = builtins.elemAt match 1;
+  };
+  # If `use-grammars.only` is set, use only those grammars.
+  # If `use-grammars.except` is set, use all other grammars.
+  # Otherwise use all grammars.
+  useGrammar = grammar:
+    if languagesConfig?use-grammars.only then
+      builtins.elem grammar.name languagesConfig.use-grammars.only
+    else if languagesConfig?use-grammars.except then
+      !(builtins.elem grammar.name languagesConfig.use-grammars.except)
+    else true;
+  grammarsToUse = builtins.filter useGrammar languagesConfig.grammar;
+  gitGrammars = builtins.filter isGitGrammar grammarsToUse;
+  buildGrammar = grammar: let
+    gh = toGitHubFetcher grammar.source.git;
+    sourceGit = builtins.fetchTree {
+      type = "git";
+      url = grammar.source.git;
+      rev = grammar.source.rev;
+      ref = grammar.source.ref or "HEAD";
+      shallow = true;
+    };
+    sourceGitHub = builtins.fetchTree {
+      type = "github";
+      owner = gh.owner;
+      repo = gh.repo;
+      inherit (grammar.source) rev;
+    };
+    source =
+      if isGitHubGrammar grammar
+      then sourceGitHub
+      else sourceGit;
+  in
+    stdenv.mkDerivation {
       # see https://github.com/NixOS/nixpkgs/blob/fbdd1a7c0bc29af5325e0d7dd70e804a972eb465/pkgs/development/tools/parsing/tree-sitter/grammar.nix
 
       pname = "helix-tree-sitter-${grammar.name}";
       version = grammar.source.rev;
 
-      src = if builtins.hasAttr "subpath" grammar.source then
-        "${source}/${grammar.source.subpath}"
+      src = source;
+      sourceRoot = if builtins.hasAttr "subpath" grammar.source then
+        "source/${grammar.source.subpath}"
       else
-        source;
+        "source";
 
-      dontUnpack = true;
       dontConfigure = true;
 
       FLAGS = [
-        "-I${src}/src"
+        "-Isrc"
         "-g"
         "-O3"
         "-fPIC"
@@ -48,13 +87,13 @@ let
       buildPhase = ''
         runHook preBuild
 
-        if [[ -e "$src/src/scanner.cc" ]]; then
-          $CXX -c "$src/src/scanner.cc" -o scanner.o $FLAGS
-        elif [[ -e "$src/src/scanner.c" ]]; then
-          $CC -c "$src/src/scanner.c" -o scanner.o $FLAGS
+        if [[ -e src/scanner.cc ]]; then
+          $CXX -c src/scanner.cc -o scanner.o $FLAGS
+        elif [[ -e src/scanner.c ]]; then
+          $CC -c src/scanner.c -o scanner.o $FLAGS
         fi
 
-        $CC -c "$src/src/parser.c" -o parser.o $FLAGS
+        $CC -c src/parser.c -o parser.o $FLAGS
         $CXX -shared -o $NAME.so *.o
 
         ls -al
@@ -76,14 +115,20 @@ let
         runHook postFixup
       '';
     };
+  grammarsToBuild = builtins.filter includeGrammarIf gitGrammars;
   builtGrammars = builtins.map (grammar: {
     inherit (grammar) name;
-    artifact = buildGrammar grammar;
-  }) gitGrammars;
-  grammarLinks = builtins.map (grammar:
-    "ln -s ${grammar.artifact}/${grammar.name}.so $out/${grammar.name}.so")
-    builtGrammars;
-in runCommand "consolidated-helix-grammars" { } ''
-  mkdir -p $out
-  ${builtins.concatStringsSep "\n" grammarLinks}
-''
+    value = buildGrammar grammar;
+  }) grammarsToBuild;
+  extensibleGrammars =
+    lib.makeExtensible (self: builtins.listToAttrs builtGrammars);
+  overlayedGrammars = lib.pipe extensibleGrammars
+    (builtins.map (overlay: grammar: grammar.extend overlay) grammarOverlays);
+  grammarLinks = lib.mapAttrsToList
+    (name: artifact: "ln -s ${artifact}/${name}.so $out/${name}.so")
+    (lib.filterAttrs (n: v: lib.isDerivation v) overlayedGrammars);
+in
+  runCommand "consolidated-helix-grammars" {} ''
+    mkdir -p $out
+    ${builtins.concatStringsSep "\n" grammarLinks}
+  ''

helix-core/Cargo.toml

@@ -1,45 +1,58 @@
 [package]
 name = "helix-core"
-version = "0.6.0"
-authors = ["Blaž Hrastnik <blaz@mxxn.io>"]
-edition = "2021"
-license = "MPL-2.0"
 description = "Helix editor core editing primitives"
-categories = ["editor"]
-repository = "https://github.com/helix-editor/helix"
-homepage = "https://helix-editor.com"
 include = ["src/**/*", "README.md"]
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+categories.workspace = true
+repository.workspace = true
+homepage.workspace = true
 
 [features]
+unicode-lines = ["ropey/unicode_lines"]
+integration = []
 
 [dependencies]
-helix-loader = { version = "0.6", path = "../helix-loader" }
+helix-stdx = { path = "../helix-stdx" }
+helix-loader = { path = "../helix-loader" }
 
-ropey = "1.3"
-smallvec = "1.8"
-smartstring = "1.0.0"
-unicode-segmentation = "1.9"
+ropey = { version = "1.6.1", default-features = false, features = ["simd"] }
+smallvec = "1.13"
+smartstring = "1.0.1"
+unicode-segmentation = "1.11"
 unicode-width = "0.1"
-unicode-general-category = "0.5"
-# slab = "0.4.2"
-slotmap = "1.0"
-tree-sitter = "0.20"
-once_cell = "1.10"
+unicode-general-category = "0.6"
+slotmap.workspace = true
+tree-sitter.workspace = true
+once_cell = "1.19"
 arc-swap = "1"
 regex = "1"
+bitflags = "2.5"
+ahash = "0.8.11"
+hashbrown = { version = "0.14.3", features = ["raw"] }
+dunce = "1.0"
 
 log = "0.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-toml = "0.5"
+toml = "0.8"
 
-similar = "2.1"
+imara-diff = "0.1.0"
 
 encoding_rs = "0.8"
 
 chrono = { version = "0.4", default-features = false, features = ["alloc", "std"] }
 
-etcetera = "0.3"
+etcetera = "0.8"
+textwrap = "0.16.1"
+
+nucleo.workspace = true
+parking_lot = "0.12"
+globset = "0.4.14"
 
 [dev-dependencies]
 quickcheck = { version = "1", default-features = false }
+indoc = "2.0.5"

helix-core/src/auto_pairs.rs

@@ -1,16 +1,12 @@
 //! When typing the opening character of one of the possible pairs defined below,
 //! this module provides the functionality to insert the paired closing character.
 
-use crate::{
-    graphemes, movement::Direction, Range, Rope, RopeGraphemes, Selection, Tendril, Transaction,
-};
+use crate::{graphemes, movement::Direction, Range, Rope, Selection, Tendril, Transaction};
 use std::collections::HashMap;
 
-use log::debug;
 use smallvec::SmallVec;
 
 // Heavily based on https://github.com/codemirror/closebrackets/
-
 pub const DEFAULT_PAIRS: &[(char, char)] = &[
     ('(', ')'),
     ('{', '}'),
@@ -21,7 +17,7 @@ pub const DEFAULT_PAIRS: &[(char, char)] = &[
 ];
 
 /// The type that represents the collection of auto pairs,
-/// keyed by the opener.
+/// keyed by both opener and closer.
 #[derive(Debug, Clone)]
 pub struct AutoPairs(HashMap<char, Pair>);
 
@@ -125,7 +121,7 @@ impl Default for AutoPairs {
 
 #[must_use]
 pub fn hook(doc: &Rope, selection: &Selection, ch: char, pairs: &AutoPairs) -> Option<Transaction> {
-    debug!("autopairs hook selection: {:#?}", selection);
+    log::trace!("autopairs hook selection: {:#?}", selection);
 
     if let Some(pair) = pairs.get(ch) {
         if pair.same() {
@@ -149,22 +145,8 @@ fn prev_char(doc: &Rope, pos: usize) -> Option<char> {
     doc.get_char(pos - 1)
 }
 
-fn is_single_grapheme(doc: &Rope, range: &Range) -> bool {
-    let mut graphemes = RopeGraphemes::new(doc.slice(range.from()..range.to()));
-    let first = graphemes.next();
-    let second = graphemes.next();
-    debug!("first: {:#?}, second: {:#?}", first, second);
-    first.is_some() && second.is_none()
-}
-
 /// calculate what the resulting range should be for an auto pair insertion
-fn get_next_range(
-    doc: &Rope,
-    start_range: &Range,
-    offset: usize,
-    typed_char: char,
-    len_inserted: usize,
-) -> Range {
+fn get_next_range(doc: &Rope, start_range: &Range, offset: usize, len_inserted: usize) -> Range {
     // When the character under the cursor changes due to complete pair
     // insertion, we must look backward a grapheme and then add the length
     // of the insertion to put the resulting cursor in the right place, e.g.
@@ -184,13 +166,13 @@ fn get_next_range(
     // inserting at the very end of the document after the last newline
     if start_range.head == doc.len_chars() && start_range.anchor == doc.len_chars() {
         return Range::new(
-            start_range.anchor + offset + typed_char.len_utf8(),
-            start_range.head + offset + typed_char.len_utf8(),
+            start_range.anchor + offset + 1,
+            start_range.head + offset + 1,
         );
     }
 
-    let single_grapheme = is_single_grapheme(doc, start_range);
     let doc_slice = doc.slice(..);
+    let single_grapheme = start_range.is_single_grapheme(doc_slice);
 
     // just skip over graphemes
     if len_inserted == 0 {
@@ -215,29 +197,28 @@ fn get_next_range(
     // trivial case: only inserted a single-char opener, just move the selection
     if len_inserted == 1 {
         let end_anchor = if single_grapheme || start_range.direction() == Direction::Backward {
-            start_range.anchor + offset + typed_char.len_utf8()
+            start_range.anchor + offset + 1
         } else {
             start_range.anchor + offset
         };
 
-        return Range::new(
-            end_anchor,
-            start_range.head + offset + typed_char.len_utf8(),
-        );
+        return Range::new(end_anchor, start_range.head + offset + 1);
     }
 
     // If the head = 0, then we must be in insert mode with a backward
     // cursor, which implies the head will just move
     let end_head = if start_range.head == 0 || start_range.direction() == Direction::Backward {
-        start_range.head + offset + typed_char.len_utf8()
+        start_range.head + offset + 1
     } else {
         // We must have a forward cursor, which means we must move to the
         // other end of the grapheme to get to where the new characters
         // are inserted, then move the head to where it should be
         let prev_bound = graphemes::prev_grapheme_boundary(doc_slice, start_range.head);
-        debug!(
+        log::trace!(
             "prev_bound: {}, offset: {}, len_inserted: {}",
-            prev_bound, offset, len_inserted
+            prev_bound,
+            offset,
+            len_inserted
         );
         prev_bound + offset + len_inserted
     };
@@ -253,8 +234,7 @@ fn get_next_range(
 
         (_, Direction::Forward) => {
             if single_grapheme {
-                graphemes::prev_grapheme_boundary(doc.slice(..), start_range.head)
-                    + typed_char.len_utf8()
+                graphemes::prev_grapheme_boundary(doc.slice(..), start_range.head) + 1
 
             // if we are appending, the anchor stays where it is; only offset
             // for multiple range insertions
@@ -268,7 +248,9 @@ fn get_next_range(
                 // if we're backward, then the head is at the first char
                 // of the typed char, so we need to add the length of
                 // the closing char
-                graphemes::prev_grapheme_boundary(doc.slice(..), start_range.anchor) + len_inserted
+                graphemes::prev_grapheme_boundary(doc.slice(..), start_range.anchor)
+                    + len_inserted
+                    + offset
             } else {
                 // when we are inserting in front of a selection, we need to move
                 // the anchor over by however many characters were inserted overall
@@ -289,9 +271,12 @@ fn handle_open(doc: &Rope, selection: &Selection, pair: &Pair) -> Transaction {
         let next_char = doc.get_char(cursor);
         let len_inserted;
 
+        // Since auto pairs are currently limited to single chars, we're either
+        // inserting exactly one or two chars. When arbitrary length pairs are
+        // added, these will need to be changed.
         let change = match next_char {
             Some(_) if !pair.should_close(doc, start_range) => {
-                len_inserted = pair.open.len_utf8();
+                len_inserted = 1;
                 let mut tendril = Tendril::new();
                 tendril.push(pair.open);
                 (cursor, cursor, Some(tendril))
@@ -299,12 +284,12 @@ fn handle_open(doc: &Rope, selection: &Selection, pair: &Pair) -> Transaction {
             _ => {
                 // insert open & close
                 let pair_str = Tendril::from_iter([pair.open, pair.close]);
-                len_inserted = pair.open.len_utf8() + pair.close.len_utf8();
+                len_inserted = 2;
                 (cursor, cursor, Some(pair_str))
             }
         };
 
-        let next_range = get_next_range(doc, start_range, offs, pair.open, len_inserted);
+        let next_range = get_next_range(doc, start_range, offs, len_inserted);
         end_ranges.push(next_range);
         offs += len_inserted;
 
@@ -312,13 +297,12 @@ fn handle_open(doc: &Rope, selection: &Selection, pair: &Pair) -> Transaction {
     });
 
     let t = transaction.with_selection(Selection::new(end_ranges, selection.primary_index()));
-    debug!("auto pair transaction: {:#?}", t);
+    log::debug!("auto pair transaction: {:#?}", t);
     t
 }
 
 fn handle_close(doc: &Rope, selection: &Selection, pair: &Pair) -> Transaction {
     let mut end_ranges = SmallVec::with_capacity(selection.len());
-
     let mut offs = 0;
 
     let transaction = Transaction::change_by_selection(doc, selection, |start_range| {
@@ -330,13 +314,13 @@ fn handle_close(doc: &Rope, selection: &Selection, pair: &Pair) -> Transaction {
             // return transaction that moves past close
             (cursor, cursor, None) // no-op
         } else {
-            len_inserted += pair.close.len_utf8();
+            len_inserted = 1;
             let mut tendril = Tendril::new();
             tendril.push(pair.close);
             (cursor, cursor, Some(tendril))
         };
 
-        let next_range = get_next_range(doc, start_range, offs, pair.close, len_inserted);
+        let next_range = get_next_range(doc, start_range, offs, len_inserted);
         end_ranges.push(next_range);
         offs += len_inserted;
 
@@ -344,7 +328,7 @@ fn handle_close(doc: &Rope, selection: &Selection, pair: &Pair) -> Transaction {
     });
 
     let t = transaction.with_selection(Selection::new(end_ranges, selection.primary_index()));
-    debug!("auto pair transaction: {:#?}", t);
+    log::debug!("auto pair transaction: {:#?}", t);
     t
 }
 
@@ -372,11 +356,11 @@ fn handle_same(doc: &Rope, selection: &Selection, pair: &Pair) -> Transaction {
                 pair_str.push(pair.close);
             }
 
-            len_inserted += pair_str.len();
+            len_inserted += pair_str.chars().count();
             (cursor, cursor, Some(pair_str))
         };
 
-        let next_range = get_next_range(doc, start_range, offs, pair.open, len_inserted);
+        let next_range = get_next_range(doc, start_range, offs, len_inserted);
         end_ranges.push(next_range);
         offs += len_inserted;
 
@@ -384,554 +368,6 @@ fn handle_same(doc: &Rope, selection: &Selection, pair: &Pair) -> Transaction {
     });
 
     let t = transaction.with_selection(Selection::new(end_ranges, selection.primary_index()));
-    debug!("auto pair transaction: {:#?}", t);
+    log::debug!("auto pair transaction: {:#?}", t);
     t
 }
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use smallvec::smallvec;
-
-    const LINE_END: &str = crate::DEFAULT_LINE_ENDING.as_str();
-
-    fn differing_pairs() -> impl Iterator<Item = &'static (char, char)> {
-        DEFAULT_PAIRS.iter().filter(|(open, close)| open != close)
-    }
-
-    fn matching_pairs() -> impl Iterator<Item = &'static (char, char)> {
-        DEFAULT_PAIRS.iter().filter(|(open, close)| open == close)
-    }
-
-    fn test_hooks(
-        in_doc: &Rope,
-        in_sel: &Selection,
-        ch: char,
-        pairs: &[(char, char)],
-        expected_doc: &Rope,
-        expected_sel: &Selection,
-    ) {
-        let pairs = AutoPairs::new(pairs.iter());
-        let trans = hook(in_doc, in_sel, ch, &pairs).unwrap();
-        let mut actual_doc = in_doc.clone();
-        assert!(trans.apply(&mut actual_doc));
-        assert_eq!(expected_doc, &actual_doc);
-        assert_eq!(expected_sel, trans.selection().unwrap());
-    }
-
-    fn test_hooks_with_pairs<I, F, R>(
-        in_doc: &Rope,
-        in_sel: &Selection,
-        test_pairs: I,
-        pairs: &[(char, char)],
-        get_expected_doc: F,
-        actual_sel: &Selection,
-    ) where
-        I: IntoIterator<Item = &'static (char, char)>,
-        F: Fn(char, char) -> R,
-        R: Into<Rope>,
-        Rope: From<R>,
-    {
-        test_pairs.into_iter().for_each(|(open, close)| {
-            test_hooks(
-                in_doc,
-                in_sel,
-                *open,
-                pairs,
-                &Rope::from(get_expected_doc(*open, *close)),
-                actual_sel,
-            )
-        });
-    }
-
-    // [] indicates range
-
-    /// [] -> insert ( -> ([])
-    #[test]
-    fn test_insert_blank() {
-        test_hooks_with_pairs(
-            &Rope::from(LINE_END),
-            &Selection::single(1, 0),
-            DEFAULT_PAIRS,
-            DEFAULT_PAIRS,
-            |open, close| format!("{}{}{}", open, close, LINE_END),
-            &Selection::single(2, 1),
-        );
-
-        let empty_doc = Rope::from(format!("{line_end}{line_end}", line_end = LINE_END));
-
-        test_hooks_with_pairs(
-            &empty_doc,
-            &Selection::single(empty_doc.len_chars(), LINE_END.len()),
-            DEFAULT_PAIRS,
-            DEFAULT_PAIRS,
-            |open, close| {
-                format!(
-                    "{line_end}{open}{close}{line_end}",
-                    open = open,
-                    close = close,
-                    line_end = LINE_END
-                )
-            },
-            &Selection::single(LINE_END.len() + 2, LINE_END.len() + 1),
-        );
-    }
-
-    #[test]
-    fn test_insert_before_multi_code_point_graphemes() {
-        for (_, close) in differing_pairs() {
-            test_hooks(
-                &Rope::from(format!("hello 👨‍👩‍👧‍👦 goodbye{}", LINE_END)),
-                &Selection::single(13, 6),
-                *close,
-                DEFAULT_PAIRS,
-                &Rope::from(format!("hello {}👨‍👩‍👧‍👦 goodbye{}", close, LINE_END)),
-                &Selection::single(14, 7),
-            );
-        }
-    }
-
-    #[test]
-    fn test_insert_at_end_of_document() {
-        test_hooks_with_pairs(
-            &Rope::from(LINE_END),
-            &Selection::single(LINE_END.len(), LINE_END.len()),
-            DEFAULT_PAIRS,
-            DEFAULT_PAIRS,
-            |open, close| format!("{}{}{}", LINE_END, open, close),
-            &Selection::single(LINE_END.len() + 1, LINE_END.len() + 1),
-        );
-
-        test_hooks_with_pairs(
-            &Rope::from(format!("foo{}", LINE_END)),
-            &Selection::single(3 + LINE_END.len(), 3 + LINE_END.len()),
-            DEFAULT_PAIRS,
-            DEFAULT_PAIRS,
-            |open, close| format!("foo{}{}{}", LINE_END, open, close),
-            &Selection::single(LINE_END.len() + 4, LINE_END.len() + 4),
-        );
-    }
-
-    /// [] -> append ( -> ([])
-    #[test]
-    fn test_append_blank() {
-        test_hooks_with_pairs(
-            // this is what happens when you have a totally blank document and then append
-            &Rope::from(format!("{line_end}{line_end}", line_end = LINE_END)),
-            // before inserting the pair, the cursor covers all of both empty lines
-            &Selection::single(0, LINE_END.len() * 2),
-            DEFAULT_PAIRS,
-            DEFAULT_PAIRS,
-            |open, close| {
-                format!(
-                    "{line_end}{open}{close}{line_end}",
-                    line_end = LINE_END,
-                    open = open,
-                    close = close
-                )
-            },
-            // after inserting pair, the cursor covers the first new line and the open char
-            &Selection::single(0, LINE_END.len() + 2),
-        );
-    }
-
-    /// []              ([])
-    /// [] -> insert -> ([])
-    /// []              ([])
-    #[test]
-    fn test_insert_blank_multi_cursor() {
-        test_hooks_with_pairs(
-            &Rope::from("\n\n\n"),
-            &Selection::new(
-                smallvec!(Range::new(1, 0), Range::new(2, 1), Range::new(3, 2),),
-                0,
-            ),
-            DEFAULT_PAIRS,
-            DEFAULT_PAIRS,
-            |open, close| {
-                format!(
-                    "{open}{close}\n{open}{close}\n{open}{close}\n",
-                    open = open,
-                    close = close
-                )
-            },
-            &Selection::new(
-                smallvec!(Range::new(2, 1), Range::new(5, 4), Range::new(8, 7),),
-                0,
-            ),
-        );
-    }
-
-    /// fo[o] -> append ( -> fo[o(])
-    #[test]
-    fn test_append() {
-        test_hooks_with_pairs(
-            &Rope::from("foo\n"),
-            &Selection::single(2, 4),
-            differing_pairs(),
-            DEFAULT_PAIRS,
-            |open, close| format!("foo{}{}\n", open, close),
-            &Selection::single(2, 5),
-        );
-    }
-
-    /// foo[] -> append to end of line ( -> foo([])
-    #[test]
-    fn test_append_single_cursor() {
-        test_hooks_with_pairs(
-            &Rope::from(format!("foo{}", LINE_END)),
-            &Selection::single(3, 3 + LINE_END.len()),
-            differing_pairs(),
-            DEFAULT_PAIRS,
-            |open, close| format!("foo{}{}{}", open, close, LINE_END),
-            &Selection::single(4, 5),
-        );
-    }
-
-    /// fo[o]                fo[o(])
-    /// fo[o] -> append ( -> fo[o(])
-    /// fo[o]                fo[o(])
-    #[test]
-    fn test_append_multi() {
-        test_hooks_with_pairs(
-            &Rope::from("foo\nfoo\nfoo\n"),
-            &Selection::new(
-                smallvec!(Range::new(2, 4), Range::new(6, 8), Range::new(10, 12)),
-                0,
-            ),
-            differing_pairs(),
-            DEFAULT_PAIRS,
-            |open, close| {
-                format!(
-                    "foo{open}{close}\nfoo{open}{close}\nfoo{open}{close}\n",
-                    open = open,
-                    close = close
-                )
-            },
-            &Selection::new(
-                smallvec!(Range::new(2, 5), Range::new(8, 11), Range::new(14, 17)),
-                0,
-            ),
-        );
-    }
-
-    /// ([)] -> insert ) -> ()[]
-    #[test]
-    fn test_insert_close_inside_pair() {
-        for (open, close) in DEFAULT_PAIRS {
-            let doc = Rope::from(format!("{}{}{}", open, close, LINE_END));
-
-            test_hooks(
-                &doc,
-                &Selection::single(2, 1),
-                *close,
-                DEFAULT_PAIRS,
-                &doc,
-                &Selection::single(2 + LINE_END.len(), 2),
-            );
-        }
-    }
-
-    /// [(]) -> append ) -> [()]
-    #[test]
-    fn test_append_close_inside_pair() {
-        for (open, close) in DEFAULT_PAIRS {
-            let doc = Rope::from(format!("{}{}{}", open, close, LINE_END));
-
-            test_hooks(
-                &doc,
-                &Selection::single(0, 2),
-                *close,
-                DEFAULT_PAIRS,
-                &doc,
-                &Selection::single(0, 2 + LINE_END.len()),
-            );
-        }
-    }
-
-    /// ([])                ()[]
-    /// ([]) -> insert ) -> ()[]
-    /// ([])                ()[]
-    #[test]
-    fn test_insert_close_inside_pair_multi_cursor() {
-        let sel = Selection::new(
-            smallvec!(Range::new(2, 1), Range::new(5, 4), Range::new(8, 7),),
-            0,
-        );
-
-        let expected_sel = Selection::new(
-            smallvec!(Range::new(3, 2), Range::new(6, 5), Range::new(9, 8),),
-            0,
-        );
-
-        for (open, close) in DEFAULT_PAIRS {
-            let doc = Rope::from(format!(
-                "{open}{close}\n{open}{close}\n{open}{close}\n",
-                open = open,
-                close = close
-            ));
-
-            test_hooks(&doc, &sel, *close, DEFAULT_PAIRS, &doc, &expected_sel);
-        }
-    }
-
-    /// [(])                [()]
-    /// [(]) -> append ) -> [()]
-    /// [(])                [()]
-    #[test]
-    fn test_append_close_inside_pair_multi_cursor() {
-        let sel = Selection::new(
-            smallvec!(Range::new(0, 2), Range::new(3, 5), Range::new(6, 8),),
-            0,
-        );
-
-        let expected_sel = Selection::new(
-            smallvec!(Range::new(0, 3), Range::new(3, 6), Range::new(6, 9),),
-            0,
-        );
-
-        for (open, close) in DEFAULT_PAIRS {
-            let doc = Rope::from(format!(
-                "{open}{close}\n{open}{close}\n{open}{close}\n",
-                open = open,
-                close = close
-            ));
-
-            test_hooks(&doc, &sel, *close, DEFAULT_PAIRS, &doc, &expected_sel);
-        }
-    }
-
-    /// ([]) -> insert ( -> (([]))
-    #[test]
-    fn test_insert_open_inside_pair() {
-        let sel = Selection::single(2, 1);
-        let expected_sel = Selection::single(3, 2);
-
-        for (open, close) in differing_pairs() {
-            let doc = Rope::from(format!("{}{}", open, close));
-            let expected_doc = Rope::from(format!(
-                "{open}{open}{close}{close}",
-                open = open,
-                close = close
-            ));
-
-            test_hooks(
-                &doc,
-                &sel,
-                *open,
-                DEFAULT_PAIRS,
-                &expected_doc,
-                &expected_sel,
-            );
-        }
-    }
-
-    /// [word(]) -> append ( -> [word((]))
-    #[test]
-    fn test_append_open_inside_pair() {
-        let sel = Selection::single(0, 6);
-        let expected_sel = Selection::single(0, 7);
-
-        for (open, close) in differing_pairs() {
-            let doc = Rope::from(format!("word{}{}", open, close));
-            let expected_doc = Rope::from(format!(
-                "word{open}{open}{close}{close}",
-                open = open,
-                close = close
-            ));
-
-            test_hooks(
-                &doc,
-                &sel,
-                *open,
-                DEFAULT_PAIRS,
-                &expected_doc,
-                &expected_sel,
-            );
-        }
-    }
-
-    /// ([]) -> insert " -> ("[]")
-    #[test]
-    fn test_insert_nested_open_inside_pair() {
-        let sel = Selection::single(2, 1);
-        let expected_sel = Selection::single(3, 2);
-
-        for (outer_open, outer_close) in differing_pairs() {
-            let doc = Rope::from(format!("{}{}", outer_open, outer_close,));
-
-            for (inner_open, inner_close) in matching_pairs() {
-                let expected_doc = Rope::from(format!(
-                    "{}{}{}{}",
-                    outer_open, inner_open, inner_close, outer_close
-                ));
-
-                test_hooks(
-                    &doc,
-                    &sel,
-                    *inner_open,
-                    DEFAULT_PAIRS,
-                    &expected_doc,
-                    &expected_sel,
-                );
-            }
-        }
-    }
-
-    /// [(]) -> append " -> [("]")
-    #[test]
-    fn test_append_nested_open_inside_pair() {
-        let sel = Selection::single(0, 2);
-        let expected_sel = Selection::single(0, 3);
-
-        for (outer_open, outer_close) in differing_pairs() {
-            let doc = Rope::from(format!("{}{}", outer_open, outer_close,));
-
-            for (inner_open, inner_close) in matching_pairs() {
-                let expected_doc = Rope::from(format!(
-                    "{}{}{}{}",
-                    outer_open, inner_open, inner_close, outer_close
-                ));
-
-                test_hooks(
-                    &doc,
-                    &sel,
-                    *inner_open,
-                    DEFAULT_PAIRS,
-                    &expected_doc,
-                    &expected_sel,
-                );
-            }
-        }
-    }
-
-    /// []word -> insert ( -> ([]word
-    #[test]
-    fn test_insert_open_before_non_pair() {
-        test_hooks_with_pairs(
-            &Rope::from("word"),
-            &Selection::single(1, 0),
-            DEFAULT_PAIRS,
-            DEFAULT_PAIRS,
-            |open, _| format!("{}word", open),
-            &Selection::single(2, 1),
-        )
-    }
-
-    /// [wor]d -> insert ( -> ([wor]d
-    #[test]
-    fn test_insert_open_with_selection() {
-        test_hooks_with_pairs(
-            &Rope::from("word"),
-            &Selection::single(3, 0),
-            DEFAULT_PAIRS,
-            DEFAULT_PAIRS,
-            |open, _| format!("{}word", open),
-            &Selection::single(4, 1),
-        )
-    }
-
-    /// [wor]d -> append ) -> [wor)]d
-    #[test]
-    fn test_append_close_inside_non_pair_with_selection() {
-        let sel = Selection::single(0, 4);
-        let expected_sel = Selection::single(0, 5);
-
-        for (_, close) in DEFAULT_PAIRS {
-            let doc = Rope::from("word");
-            let expected_doc = Rope::from(format!("wor{}d", close));
-            test_hooks(
-                &doc,
-                &sel,
-                *close,
-                DEFAULT_PAIRS,
-                &expected_doc,
-                &expected_sel,
-            );
-        }
-    }
-
-    /// foo[ wor]d -> insert ( -> foo([) wor]d
-    #[test]
-    fn test_insert_open_trailing_word_with_selection() {
-        test_hooks_with_pairs(
-            &Rope::from("foo word"),
-            &Selection::single(7, 3),
-            differing_pairs(),
-            DEFAULT_PAIRS,
-            |open, close| format!("foo{}{} word", open, close),
-            &Selection::single(9, 4),
-        )
-    }
-
-    /// foo([) wor]d -> insert ) -> foo()[ wor]d
-    #[test]
-    fn test_insert_close_inside_pair_trailing_word_with_selection() {
-        for (open, close) in differing_pairs() {
-            test_hooks(
-                &Rope::from(format!("foo{}{} word{}", open, close, LINE_END)),
-                &Selection::single(9, 4),
-                *close,
-                DEFAULT_PAIRS,
-                &Rope::from(format!("foo{}{} word{}", open, close, LINE_END)),
-                &Selection::single(9, 5),
-            )
-        }
-    }
-
-    /// we want pairs that are *not* the same char to be inserted after
-    /// a non-pair char, for cases like functions, but for pairs that are
-    /// the same char, we want to *not* insert a pair to handle cases like "I'm"
-    ///
-    /// word[]  -> insert ( -> word([])
-    /// word[]  -> insert ' -> word'[]
-    #[test]
-    fn test_insert_open_after_non_pair() {
-        let doc = Rope::from(format!("word{}", LINE_END));
-        let sel = Selection::single(5, 4);
-        let expected_sel = Selection::single(6, 5);
-
-        test_hooks_with_pairs(
-            &doc,
-            &sel,
-            differing_pairs(),
-            DEFAULT_PAIRS,
-            |open, close| format!("word{}{}{}", open, close, LINE_END),
-            &expected_sel,
-        );
-
-        test_hooks_with_pairs(
-            &doc,
-            &sel,
-            matching_pairs(),
-            DEFAULT_PAIRS,
-            |open, _| format!("word{}{}", open, LINE_END),
-            &expected_sel,
-        );
-    }
-
-    #[test]
-    fn test_configured_pairs() {
-        let test_pairs = &[('`', ':'), ('+', '-')];
-
-        test_hooks_with_pairs(
-            &Rope::from(LINE_END),
-            &Selection::single(1, 0),
-            test_pairs,
-            test_pairs,
-            |open, close| format!("{}{}{}", open, close, LINE_END),
-            &Selection::single(2, 1),
-        );
-
-        let doc = Rope::from(format!("foo`: word{}", LINE_END));
-
-        test_hooks(
-            &doc,
-            &Selection::single(9, 4),
-            ':',
-            test_pairs,
-            &doc,
-            &Selection::single(9, 5),
-        )
-    }
-}

helix-core/src/chars.rs

@@ -91,7 +91,10 @@ mod test {
 
     #[test]
     fn test_categorize() {
-        const EOL_TEST_CASE: &str = "\n\r\u{000B}\u{000C}\u{0085}\u{2028}\u{2029}";
+        #[cfg(not(feature = "unicode-lines"))]
+        const EOL_TEST_CASE: &str = "\n";
+        #[cfg(feature = "unicode-lines")]
+        const EOL_TEST_CASE: &str = "\n\u{000B}\u{000C}\u{0085}\u{2028}\u{2029}";
         const WORD_TEST_CASE: &str = "_hello_world_あいうえおー1234567890１２３４５６７８９０";
         const PUNCTUATION_TEST_CASE: &str =
             "!\"#$%&\'()*+,-./:;<=>?@[\\]^`{|}~！”＃＄％＆’（）＊＋、。：；＜＝＞？＠「」＾｀｛｜｝～";

helix-core/src/comment.rs

@@ -1,9 +1,12 @@
 //! This module contains the functionality toggle comments on lines over the selection
 //! using the comment character defined in the user's `languages.toml`
 
+use smallvec::SmallVec;
+
 use crate::{
-    find_first_non_whitespace_char, Change, Rope, RopeSlice, Selection, Tendril, Transaction,
+    syntax::BlockCommentToken, Change, Range, Rope, RopeSlice, Selection, Tendril, Transaction,
 };
+use helix_stdx::rope::RopeSliceExt;
 use std::borrow::Cow;
 
 /// Given text, a comment token, and a set of line indices, returns the following:
@@ -22,12 +25,12 @@ fn find_line_comment(
 ) -> (bool, Vec<usize>, usize, usize) {
     let mut commented = true;
     let mut to_change = Vec::new();
-    let mut min = usize::MAX; // minimum col for find_first_non_whitespace_char
+    let mut min = usize::MAX; // minimum col for first_non_whitespace_char
     let mut margin = 1;
     let token_len = token.chars().count();
     for line in lines {
         let line_slice = text.line(line);
-        if let Some(pos) = find_first_non_whitespace_char(line_slice) {
+        if let Some(pos) = line_slice.first_non_whitespace_char() {
             let len = line_slice.len_chars();
 
             if pos < min {
@@ -45,7 +48,7 @@ fn find_line_comment(
 
             // determine margin of 0 or 1 for uncommenting; if any comment token is not followed by a space,
             // a margin of 0 is used for all lines.
-            if matches!(line_slice.get_char(pos + token_len), Some(c) if c != ' ') {
+            if !matches!(line_slice.get_char(pos + token_len), Some(c) if c == ' ') {
                 margin = 0;
             }
 
@@ -68,11 +71,11 @@ pub fn toggle_line_comments(doc: &Rope, selection: &Selection, token: Option<&st
     let mut min_next_line = 0;
     for selection in selection {
         let (start, end) = selection.line_range(text);
-        let start = start.max(min_next_line).min(text.len_lines());
+        let start = start.clamp(min_next_line, text.len_lines());
         let end = (end + 1).min(text.len_lines());
 
         lines.extend(start..end);
-        min_next_line = end + 1;
+        min_next_line = end;
     }
 
     let (commented, to_change, min, margin) = find_line_comment(token, text, lines);
@@ -94,50 +97,320 @@ pub fn toggle_line_comments(doc: &Rope, selection: &Selection, token: Option<&st
     Transaction::change(doc, changes.into_iter())
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub enum CommentChange {
+    Commented {
+        range: Range,
+        start_pos: usize,
+        end_pos: usize,
+        start_margin: bool,
+        end_margin: bool,
+        start_token: String,
+        end_token: String,
+    },
+    Uncommented {
+        range: Range,
+        start_pos: usize,
+        end_pos: usize,
+        start_token: String,
+        end_token: String,
+    },
+    Whitespace {
+        range: Range,
+    },
+}
+
+pub fn find_block_comments(
+    tokens: &[BlockCommentToken],
+    text: RopeSlice,
+    selection: &Selection,
+) -> (bool, Vec<CommentChange>) {
+    let mut commented = true;
+    let mut only_whitespace = true;
+    let mut comment_changes = Vec::with_capacity(selection.len());
+    let default_tokens = tokens.first().cloned().unwrap_or_default();
+    // TODO: check if this can be removed on MSRV bump
+    #[allow(clippy::redundant_clone)]
+    let mut start_token = default_tokens.start.clone();
+    #[allow(clippy::redundant_clone)]
+    let mut end_token = default_tokens.end.clone();
+
+    let mut tokens = tokens.to_vec();
+    // sort the tokens by length, so longer tokens will match first
+    tokens.sort_by(|a, b| {
+        if a.start.len() == b.start.len() {
+            b.end.len().cmp(&a.end.len())
+        } else {
+            b.start.len().cmp(&a.start.len())
+        }
+    });
+    for range in selection {
+        let selection_slice = range.slice(text);
+        if let (Some(start_pos), Some(end_pos)) = (
+            selection_slice.first_non_whitespace_char(),
+            selection_slice.last_non_whitespace_char(),
+        ) {
+            let mut line_commented = false;
+            let mut after_start = 0;
+            let mut before_end = 0;
+            let len = (end_pos + 1) - start_pos;
+
+            for BlockCommentToken { start, end } in &tokens {
+                let start_len = start.chars().count();
+                let end_len = end.chars().count();
+                after_start = start_pos + start_len;
+                before_end = end_pos.saturating_sub(end_len);
+
+                if len >= start_len + end_len {
+                    let start_fragment = selection_slice.slice(start_pos..after_start);
+                    let end_fragment = selection_slice.slice(before_end + 1..end_pos + 1);
+
+                    // block commented with these tokens
+                    if start_fragment == start.as_str() && end_fragment == end.as_str() {
+                        start_token = start.to_string();
+                        end_token = end.to_string();
+                        line_commented = true;
+                        break;
+                    }
+                }
+            }
+
+            if !line_commented {
+                comment_changes.push(CommentChange::Uncommented {
+                    range: *range,
+                    start_pos,
+                    end_pos,
+                    start_token: default_tokens.start.clone(),
+                    end_token: default_tokens.end.clone(),
+                });
+                commented = false;
+            } else {
+                comment_changes.push(CommentChange::Commented {
+                    range: *range,
+                    start_pos,
+                    end_pos,
+                    start_margin: selection_slice
+                        .get_char(after_start)
+                        .map_or(false, |c| c == ' '),
+                    end_margin: after_start != before_end
+                        && selection_slice
+                            .get_char(before_end)
+                            .map_or(false, |c| c == ' '),
+                    start_token: start_token.to_string(),
+                    end_token: end_token.to_string(),
+                });
+            }
+            only_whitespace = false;
+        } else {
+            comment_changes.push(CommentChange::Whitespace { range: *range });
+        }
+    }
+    if only_whitespace {
+        commented = false;
+    }
+    (commented, comment_changes)
+}
+
+#[must_use]
+pub fn create_block_comment_transaction(
+    doc: &Rope,
+    selection: &Selection,
+    commented: bool,
+    comment_changes: Vec<CommentChange>,
+) -> (Transaction, SmallVec<[Range; 1]>) {
+    let mut changes: Vec<Change> = Vec::with_capacity(selection.len() * 2);
+    let mut ranges: SmallVec<[Range; 1]> = SmallVec::with_capacity(selection.len());
+    let mut offs = 0;
+    for change in comment_changes {
+        if commented {
+            if let CommentChange::Commented {
+                range,
+                start_pos,
+                end_pos,
+                start_token,
+                end_token,
+                start_margin,
+                end_margin,
+            } = change
+            {
+                let from = range.from();
+                changes.push((
+                    from + start_pos,
+                    from + start_pos + start_token.len() + start_margin as usize,
+                    None,
+                ));
+                changes.push((
+                    from + end_pos - end_token.len() - end_margin as usize + 1,
+                    from + end_pos + 1,
+                    None,
+                ));
+            }
+        } else {
+            // uncommented so manually map ranges through changes
+            match change {
+                CommentChange::Uncommented {
+                    range,
+                    start_pos,
+                    end_pos,
+                    start_token,
+                    end_token,
+                } => {
+                    let from = range.from();
+                    changes.push((
+                        from + start_pos,
+                        from + start_pos,
+                        Some(Tendril::from(format!("{} ", start_token))),
+                    ));
+                    changes.push((
+                        from + end_pos + 1,
+                        from + end_pos + 1,
+                        Some(Tendril::from(format!(" {}", end_token))),
+                    ));
+
+                    let offset = start_token.chars().count() + end_token.chars().count() + 2;
+                    ranges.push(
+                        Range::new(from + offs, from + offs + end_pos + 1 + offset)
+                            .with_direction(range.direction()),
+                    );
+                    offs += offset;
+                }
+                CommentChange::Commented { range, .. } | CommentChange::Whitespace { range } => {
+                    ranges.push(Range::new(range.from() + offs, range.to() + offs));
+                }
+            }
+        }
+    }
+    (Transaction::change(doc, changes.into_iter()), ranges)
+}
+
+#[must_use]
+pub fn toggle_block_comments(
+    doc: &Rope,
+    selection: &Selection,
+    tokens: &[BlockCommentToken],
+) -> Transaction {
+    let text = doc.slice(..);
+    let (commented, comment_changes) = find_block_comments(tokens, text, selection);
+    let (mut transaction, ranges) =
+        create_block_comment_transaction(doc, selection, commented, comment_changes);
+    if !commented {
+        transaction = transaction.with_selection(Selection::new(ranges, selection.primary_index()));
+    }
+    transaction
+}
+
+pub fn split_lines_of_selection(text: RopeSlice, selection: &Selection) -> Selection {
+    let mut ranges = SmallVec::new();
+    for range in selection.ranges() {
+        let (line_start, line_end) = range.line_range(text.slice(..));
+        let mut pos = text.line_to_char(line_start);
+        for line in text.slice(pos..text.line_to_char(line_end + 1)).lines() {
+            let start = pos;
+            pos += line.len_chars();
+            ranges.push(Range::new(start, pos));
+        }
+    }
+    Selection::new(ranges, 0)
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
 
     #[test]
     fn test_find_line_comment() {
-        use crate::State;
-
         // four lines, two space indented, except for line 1 which is blank.
-        let doc = Rope::from("  1\n\n  2\n  3");
-
-        let mut state = State::new(doc);
+        let mut doc = Rope::from("  1\n\n  2\n  3");
         // select whole document
-        state.selection = Selection::single(0, state.doc.len_chars() - 1);
+        let mut selection = Selection::single(0, doc.len_chars() - 1);
 
-        let text = state.doc.slice(..);
+        let text = doc.slice(..);
 
         let res = find_line_comment("//", text, 0..3);
-        // (commented = true, to_change = [line 0, line 2], min = col 2, margin = 1)
-        assert_eq!(res, (false, vec![0, 2], 2, 1));
+        // (commented = true, to_change = [line 0, line 2], min = col 2, margin = 0)
+        assert_eq!(res, (false, vec![0, 2], 2, 0));
 
         // comment
-        let transaction = toggle_line_comments(&state.doc, &state.selection, None);
-        transaction.apply(&mut state.doc);
-        state.selection = state.selection.map(transaction.changes());
+        let transaction = toggle_line_comments(&doc, &selection, None);
+        transaction.apply(&mut doc);
+        selection = selection.map(transaction.changes());
 
-        assert_eq!(state.doc, "  // 1\n\n  // 2\n  // 3");
+        assert_eq!(doc, "  // 1\n\n  // 2\n  // 3");
 
         // uncomment
-        let transaction = toggle_line_comments(&state.doc, &state.selection, None);
-        transaction.apply(&mut state.doc);
-        state.selection = state.selection.map(transaction.changes());
-        assert_eq!(state.doc, "  1\n\n  2\n  3");
+        let transaction = toggle_line_comments(&doc, &selection, None);
+        transaction.apply(&mut doc);
+        selection = selection.map(transaction.changes());
+        assert_eq!(doc, "  1\n\n  2\n  3");
+        assert!(selection.len() == 1); // to ignore the selection unused warning
 
         // 0 margin comments
-        state.doc = Rope::from("  //1\n\n  //2\n  //3");
+        doc = Rope::from("  //1\n\n  //2\n  //3");
         // reset the selection.
-        state.selection = Selection::single(0, state.doc.len_chars() - 1);
+        selection = Selection::single(0, doc.len_chars() - 1);
 
-        let transaction = toggle_line_comments(&state.doc, &state.selection, None);
-        transaction.apply(&mut state.doc);
-        state.selection = state.selection.map(transaction.changes());
-        assert_eq!(state.doc, "  1\n\n  2\n  3");
+        let transaction = toggle_line_comments(&doc, &selection, None);
+        transaction.apply(&mut doc);
+        selection = selection.map(transaction.changes());
+        assert_eq!(doc, "  1\n\n  2\n  3");
+        assert!(selection.len() == 1); // to ignore the selection unused warning
+
+        // 0 margin comments, with no space
+        doc = Rope::from("//");
+        // reset the selection.
+        selection = Selection::single(0, doc.len_chars() - 1);
+
+        let transaction = toggle_line_comments(&doc, &selection, None);
+        transaction.apply(&mut doc);
+        selection = selection.map(transaction.changes());
+        assert_eq!(doc, "");
+        assert!(selection.len() == 1); // to ignore the selection unused warning
 
         // TODO: account for uncommenting with uneven comment indentation
     }
+
+    #[test]
+    fn test_find_block_comments() {
+        // three lines 5 characters.
+        let mut doc = Rope::from("1\n2\n3");
+        // select whole document
+        let selection = Selection::single(0, doc.len_chars());
+
+        let text = doc.slice(..);
+
+        let res = find_block_comments(&[BlockCommentToken::default()], text, &selection);
+
+        assert_eq!(
+            res,
+            (
+                false,
+                vec![CommentChange::Uncommented {
+                    range: Range::new(0, 5),
+                    start_pos: 0,
+                    end_pos: 4,
+                    start_token: "/*".to_string(),
+                    end_token: "*/".to_string(),
+                }]
+            )
+        );
+
+        // comment
+        let transaction = toggle_block_comments(&doc, &selection, &[BlockCommentToken::default()]);
+        transaction.apply(&mut doc);
+
+        assert_eq!(doc, "/* 1\n2\n3 */");
+
+        // uncomment
+        let selection = Selection::single(0, doc.len_chars());
+        let transaction = toggle_block_comments(&doc, &selection, &[BlockCommentToken::default()]);
+        transaction.apply(&mut doc);
+        assert_eq!(doc, "1\n2\n3");
+
+        // don't panic when there is just a space in comment
+        doc = Rope::from("/* */");
+        let selection = Selection::single(0, doc.len_chars());
+        let transaction = toggle_block_comments(&doc, &selection, &[BlockCommentToken::default()]);
+        transaction.apply(&mut doc);
+        assert_eq!(doc, "");
+    }
 }

helix-core/src/config.rs

@@ -1,10 +1,45 @@
-/// Syntax configuration loader based on built-in languages.toml.
-pub fn default_syntax_loader() -> crate::syntax::Configuration {
-    helix_loader::default_lang_config()
+use crate::syntax::{Configuration, Loader, LoaderError};
+
+/// Language configuration based on built-in languages.toml.
+pub fn default_lang_config() -> Configuration {
+    helix_loader::config::default_lang_config()
         .try_into()
-        .expect("Could not serialize built-in languages.toml")
+        .expect("Could not deserialize built-in languages.toml")
 }
-/// Syntax configuration loader based on user configured languages.toml.
-pub fn user_syntax_loader() -> Result<crate::syntax::Configuration, toml::de::Error> {
-    helix_loader::user_lang_config()?.try_into()
+
+/// Language configuration loader based on built-in languages.toml.
+pub fn default_lang_loader() -> Loader {
+    Loader::new(default_lang_config()).expect("Could not compile loader for default config")
+}
+
+#[derive(Debug)]
+pub enum LanguageLoaderError {
+    DeserializeError(toml::de::Error),
+    LoaderError(LoaderError),
+}
+
+impl std::fmt::Display for LanguageLoaderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::DeserializeError(err) => write!(f, "Failed to parse language config: {err}"),
+            Self::LoaderError(err) => write!(f, "Failed to compile language config: {err}"),
+        }
+    }
+}
+
+impl std::error::Error for LanguageLoaderError {}
+
+/// Language configuration based on user configured languages.toml.
+pub fn user_lang_config() -> Result<Configuration, toml::de::Error> {
+    helix_loader::config::user_lang_config()?.try_into()
+}
+
+/// Language configuration loader based on user configured languages.toml.
+pub fn user_lang_loader() -> Result<Loader, LanguageLoaderError> {
+    let config: Configuration = helix_loader::config::user_lang_config()
+        .map_err(LanguageLoaderError::DeserializeError)?
+        .try_into()
+        .map_err(LanguageLoaderError::DeserializeError)?;
+
+    Loader::new(config).map_err(LanguageLoaderError::LoaderError)
 }

helix-core/src/diagnostic.rs

@@ -1,4 +1,6 @@
 //! LSP diagnostic utility types.
+use std::fmt;
+
 use serde::{Deserialize, Serialize};
 
 /// Describes the severity level of a [`Diagnostic`].
@@ -23,11 +25,49 @@ pub struct Range {
     pub end: usize,
 }
 
-/// Corresponds to [`lsp_types::Diagnostic`](https://docs.rs/lsp-types/0.91.0/lsp_types/struct.Diagnostic.html)
+#[derive(Debug, Eq, Hash, PartialEq, Clone, Deserialize, Serialize)]
+pub enum NumberOrString {
+    Number(i32),
+    String(String),
+}
+
+#[derive(Debug, Clone)]
+pub enum DiagnosticTag {
+    Unnecessary,
+    Deprecated,
+}
+
+/// Corresponds to [`lsp_types::Diagnostic`](https://docs.rs/lsp-types/0.94.0/lsp_types/struct.Diagnostic.html)
 #[derive(Debug, Clone)]
 pub struct Diagnostic {
     pub range: Range,
+    // whether this diagnostic ends at the end of(or inside) a word
+    pub ends_at_word: bool,
+    pub starts_at_word: bool,
+    pub zero_width: bool,
     pub line: usize,
     pub message: String,
     pub severity: Option<Severity>,
+    pub code: Option<NumberOrString>,
+    pub provider: DiagnosticProvider,
+    pub tags: Vec<DiagnosticTag>,
+    pub source: Option<String>,
+    pub data: Option<serde_json::Value>,
+}
+
+// TODO turn this into an enum + feature flag when lsp becomes optional
+pub type DiagnosticProvider = LanguageServerId;
+
+// while I would prefer having this in helix-lsp that necessitates a bunch of
+// conversions I would rather not add. I think its fine since this just a very
+// trivial newtype wrapper and we would need something similar once we define
+// completions in core
+slotmap::new_key_type! {
+    pub struct LanguageServerId;
+}
+
+impl fmt::Display for LanguageServerId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.0)
+    }
 }

helix-core/src/diff.rs

@@ -1,58 +1,194 @@
-use crate::{Rope, Transaction};
+use std::ops::Range;
+use std::time::Instant;
+
+use imara_diff::intern::InternedInput;
+use imara_diff::Algorithm;
+use ropey::RopeSlice;
+
+use crate::{ChangeSet, Rope, Tendril, Transaction};
+
+/// A `imara_diff::Sink` that builds a `ChangeSet` for a character diff of a hunk
+struct CharChangeSetBuilder<'a> {
+    res: &'a mut ChangeSet,
+    hunk: &'a InternedInput<char>,
+    pos: u32,
+}
+
+impl imara_diff::Sink for CharChangeSetBuilder<'_> {
+    type Out = ();
+    fn process_change(&mut self, before: Range<u32>, after: Range<u32>) {
+        self.res.retain((before.start - self.pos) as usize);
+        self.res.delete(before.len());
+        self.pos = before.end;
+
+        let res = self.hunk.after[after.start as usize..after.end as usize]
+            .iter()
+            .map(|&token| self.hunk.interner[token])
+            .collect();
+
+        self.res.insert(res);
+    }
+
+    fn finish(self) -> Self::Out {
+        self.res.retain(self.hunk.before.len() - self.pos as usize);
+    }
+}
+
+struct LineChangeSetBuilder<'a> {
+    res: ChangeSet,
+    after: RopeSlice<'a>,
+    file: &'a InternedInput<RopeSlice<'a>>,
+    current_hunk: InternedInput<char>,
+    pos: u32,
+}
+
+impl imara_diff::Sink for LineChangeSetBuilder<'_> {
+    type Out = ChangeSet;
+
+    fn process_change(&mut self, before: Range<u32>, after: Range<u32>) {
+        let len = self.file.before[self.pos as usize..before.start as usize]
+            .iter()
+            .map(|&it| self.file.interner[it].len_chars())
+            .sum();
+        self.res.retain(len);
+        self.pos = before.end;
+
+        // do not perform diffs on large hunks
+        let len_before = before.end - before.start;
+        let len_after = after.end - after.start;
+
+        // Pure insertions/removals do not require a character diff.
+        // Very large changes are ignored because their character diff is expensive to compute
+        // TODO adjust heuristic to detect large changes?
+        if len_before == 0
+            || len_after == 0
+            || len_after > 5 * len_before
+            || 5 * len_after < len_before && len_before > 10
+            || len_before + len_after > 200
+        {
+            let remove = self.file.before[before.start as usize..before.end as usize]
+                .iter()
+                .map(|&it| self.file.interner[it].len_chars())
+                .sum();
+            self.res.delete(remove);
+            let mut fragment = Tendril::new();
+            if len_after > 500 {
+                // copying a rope line by line is slower then copying the entire
+                // rope. Use to_string for very large changes instead..
+                if self.file.after.len() == after.end as usize {
+                    if after.start == 0 {
+                        fragment = self.after.to_string().into();
+                    } else {
+                        let start = self.after.line_to_char(after.start as usize);
+                        fragment = self.after.slice(start..).to_string().into();
+                    }
+                } else if after.start == 0 {
+                    let end = self.after.line_to_char(after.end as usize);
+                    fragment = self.after.slice(..end).to_string().into();
+                } else {
+                    let start = self.after.line_to_char(after.start as usize);
+                    let end = self.after.line_to_char(after.end as usize);
+                    fragment = self.after.slice(start..end).to_string().into();
+                }
+            } else {
+                for &line in &self.file.after[after.start as usize..after.end as usize] {
+                    for chunk in self.file.interner[line].chunks() {
+                        fragment.push_str(chunk)
+                    }
+                }
+            };
+            self.res.insert(fragment);
+        } else {
+            // for reasonably small hunks, generating a ChangeSet from char diff can save memory
+            // TODO use a tokenizer (word diff?) for improved performance
+            let hunk_before = self.file.before[before.start as usize..before.end as usize]
+                .iter()
+                .flat_map(|&it| self.file.interner[it].chars());
+            let hunk_after = self.file.after[after.start as usize..after.end as usize]
+                .iter()
+                .flat_map(|&it| self.file.interner[it].chars());
+            self.current_hunk.update_before(hunk_before);
+            self.current_hunk.update_after(hunk_after);
+
+            // the histogram heuristic does not work as well
+            // for characters because the same characters often reoccur
+            // use myer diff instead
+            imara_diff::diff(
+                Algorithm::Myers,
+                &self.current_hunk,
+                CharChangeSetBuilder {
+                    res: &mut self.res,
+                    hunk: &self.current_hunk,
+                    pos: 0,
+                },
+            );
+
+            self.current_hunk.clear();
+        }
+    }
+
+    fn finish(mut self) -> Self::Out {
+        let len = self.file.before[self.pos as usize..]
+            .iter()
+            .map(|&it| self.file.interner[it].len_chars())
+            .sum();
+
+        self.res.retain(len);
+        self.res
+    }
+}
+
+struct RopeLines<'a>(RopeSlice<'a>);
+
+impl<'a> imara_diff::intern::TokenSource for RopeLines<'a> {
+    type Token = RopeSlice<'a>;
+    type Tokenizer = ropey::iter::Lines<'a>;
+
+    fn tokenize(&self) -> Self::Tokenizer {
+        self.0.lines()
+    }
+
+    fn estimate_tokens(&self) -> u32 {
+        // we can provide a perfect estimate which is very nice for performance
+        self.0.len_lines() as u32
+    }
+}
 
 /// Compares `old` and `new` to generate a [`Transaction`] describing
 /// the steps required to get from `old` to `new`.
-pub fn compare_ropes(old: &Rope, new: &Rope) -> Transaction {
-    // `similar` only works on contiguous data, so a `Rope` has
-    // to be temporarily converted into a `String`.
-    let old_converted = old.to_string();
-    let new_converted = new.to_string();
+pub fn compare_ropes(before: &Rope, after: &Rope) -> Transaction {
+    let start = Instant::now();
+    let res = ChangeSet::with_capacity(32);
+    let after = after.slice(..);
+    let file = InternedInput::new(RopeLines(before.slice(..)), RopeLines(after));
+    let builder = LineChangeSetBuilder {
+        res,
+        file: &file,
+        after,
+        pos: 0,
+        current_hunk: InternedInput::default(),
+    };
 
-    // A timeout is set so after 1 seconds, the algorithm will start
-    // approximating. This is especially important for big `Rope`s or
-    // `Rope`s that are extremely dissimilar to each other.
-    let mut config = similar::TextDiff::configure();
-    config.timeout(std::time::Duration::from_secs(1));
+    let res = imara_diff::diff(Algorithm::Histogram, &file, builder).into();
 
-    let diff = config.diff_chars(&old_converted, &new_converted);
-
-    // The current position of the change needs to be tracked to
-    // construct the `Change`s.
-    let mut pos = 0;
-    Transaction::change(
-        old,
-        diff.ops()
-            .iter()
-            .map(|op| op.as_tag_tuple())
-            .filter_map(|(tag, old_range, new_range)| {
-                // `old_pos..pos` is equivalent to `start..end` for where
-                // the change should be applied.
-                let old_pos = pos;
-                pos += old_range.end - old_range.start;
-
-                match tag {
-                    // Semantically, inserts and replacements are the same thing.
-                    similar::DiffTag::Insert | similar::DiffTag::Replace => {
-                        // This is the text from the `new` rope that should be
-                        // inserted into `old`.
-                        let text: &str = {
-                            let start = new.char_to_byte(new_range.start);
-                            let end = new.char_to_byte(new_range.end);
-                            &new_converted[start..end]
-                        };
-                        Some((old_pos, pos, Some(text.into())))
-                    }
-                    similar::DiffTag::Delete => Some((old_pos, pos, None)),
-                    similar::DiffTag::Equal => None,
-                }
-            }),
-    )
+    log::debug!(
+        "rope diff took {}s",
+        Instant::now().duration_since(start).as_secs_f64()
+    );
+    res
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    fn test_identity(a: &str, b: &str) {
+        let mut old = Rope::from(a);
+        let new = Rope::from(b);
+        compare_ropes(&old, &new).apply(&mut old);
+        assert_eq!(old, new);
+    }
+
     quickcheck::quickcheck! {
         fn test_compare_ropes(a: String, b: String) -> bool {
             let mut old = Rope::from(a);
@@ -61,4 +197,25 @@ mod tests {
             old == new
         }
     }
+
+    #[test]
+    fn equal_files() {
+        test_identity("foo", "foo");
+    }
+
+    #[test]
+    fn trailing_newline() {
+        test_identity("foo\n", "foo");
+        test_identity("foo", "foo\n");
+    }
+
+    #[test]
+    fn new_file() {
+        test_identity("", "foo");
+    }
+
+    #[test]
+    fn deleted_file() {
+        test_identity("foo", "");
+    }
 }

helix-core/src/doc_formatter.rs

@@ -0,0 +1,384 @@
+//! The `DocumentFormatter` forms the bridge between the raw document text
+//! and onscreen positioning. It yields the text graphemes as an iterator
+//! and traverses (part) of the document text. During that traversal it
+//! handles grapheme detection, softwrapping and annotations.
+//! It yields `FormattedGrapheme`s and their corresponding visual coordinates.
+//!
+//! As both virtual text and softwrapping can insert additional lines into the document
+//! it is generally not possible to find the start of the previous visual line.
+//! Instead the `DocumentFormatter` starts at the last "checkpoint" (usually a linebreak)
+//! called a "block" and the caller must advance it as needed.
+
+use std::borrow::Cow;
+use std::fmt::Debug;
+use std::mem::{replace, take};
+
+#[cfg(test)]
+mod test;
+
+use unicode_segmentation::{Graphemes, UnicodeSegmentation};
+
+use crate::graphemes::{Grapheme, GraphemeStr};
+use crate::syntax::Highlight;
+use crate::text_annotations::TextAnnotations;
+use crate::{Position, RopeGraphemes, RopeSlice};
+
+/// TODO make Highlight a u32 to reduce the size of this enum to a single word.
+#[derive(Debug, Clone, Copy)]
+pub enum GraphemeSource {
+    Document {
+        codepoints: u32,
+    },
+    /// Inline virtual text can not be highlighted with a `Highlight` iterator
+    /// because it's not part of the document. Instead the `Highlight`
+    /// is emitted right by the document formatter
+    VirtualText {
+        highlight: Option<Highlight>,
+    },
+}
+
+#[derive(Debug, Clone)]
+pub struct FormattedGrapheme<'a> {
+    pub grapheme: Grapheme<'a>,
+    pub source: GraphemeSource,
+}
+
+impl<'a> FormattedGrapheme<'a> {
+    pub fn new(
+        g: GraphemeStr<'a>,
+        visual_x: usize,
+        tab_width: u16,
+        source: GraphemeSource,
+    ) -> FormattedGrapheme<'a> {
+        FormattedGrapheme {
+            grapheme: Grapheme::new(g, visual_x, tab_width),
+            source,
+        }
+    }
+    /// Returns whether this grapheme is virtual inline text
+    pub fn is_virtual(&self) -> bool {
+        matches!(self.source, GraphemeSource::VirtualText { .. })
+    }
+
+    pub fn placeholder() -> Self {
+        FormattedGrapheme {
+            grapheme: Grapheme::Other { g: " ".into() },
+            source: GraphemeSource::Document { codepoints: 0 },
+        }
+    }
+
+    pub fn doc_chars(&self) -> usize {
+        match self.source {
+            GraphemeSource::Document { codepoints } => codepoints as usize,
+            GraphemeSource::VirtualText { .. } => 0,
+        }
+    }
+
+    pub fn is_whitespace(&self) -> bool {
+        self.grapheme.is_whitespace()
+    }
+
+    pub fn width(&self) -> usize {
+        self.grapheme.width()
+    }
+
+    pub fn is_word_boundary(&self) -> bool {
+        self.grapheme.is_word_boundary()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct TextFormat {
+    pub soft_wrap: bool,
+    pub tab_width: u16,
+    pub max_wrap: u16,
+    pub max_indent_retain: u16,
+    pub wrap_indicator: Box<str>,
+    pub wrap_indicator_highlight: Option<Highlight>,
+    pub viewport_width: u16,
+}
+
+// test implementation is basically only used for testing or when softwrap is always disabled
+impl Default for TextFormat {
+    fn default() -> Self {
+        TextFormat {
+            soft_wrap: false,
+            tab_width: 4,
+            max_wrap: 3,
+            max_indent_retain: 4,
+            wrap_indicator: Box::from(" "),
+            viewport_width: 17,
+            wrap_indicator_highlight: None,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct DocumentFormatter<'t> {
+    text_fmt: &'t TextFormat,
+    annotations: &'t TextAnnotations<'t>,
+
+    /// The visual position at the end of the last yielded word boundary
+    visual_pos: Position,
+    graphemes: RopeGraphemes<'t>,
+    /// The character pos of the `graphemes` iter used for inserting annotations
+    char_pos: usize,
+    /// The line pos of the `graphemes` iter used for inserting annotations
+    line_pos: usize,
+    exhausted: bool,
+
+    /// Line breaks to be reserved for virtual text
+    /// at the next line break
+    virtual_lines: usize,
+    inline_anntoation_graphemes: Option<(Graphemes<'t>, Option<Highlight>)>,
+
+    // softwrap specific
+    /// The indentation of the current line
+    /// Is set to `None` if the indentation level is not yet known
+    /// because no non-whitespace graphemes have been encountered yet
+    indent_level: Option<usize>,
+    /// In case a long word needs to be split a single grapheme might need to be wrapped
+    /// while the rest of the word stays on the same line
+    peeked_grapheme: Option<(FormattedGrapheme<'t>, usize)>,
+    /// A first-in first-out (fifo) buffer for the Graphemes of any given word
+    word_buf: Vec<FormattedGrapheme<'t>>,
+    /// The index of the next grapheme that will be yielded from the `word_buf`
+    word_i: usize,
+}
+
+impl<'t> DocumentFormatter<'t> {
+    /// Creates a new formatter at the last block before `char_idx`.
+    /// A block is a chunk which always ends with a linebreak.
+    /// This is usually just a normal line break.
+    /// However very long lines are always wrapped at constant intervals that can be cheaply calculated
+    /// to avoid pathological behaviour.
+    pub fn new_at_prev_checkpoint(
+        text: RopeSlice<'t>,
+        text_fmt: &'t TextFormat,
+        annotations: &'t TextAnnotations,
+        char_idx: usize,
+    ) -> (Self, usize) {
+        // TODO divide long lines into blocks to avoid bad performance for long lines
+        let block_line_idx = text.char_to_line(char_idx.min(text.len_chars()));
+        let block_char_idx = text.line_to_char(block_line_idx);
+        annotations.reset_pos(block_char_idx);
+        (
+            DocumentFormatter {
+                text_fmt,
+                annotations,
+                visual_pos: Position { row: 0, col: 0 },
+                graphemes: RopeGraphemes::new(text.slice(block_char_idx..)),
+                char_pos: block_char_idx,
+                exhausted: false,
+                virtual_lines: 0,
+                indent_level: None,
+                peeked_grapheme: None,
+                word_buf: Vec::with_capacity(64),
+                word_i: 0,
+                line_pos: block_line_idx,
+                inline_anntoation_graphemes: None,
+            },
+            block_char_idx,
+        )
+    }
+
+    fn next_inline_annotation_grapheme(&mut self) -> Option<(&'t str, Option<Highlight>)> {
+        loop {
+            if let Some(&mut (ref mut annotation, highlight)) =
+                self.inline_anntoation_graphemes.as_mut()
+            {
+                if let Some(grapheme) = annotation.next() {
+                    return Some((grapheme, highlight));
+                }
+            }
+
+            if let Some((annotation, highlight)) =
+                self.annotations.next_inline_annotation_at(self.char_pos)
+            {
+                self.inline_anntoation_graphemes = Some((
+                    UnicodeSegmentation::graphemes(&*annotation.text, true),
+                    highlight,
+                ))
+            } else {
+                return None;
+            }
+        }
+    }
+
+    fn advance_grapheme(&mut self, col: usize) -> Option<FormattedGrapheme<'t>> {
+        let (grapheme, source) =
+            if let Some((grapheme, highlight)) = self.next_inline_annotation_grapheme() {
+                (grapheme.into(), GraphemeSource::VirtualText { highlight })
+            } else if let Some(grapheme) = self.graphemes.next() {
+                self.virtual_lines += self.annotations.annotation_lines_at(self.char_pos);
+                let codepoints = grapheme.len_chars() as u32;
+
+                let overlay = self.annotations.overlay_at(self.char_pos);
+                let grapheme = match overlay {
+                    Some((overlay, _)) => overlay.grapheme.as_str().into(),
+                    None => Cow::from(grapheme).into(),
+                };
+
+                self.char_pos += codepoints as usize;
+                (grapheme, GraphemeSource::Document { codepoints })
+            } else {
+                if self.exhausted {
+                    return None;
+                }
+                self.exhausted = true;
+                // EOF grapheme is required for rendering
+                // and correct position computations
+                return Some(FormattedGrapheme {
+                    grapheme: Grapheme::Other { g: " ".into() },
+                    source: GraphemeSource::Document { codepoints: 0 },
+                });
+            };
+
+        let grapheme = FormattedGrapheme::new(grapheme, col, self.text_fmt.tab_width, source);
+
+        Some(grapheme)
+    }
+
+    /// Move a word to the next visual line
+    fn wrap_word(&mut self, virtual_lines_before_word: usize) -> usize {
+        // softwrap this word to the next line
+        let indent_carry_over = if let Some(indent) = self.indent_level {
+            if indent as u16 <= self.text_fmt.max_indent_retain {
+                indent as u16
+            } else {
+                0
+            }
+        } else {
+            // ensure the indent stays 0
+            self.indent_level = Some(0);
+            0
+        };
+
+        self.visual_pos.col = indent_carry_over as usize;
+        self.virtual_lines -= virtual_lines_before_word;
+        self.visual_pos.row += 1 + virtual_lines_before_word;
+        let mut i = 0;
+        let mut word_width = 0;
+        let wrap_indicator = UnicodeSegmentation::graphemes(&*self.text_fmt.wrap_indicator, true)
+            .map(|g| {
+                i += 1;
+                let grapheme = FormattedGrapheme::new(
+                    g.into(),
+                    self.visual_pos.col + word_width,
+                    self.text_fmt.tab_width,
+                    GraphemeSource::VirtualText {
+                        highlight: self.text_fmt.wrap_indicator_highlight,
+                    },
+                );
+                word_width += grapheme.width();
+                grapheme
+            });
+        self.word_buf.splice(0..0, wrap_indicator);
+
+        for grapheme in &mut self.word_buf[i..] {
+            let visual_x = self.visual_pos.col + word_width;
+            grapheme
+                .grapheme
+                .change_position(visual_x, self.text_fmt.tab_width);
+            word_width += grapheme.width();
+        }
+        word_width
+    }
+
+    fn advance_to_next_word(&mut self) {
+        self.word_buf.clear();
+        let mut word_width = 0;
+        let virtual_lines_before_word = self.virtual_lines;
+        let mut virtual_lines_before_grapheme = self.virtual_lines;
+
+        loop {
+            // softwrap word if necessary
+            if word_width + self.visual_pos.col >= self.text_fmt.viewport_width as usize {
+                // wrapping this word would move too much text to the next line
+                // split the word at the line end instead
+                if word_width > self.text_fmt.max_wrap as usize {
+                    // Usually we stop accomulating graphemes as soon as softwrapping becomes necessary.
+                    // However if the last grapheme is multiple columns wide it might extend beyond the EOL.
+                    // The condition below ensures that this grapheme is not cutoff and instead wrapped to the next line
+                    if word_width + self.visual_pos.col > self.text_fmt.viewport_width as usize {
+                        self.peeked_grapheme = self.word_buf.pop().map(|grapheme| {
+                            (grapheme, self.virtual_lines - virtual_lines_before_grapheme)
+                        });
+                        self.virtual_lines = virtual_lines_before_grapheme;
+                    }
+                    return;
+                }
+
+                word_width = self.wrap_word(virtual_lines_before_word);
+            }
+
+            virtual_lines_before_grapheme = self.virtual_lines;
+
+            let grapheme = if let Some((grapheme, virtual_lines)) = self.peeked_grapheme.take() {
+                self.virtual_lines += virtual_lines;
+                grapheme
+            } else if let Some(grapheme) = self.advance_grapheme(self.visual_pos.col + word_width) {
+                grapheme
+            } else {
+                return;
+            };
+
+            // Track indentation
+            if !grapheme.is_whitespace() && self.indent_level.is_none() {
+                self.indent_level = Some(self.visual_pos.col);
+            } else if grapheme.grapheme == Grapheme::Newline {
+                self.indent_level = None;
+            }
+
+            let is_word_boundary = grapheme.is_word_boundary();
+            word_width += grapheme.width();
+            self.word_buf.push(grapheme);
+
+            if is_word_boundary {
+                return;
+            }
+        }
+    }
+
+    /// returns the document line pos of the **next** grapheme that will be yielded
+    pub fn line_pos(&self) -> usize {
+        self.line_pos
+    }
+
+    /// returns the visual pos of the **next** grapheme that will be yielded
+    pub fn visual_pos(&self) -> Position {
+        self.visual_pos
+    }
+}
+
+impl<'t> Iterator for DocumentFormatter<'t> {
+    type Item = (FormattedGrapheme<'t>, Position);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let grapheme = if self.text_fmt.soft_wrap {
+            if self.word_i >= self.word_buf.len() {
+                self.advance_to_next_word();
+                self.word_i = 0;
+            }
+            let grapheme = replace(
+                self.word_buf.get_mut(self.word_i)?,
+                FormattedGrapheme::placeholder(),
+            );
+            self.word_i += 1;
+            grapheme
+        } else {
+            self.advance_grapheme(self.visual_pos.col)?
+        };
+
+        let pos = self.visual_pos;
+        if grapheme.grapheme == Grapheme::Newline {
+            self.visual_pos.row += 1;
+            self.visual_pos.row += take(&mut self.virtual_lines);
+            self.visual_pos.col = 0;
+            self.line_pos += 1;
+        } else {
+            self.visual_pos.col += grapheme.width();
+        }
+        Some((grapheme, pos))
+    }
+}

helix-core/src/doc_formatter/test.rs

@@ -0,0 +1,189 @@
+use crate::doc_formatter::{DocumentFormatter, TextFormat};
+use crate::text_annotations::{InlineAnnotation, Overlay, TextAnnotations};
+
+impl TextFormat {
+    fn new_test(softwrap: bool) -> Self {
+        TextFormat {
+            soft_wrap: softwrap,
+            tab_width: 2,
+            max_wrap: 3,
+            max_indent_retain: 4,
+            wrap_indicator: ".".into(),
+            wrap_indicator_highlight: None,
+            // use a prime number to allow lining up too often with repeat
+            viewport_width: 17,
+        }
+    }
+}
+
+impl<'t> DocumentFormatter<'t> {
+    fn collect_to_str(&mut self) -> String {
+        use std::fmt::Write;
+        let mut res = String::new();
+        let viewport_width = self.text_fmt.viewport_width;
+        let mut line = 0;
+
+        for (grapheme, pos) in self {
+            if pos.row != line {
+                line += 1;
+                assert_eq!(pos.row, line);
+                write!(res, "\n{}", ".".repeat(pos.col)).unwrap();
+                assert!(
+                    pos.col <= viewport_width as usize,
+                    "softwrapped failed {}<={viewport_width}",
+                    pos.col
+                );
+            }
+            write!(res, "{}", grapheme.grapheme).unwrap();
+        }
+
+        res
+    }
+}
+
+fn softwrap_text(text: &str) -> String {
+    DocumentFormatter::new_at_prev_checkpoint(
+        text.into(),
+        &TextFormat::new_test(true),
+        &TextAnnotations::default(),
+        0,
+    )
+    .0
+    .collect_to_str()
+}
+
+#[test]
+fn basic_softwrap() {
+    assert_eq!(
+        softwrap_text(&"foo ".repeat(10)),
+        "foo foo foo foo \n.foo foo foo foo \n.foo foo  "
+    );
+    assert_eq!(
+        softwrap_text(&"fooo ".repeat(10)),
+        "fooo fooo fooo \n.fooo fooo fooo \n.fooo fooo fooo \n.fooo  "
+    );
+
+    // check that we don't wrap unnecessarily
+    assert_eq!(softwrap_text("\t\txxxx1xxxx2xx\n"), "    xxxx1xxxx2xx \n ");
+}
+
+#[test]
+fn softwrap_indentation() {
+    assert_eq!(
+        softwrap_text("\t\tfoo1 foo2 foo3 foo4 foo5 foo6\n"),
+        "    foo1 foo2 \n.....foo3 foo4 \n.....foo5 foo6 \n "
+    );
+    assert_eq!(
+        softwrap_text("\t\t\tfoo1 foo2 foo3 foo4 foo5 foo6\n"),
+        "      foo1 foo2 \n.foo3 foo4 foo5 \n.foo6 \n "
+    );
+}
+
+#[test]
+fn long_word_softwrap() {
+    assert_eq!(
+        softwrap_text("\t\txxxx1xxxx2xxxx3xxxx4xxxx5xxxx6xxxx7xxxx8xxxx9xxx\n"),
+        "    xxxx1xxxx2xxx\n.....x3xxxx4xxxx5\n.....xxxx6xxxx7xx\n.....xx8xxxx9xxx \n "
+    );
+    assert_eq!(
+        softwrap_text("xxxxxxxx1xxxx2xxx\n"),
+        "xxxxxxxx1xxxx2xxx\n. \n "
+    );
+    assert_eq!(
+        softwrap_text("\t\txxxx1xxxx 2xxxx3xxxx4xxxx5xxxx6xxxx7xxxx8xxxx9xxx\n"),
+        "    xxxx1xxxx \n.....2xxxx3xxxx4x\n.....xxx5xxxx6xxx\n.....x7xxxx8xxxx9\n.....xxx \n "
+    );
+    assert_eq!(
+        softwrap_text("\t\txxxx1xxx 2xxxx3xxxx4xxxx5xxxx6xxxx7xxxx8xxxx9xxx\n"),
+        "    xxxx1xxx 2xxx\n.....x3xxxx4xxxx5\n.....xxxx6xxxx7xx\n.....xx8xxxx9xxx \n "
+    );
+}
+
+fn overlay_text(text: &str, char_pos: usize, softwrap: bool, overlays: &[Overlay]) -> String {
+    DocumentFormatter::new_at_prev_checkpoint(
+        text.into(),
+        &TextFormat::new_test(softwrap),
+        TextAnnotations::default().add_overlay(overlays, None),
+        char_pos,
+    )
+    .0
+    .collect_to_str()
+}
+
+#[test]
+fn overlay() {
+    assert_eq!(
+        overlay_text(
+            "foobar",
+            0,
+            false,
+            &[Overlay::new(0, "X"), Overlay::new(2, "\t")],
+        ),
+        "Xo  bar "
+    );
+    assert_eq!(
+        overlay_text(
+            &"foo ".repeat(10),
+            0,
+            true,
+            &[
+                Overlay::new(2, "\t"),
+                Overlay::new(5, "\t"),
+                Overlay::new(16, "X"),
+            ]
+        ),
+        "fo   f  o foo \n.foo Xoo foo foo \n.foo foo foo  "
+    );
+}
+
+fn annotate_text(text: &str, softwrap: bool, annotations: &[InlineAnnotation]) -> String {
+    DocumentFormatter::new_at_prev_checkpoint(
+        text.into(),
+        &TextFormat::new_test(softwrap),
+        TextAnnotations::default().add_inline_annotations(annotations, None),
+        0,
+    )
+    .0
+    .collect_to_str()
+}
+
+#[test]
+fn annotation() {
+    assert_eq!(
+        annotate_text("bar", false, &[InlineAnnotation::new(0, "foo")]),
+        "foobar "
+    );
+    assert_eq!(
+        annotate_text(
+            &"foo ".repeat(10),
+            true,
+            &[InlineAnnotation::new(0, "foo ")]
+        ),
+        "foo foo foo foo \n.foo foo foo foo \n.foo foo foo  "
+    );
+}
+
+#[test]
+fn annotation_and_overlay() {
+    let annotations = [InlineAnnotation {
+        char_idx: 0,
+        text: "fooo".into(),
+    }];
+    let overlay = [Overlay {
+        char_idx: 0,
+        grapheme: "\t".into(),
+    }];
+    assert_eq!(
+        DocumentFormatter::new_at_prev_checkpoint(
+            "bbar".into(),
+            &TextFormat::new_test(false),
+            TextAnnotations::default()
+                .add_inline_annotations(annotations.as_slice(), None)
+                .add_overlay(overlay.as_slice(), None),
+            0,
+        )
+        .0
+        .collect_to_str(),
+        "fooo  bar "
+    );
+}

helix-core/src/fuzzy.rs

@@ -0,0 +1,43 @@
+use std::ops::DerefMut;
+
+use nucleo::pattern::{Atom, AtomKind, CaseMatching};
+use nucleo::Config;
+use parking_lot::Mutex;
+
+pub struct LazyMutex<T> {
+    inner: Mutex<Option<T>>,
+    init: fn() -> T,
+}
+
+impl<T> LazyMutex<T> {
+    pub const fn new(init: fn() -> T) -> Self {
+        Self {
+            inner: Mutex::new(None),
+            init,
+        }
+    }
+
+    pub fn lock(&self) -> impl DerefMut<Target = T> + '_ {
+        parking_lot::MutexGuard::map(self.inner.lock(), |val| val.get_or_insert_with(self.init))
+    }
+}
+
+pub static MATCHER: LazyMutex<nucleo::Matcher> = LazyMutex::new(nucleo::Matcher::default);
+
+/// convenience function to easily fuzzy match
+/// on a (relatively small list of inputs). This is not recommended for building a full tui
+/// application that can match large numbers of matches as all matching is done on the current
+/// thread, effectively blocking the UI
+pub fn fuzzy_match<T: AsRef<str>>(
+    pattern: &str,
+    items: impl IntoIterator<Item = T>,
+    path: bool,
+) -> Vec<(T, u16)> {
+    let mut matcher = MATCHER.lock();
+    matcher.config = Config::DEFAULT;
+    if path {
+        matcher.config.set_match_paths();
+    }
+    let pattern = Atom::new(pattern, CaseMatching::Smart, AtomKind::Fuzzy, false);
+    pattern.match_list(items, &mut matcher)
+}

helix-core/src/graphemes.rs

@@ -5,7 +5,88 @@ use ropey::{iter::Chunks, str_utils::byte_to_char_idx, RopeSlice};
 use unicode_segmentation::{GraphemeCursor, GraphemeIncomplete};
 use unicode_width::UnicodeWidthStr;
 
-use std::fmt;
+use std::borrow::Cow;
+use std::fmt::{self, Debug, Display};
+use std::marker::PhantomData;
+use std::ops::Deref;
+use std::ptr::NonNull;
+use std::{slice, str};
+
+use crate::chars::{char_is_whitespace, char_is_word};
+use crate::LineEnding;
+
+#[inline]
+pub fn tab_width_at(visual_x: usize, tab_width: u16) -> usize {
+    tab_width as usize - (visual_x % tab_width as usize)
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Grapheme<'a> {
+    Newline,
+    Tab { width: usize },
+    Other { g: GraphemeStr<'a> },
+}
+
+impl<'a> Grapheme<'a> {
+    pub fn new(g: GraphemeStr<'a>, visual_x: usize, tab_width: u16) -> Grapheme<'a> {
+        match g {
+            g if g == "\t" => Grapheme::Tab {
+                width: tab_width_at(visual_x, tab_width),
+            },
+            _ if LineEnding::from_str(&g).is_some() => Grapheme::Newline,
+            _ => Grapheme::Other { g },
+        }
+    }
+
+    pub fn change_position(&mut self, visual_x: usize, tab_width: u16) {
+        if let Grapheme::Tab { width } = self {
+            *width = tab_width_at(visual_x, tab_width)
+        }
+    }
+
+    /// Returns the a visual width of this grapheme,
+    #[inline]
+    pub fn width(&self) -> usize {
+        match *self {
+            // width is not cached because we are dealing with
+            // ASCII almost all the time which already has a fastpath
+            // it's okay to convert to u16 here because no codepoint has a width larger
+            // than 2 and graphemes are usually atmost two visible codepoints wide
+            Grapheme::Other { ref g } => grapheme_width(g),
+            Grapheme::Tab { width } => width,
+            Grapheme::Newline => 1,
+        }
+    }
+
+    pub fn is_whitespace(&self) -> bool {
+        !matches!(&self, Grapheme::Other { g } if !g.chars().all(char_is_whitespace))
+    }
+
+    // TODO currently word boundaries are used for softwrapping.
+    // This works best for programming languages and well for prose.
+    // This could however be improved in the future by considering unicode
+    // character classes but
+    pub fn is_word_boundary(&self) -> bool {
+        !matches!(&self, Grapheme::Other { g,.. } if g.chars().all(char_is_word))
+    }
+}
+
+impl Display for Grapheme<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Grapheme::Newline => write!(f, " "),
+            Grapheme::Tab { width } => {
+                for _ in 0..width {
+                    write!(f, " ")?;
+                }
+                Ok(())
+            }
+            Grapheme::Other { ref g } => {
+                write!(f, "{g}")
+            }
+        }
+    }
+}
 
 #[must_use]
 pub fn grapheme_width(g: &str) -> usize {
@@ -14,7 +95,7 @@ pub fn grapheme_width(g: &str) -> usize {
         // Point 1: theoretically, ascii control characters should have zero
         // width, but in our case we actually want them to have width: if they
         // show up in text, we want to treat them as textual elements that can
-        // be editied.  So we can get away with making all ascii single width
+        // be edited.  So we can get away with making all ascii single width
         // here.
         // Point 2: we're only examining the first codepoint here, which means
         // we're ignoring graphemes formed with combining characters.  However,
@@ -27,6 +108,8 @@ pub fn grapheme_width(g: &str) -> usize {
         // We use max(1) here because all grapeheme clusters--even illformed
         // ones--should have at least some width so they can be edited
         // properly.
+        // TODO properly handle unicode width for all codepoints
+        // example of where unicode width is currently wrong: 🤦🏼‍♂️ (taken from https://hsivonen.fi/string-length/)
         UnicodeWidthStr::width(g).max(1)
     }
 }
@@ -195,23 +278,6 @@ pub fn ensure_grapheme_boundary_prev(slice: RopeSlice, char_idx: usize) -> usize
     }
 }
 
-/// Returns the passed byte index if it's already a grapheme boundary,
-/// or the next grapheme boundary byte index if not.
-#[must_use]
-#[inline]
-pub fn ensure_grapheme_boundary_next_byte(slice: RopeSlice, byte_idx: usize) -> usize {
-    if byte_idx == 0 {
-        byte_idx
-    } else {
-        // TODO: optimize so we're not constructing grapheme cursor twice
-        if is_grapheme_boundary_byte(slice, byte_idx) {
-            byte_idx
-        } else {
-            next_grapheme_boundary_byte(slice, byte_idx)
-        }
-    }
-}
-
 /// Returns whether the given char position is a grapheme boundary.
 #[must_use]
 pub fn is_grapheme_boundary(slice: RopeSlice, char_idx: usize) -> bool {
@@ -333,10 +399,7 @@ impl<'a> Iterator for RopeGraphemes<'a> {
         }
 
         if a < self.cur_chunk_start {
-            let a_char = self.text.byte_to_char(a);
-            let b_char = self.text.byte_to_char(b);
-
-            Some(self.text.slice(a_char..b_char))
+            Some(self.text.byte_slice(a..b))
         } else {
             let a2 = a - self.cur_chunk_start;
             let b2 = b - self.cur_chunk_start;
@@ -344,3 +407,180 @@ impl<'a> Iterator for RopeGraphemes<'a> {
         }
     }
 }
+
+/// An iterator over the graphemes of a `RopeSlice` in reverse.
+#[derive(Clone)]
+pub struct RevRopeGraphemes<'a> {
+    text: RopeSlice<'a>,
+    chunks: Chunks<'a>,
+    cur_chunk: &'a str,
+    cur_chunk_start: usize,
+    cursor: GraphemeCursor,
+}
+
+impl<'a> fmt::Debug for RevRopeGraphemes<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("RevRopeGraphemes")
+            .field("text", &self.text)
+            .field("chunks", &self.chunks)
+            .field("cur_chunk", &self.cur_chunk)
+            .field("cur_chunk_start", &self.cur_chunk_start)
+            // .field("cursor", &self.cursor)
+            .finish()
+    }
+}
+
+impl<'a> RevRopeGraphemes<'a> {
+    #[must_use]
+    pub fn new(slice: RopeSlice) -> RevRopeGraphemes {
+        let (mut chunks, mut cur_chunk_start, _, _) = slice.chunks_at_byte(slice.len_bytes());
+        chunks.reverse();
+        let first_chunk = chunks.next().unwrap_or("");
+        cur_chunk_start -= first_chunk.len();
+        RevRopeGraphemes {
+            text: slice,
+            chunks,
+            cur_chunk: first_chunk,
+            cur_chunk_start,
+            cursor: GraphemeCursor::new(slice.len_bytes(), slice.len_bytes(), true),
+        }
+    }
+}
+
+impl<'a> Iterator for RevRopeGraphemes<'a> {
+    type Item = RopeSlice<'a>;
+
+    fn next(&mut self) -> Option<RopeSlice<'a>> {
+        let a = self.cursor.cur_cursor();
+        let b;
+        loop {
+            match self
+                .cursor
+                .prev_boundary(self.cur_chunk, self.cur_chunk_start)
+            {
+                Ok(None) => {
+                    return None;
+                }
+                Ok(Some(n)) => {
+                    b = n;
+                    break;
+                }
+                Err(GraphemeIncomplete::PrevChunk) => {
+                    self.cur_chunk = self.chunks.next().unwrap_or("");
+                    self.cur_chunk_start -= self.cur_chunk.len();
+                }
+                Err(GraphemeIncomplete::PreContext(idx)) => {
+                    let (chunk, byte_idx, _, _) = self.text.chunk_at_byte(idx.saturating_sub(1));
+                    self.cursor.provide_context(chunk, byte_idx);
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        if a >= self.cur_chunk_start + self.cur_chunk.len() {
+            Some(self.text.byte_slice(b..a))
+        } else {
+            let a2 = a - self.cur_chunk_start;
+            let b2 = b - self.cur_chunk_start;
+            Some((&self.cur_chunk[b2..a2]).into())
+        }
+    }
+}
+
+/// A highly compressed Cow<'a, str> that holds
+/// atmost u31::MAX bytes and is readonly
+pub struct GraphemeStr<'a> {
+    ptr: NonNull<u8>,
+    len: u32,
+    phantom: PhantomData<&'a str>,
+}
+
+impl GraphemeStr<'_> {
+    const MASK_OWNED: u32 = 1 << 31;
+
+    fn compute_len(&self) -> usize {
+        (self.len & !Self::MASK_OWNED) as usize
+    }
+}
+
+impl Deref for GraphemeStr<'_> {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        unsafe {
+            let bytes = slice::from_raw_parts(self.ptr.as_ptr(), self.compute_len());
+            str::from_utf8_unchecked(bytes)
+        }
+    }
+}
+
+impl Drop for GraphemeStr<'_> {
+    fn drop(&mut self) {
+        if self.len & Self::MASK_OWNED != 0 {
+            // free allocation
+            unsafe {
+                drop(Box::from_raw(slice::from_raw_parts_mut(
+                    self.ptr.as_ptr(),
+                    self.compute_len(),
+                )));
+            }
+        }
+    }
+}
+
+impl<'a> From<&'a str> for GraphemeStr<'a> {
+    fn from(g: &'a str) -> Self {
+        GraphemeStr {
+            ptr: unsafe { NonNull::new_unchecked(g.as_bytes().as_ptr() as *mut u8) },
+            len: i32::try_from(g.len()).unwrap() as u32,
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<'a> From<String> for GraphemeStr<'a> {
+    fn from(g: String) -> Self {
+        let len = g.len();
+        let ptr = Box::into_raw(g.into_bytes().into_boxed_slice()) as *mut u8;
+        GraphemeStr {
+            ptr: unsafe { NonNull::new_unchecked(ptr) },
+            len: (i32::try_from(len).unwrap() as u32) | Self::MASK_OWNED,
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<'a> From<Cow<'a, str>> for GraphemeStr<'a> {
+    fn from(g: Cow<'a, str>) -> Self {
+        match g {
+            Cow::Borrowed(g) => g.into(),
+            Cow::Owned(g) => g.into(),
+        }
+    }
+}
+
+impl<T: Deref<Target = str>> PartialEq<T> for GraphemeStr<'_> {
+    fn eq(&self, other: &T) -> bool {
+        self.deref() == other.deref()
+    }
+}
+impl PartialEq<str> for GraphemeStr<'_> {
+    fn eq(&self, other: &str) -> bool {
+        self.deref() == other
+    }
+}
+impl Eq for GraphemeStr<'_> {}
+impl Debug for GraphemeStr<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Debug::fmt(self.deref(), f)
+    }
+}
+impl Display for GraphemeStr<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Display::fmt(self.deref(), f)
+    }
+}
+impl Clone for GraphemeStr<'_> {
+    fn clone(&self) -> Self {
+        self.deref().to_owned().into()
+    }
+}

helix-core/src/history.rs

@@ -1,9 +1,15 @@
-use crate::{Assoc, ChangeSet, Range, Rope, State, Transaction};
+use crate::{Assoc, ChangeSet, Range, Rope, Selection, Transaction};
 use once_cell::sync::Lazy;
 use regex::Regex;
 use std::num::NonZeroUsize;
 use std::time::{Duration, Instant};
 
+#[derive(Debug, Clone)]
+pub struct State {
+    pub doc: Rope,
+    pub selection: Selection,
+}
+
 /// Stores the history of changes to a buffer.
 ///
 /// Currently the history is represented as a vector of revisions. The vector
@@ -22,10 +28,10 @@ use std::time::{Duration, Instant};
 ///
 /// The current revision is the one currently displayed in the buffer.
 ///
-/// Commiting a new revision to the history will update the last child of the
+/// Committing a new revision to the history will update the last child of the
 /// current revision, and push a new revision to the end of the vector.
 ///
-/// Revisions are commited with a timestamp. :earlier and :later can be used
+/// Revisions are committed with a timestamp. :earlier and :later can be used
 /// to jump to the closest revision to a moment in time relative to the timestamp
 /// of the current revision plus (:later) or minus (:earlier) the duration
 /// given to the command. If a single integer is given, the editor will instead
@@ -33,7 +39,7 @@ use std::time::{Duration, Instant};
 ///
 /// Limitations:
 ///  * Changes in selections currently don't commit history changes. The selection
-///    will only be updated to the state after a commited buffer change.
+///    will only be updated to the state after a committed buffer change.
 ///  * The vector of history revisions is currently unbounded. This might
 ///    cause the memory consumption to grow significantly large during long
 ///    editing sessions.
@@ -48,7 +54,7 @@ pub struct History {
 }
 
 /// A single point in history. See [History] for more information.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 struct Revision {
     parent: usize,
     last_child: Option<NonZeroUsize>,
@@ -66,8 +72,8 @@ impl Default for History {
             revisions: vec![Revision {
                 parent: 0,
                 last_child: None,
-                transaction: Transaction::from(ChangeSet::new(&Rope::new())),
-                inversion: Transaction::from(ChangeSet::new(&Rope::new())),
+                transaction: Transaction::from(ChangeSet::new("".into())),
+                inversion: Transaction::from(ChangeSet::new("".into())),
                 timestamp: Instant::now(),
             }],
             current: 0,
@@ -113,6 +119,21 @@ impl History {
         self.current == 0
     }
 
+    /// Returns the changes since the given revision composed into a transaction.
+    /// Returns None if there are no changes between the current and given revisions.
+    pub fn changes_since(&self, revision: usize) -> Option<Transaction> {
+        let lca = self.lowest_common_ancestor(revision, self.current);
+        let up = self.path_up(revision, lca);
+        let down = self.path_up(self.current, lca);
+        let up_txns = up
+            .iter()
+            .rev()
+            .map(|&n| self.revisions[n].inversion.clone());
+        let down_txns = down.iter().map(|&n| self.revisions[n].transaction.clone());
+
+        down_txns.chain(up_txns).reduce(|acc, tx| tx.compose(acc))
+    }
+
     /// Undo the last edit.
     pub fn undo(&mut self) -> Option<&Transaction> {
         if self.at_root() {
@@ -177,7 +198,7 @@ impl History {
         }
     }
 
-    /// List of nodes on the way from `n` to 'a`. Doesn`t include `a`.
+    /// List of nodes on the way from `n` to 'a`. Doesn't include `a`.
     /// Includes `n` unless `a == n`. `a` must be an ancestor of `n`.
     fn path_up(&self, mut n: usize, a: usize) -> Vec<usize> {
         let mut path = Vec::new();
@@ -282,13 +303,13 @@ impl History {
 }
 
 /// Whether to undo by a number of edits or a duration of time.
-#[derive(Debug, PartialEq, Clone, Copy)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum UndoKind {
     Steps(usize),
     TimePeriod(std::time::Duration),
 }
 
-/// A subset of sytemd.time time span syntax units.
+/// A subset of systemd.time time span syntax units.
 const TIME_UNITS: &[(&[&str], &str, u64)] = &[
     (&["seconds", "second", "sec", "s"], "seconds", 1),
     (&["minutes", "minute", "min", "m"], "minutes", 60),
@@ -366,12 +387,16 @@ impl std::str::FromStr for UndoKind {
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::Selection;
 
     #[test]
     fn test_undo_redo() {
         let mut history = History::default();
         let doc = Rope::from("hello");
-        let mut state = State::new(doc);
+        let mut state = State {
+            doc,
+            selection: Selection::point(0),
+        };
 
         let transaction1 =
             Transaction::change(&state.doc, vec![(5, 5, Some(" world!".into()))].into_iter());
@@ -420,7 +445,10 @@ mod test {
     fn test_earlier_later() {
         let mut history = History::default();
         let doc = Rope::from("a\n");
-        let mut state = State::new(doc);
+        let mut state = State {
+            doc,
+            selection: Selection::point(0),
+        };
 
         fn undo(history: &mut History, state: &mut State) {
             if let Some(transaction) = history.undo() {
@@ -546,8 +574,8 @@ mod test {
 
         // Units are validated.
         assert_eq!(
-            "1 millenium".parse::<UndoKind>(),
-            Err("incorrect time unit: millenium".to_string())
+            "1 millennium".parse::<UndoKind>(),
+            Err("incorrect time unit: millennium".to_string())
         );
 
         // Units can't be specified twice.

helix-core/src/increment/date_time.rs

@@ -1,113 +1,54 @@
-use chrono::{Datelike, Duration, NaiveDate, NaiveDateTime, NaiveTime, Timelike};
+use chrono::{Duration, NaiveDate, NaiveDateTime, NaiveTime};
 use once_cell::sync::Lazy;
 use regex::Regex;
-use ropey::RopeSlice;
+use std::fmt::Write;
 
-use std::borrow::Cow;
-use std::cmp;
-
-use super::Increment;
-use crate::{Range, Tendril};
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct DateTimeIncrementor {
-    date_time: NaiveDateTime,
-    range: Range,
-    fmt: &'static str,
-    field: DateField,
-}
-
-impl DateTimeIncrementor {
-    pub fn from_range(text: RopeSlice, range: Range) -> Option<DateTimeIncrementor> {
-        let range = if range.is_empty() {
-            if range.anchor < text.len_chars() {
-                // Treat empty range as a cursor range.
-                range.put_cursor(text, range.anchor + 1, true)
-            } else {
-                // The range is empty and at the end of the text.
-                return None;
-            }
-        } else {
-            range
-        };
-
-        FORMATS.iter().find_map(|format| {
-            let from = range.from().saturating_sub(format.max_len);
-            let to = (range.from() + format.max_len).min(text.len_chars());
-
-            let (from_in_text, to_in_text) = (range.from() - from, range.to() - from);
-            let text: Cow<str> = text.slice(from..to).into();
-
-            let captures = format.regex.captures(&text)?;
-            if captures.len() - 1 != format.fields.len() {
-                return None;
-            }
-
-            let date_time = captures.get(0)?;
-            let offset = range.from() - from_in_text;
-            let range = Range::new(date_time.start() + offset, date_time.end() + offset);
-
-            let field = captures
-                .iter()
-                .skip(1)
-                .enumerate()
-                .find_map(|(i, capture)| {
-                    let capture = capture?;
-                    let capture_range = capture.range();
-
-                    if capture_range.contains(&from_in_text)
-                        && capture_range.contains(&(to_in_text - 1))
-                    {
-                        Some(format.fields[i])
-                    } else {
-                        None
-                    }
-                })?;
-
-            let has_date = format.fields.iter().any(|f| f.unit.is_date());
-            let has_time = format.fields.iter().any(|f| f.unit.is_time());
-
-            let date_time = &text[date_time.start()..date_time.end()];
-            let date_time = match (has_date, has_time) {
-                (true, true) => NaiveDateTime::parse_from_str(date_time, format.fmt).ok()?,
-                (true, false) => {
-                    let date = NaiveDate::parse_from_str(date_time, format.fmt).ok()?;
-
-                    date.and_hms(0, 0, 0)
-                }
-                (false, true) => {
-                    let time = NaiveTime::parse_from_str(date_time, format.fmt).ok()?;
-
-                    NaiveDate::from_ymd(0, 1, 1).and_time(time)
-                }
-                (false, false) => return None,
-            };
-
-            Some(DateTimeIncrementor {
-                date_time,
-                range,
-                fmt: format.fmt,
-                field,
-            })
-        })
+/// Increment a Date or DateTime
+///
+/// If just a Date is selected the day will be incremented.
+/// If a DateTime is selected the second will be incremented.
+pub fn increment(selected_text: &str, amount: i64) -> Option<String> {
+    if selected_text.is_empty() {
+        return None;
     }
-}
 
-impl Increment for DateTimeIncrementor {
-    fn increment(&self, amount: i64) -> (Range, Tendril) {
-        let date_time = match self.field.unit {
-            DateUnit::Years => add_years(self.date_time, amount),
-            DateUnit::Months => add_months(self.date_time, amount),
-            DateUnit::Days => add_duration(self.date_time, Duration::days(amount)),
-            DateUnit::Hours => add_duration(self.date_time, Duration::hours(amount)),
-            DateUnit::Minutes => add_duration(self.date_time, Duration::minutes(amount)),
-            DateUnit::Seconds => add_duration(self.date_time, Duration::seconds(amount)),
-            DateUnit::AmPm => toggle_am_pm(self.date_time),
+    FORMATS.iter().find_map(|format| {
+        let captures = format.regex.captures(selected_text)?;
+        if captures.len() - 1 != format.fields.len() {
+            return None;
         }
-        .unwrap_or(self.date_time);
 
-        (self.range, date_time.format(self.fmt).to_string().into())
-    }
+        let date_time = captures.get(0)?;
+        let has_date = format.fields.iter().any(|f| f.unit.is_date());
+        let has_time = format.fields.iter().any(|f| f.unit.is_time());
+        let date_time = &selected_text[date_time.start()..date_time.end()];
+        match (has_date, has_time) {
+            (true, true) => {
+                let date_time = NaiveDateTime::parse_from_str(date_time, format.fmt).ok()?;
+                Some(
+                    date_time
+                        .checked_add_signed(Duration::try_minutes(amount)?)?
+                        .format(format.fmt)
+                        .to_string(),
+                )
+            }
+            (true, false) => {
+                let date = NaiveDate::parse_from_str(date_time, format.fmt).ok()?;
+                Some(
+                    date.checked_add_signed(Duration::try_days(amount)?)?
+                        .format(format.fmt)
+                        .to_string(),
+                )
+            }
+            (false, true) => {
+                let time = NaiveTime::parse_from_str(date_time, format.fmt).ok()?;
+                let (adjusted_time, _) =
+                    time.overflowing_add_signed(Duration::try_minutes(amount)?);
+                Some(adjusted_time.format(format.fmt).to_string())
+            }
+            (false, false) => None,
+        }
+    })
 }
 
 static FORMATS: Lazy<Vec<Format>> = Lazy::new(|| {
@@ -143,7 +84,7 @@ impl Format {
     fn new(fmt: &'static str) -> Self {
         let mut remaining = fmt;
         let mut fields = Vec::new();
-        let mut regex = String::new();
+        let mut regex = "^".to_string();
         let mut max_len = 0;
 
         while let Some(i) = remaining.find('%') {
@@ -162,9 +103,10 @@ impl Format {
             fields.push(field);
             max_len += field.max_len + remaining[..i].len();
             regex += &remaining[..i];
-            regex += &format!("({})", field.regex);
+            write!(regex, "({})", field.regex).unwrap();
             remaining = &after[spec_len..];
         }
+        regex += "$";
 
         let regex = Regex::new(&regex).unwrap();
 
@@ -304,155 +246,47 @@ impl DateUnit {
     }
 }
 
-fn ndays_in_month(year: i32, month: u32) -> u32 {
-    // The first day of the next month...
-    let (y, m) = if month == 12 {
-        (year + 1, 1)
-    } else {
-        (year, month + 1)
-    };
-    let d = NaiveDate::from_ymd(y, m, 1);
-
-    // ...is preceded by the last day of the original month.
-    d.pred().day()
-}
-
-fn add_months(date_time: NaiveDateTime, amount: i64) -> Option<NaiveDateTime> {
-    let month = (date_time.month0() as i64).checked_add(amount)?;
-    let year = date_time.year() + i32::try_from(month / 12).ok()?;
-    let year = if month.is_negative() { year - 1 } else { year };
-
-    // Normalize month
-    let month = month % 12;
-    let month = if month.is_negative() {
-        month + 12
-    } else {
-        month
-    } as u32
-        + 1;
-
-    let day = cmp::min(date_time.day(), ndays_in_month(year, month));
-
-    Some(NaiveDate::from_ymd(year, month, day).and_time(date_time.time()))
-}
-
-fn add_years(date_time: NaiveDateTime, amount: i64) -> Option<NaiveDateTime> {
-    let year = i32::try_from((date_time.year() as i64).checked_add(amount)?).ok()?;
-    let ndays = ndays_in_month(year, date_time.month());
-
-    if date_time.day() > ndays {
-        let d = NaiveDate::from_ymd(year, date_time.month(), ndays);
-        Some(d.succ().and_time(date_time.time()))
-    } else {
-        date_time.with_year(year)
-    }
-}
-
-fn add_duration(date_time: NaiveDateTime, duration: Duration) -> Option<NaiveDateTime> {
-    date_time.checked_add_signed(duration)
-}
-
-fn toggle_am_pm(date_time: NaiveDateTime) -> Option<NaiveDateTime> {
-    if date_time.hour() < 12 {
-        add_duration(date_time, Duration::hours(12))
-    } else {
-        add_duration(date_time, Duration::hours(-12))
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::Rope;
 
     #[test]
     fn test_increment_date_times() {
         let tests = [
             // (original, cursor, amount, expected)
-            ("2020-02-28", 0, 1, "2021-02-28"),
-            ("2020-02-29", 0, 1, "2021-03-01"),
-            ("2020-01-31", 5, 1, "2020-02-29"),
-            ("2020-01-20", 5, 1, "2020-02-20"),
-            ("2021-01-01", 5, -1, "2020-12-01"),
-            ("2021-01-31", 5, -2, "2020-11-30"),
-            ("2020-02-28", 8, 1, "2020-02-29"),
-            ("2021-02-28", 8, 1, "2021-03-01"),
-            ("2021-02-28", 0, -1, "2020-02-28"),
-            ("2021-03-01", 0, -1, "2020-03-01"),
-            ("2020-02-29", 5, -1, "2020-01-29"),
-            ("2020-02-20", 5, -1, "2020-01-20"),
-            ("2020-02-29", 8, -1, "2020-02-28"),
-            ("2021-03-01", 8, -1, "2021-02-28"),
-            ("1980/12/21", 8, 100, "1981/03/31"),
-            ("1980/12/21", 8, -100, "1980/09/12"),
-            ("1980/12/21", 8, 1000, "1983/09/17"),
-            ("1980/12/21", 8, -1000, "1978/03/27"),
-            ("2021-11-24 07:12:23", 0, 1, "2022-11-24 07:12:23"),
-            ("2021-11-24 07:12:23", 5, 1, "2021-12-24 07:12:23"),
-            ("2021-11-24 07:12:23", 8, 1, "2021-11-25 07:12:23"),
-            ("2021-11-24 07:12:23", 11, 1, "2021-11-24 08:12:23"),
-            ("2021-11-24 07:12:23", 14, 1, "2021-11-24 07:13:23"),
-            ("2021-11-24 07:12:23", 17, 1, "2021-11-24 07:12:24"),
-            ("2021/11/24 07:12:23", 0, 1, "2022/11/24 07:12:23"),
-            ("2021/11/24 07:12:23", 5, 1, "2021/12/24 07:12:23"),
-            ("2021/11/24 07:12:23", 8, 1, "2021/11/25 07:12:23"),
-            ("2021/11/24 07:12:23", 11, 1, "2021/11/24 08:12:23"),
-            ("2021/11/24 07:12:23", 14, 1, "2021/11/24 07:13:23"),
-            ("2021/11/24 07:12:23", 17, 1, "2021/11/24 07:12:24"),
-            ("2021-11-24 07:12", 0, 1, "2022-11-24 07:12"),
-            ("2021-11-24 07:12", 5, 1, "2021-12-24 07:12"),
-            ("2021-11-24 07:12", 8, 1, "2021-11-25 07:12"),
-            ("2021-11-24 07:12", 11, 1, "2021-11-24 08:12"),
-            ("2021-11-24 07:12", 14, 1, "2021-11-24 07:13"),
-            ("2021/11/24 07:12", 0, 1, "2022/11/24 07:12"),
-            ("2021/11/24 07:12", 5, 1, "2021/12/24 07:12"),
-            ("2021/11/24 07:12", 8, 1, "2021/11/25 07:12"),
-            ("2021/11/24 07:12", 11, 1, "2021/11/24 08:12"),
-            ("2021/11/24 07:12", 14, 1, "2021/11/24 07:13"),
-            ("Wed Nov 24 2021", 0, 1, "Thu Nov 25 2021"),
-            ("Wed Nov 24 2021", 4, 1, "Fri Dec 24 2021"),
-            ("Wed Nov 24 2021", 8, 1, "Thu Nov 25 2021"),
-            ("Wed Nov 24 2021", 11, 1, "Thu Nov 24 2022"),
-            ("24-Nov-2021", 0, 1, "25-Nov-2021"),
-            ("24-Nov-2021", 3, 1, "24-Dec-2021"),
-            ("24-Nov-2021", 7, 1, "24-Nov-2022"),
-            ("2021 Nov 24", 0, 1, "2022 Nov 24"),
-            ("2021 Nov 24", 5, 1, "2021 Dec 24"),
-            ("2021 Nov 24", 9, 1, "2021 Nov 25"),
-            ("Nov 24, 2021", 0, 1, "Dec 24, 2021"),
-            ("Nov 24, 2021", 4, 1, "Nov 25, 2021"),
-            ("Nov 24, 2021", 8, 1, "Nov 24, 2022"),
-            ("7:21:53 am", 0, 1, "8:21:53 am"),
-            ("7:21:53 am", 3, 1, "7:22:53 am"),
-            ("7:21:53 am", 5, 1, "7:21:54 am"),
-            ("7:21:53 am", 8, 1, "7:21:53 pm"),
-            ("7:21:53 AM", 0, 1, "8:21:53 AM"),
-            ("7:21:53 AM", 3, 1, "7:22:53 AM"),
-            ("7:21:53 AM", 5, 1, "7:21:54 AM"),
-            ("7:21:53 AM", 8, 1, "7:21:53 PM"),
-            ("7:21 am", 0, 1, "8:21 am"),
-            ("7:21 am", 3, 1, "7:22 am"),
-            ("7:21 am", 5, 1, "7:21 pm"),
-            ("7:21 AM", 0, 1, "8:21 AM"),
-            ("7:21 AM", 3, 1, "7:22 AM"),
-            ("7:21 AM", 5, 1, "7:21 PM"),
-            ("23:24:23", 1, 1, "00:24:23"),
-            ("23:24:23", 3, 1, "23:25:23"),
-            ("23:24:23", 6, 1, "23:24:24"),
-            ("23:24", 1, 1, "00:24"),
-            ("23:24", 3, 1, "23:25"),
+            ("2020-02-28", 1, "2020-02-29"),
+            ("2020-02-29", 1, "2020-03-01"),
+            ("2020-01-31", 1, "2020-02-01"),
+            ("2020-01-20", 1, "2020-01-21"),
+            ("2021-01-01", -1, "2020-12-31"),
+            ("2021-01-31", -2, "2021-01-29"),
+            ("2020-02-28", 1, "2020-02-29"),
+            ("2021-02-28", 1, "2021-03-01"),
+            ("2021-03-01", -1, "2021-02-28"),
+            ("2020-02-29", -1, "2020-02-28"),
+            ("2020-02-20", -1, "2020-02-19"),
+            ("2021-03-01", -1, "2021-02-28"),
+            ("1980/12/21", 100, "1981/03/31"),
+            ("1980/12/21", -100, "1980/09/12"),
+            ("1980/12/21", 1000, "1983/09/17"),
+            ("1980/12/21", -1000, "1978/03/27"),
+            ("2021-11-24 07:12:23", 1, "2021-11-24 07:13:23"),
+            ("2021-11-24 07:12", 1, "2021-11-24 07:13"),
+            ("Wed Nov 24 2021", 1, "Thu Nov 25 2021"),
+            ("24-Nov-2021", 1, "25-Nov-2021"),
+            ("2021 Nov 24", 1, "2021 Nov 25"),
+            ("Nov 24, 2021", 1, "Nov 25, 2021"),
+            ("7:21:53 am", 1, "7:22:53 am"),
+            ("7:21:53 AM", 1, "7:22:53 AM"),
+            ("7:21 am", 1, "7:22 am"),
+            ("23:24:23", 1, "23:25:23"),
+            ("23:24", 1, "23:25"),
+            ("23:59", 1, "00:00"),
+            ("23:59:59", 1, "00:00:59"),
         ];
 
-        for (original, cursor, amount, expected) in tests {
-            let rope = Rope::from_str(original);
-            let range = Range::new(cursor, cursor + 1);
-            assert_eq!(
-                DateTimeIncrementor::from_range(rope.slice(..), range)
-                    .unwrap()
-                    .increment(amount)
-                    .1,
-                Tendril::from(expected)
-            );
+        for (original, amount, expected) in tests {
+            assert_eq!(increment(original, amount).unwrap(), expected);
         }
     }
 
@@ -481,10 +315,7 @@ mod test {
         ];
 
         for invalid in tests {
-            let rope = Rope::from_str(invalid);
-            let range = Range::new(0, 1);
-
-            assert_eq!(DateTimeIncrementor::from_range(rope.slice(..), range), None)
+            assert_eq!(increment(invalid, 1), None)
         }
     }
 }

helix-core/src/increment/integer.rs

@@ -0,0 +1,235 @@
+const SEPARATOR: char = '_';
+
+/// Increment an integer.
+///
+/// Supported bases:
+///     2 with prefix 0b
+///     8 with prefix 0o
+///     10 with no prefix
+///     16 with prefix 0x
+///
+/// An integer can contain `_` as a separator but may not start or end with a separator.
+/// Base 10 integers can go negative, but bases 2, 8, and 16 cannot.
+/// All addition and subtraction is saturating.
+pub fn increment(selected_text: &str, amount: i64) -> Option<String> {
+    if selected_text.is_empty()
+        || selected_text.ends_with(SEPARATOR)
+        || selected_text.starts_with(SEPARATOR)
+    {
+        return None;
+    }
+
+    let radix = if selected_text.starts_with("0x") {
+        16
+    } else if selected_text.starts_with("0o") {
+        8
+    } else if selected_text.starts_with("0b") {
+        2
+    } else {
+        10
+    };
+
+    // Get separator indexes from right to left.
+    let separator_rtl_indexes: Vec<usize> = selected_text
+        .chars()
+        .rev()
+        .enumerate()
+        .filter_map(|(i, c)| if c == SEPARATOR { Some(i) } else { None })
+        .collect();
+
+    let word: String = selected_text.chars().filter(|&c| c != SEPARATOR).collect();
+
+    let mut new_text = if radix == 10 {
+        let number = &word;
+        let value = i128::from_str_radix(number, radix).ok()?;
+        let new_value = value.saturating_add(amount as i128);
+
+        let format_length = match (value.is_negative(), new_value.is_negative()) {
+            (true, false) => number.len() - 1,
+            (false, true) => number.len() + 1,
+            _ => number.len(),
+        } - separator_rtl_indexes.len();
+
+        if number.starts_with('0') || number.starts_with("-0") {
+            format!("{:01$}", new_value, format_length)
+        } else {
+            format!("{}", new_value)
+        }
+    } else {
+        let number = &word[2..];
+        let value = u128::from_str_radix(number, radix).ok()?;
+        let new_value = (value as i128).saturating_add(amount as i128);
+        let new_value = if new_value < 0 { 0 } else { new_value };
+        let format_length = selected_text.len() - 2 - separator_rtl_indexes.len();
+
+        match radix {
+            2 => format!("0b{:01$b}", new_value, format_length),
+            8 => format!("0o{:01$o}", new_value, format_length),
+            16 => {
+                let (lower_count, upper_count): (usize, usize) =
+                    number.chars().fold((0, 0), |(lower, upper), c| {
+                        (
+                            lower + c.is_ascii_lowercase() as usize,
+                            upper + c.is_ascii_uppercase() as usize,
+                        )
+                    });
+                if upper_count > lower_count {
+                    format!("0x{:01$X}", new_value, format_length)
+                } else {
+                    format!("0x{:01$x}", new_value, format_length)
+                }
+            }
+            _ => unimplemented!("radix not supported: {}", radix),
+        }
+    };
+
+    // Add separators from original number.
+    for &rtl_index in &separator_rtl_indexes {
+        if rtl_index < new_text.len() {
+            let new_index = new_text.len().saturating_sub(rtl_index);
+            if new_index > 0 {
+                new_text.insert(new_index, SEPARATOR);
+            }
+        }
+    }
+
+    // Add in additional separators if necessary.
+    if new_text.len() > selected_text.len() && !separator_rtl_indexes.is_empty() {
+        let spacing = match separator_rtl_indexes.as_slice() {
+            [.., b, a] => a - b - 1,
+            _ => separator_rtl_indexes[0],
+        };
+
+        let prefix_length = if radix == 10 { 0 } else { 2 };
+        if let Some(mut index) = new_text.find(SEPARATOR) {
+            while index - prefix_length > spacing {
+                index -= spacing;
+                new_text.insert(index, SEPARATOR);
+            }
+        }
+    }
+
+    Some(new_text)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_increment_basic_decimal_numbers() {
+        let tests = [
+            ("100", 1, "101"),
+            ("100", -1, "99"),
+            ("99", 1, "100"),
+            ("100", 1000, "1100"),
+            ("100", -1000, "-900"),
+            ("-1", 1, "0"),
+            ("-1", 2, "1"),
+            ("1", -1, "0"),
+            ("1", -2, "-1"),
+        ];
+
+        for (original, amount, expected) in tests {
+            assert_eq!(increment(original, amount).unwrap(), expected);
+        }
+    }
+
+    #[test]
+    fn test_increment_basic_hexadecimal_numbers() {
+        let tests = [
+            ("0x0100", 1, "0x0101"),
+            ("0x0100", -1, "0x00ff"),
+            ("0x0001", -1, "0x0000"),
+            ("0x0000", -1, "0x0000"),
+            ("0xffffffffffffffff", 1, "0x10000000000000000"),
+            ("0xffffffffffffffff", 2, "0x10000000000000001"),
+            ("0xffffffffffffffff", -1, "0xfffffffffffffffe"),
+            ("0xABCDEF1234567890", 1, "0xABCDEF1234567891"),
+            ("0xabcdef1234567890", 1, "0xabcdef1234567891"),
+        ];
+
+        for (original, amount, expected) in tests {
+            assert_eq!(increment(original, amount).unwrap(), expected);
+        }
+    }
+
+    #[test]
+    fn test_increment_basic_octal_numbers() {
+        let tests = [
+            ("0o0107", 1, "0o0110"),
+            ("0o0110", -1, "0o0107"),
+            ("0o0001", -1, "0o0000"),
+            ("0o7777", 1, "0o10000"),
+            ("0o1000", -1, "0o0777"),
+            ("0o0107", 10, "0o0121"),
+            ("0o0000", -1, "0o0000"),
+            ("0o1777777777777777777777", 1, "0o2000000000000000000000"),
+            ("0o1777777777777777777777", 2, "0o2000000000000000000001"),
+            ("0o1777777777777777777777", -1, "0o1777777777777777777776"),
+        ];
+
+        for (original, amount, expected) in tests {
+            assert_eq!(increment(original, amount).unwrap(), expected);
+        }
+    }
+
+    #[test]
+    fn test_increment_basic_binary_numbers() {
+        let tests = [
+            ("0b00000100", 1, "0b00000101"),
+            ("0b00000100", -1, "0b00000011"),
+            ("0b00000100", 2, "0b00000110"),
+            ("0b00000100", -2, "0b00000010"),
+            ("0b00000001", -1, "0b00000000"),
+            ("0b00111111", 10, "0b01001001"),
+            ("0b11111111", 1, "0b100000000"),
+            ("0b10000000", -1, "0b01111111"),
+            ("0b0000", -1, "0b0000"),
+            (
+                "0b1111111111111111111111111111111111111111111111111111111111111111",
+                1,
+                "0b10000000000000000000000000000000000000000000000000000000000000000",
+            ),
+            (
+                "0b1111111111111111111111111111111111111111111111111111111111111111",
+                2,
+                "0b10000000000000000000000000000000000000000000000000000000000000001",
+            ),
+            (
+                "0b1111111111111111111111111111111111111111111111111111111111111111",
+                -1,
+                "0b1111111111111111111111111111111111111111111111111111111111111110",
+            ),
+        ];
+
+        for (original, amount, expected) in tests {
+            assert_eq!(increment(original, amount).unwrap(), expected);
+        }
+    }
+
+    #[test]
+    fn test_increment_with_separators() {
+        let tests = [
+            ("999_999", 1, "1_000_000"),
+            ("1_000_000", -1, "999_999"),
+            ("-999_999", -1, "-1_000_000"),
+            ("0x0000_0000_0001", 0x1_ffff_0000, "0x0001_ffff_0001"),
+            ("0x0000_0000", -1, "0x0000_0000"),
+            ("0x0000_0000_0000", -1, "0x0000_0000_0000"),
+            ("0b01111111_11111111", 1, "0b10000000_00000000"),
+            ("0b11111111_11111111", 1, "0b1_00000000_00000000"),
+        ];
+
+        for (original, amount, expected) in tests {
+            assert_eq!(increment(original, amount).unwrap(), expected);
+        }
+    }
+
+    #[test]
+    fn test_leading_and_trailing_separators_arent_a_match() {
+        assert_eq!(increment("9_", 1), None);
+        assert_eq!(increment("_9", 1), None);
+        assert_eq!(increment("_9_", 1), None);
+    }
+}

helix-core/src/increment/mod.rs

@@ -1,8 +1,10 @@
-pub mod date_time;
-pub mod number;
+mod date_time;
+mod integer;
 
-use crate::{Range, Tendril};
-
-pub trait Increment {
-    fn increment(&self, amount: i64) -> (Range, Tendril);
+pub fn integer(selected_text: &str, amount: i64) -> Option<String> {
+    integer::increment(selected_text, amount)
+}
+
+pub fn date_time(selected_text: &str, amount: i64) -> Option<String> {
+    date_time::increment(selected_text, amount)
 }

helix-core/src/increment/number.rs

@@ -1,507 +0,0 @@
-use std::borrow::Cow;
-
-use ropey::RopeSlice;
-
-use super::Increment;
-
-use crate::{
-    textobject::{textobject_word, TextObject},
-    Range, Tendril,
-};
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct NumberIncrementor<'a> {
-    value: i64,
-    radix: u32,
-    range: Range,
-
-    text: RopeSlice<'a>,
-}
-
-impl<'a> NumberIncrementor<'a> {
-    /// Return information about number under rang if there is one.
-    pub fn from_range(text: RopeSlice, range: Range) -> Option<NumberIncrementor> {
-        // If the cursor is on the minus sign of a number we want to get the word textobject to the
-        // right of it.
-        let range = if range.to() < text.len_chars()
-            && range.to() - range.from() <= 1
-            && text.char(range.from()) == '-'
-        {
-            Range::new(range.from() + 1, range.to() + 1)
-        } else {
-            range
-        };
-
-        let range = textobject_word(text, range, TextObject::Inside, 1, false);
-
-        // If there is a minus sign to the left of the word object, we want to include it in the range.
-        let range = if range.from() > 0 && text.char(range.from() - 1) == '-' {
-            range.extend(range.from() - 1, range.from())
-        } else {
-            range
-        };
-
-        let word: String = text
-            .slice(range.from()..range.to())
-            .chars()
-            .filter(|&c| c != '_')
-            .collect();
-        let (radix, prefixed) = if word.starts_with("0x") {
-            (16, true)
-        } else if word.starts_with("0o") {
-            (8, true)
-        } else if word.starts_with("0b") {
-            (2, true)
-        } else {
-            (10, false)
-        };
-
-        let number = if prefixed { &word[2..] } else { &word };
-
-        let value = i128::from_str_radix(number, radix).ok()?;
-        if (value.is_positive() && value.leading_zeros() < 64)
-            || (value.is_negative() && value.leading_ones() < 64)
-        {
-            return None;
-        }
-
-        let value = value as i64;
-        Some(NumberIncrementor {
-            range,
-            value,
-            radix,
-            text,
-        })
-    }
-}
-
-impl<'a> Increment for NumberIncrementor<'a> {
-    fn increment(&self, amount: i64) -> (Range, Tendril) {
-        let old_text: Cow<str> = self.text.slice(self.range.from()..self.range.to()).into();
-        let old_length = old_text.len();
-        let new_value = self.value.wrapping_add(amount);
-
-        // Get separator indexes from right to left.
-        let separator_rtl_indexes: Vec<usize> = old_text
-            .chars()
-            .rev()
-            .enumerate()
-            .filter_map(|(i, c)| if c == '_' { Some(i) } else { None })
-            .collect();
-
-        let format_length = if self.radix == 10 {
-            match (self.value.is_negative(), new_value.is_negative()) {
-                (true, false) => old_length - 1,
-                (false, true) => old_length + 1,
-                _ => old_text.len(),
-            }
-        } else {
-            old_text.len() - 2
-        } - separator_rtl_indexes.len();
-
-        let mut new_text = match self.radix {
-            2 => format!("0b{:01$b}", new_value, format_length),
-            8 => format!("0o{:01$o}", new_value, format_length),
-            10 if old_text.starts_with('0') || old_text.starts_with("-0") => {
-                format!("{:01$}", new_value, format_length)
-            }
-            10 => format!("{}", new_value),
-            16 => {
-                let (lower_count, upper_count): (usize, usize) =
-                    old_text.chars().skip(2).fold((0, 0), |(lower, upper), c| {
-                        (
-                            lower + c.is_ascii_lowercase().then(|| 1).unwrap_or(0),
-                            upper + c.is_ascii_uppercase().then(|| 1).unwrap_or(0),
-                        )
-                    });
-                if upper_count > lower_count {
-                    format!("0x{:01$X}", new_value, format_length)
-                } else {
-                    format!("0x{:01$x}", new_value, format_length)
-                }
-            }
-            _ => unimplemented!("radix not supported: {}", self.radix),
-        };
-
-        // Add separators from original number.
-        for &rtl_index in &separator_rtl_indexes {
-            if rtl_index < new_text.len() {
-                let new_index = new_text.len() - rtl_index;
-                new_text.insert(new_index, '_');
-            }
-        }
-
-        // Add in additional separators if necessary.
-        if new_text.len() > old_length && !separator_rtl_indexes.is_empty() {
-            let spacing = match separator_rtl_indexes.as_slice() {
-                [.., b, a] => a - b - 1,
-                _ => separator_rtl_indexes[0],
-            };
-
-            let prefix_length = if self.radix == 10 { 0 } else { 2 };
-            if let Some(mut index) = new_text.find('_') {
-                while index - prefix_length > spacing {
-                    index -= spacing;
-                    new_text.insert(index, '_');
-                }
-            }
-        }
-
-        (self.range, new_text.into())
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::Rope;
-
-    #[test]
-    fn test_decimal_at_point() {
-        let rope = Rope::from_str("Test text 12345 more text.");
-        let range = Range::point(12);
-        assert_eq!(
-            NumberIncrementor::from_range(rope.slice(..), range),
-            Some(NumberIncrementor {
-                range: Range::new(10, 15),
-                value: 12345,
-                radix: 10,
-                text: rope.slice(..),
-            })
-        );
-    }
-
-    #[test]
-    fn test_uppercase_hexadecimal_at_point() {
-        let rope = Rope::from_str("Test text 0x123ABCDEF more text.");
-        let range = Range::point(12);
-        assert_eq!(
-            NumberIncrementor::from_range(rope.slice(..), range),
-            Some(NumberIncrementor {
-                range: Range::new(10, 21),
-                value: 0x123ABCDEF,
-                radix: 16,
-                text: rope.slice(..),
-            })
-        );
-    }
-
-    #[test]
-    fn test_lowercase_hexadecimal_at_point() {
-        let rope = Rope::from_str("Test text 0xfa3b4e more text.");
-        let range = Range::point(12);
-        assert_eq!(
-            NumberIncrementor::from_range(rope.slice(..), range),
-            Some(NumberIncrementor {
-                range: Range::new(10, 18),
-                value: 0xfa3b4e,
-                radix: 16,
-                text: rope.slice(..),
-            })
-        );
-    }
-
-    #[test]
-    fn test_octal_at_point() {
-        let rope = Rope::from_str("Test text 0o1074312 more text.");
-        let range = Range::point(12);
-        assert_eq!(
-            NumberIncrementor::from_range(rope.slice(..), range),
-            Some(NumberIncrementor {
-                range: Range::new(10, 19),
-                value: 0o1074312,
-                radix: 8,
-                text: rope.slice(..),
-            })
-        );
-    }
-
-    #[test]
-    fn test_binary_at_point() {
-        let rope = Rope::from_str("Test text 0b10111010010101 more text.");
-        let range = Range::point(12);
-        assert_eq!(
-            NumberIncrementor::from_range(rope.slice(..), range),
-            Some(NumberIncrementor {
-                range: Range::new(10, 26),
-                value: 0b10111010010101,
-                radix: 2,
-                text: rope.slice(..),
-            })
-        );
-    }
-
-    #[test]
-    fn test_negative_decimal_at_point() {
-        let rope = Rope::from_str("Test text -54321 more text.");
-        let range = Range::point(12);
-        assert_eq!(
-            NumberIncrementor::from_range(rope.slice(..), range),
-            Some(NumberIncrementor {
-                range: Range::new(10, 16),
-                value: -54321,
-                radix: 10,
-                text: rope.slice(..),
-            })
-        );
-    }
-
-    #[test]
-    fn test_decimal_with_leading_zeroes_at_point() {
-        let rope = Rope::from_str("Test text 000045326 more text.");
-        let range = Range::point(12);
-        assert_eq!(
-            NumberIncrementor::from_range(rope.slice(..), range),
-            Some(NumberIncrementor {
-                range: Range::new(10, 19),
-                value: 45326,
-                radix: 10,
-                text: rope.slice(..),
-            })
-        );
-    }
-
-    #[test]
-    fn test_negative_decimal_cursor_on_minus_sign() {
-        let rope = Rope::from_str("Test text -54321 more text.");
-        let range = Range::point(10);
-        assert_eq!(
-            NumberIncrementor::from_range(rope.slice(..), range),
-            Some(NumberIncrementor {
-                range: Range::new(10, 16),
-                value: -54321,
-                radix: 10,
-                text: rope.slice(..),
-            })
-        );
-    }
-
-    #[test]
-    fn test_number_under_range_start_of_rope() {
-        let rope = Rope::from_str("100");
-        let range = Range::point(0);
-        assert_eq!(
-            NumberIncrementor::from_range(rope.slice(..), range),
-            Some(NumberIncrementor {
-                range: Range::new(0, 3),
-                value: 100,
-                radix: 10,
-                text: rope.slice(..),
-            })
-        );
-    }
-
-    #[test]
-    fn test_number_under_range_end_of_rope() {
-        let rope = Rope::from_str("100");
-        let range = Range::point(2);
-        assert_eq!(
-            NumberIncrementor::from_range(rope.slice(..), range),
-            Some(NumberIncrementor {
-                range: Range::new(0, 3),
-                value: 100,
-                radix: 10,
-                text: rope.slice(..),
-            })
-        );
-    }
-
-    #[test]
-    fn test_number_surrounded_by_punctuation() {
-        let rope = Rope::from_str(",100;");
-        let range = Range::point(1);
-        assert_eq!(
-            NumberIncrementor::from_range(rope.slice(..), range),
-            Some(NumberIncrementor {
-                range: Range::new(1, 4),
-                value: 100,
-                radix: 10,
-                text: rope.slice(..),
-            })
-        );
-    }
-
-    #[test]
-    fn test_not_a_number_point() {
-        let rope = Rope::from_str("Test text 45326 more text.");
-        let range = Range::point(6);
-        assert_eq!(NumberIncrementor::from_range(rope.slice(..), range), None);
-    }
-
-    #[test]
-    fn test_number_too_large_at_point() {
-        let rope = Rope::from_str("Test text 0xFFFFFFFFFFFFFFFFF more text.");
-        let range = Range::point(12);
-        assert_eq!(NumberIncrementor::from_range(rope.slice(..), range), None);
-    }
-
-    #[test]
-    fn test_number_cursor_one_right_of_number() {
-        let rope = Rope::from_str("100 ");
-        let range = Range::point(3);
-        assert_eq!(NumberIncrementor::from_range(rope.slice(..), range), None);
-    }
-
-    #[test]
-    fn test_number_cursor_one_left_of_number() {
-        let rope = Rope::from_str(" 100");
-        let range = Range::point(0);
-        assert_eq!(NumberIncrementor::from_range(rope.slice(..), range), None);
-    }
-
-    #[test]
-    fn test_increment_basic_decimal_numbers() {
-        let tests = [
-            ("100", 1, "101"),
-            ("100", -1, "99"),
-            ("99", 1, "100"),
-            ("100", 1000, "1100"),
-            ("100", -1000, "-900"),
-            ("-1", 1, "0"),
-            ("-1", 2, "1"),
-            ("1", -1, "0"),
-            ("1", -2, "-1"),
-        ];
-
-        for (original, amount, expected) in tests {
-            let rope = Rope::from_str(original);
-            let range = Range::point(0);
-            assert_eq!(
-                NumberIncrementor::from_range(rope.slice(..), range)
-                    .unwrap()
-                    .increment(amount)
-                    .1,
-                Tendril::from(expected)
-            );
-        }
-    }
-
-    #[test]
-    fn test_increment_basic_hexadedimal_numbers() {
-        let tests = [
-            ("0x0100", 1, "0x0101"),
-            ("0x0100", -1, "0x00ff"),
-            ("0x0001", -1, "0x0000"),
-            ("0x0000", -1, "0xffffffffffffffff"),
-            ("0xffffffffffffffff", 1, "0x0000000000000000"),
-            ("0xffffffffffffffff", 2, "0x0000000000000001"),
-            ("0xffffffffffffffff", -1, "0xfffffffffffffffe"),
-            ("0xABCDEF1234567890", 1, "0xABCDEF1234567891"),
-            ("0xabcdef1234567890", 1, "0xabcdef1234567891"),
-        ];
-
-        for (original, amount, expected) in tests {
-            let rope = Rope::from_str(original);
-            let range = Range::point(0);
-            assert_eq!(
-                NumberIncrementor::from_range(rope.slice(..), range)
-                    .unwrap()
-                    .increment(amount)
-                    .1,
-                Tendril::from(expected)
-            );
-        }
-    }
-
-    #[test]
-    fn test_increment_basic_octal_numbers() {
-        let tests = [
-            ("0o0107", 1, "0o0110"),
-            ("0o0110", -1, "0o0107"),
-            ("0o0001", -1, "0o0000"),
-            ("0o7777", 1, "0o10000"),
-            ("0o1000", -1, "0o0777"),
-            ("0o0107", 10, "0o0121"),
-            ("0o0000", -1, "0o1777777777777777777777"),
-            ("0o1777777777777777777777", 1, "0o0000000000000000000000"),
-            ("0o1777777777777777777777", 2, "0o0000000000000000000001"),
-            ("0o1777777777777777777777", -1, "0o1777777777777777777776"),
-        ];
-
-        for (original, amount, expected) in tests {
-            let rope = Rope::from_str(original);
-            let range = Range::point(0);
-            assert_eq!(
-                NumberIncrementor::from_range(rope.slice(..), range)
-                    .unwrap()
-                    .increment(amount)
-                    .1,
-                Tendril::from(expected)
-            );
-        }
-    }
-
-    #[test]
-    fn test_increment_basic_binary_numbers() {
-        let tests = [
-            ("0b00000100", 1, "0b00000101"),
-            ("0b00000100", -1, "0b00000011"),
-            ("0b00000100", 2, "0b00000110"),
-            ("0b00000100", -2, "0b00000010"),
-            ("0b00000001", -1, "0b00000000"),
-            ("0b00111111", 10, "0b01001001"),
-            ("0b11111111", 1, "0b100000000"),
-            ("0b10000000", -1, "0b01111111"),
-            (
-                "0b0000",
-                -1,
-                "0b1111111111111111111111111111111111111111111111111111111111111111",
-            ),
-            (
-                "0b1111111111111111111111111111111111111111111111111111111111111111",
-                1,
-                "0b0000000000000000000000000000000000000000000000000000000000000000",
-            ),
-            (
-                "0b1111111111111111111111111111111111111111111111111111111111111111",
-                2,
-                "0b0000000000000000000000000000000000000000000000000000000000000001",
-            ),
-            (
-                "0b1111111111111111111111111111111111111111111111111111111111111111",
-                -1,
-                "0b1111111111111111111111111111111111111111111111111111111111111110",
-            ),
-        ];
-
-        for (original, amount, expected) in tests {
-            let rope = Rope::from_str(original);
-            let range = Range::point(0);
-            assert_eq!(
-                NumberIncrementor::from_range(rope.slice(..), range)
-                    .unwrap()
-                    .increment(amount)
-                    .1,
-                Tendril::from(expected)
-            );
-        }
-    }
-
-    #[test]
-    fn test_increment_with_separators() {
-        let tests = [
-            ("999_999", 1, "1_000_000"),
-            ("1_000_000", -1, "999_999"),
-            ("-999_999", -1, "-1_000_000"),
-            ("0x0000_0000_0001", 0x1_ffff_0000, "0x0001_ffff_0001"),
-            ("0x0000_0000_0001", 0x1_ffff_0000, "0x0001_ffff_0001"),
-            ("0x0000_0000_0001", 0x1_ffff_0000, "0x0001_ffff_0001"),
-            ("0x0000_0000", -1, "0xffff_ffff_ffff_ffff"),
-            ("0x0000_0000_0000", -1, "0xffff_ffff_ffff_ffff"),
-            ("0b01111111_11111111", 1, "0b10000000_00000000"),
-            ("0b11111111_11111111", 1, "0b1_00000000_00000000"),
-        ];
-
-        for (original, amount, expected) in tests {
-            let rope = Rope::from_str(original);
-            let range = Range::point(0);
-            assert_eq!(
-                NumberIncrementor::from_range(rope.slice(..), range)
-                    .unwrap()
-                    .increment(amount)
-                    .1,
-                Tendril::from(expected)
-            );
-        }
-    }
-}

helix-core/src/lib.rs

@@ -6,6 +6,8 @@ pub mod comment;
 pub mod config;
 pub mod diagnostic;
 pub mod diff;
+pub mod doc_formatter;
+pub mod fuzzy;
 pub mod graphemes;
 pub mod history;
 pub mod increment;
@@ -15,17 +17,17 @@ pub mod macros;
 pub mod match_brackets;
 pub mod movement;
 pub mod object;
-pub mod path;
 mod position;
-pub mod register;
 pub mod search;
 pub mod selection;
 pub mod shellwords;
-mod state;
 pub mod surround;
 pub mod syntax;
+pub mod test;
+pub mod text_annotations;
 pub mod textobject;
 mod transaction;
+pub mod wrap;
 
 pub mod unicode {
     pub use unicode_general_category as category;
@@ -33,56 +35,12 @@ pub mod unicode {
     pub use unicode_width as width;
 }
 
-pub fn find_first_non_whitespace_char(line: RopeSlice) -> Option<usize> {
-    line.chars().position(|ch| !ch.is_whitespace())
-}
+pub use helix_loader::find_workspace;
 
-/// Find project root.
-///
-/// Order of detection:
-/// * Top-most folder containing a root marker in current git repository
-/// * Git repostory root if no marker detected
-/// * Top-most folder containing a root marker if not git repository detected
-/// * Current working directory as fallback
-pub fn find_root(root: Option<&str>, root_markers: &[String]) -> Option<std::path::PathBuf> {
-    let current_dir = std::env::current_dir().expect("unable to determine current directory");
+mod rope_reader;
 
-    let root = match root {
-        Some(root) => {
-            let root = std::path::Path::new(root);
-            if root.is_absolute() {
-                root.to_path_buf()
-            } else {
-                current_dir.join(root)
-            }
-        }
-        None => current_dir.clone(),
-    };
-
-    let mut top_marker = None;
-    for ancestor in root.ancestors() {
-        for marker in root_markers {
-            if ancestor.join(marker).exists() {
-                top_marker = Some(ancestor);
-                break;
-            }
-        }
-        // don't go higher than repo
-        if ancestor.join(".git").is_dir() {
-            // Use workspace if detected from marker
-            return Some(top_marker.unwrap_or(ancestor).to_path_buf());
-        }
-    }
-
-    // In absence of git repo, use workspace if detected
-    if top_marker.is_some() {
-        top_marker.map(|a| a.to_path_buf())
-    } else {
-        Some(current_dir)
-    }
-}
-
-pub use ropey::{Rope, RopeBuilder, RopeSlice};
+pub use rope_reader::RopeReader;
+pub use ropey::{self, str_utils, Rope, RopeBuilder, RopeSlice};
 
 // pub use tendril::StrTendril as Tendril;
 pub use smartstring::SmartString;
@@ -93,13 +51,18 @@ pub type Tendril = SmartString<smartstring::LazyCompact>;
 pub use {regex, tree_sitter};
 
 pub use graphemes::RopeGraphemes;
-pub use position::{coords_at_pos, pos_at_coords, visual_coords_at_pos, Position};
+pub use position::{
+    char_idx_at_visual_offset, coords_at_pos, pos_at_coords, visual_offset_from_anchor,
+    visual_offset_from_block, Position, VisualOffsetError,
+};
+#[allow(deprecated)]
+pub use position::{pos_at_visual_coords, visual_coords_at_pos};
+
 pub use selection::{Range, Selection};
 pub use smallvec::{smallvec, SmallVec};
 pub use syntax::Syntax;
 
 pub use diagnostic::Diagnostic;
-pub use state::State;
 
-pub use line_ending::{LineEnding, DEFAULT_LINE_ENDING};
-pub use transaction::{Assoc, Change, ChangeSet, Operation, Transaction};
+pub use line_ending::{LineEnding, NATIVE_LINE_ENDING};
+pub use transaction::{Assoc, Change, ChangeSet, Deletion, Operation, Transaction};

helix-core/src/line_ending.rs

@@ -1,21 +1,27 @@
 use crate::{Rope, RopeSlice};
 
 #[cfg(target_os = "windows")]
-pub const DEFAULT_LINE_ENDING: LineEnding = LineEnding::Crlf;
+pub const NATIVE_LINE_ENDING: LineEnding = LineEnding::Crlf;
 #[cfg(not(target_os = "windows"))]
-pub const DEFAULT_LINE_ENDING: LineEnding = LineEnding::LF;
+pub const NATIVE_LINE_ENDING: LineEnding = LineEnding::LF;
 
 /// Represents one of the valid Unicode line endings.
-#[derive(PartialEq, Copy, Clone, Debug)]
+#[derive(PartialEq, Eq, Copy, Clone, Debug)]
 pub enum LineEnding {
     Crlf, // CarriageReturn followed by LineFeed
     LF,   // U+000A -- LineFeed
-    VT,   // U+000B -- VerticalTab
-    FF,   // U+000C -- FormFeed
-    CR,   // U+000D -- CarriageReturn
-    Nel,  // U+0085 -- NextLine
-    LS,   // U+2028 -- Line Separator
-    PS,   // U+2029 -- ParagraphSeparator
+    #[cfg(feature = "unicode-lines")]
+    VT, // U+000B -- VerticalTab
+    #[cfg(feature = "unicode-lines")]
+    FF, // U+000C -- FormFeed
+    #[cfg(feature = "unicode-lines")]
+    CR, // U+000D -- CarriageReturn
+    #[cfg(feature = "unicode-lines")]
+    Nel, // U+0085 -- NextLine
+    #[cfg(feature = "unicode-lines")]
+    LS, // U+2028 -- Line Separator
+    #[cfg(feature = "unicode-lines")]
+    PS, // U+2029 -- ParagraphSeparator
 }
 
 impl LineEnding {
@@ -32,11 +38,17 @@ impl LineEnding {
         match self {
             Self::Crlf => "\u{000D}\u{000A}",
             Self::LF => "\u{000A}",
+            #[cfg(feature = "unicode-lines")]
             Self::VT => "\u{000B}",
+            #[cfg(feature = "unicode-lines")]
             Self::FF => "\u{000C}",
+            #[cfg(feature = "unicode-lines")]
             Self::CR => "\u{000D}",
+            #[cfg(feature = "unicode-lines")]
             Self::Nel => "\u{0085}",
+            #[cfg(feature = "unicode-lines")]
             Self::LS => "\u{2028}",
+            #[cfg(feature = "unicode-lines")]
             Self::PS => "\u{2029}",
         }
     }
@@ -45,11 +57,17 @@ impl LineEnding {
     pub const fn from_char(ch: char) -> Option<LineEnding> {
         match ch {
             '\u{000A}' => Some(LineEnding::LF),
+            #[cfg(feature = "unicode-lines")]
             '\u{000B}' => Some(LineEnding::VT),
+            #[cfg(feature = "unicode-lines")]
             '\u{000C}' => Some(LineEnding::FF),
+            #[cfg(feature = "unicode-lines")]
             '\u{000D}' => Some(LineEnding::CR),
+            #[cfg(feature = "unicode-lines")]
             '\u{0085}' => Some(LineEnding::Nel),
+            #[cfg(feature = "unicode-lines")]
             '\u{2028}' => Some(LineEnding::LS),
+            #[cfg(feature = "unicode-lines")]
             '\u{2029}' => Some(LineEnding::PS),
             // Not a line ending
             _ => None,
@@ -65,11 +83,17 @@ impl LineEnding {
         match g {
             "\u{000D}\u{000A}" => Some(LineEnding::Crlf),
             "\u{000A}" => Some(LineEnding::LF),
+            #[cfg(feature = "unicode-lines")]
             "\u{000B}" => Some(LineEnding::VT),
+            #[cfg(feature = "unicode-lines")]
             "\u{000C}" => Some(LineEnding::FF),
+            #[cfg(feature = "unicode-lines")]
             "\u{000D}" => Some(LineEnding::CR),
+            #[cfg(feature = "unicode-lines")]
             "\u{0085}" => Some(LineEnding::Nel),
+            #[cfg(feature = "unicode-lines")]
             "\u{2028}" => Some(LineEnding::LS),
+            #[cfg(feature = "unicode-lines")]
             "\u{2029}" => Some(LineEnding::PS),
             // Not a line ending
             _ => None,
@@ -95,13 +119,20 @@ pub fn str_is_line_ending(s: &str) -> bool {
     LineEnding::from_str(s).is_some()
 }
 
+#[inline]
+pub fn rope_is_line_ending(r: RopeSlice) -> bool {
+    r.chunks().all(str_is_line_ending)
+}
+
 /// Attempts to detect what line ending the passed document uses.
 pub fn auto_detect_line_ending(doc: &Rope) -> Option<LineEnding> {
     // Return first matched line ending. Not all possible line endings
     // are being matched, as they might be special-use only
     for line in doc.lines().take(100) {
         match get_line_ending(&line) {
-            None | Some(LineEnding::VT) | Some(LineEnding::FF) | Some(LineEnding::PS) => {}
+            None => {}
+            #[cfg(feature = "unicode-lines")]
+            Some(LineEnding::VT) | Some(LineEnding::FF) | Some(LineEnding::PS) => {}
             ending => return ending,
         }
     }
@@ -128,6 +159,19 @@ pub fn get_line_ending(line: &RopeSlice) -> Option<LineEnding> {
     LineEnding::from_str(g2).or_else(|| LineEnding::from_str(g1))
 }
 
+#[cfg(not(feature = "unicode-lines"))]
+/// Returns the passed line's line ending, if any.
+pub fn get_line_ending_of_str(line: &str) -> Option<LineEnding> {
+    if line.ends_with("\u{000D}\u{000A}") {
+        Some(LineEnding::Crlf)
+    } else if line.ends_with('\u{000A}') {
+        Some(LineEnding::LF)
+    } else {
+        None
+    }
+}
+
+#[cfg(feature = "unicode-lines")]
 /// Returns the passed line's line ending, if any.
 pub fn get_line_ending_of_str(line: &str) -> Option<LineEnding> {
     if line.ends_with("\u{000D}\u{000A}") {
@@ -159,6 +203,13 @@ pub fn line_end_char_index(slice: &RopeSlice, line: usize) -> usize {
             .unwrap_or(0)
 }
 
+pub fn line_end_byte_index(slice: &RopeSlice, line: usize) -> usize {
+    slice.line_to_byte(line + 1)
+        - get_line_ending(&slice.line(line))
+            .map(|le| le.as_str().len())
+            .unwrap_or(0)
+}
+
 /// Fetches line `line_idx` from the passed rope slice, sans any line ending.
 pub fn line_without_line_ending<'a>(slice: &'a RopeSlice, line_idx: usize) -> RopeSlice<'a> {
     let start = slice.line_to_char(line_idx);
@@ -211,6 +262,7 @@ mod line_ending_tests {
 
     #[test]
     fn str_to_line_ending() {
+        #[cfg(feature = "unicode-lines")]
         assert_eq!(LineEnding::from_str("\r"), Some(LineEnding::CR));
         assert_eq!(LineEnding::from_str("\n"), Some(LineEnding::LF));
         assert_eq!(LineEnding::from_str("\r\n"), Some(LineEnding::Crlf));
@@ -220,6 +272,7 @@ mod line_ending_tests {
     #[test]
     fn rope_slice_to_line_ending() {
         let r = Rope::from_str("hello\r\n");
+        #[cfg(feature = "unicode-lines")]
         assert_eq!(
             LineEnding::from_rope_slice(&r.slice(5..6)),
             Some(LineEnding::CR)
@@ -238,6 +291,7 @@ mod line_ending_tests {
     #[test]
     fn get_line_ending_rope_slice() {
         let r = Rope::from_str("Hello\rworld\nhow\r\nare you?");
+        #[cfg(feature = "unicode-lines")]
         assert_eq!(get_line_ending(&r.slice(..6)), Some(LineEnding::CR));
         assert_eq!(get_line_ending(&r.slice(..12)), Some(LineEnding::LF));
         assert_eq!(get_line_ending(&r.slice(..17)), Some(LineEnding::Crlf));
@@ -247,6 +301,7 @@ mod line_ending_tests {
     #[test]
     fn get_line_ending_str() {
         let text = "Hello\rworld\nhow\r\nare you?";
+        #[cfg(feature = "unicode-lines")]
         assert_eq!(get_line_ending_of_str(&text[..6]), Some(LineEnding::CR));
         assert_eq!(get_line_ending_of_str(&text[..12]), Some(LineEnding::LF));
         assert_eq!(get_line_ending_of_str(&text[..17]), Some(LineEnding::Crlf));
@@ -257,9 +312,17 @@ mod line_ending_tests {
     fn line_end_char_index_rope_slice() {
         let r = Rope::from_str("Hello\rworld\nhow\r\nare you?");
         let s = &r.slice(..);
-        assert_eq!(line_end_char_index(s, 0), 5);
-        assert_eq!(line_end_char_index(s, 1), 11);
-        assert_eq!(line_end_char_index(s, 2), 15);
-        assert_eq!(line_end_char_index(s, 3), 25);
+        #[cfg(not(feature = "unicode-lines"))]
+        {
+            assert_eq!(line_end_char_index(s, 0), 11);
+            assert_eq!(line_end_char_index(s, 1), 15);
+            assert_eq!(line_end_char_index(s, 2), 25);
+        }
+        #[cfg(feature = "unicode-lines")]
+        {
+            assert_eq!(line_end_char_index(s, 0), 5);
+            assert_eq!(line_end_char_index(s, 1), 11);
+            assert_eq!(line_end_char_index(s, 2), 15);
+        }
     }
 }

helix-core/src/match_brackets.rs

@@ -1,7 +1,15 @@
+use std::iter;
+
+use ropey::RopeSlice;
 use tree_sitter::Node;
 
-use crate::{Rope, Syntax};
+use crate::movement::Direction::{self, Backward, Forward};
+use crate::Syntax;
 
+const MAX_PLAINTEXT_SCAN: usize = 10000;
+const MATCH_LIMIT: usize = 16;
+
+// Limit matching pairs to only ( ) { } [ ] < > ' ' " "
 const PAIRS: &[(char, char)] = &[
     ('(', ')'),
     ('{', '}'),
@@ -11,17 +19,17 @@ const PAIRS: &[(char, char)] = &[
     ('\"', '\"'),
 ];
 
-// limit matching pairs to only ( ) { } [ ] < > ' ' " "
-
-// Returns the position of the matching bracket under cursor.
-//
-// If the cursor is one the opening bracket, the position of
-// the closing bracket is returned. If the cursor in the closing
-// bracket, the position of the opening bracket is returned.
-//
-// If the cursor is not on a bracket, `None` is returned.
+/// Returns the position of the matching bracket under cursor.
+///
+/// If the cursor is on the opening bracket, the position of
+/// the closing bracket is returned. If the cursor on the closing
+/// bracket, the position of the opening bracket is returned.
+///
+/// If the cursor is not on a bracket, `None` is returned.
+///
+/// If no matching bracket is found, `None` is returned.
 #[must_use]
-pub fn find_matching_bracket(syntax: &Syntax, doc: &Rope, pos: usize) -> Option<usize> {
+pub fn find_matching_bracket(syntax: &Syntax, doc: RopeSlice, pos: usize) -> Option<usize> {
     if pos >= doc.len_chars() || !is_valid_bracket(doc.char(pos)) {
         return None;
     }
@@ -39,46 +47,159 @@ pub fn find_matching_bracket(syntax: &Syntax, doc: &Rope, pos: usize) -> Option<
 //
 // If no surrounding scope is found, the function returns `None`.
 #[must_use]
-pub fn find_matching_bracket_fuzzy(syntax: &Syntax, doc: &Rope, pos: usize) -> Option<usize> {
+pub fn find_matching_bracket_fuzzy(syntax: &Syntax, doc: RopeSlice, pos: usize) -> Option<usize> {
     find_pair(syntax, doc, pos, true)
 }
 
-fn find_pair(syntax: &Syntax, doc: &Rope, pos: usize, traverse_parents: bool) -> Option<usize> {
-    let tree = syntax.tree();
-    let pos = doc.char_to_byte(pos);
+fn find_pair(
+    syntax: &Syntax,
+    doc: RopeSlice,
+    pos_: usize,
+    traverse_parents: bool,
+) -> Option<usize> {
+    let pos = doc.char_to_byte(pos_);
 
-    let mut node = tree.root_node().named_descendant_for_byte_range(pos, pos)?;
+    let root = syntax.tree_for_byte_range(pos, pos + 1).root_node();
+    let mut node = root.descendant_for_byte_range(pos, pos + 1)?;
 
     loop {
-        let (start_byte, end_byte) = surrounding_bytes(doc, &node)?;
-        let (start_char, end_char) = (doc.byte_to_char(start_byte), doc.byte_to_char(end_byte));
+        if node.is_named() {
+            let (start_byte, end_byte) = surrounding_bytes(doc, &node)?;
+            let (start_char, end_char) = (doc.byte_to_char(start_byte), doc.byte_to_char(end_byte));
 
-        if is_valid_pair(doc, start_char, end_char) {
-            if end_byte == pos {
-                return Some(start_char);
+            if is_valid_pair(doc, start_char, end_char) {
+                if end_byte == pos {
+                    return Some(start_char);
+                }
+
+                // We return the end char if the cursor is either on the start char
+                // or at some arbitrary position between start and end char.
+                if traverse_parents || start_byte == pos {
+                    return Some(end_char);
+                }
+            }
+        }
+        // this node itselt wasn't a pair but maybe its siblings are
+
+        // check if we are *on* the pair (special cased so we don't look
+        // at the current node twice and to jump to the start on that case)
+        if let Some(open) = as_close_pair(doc, &node) {
+            if let Some(pair_start) = find_pair_end(doc, node.prev_sibling(), open, Backward) {
+                return Some(pair_start);
             }
-            // We return the end char if the cursor is either on the start char
-            // or at some arbitrary position between start and end char.
-            return Some(end_char);
         }
 
-        if traverse_parents {
-            node = node.parent()?;
-        } else {
-            return None;
+        if !traverse_parents {
+            // check if we are *on* the opening pair (special cased here as
+            // an opptimization since we only care about bracket on the cursor
+            // here)
+            if let Some(close) = as_open_pair(doc, &node) {
+                if let Some(pair_end) = find_pair_end(doc, node.next_sibling(), close, Forward) {
+                    return Some(pair_end);
+                }
+            }
+            if node.is_named() {
+                break;
+            }
+        }
+
+        for close in
+            iter::successors(node.next_sibling(), |node| node.next_sibling()).take(MATCH_LIMIT)
+        {
+            let Some(open) = as_close_pair(doc, &close) else {
+                continue;
+            };
+            if find_pair_end(doc, Some(node), open, Backward).is_some() {
+                return doc.try_byte_to_char(close.start_byte()).ok();
+            }
+        }
+        let Some(parent) = node.parent() else {
+            break;
+        };
+        node = parent;
+    }
+    let node = root.named_descendant_for_byte_range(pos, pos + 1)?;
+    if node.child_count() != 0 {
+        return None;
+    }
+    let node_start = doc.byte_to_char(node.start_byte());
+    find_matching_bracket_plaintext(doc.byte_slice(node.byte_range()), pos_ - node_start)
+        .map(|pos| pos + node_start)
+}
+
+/// Returns the position of the matching bracket under cursor.
+/// This function works on plain text and ignores tree-sitter grammar.
+/// The search is limited to `MAX_PLAINTEXT_SCAN` characters
+///
+/// If the cursor is on the opening bracket, the position of
+/// the closing bracket is returned. If the cursor on the closing
+/// bracket, the position of the opening bracket is returned.
+///
+/// If the cursor is not on a bracket, `None` is returned.
+///
+/// If no matching bracket is found, `None` is returned.
+#[must_use]
+pub fn find_matching_bracket_plaintext(doc: RopeSlice, cursor_pos: usize) -> Option<usize> {
+    // Don't do anything when the cursor is not on top of a bracket.
+    let bracket = doc.get_char(cursor_pos)?;
+    if !is_valid_bracket(bracket) {
+        return None;
+    }
+
+    // Determine the direction of the matching.
+    let is_fwd = is_forward_bracket(bracket);
+    let chars_iter = if is_fwd {
+        doc.chars_at(cursor_pos + 1)
+    } else {
+        doc.chars_at(cursor_pos).reversed()
+    };
+
+    let mut open_cnt = 1;
+
+    for (i, candidate) in chars_iter.take(MAX_PLAINTEXT_SCAN).enumerate() {
+        if candidate == bracket {
+            open_cnt += 1;
+        } else if is_valid_pair(
+            doc,
+            if is_fwd {
+                cursor_pos
+            } else {
+                cursor_pos - i - 1
+            },
+            if is_fwd {
+                cursor_pos + i + 1
+            } else {
+                cursor_pos
+            },
+        ) {
+            // Return when all pending brackets have been closed.
+            if open_cnt == 1 {
+                return Some(if is_fwd {
+                    cursor_pos + i + 1
+                } else {
+                    cursor_pos - i - 1
+                });
+            }
+            open_cnt -= 1;
         }
     }
+
+    None
 }
 
 fn is_valid_bracket(c: char) -> bool {
     PAIRS.iter().any(|(l, r)| *l == c || *r == c)
 }
 
-fn is_valid_pair(doc: &Rope, start_char: usize, end_char: usize) -> bool {
+fn is_forward_bracket(c: char) -> bool {
+    PAIRS.iter().any(|(l, _)| *l == c)
+}
+
+fn is_valid_pair(doc: RopeSlice, start_char: usize, end_char: usize) -> bool {
     PAIRS.contains(&(doc.char(start_char), doc.char(end_char)))
 }
 
-fn surrounding_bytes(doc: &Rope, node: &Node) -> Option<(usize, usize)> {
+fn surrounding_bytes(doc: RopeSlice, node: &Node) -> Option<(usize, usize)> {
     let len = doc.len_bytes();
 
     let start_byte = node.start_byte();
@@ -90,3 +211,91 @@ fn surrounding_bytes(doc: &Rope, node: &Node) -> Option<(usize, usize)> {
 
     Some((start_byte, end_byte))
 }
+
+/// Tests if this node is a pair close char and returns the expected open char
+fn as_close_pair(doc: RopeSlice, node: &Node) -> Option<char> {
+    let close = as_char(doc, node)?.1;
+    PAIRS
+        .iter()
+        .find_map(|&(open, close_)| (close_ == close).then_some(open))
+}
+
+/// Checks if `node` or its siblings (at most MATCH_LIMIT nodes) is the specified closing char
+///
+/// # Returns
+///
+/// The position of the found node or `None` otherwise
+fn find_pair_end(
+    doc: RopeSlice,
+    node: Option<Node>,
+    end_char: char,
+    direction: Direction,
+) -> Option<usize> {
+    let advance = match direction {
+        Forward => Node::next_sibling,
+        Backward => Node::prev_sibling,
+    };
+    iter::successors(node, advance)
+        .take(MATCH_LIMIT)
+        .find_map(|node| {
+            let (pos, c) = as_char(doc, &node)?;
+            (end_char == c).then_some(pos)
+        })
+}
+
+/// Tests if this node is a pair close char and returns the expected open char
+fn as_open_pair(doc: RopeSlice, node: &Node) -> Option<char> {
+    let open = as_char(doc, node)?.1;
+    PAIRS
+        .iter()
+        .find_map(|&(open_, close)| (open_ == open).then_some(close))
+}
+
+/// If node is a single char return it (and its char position)
+fn as_char(doc: RopeSlice, node: &Node) -> Option<(usize, char)> {
+    // TODO: multi char/non ASCII pairs
+    if node.byte_range().len() != 1 {
+        return None;
+    }
+    let pos = doc.try_byte_to_char(node.start_byte()).ok()?;
+    Some((pos, doc.char(pos)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn find_matching_bracket_empty_file() {
+        let actual = find_matching_bracket_plaintext("".into(), 0);
+        assert_eq!(actual, None);
+    }
+
+    #[test]
+    fn test_find_matching_bracket_current_line_plaintext() {
+        let assert = |input: &str, pos, expected| {
+            let input = RopeSlice::from(input);
+            let actual = find_matching_bracket_plaintext(input, pos);
+            assert_eq!(expected, actual.unwrap());
+
+            let actual = find_matching_bracket_plaintext(input, expected);
+            assert_eq!(pos, actual.unwrap(), "expected symmetrical behaviour");
+        };
+
+        assert("(hello)", 0, 6);
+        assert("((hello))", 0, 8);
+        assert("((hello))", 1, 7);
+        assert("(((hello)))", 2, 8);
+
+        assert("key: ${value}", 6, 12);
+        assert("key: ${value} # (some comment)", 16, 29);
+
+        assert("(paren (paren {bracket}))", 0, 24);
+        assert("(paren (paren {bracket}))", 7, 23);
+        assert("(paren (paren {bracket}))", 14, 22);
+
+        assert("(prev line\n ) (middle) ( \n next line)", 0, 12);
+        assert("(prev line\n ) (middle) ( \n next line)", 14, 21);
+        assert("(prev line\n ) (middle) ( \n next line)", 23, 36);
+    }
+}

helix-core/src/movement.rs

@@ -1,19 +1,22 @@
-use std::iter;
+use std::{cmp::Reverse, iter};
 
 use ropey::iter::Chars;
 use tree_sitter::{Node, QueryCursor};
 
 use crate::{
+    char_idx_at_visual_offset,
     chars::{categorize_char, char_is_line_ending, CharCategory},
-    coords_at_pos,
+    doc_formatter::TextFormat,
     graphemes::{
         next_grapheme_boundary, nth_next_grapheme_boundary, nth_prev_grapheme_boundary,
         prev_grapheme_boundary,
     },
-    pos_at_coords,
+    line_ending::rope_is_line_ending,
+    position::char_idx_at_visual_block_offset,
     syntax::LanguageConfiguration,
+    text_annotations::TextAnnotations,
     textobject::TextObject,
-    Position, Range, RopeSlice,
+    visual_offset_from_block, Range, RopeSlice, Selection, Syntax,
 };
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -34,6 +37,8 @@ pub fn move_horizontally(
     dir: Direction,
     count: usize,
     behaviour: Movement,
+    _: &TextFormat,
+    _: &mut TextAnnotations,
 ) -> Range {
     let pos = range.cursor(slice);
 
@@ -47,38 +52,116 @@ pub fn move_horizontally(
     range.put_cursor(slice, new_pos, behaviour == Movement::Extend)
 }
 
+pub fn move_vertically_visual(
+    slice: RopeSlice,
+    range: Range,
+    dir: Direction,
+    count: usize,
+    behaviour: Movement,
+    text_fmt: &TextFormat,
+    annotations: &mut TextAnnotations,
+) -> Range {
+    if !text_fmt.soft_wrap {
+        return move_vertically(slice, range, dir, count, behaviour, text_fmt, annotations);
+    }
+    annotations.clear_line_annotations();
+    let pos = range.cursor(slice);
+
+    // Compute the current position's 2d coordinates.
+    let (visual_pos, block_off) = visual_offset_from_block(slice, pos, pos, text_fmt, annotations);
+    let new_col = range
+        .old_visual_position
+        .map_or(visual_pos.col as u32, |(_, col)| col);
+
+    // Compute the new position.
+    let mut row_off = match dir {
+        Direction::Forward => count as isize,
+        Direction::Backward => -(count as isize),
+    };
+
+    // TODO how to handle inline annotations that span an entire visual line (very unlikely).
+
+    // Compute visual offset relative to block start to avoid trasversing the block twice
+    row_off += visual_pos.row as isize;
+    let new_pos = char_idx_at_visual_offset(
+        slice,
+        block_off,
+        row_off,
+        new_col as usize,
+        text_fmt,
+        annotations,
+    )
+    .0;
+
+    // Special-case to avoid moving to the end of the last non-empty line.
+    if behaviour == Movement::Extend && slice.line(slice.char_to_line(new_pos)).len_chars() == 0 {
+        return range;
+    }
+
+    let mut new_range = range.put_cursor(slice, new_pos, behaviour == Movement::Extend);
+    new_range.old_visual_position = Some((0, new_col));
+    new_range
+}
+
 pub fn move_vertically(
     slice: RopeSlice,
     range: Range,
     dir: Direction,
     count: usize,
     behaviour: Movement,
+    text_fmt: &TextFormat,
+    annotations: &mut TextAnnotations,
 ) -> Range {
+    annotations.clear_line_annotations();
     let pos = range.cursor(slice);
+    let line_idx = slice.char_to_line(pos);
+    let line_start = slice.line_to_char(line_idx);
 
     // Compute the current position's 2d coordinates.
-    // TODO: switch this to use `visual_coords_at_pos` rather than
-    // `coords_at_pos` as this will cause a jerky movement when the visual
-    // position does not match, like moving from a line with tabs/CJK to
-    // a line without
-    let Position { row, col } = coords_at_pos(slice, pos);
-    let horiz = range.horiz.unwrap_or(col as u32);
+    let visual_pos = visual_offset_from_block(slice, line_start, pos, text_fmt, annotations).0;
+    let (mut new_row, new_col) = range
+        .old_visual_position
+        .map_or((visual_pos.row as u32, visual_pos.col as u32), |pos| pos);
+    new_row = new_row.max(visual_pos.row as u32);
+    let line_idx = slice.char_to_line(pos);
 
     // Compute the new position.
-    let new_row = match dir {
-        Direction::Forward => (row + count).min(slice.len_lines().saturating_sub(1)),
-        Direction::Backward => row.saturating_sub(count),
+    let mut new_line_idx = match dir {
+        Direction::Forward => line_idx.saturating_add(count),
+        Direction::Backward => line_idx.saturating_sub(count),
     };
-    let new_col = col.max(horiz as usize);
-    let new_pos = pos_at_coords(slice, Position::new(new_row, new_col), true);
+
+    let line = if new_line_idx >= slice.len_lines() - 1 {
+        // there is no line terminator for the last line
+        // so the logic below is not necessary here
+        new_line_idx = slice.len_lines() - 1;
+        slice
+    } else {
+        // char_idx_at_visual_block_offset returns a one-past-the-end index
+        // in case it reaches the end of the slice
+        // to avoid moving to the nextline in that case the line terminator is removed from the line
+        let new_line_end = prev_grapheme_boundary(slice, slice.line_to_char(new_line_idx + 1));
+        slice.slice(..new_line_end)
+    };
+
+    let new_line_start = line.line_to_char(new_line_idx);
+
+    let (new_pos, _) = char_idx_at_visual_block_offset(
+        line,
+        new_line_start,
+        new_row as usize,
+        new_col as usize,
+        text_fmt,
+        annotations,
+    );
 
     // Special-case to avoid moving to the end of the last non-empty line.
-    if behaviour == Movement::Extend && slice.line(new_row).len_chars() == 0 {
+    if behaviour == Movement::Extend && slice.line(new_line_idx).len_chars() == 0 {
         return range;
     }
 
     let mut new_range = range.put_cursor(slice, new_pos, behaviour == Movement::Extend);
-    new_range.horiz = Some(horiz);
+    new_range.old_visual_position = Some((new_row, new_col));
     new_range
 }
 
@@ -94,6 +177,10 @@ pub fn move_prev_word_start(slice: RopeSlice, range: Range, count: usize) -> Ran
     word_move(slice, range, count, WordMotionTarget::PrevWordStart)
 }
 
+pub fn move_prev_word_end(slice: RopeSlice, range: Range, count: usize) -> Range {
+    word_move(slice, range, count, WordMotionTarget::PrevWordEnd)
+}
+
 pub fn move_next_long_word_start(slice: RopeSlice, range: Range, count: usize) -> Range {
     word_move(slice, range, count, WordMotionTarget::NextLongWordStart)
 }
@@ -106,8 +193,8 @@ pub fn move_prev_long_word_start(slice: RopeSlice, range: Range, count: usize) -
     word_move(slice, range, count, WordMotionTarget::PrevLongWordStart)
 }
 
-pub fn move_prev_word_end(slice: RopeSlice, range: Range, count: usize) -> Range {
-    word_move(slice, range, count, WordMotionTarget::PrevWordEnd)
+pub fn move_prev_long_word_end(slice: RopeSlice, range: Range, count: usize) -> Range {
+    word_move(slice, range, count, WordMotionTarget::PrevLongWordEnd)
 }
 
 fn word_move(slice: RopeSlice, range: Range, count: usize, target: WordMotionTarget) -> Range {
@@ -116,6 +203,7 @@ fn word_move(slice: RopeSlice, range: Range, count: usize, target: WordMotionTar
         WordMotionTarget::PrevWordStart
             | WordMotionTarget::PrevLongWordStart
             | WordMotionTarget::PrevWordEnd
+            | WordMotionTarget::PrevLongWordEnd
     );
 
     // Special-case early-out.
@@ -144,9 +232,107 @@ fn word_move(slice: RopeSlice, range: Range, count: usize, target: WordMotionTar
     };
 
     // Do the main work.
-    (0..count).fold(start_range, |r, _| {
-        slice.chars_at(r.head).range_to_target(target, r)
-    })
+    let mut range = start_range;
+    for _ in 0..count {
+        let next_range = slice.chars_at(range.head).range_to_target(target, range);
+        if range == next_range {
+            break;
+        }
+        range = next_range;
+    }
+    range
+}
+
+pub fn move_prev_paragraph(
+    slice: RopeSlice,
+    range: Range,
+    count: usize,
+    behavior: Movement,
+) -> Range {
+    let mut line = range.cursor_line(slice);
+    let first_char = slice.line_to_char(line) == range.cursor(slice);
+    let prev_line_empty = rope_is_line_ending(slice.line(line.saturating_sub(1)));
+    let curr_line_empty = rope_is_line_ending(slice.line(line));
+    let prev_empty_to_line = prev_line_empty && !curr_line_empty;
+
+    // skip character before paragraph boundary
+    if prev_empty_to_line && !first_char {
+        line += 1;
+    }
+    let mut lines = slice.lines_at(line);
+    lines.reverse();
+    let mut lines = lines.map(rope_is_line_ending).peekable();
+    let mut last_line = line;
+    for _ in 0..count {
+        while lines.next_if(|&e| e).is_some() {
+            line -= 1;
+        }
+        while lines.next_if(|&e| !e).is_some() {
+            line -= 1;
+        }
+        if line == last_line {
+            break;
+        }
+        last_line = line;
+    }
+
+    let head = slice.line_to_char(line);
+    let anchor = if behavior == Movement::Move {
+        // exclude first character after paragraph boundary
+        if prev_empty_to_line && first_char {
+            range.cursor(slice)
+        } else {
+            range.head
+        }
+    } else {
+        range.put_cursor(slice, head, true).anchor
+    };
+    Range::new(anchor, head)
+}
+
+pub fn move_next_paragraph(
+    slice: RopeSlice,
+    range: Range,
+    count: usize,
+    behavior: Movement,
+) -> Range {
+    let mut line = range.cursor_line(slice);
+    let last_char =
+        prev_grapheme_boundary(slice, slice.line_to_char(line + 1)) == range.cursor(slice);
+    let curr_line_empty = rope_is_line_ending(slice.line(line));
+    let next_line_empty =
+        rope_is_line_ending(slice.line(slice.len_lines().saturating_sub(1).min(line + 1)));
+    let curr_empty_to_line = curr_line_empty && !next_line_empty;
+
+    // skip character after paragraph boundary
+    if curr_empty_to_line && last_char {
+        line += 1;
+    }
+    let mut lines = slice.lines_at(line).map(rope_is_line_ending).peekable();
+    let mut last_line = line;
+    for _ in 0..count {
+        while lines.next_if(|&e| !e).is_some() {
+            line += 1;
+        }
+        while lines.next_if(|&e| e).is_some() {
+            line += 1;
+        }
+        if line == last_line {
+            break;
+        }
+        last_line = line;
+    }
+    let head = slice.line_to_char(line);
+    let anchor = if behavior == Movement::Move {
+        if curr_empty_to_line && last_char {
+            range.head
+        } else {
+            range.cursor(slice)
+        }
+    } else {
+        range.put_cursor(slice, head, true).anchor
+    };
+    Range::new(anchor, head)
 }
 
 // ---- util ------------
@@ -190,12 +376,13 @@ pub enum WordMotionTarget {
     NextWordEnd,
     PrevWordStart,
     PrevWordEnd,
-    // A "Long word" (also known as a WORD in vim/kakoune) is strictly
+    // A "Long word" (also known as a WORD in Vim/Kakoune) is strictly
     // delimited by whitespace, and can consist of punctuation as well
     // as alphanumerics.
     NextLongWordStart,
     NextLongWordEnd,
     PrevLongWordStart,
+    PrevLongWordEnd,
 }
 
 pub trait CharHelpers {
@@ -212,6 +399,7 @@ impl CharHelpers for Chars<'_> {
             WordMotionTarget::PrevWordStart
                 | WordMotionTarget::PrevLongWordStart
                 | WordMotionTarget::PrevWordEnd
+                | WordMotionTarget::PrevLongWordEnd
         );
 
         // Reverse the iterator if needed for the motion direction.
@@ -298,7 +486,7 @@ fn reached_target(target: WordMotionTarget, prev_ch: char, next_ch: char) -> boo
             is_word_boundary(prev_ch, next_ch)
                 && (!prev_ch.is_whitespace() || char_is_line_ending(next_ch))
         }
-        WordMotionTarget::NextLongWordStart => {
+        WordMotionTarget::NextLongWordStart | WordMotionTarget::PrevLongWordEnd => {
             is_long_word_boundary(prev_ch, next_ch)
                 && (char_is_line_ending(next_ch) || !next_ch.is_whitespace())
         }
@@ -309,6 +497,8 @@ fn reached_target(target: WordMotionTarget, prev_ch: char, next_ch: char) -> boo
     }
 }
 
+/// Finds the range of the next or previous textobject in the syntax sub-tree of `node`.
+/// Returns the range in the forwards direction.
 pub fn goto_treesitter_object(
     slice: RopeSlice,
     range: Range,
@@ -316,9 +506,9 @@ pub fn goto_treesitter_object(
     dir: Direction,
     slice_tree: Node,
     lang_config: &LanguageConfiguration,
-    _count: usize,
+    count: usize,
 ) -> Range {
-    let get_range = move || -> Option<Range> {
+    let get_range = move |range: Range| -> Option<Range> {
         let byte_pos = slice.char_to_byte(range.cursor(slice));
 
         let cap_name = |t: TextObject| format!("{}.{}", object_name, t);
@@ -337,10 +527,10 @@ pub fn goto_treesitter_object(
         let node = match dir {
             Direction::Forward => nodes
                 .filter(|n| n.start_byte() > byte_pos)
-                .min_by_key(|n| n.start_byte())?,
+                .min_by_key(|n| (n.start_byte(), Reverse(n.end_byte())))?,
             Direction::Backward => nodes
-                .filter(|n| n.start_byte() < byte_pos)
-                .max_by_key(|n| n.start_byte())?,
+                .filter(|n| n.end_byte() < byte_pos)
+                .max_by_key(|n| (n.end_byte(), Reverse(n.start_byte())))?,
         };
 
         let len = slice.len_bytes();
@@ -354,15 +544,98 @@ pub fn goto_treesitter_object(
         let end_char = slice.byte_to_char(end_byte);
 
         // head of range should be at beginning
-        Some(Range::new(end_char, start_char))
+        Some(Range::new(start_char, end_char))
     };
-    get_range().unwrap_or(range)
+    let mut last_range = range;
+    for _ in 0..count {
+        match get_range(last_range) {
+            Some(r) if r != last_range => last_range = r,
+            _ => break,
+        }
+    }
+    last_range
+}
+
+fn find_parent_start(mut node: Node) -> Option<Node> {
+    let start = node.start_byte();
+
+    while node.start_byte() >= start || !node.is_named() {
+        node = node.parent()?;
+    }
+
+    Some(node)
+}
+
+pub fn move_parent_node_end(
+    syntax: &Syntax,
+    text: RopeSlice,
+    selection: Selection,
+    dir: Direction,
+    movement: Movement,
+) -> Selection {
+    selection.transform(|range| {
+        let start_from = text.char_to_byte(range.from());
+        let start_to = text.char_to_byte(range.to());
+
+        let mut node = match syntax.named_descendant_for_byte_range(start_from, start_to) {
+            Some(node) => node,
+            None => {
+                log::debug!(
+                    "no descendant found for byte range: {} - {}",
+                    start_from,
+                    start_to
+                );
+                return range;
+            }
+        };
+
+        let mut end_head = match dir {
+            // moving forward, we always want to move one past the end of the
+            // current node, so use the end byte of the current node, which is an exclusive
+            // end of the range
+            Direction::Forward => text.byte_to_char(node.end_byte()),
+
+            // moving backward, we want the cursor to land on the start char of
+            // the current node, or if it is already at the start of a node, to traverse up to
+            // the parent
+            Direction::Backward => {
+                let end_head = text.byte_to_char(node.start_byte());
+
+                // if we're already on the beginning, look up to the parent
+                if end_head == range.cursor(text) {
+                    node = find_parent_start(node).unwrap_or(node);
+                    text.byte_to_char(node.start_byte())
+                } else {
+                    end_head
+                }
+            }
+        };
+
+        if movement == Movement::Move {
+            // preserve direction of original range
+            if range.direction() == Direction::Forward {
+                Range::new(end_head, end_head + 1)
+            } else {
+                Range::new(end_head + 1, end_head)
+            }
+        } else {
+            // if we end up with a forward range, then adjust it to be one past
+            // where we want
+            if end_head >= range.anchor {
+                end_head += 1;
+            }
+
+            Range::new(range.anchor, end_head)
+        }
+    })
 }
 
 #[cfg(test)]
 mod test {
     use ropey::Rope;
 
+    use crate::{coords_at_pos, pos_at_coords};
+
     use super::*;
 
     const SINGLE_LINE_SAMPLE: &str = "This is a simple alphabetic line";
@@ -389,7 +662,16 @@ mod test {
         assert_eq!(
             coords_at_pos(
                 slice,
-                move_vertically(slice, range, Direction::Forward, 1, Movement::Move).head
+                move_vertically_visual(
+                    slice,
+                    range,
+                    Direction::Forward,
+                    1,
+                    Movement::Move,
+                    &TextFormat::default(),
+                    &mut TextAnnotations::default(),
+                )
+                .head
             ),
             (1, 3).into()
         );
@@ -413,7 +695,15 @@ mod test {
         ];
 
         for ((direction, amount), coordinates) in moves_and_expected_coordinates {
-            range = move_horizontally(slice, range, direction, amount, Movement::Move);
+            range = move_horizontally(
+                slice,
+                range,
+                direction,
+                amount,
+                Movement::Move,
+                &TextFormat::default(),
+                &mut TextAnnotations::default(),
+            );
             assert_eq!(coords_at_pos(slice, range.head), coordinates.into())
         }
     }
@@ -439,7 +729,15 @@ mod test {
         ];
 
         for ((direction, amount), coordinates) in moves_and_expected_coordinates {
-            range = move_horizontally(slice, range, direction, amount, Movement::Move);
+            range = move_horizontally(
+                slice,
+                range,
+                direction,
+                amount,
+                Movement::Move,
+                &TextFormat::default(),
+                &mut TextAnnotations::default(),
+            );
             assert_eq!(coords_at_pos(slice, range.head), coordinates.into());
             assert_eq!(range.head, range.anchor);
         }
@@ -461,7 +759,15 @@ mod test {
         ];
 
         for (direction, amount) in moves {
-            range = move_horizontally(slice, range, direction, amount, Movement::Extend);
+            range = move_horizontally(
+                slice,
+                range,
+                direction,
+                amount,
+                Movement::Extend,
+                &TextFormat::default(),
+                &mut TextAnnotations::default(),
+            );
             assert_eq!(range.anchor, original_anchor);
         }
     }
@@ -485,7 +791,15 @@ mod test {
         ];
 
         for ((direction, amount), coordinates) in moves_and_expected_coordinates {
-            range = move_vertically(slice, range, direction, amount, Movement::Move);
+            range = move_vertically_visual(
+                slice,
+                range,
+                direction,
+                amount,
+                Movement::Move,
+                &TextFormat::default(),
+                &mut TextAnnotations::default(),
+            );
             assert_eq!(coords_at_pos(slice, range.head), coordinates.into());
             assert_eq!(range.head, range.anchor);
         }
@@ -519,8 +833,24 @@ mod test {
 
         for ((axis, direction, amount), coordinates) in moves_and_expected_coordinates {
             range = match axis {
-                Axis::H => move_horizontally(slice, range, direction, amount, Movement::Move),
-                Axis::V => move_vertically(slice, range, direction, amount, Movement::Move),
+                Axis::H => move_horizontally(
+                    slice,
+                    range,
+                    direction,
+                    amount,
+                    Movement::Move,
+                    &TextFormat::default(),
+                    &mut TextAnnotations::default(),
+                ),
+                Axis::V => move_vertically_visual(
+                    slice,
+                    range,
+                    direction,
+                    amount,
+                    Movement::Move,
+                    &TextFormat::default(),
+                    &mut TextAnnotations::default(),
+                ),
             };
             assert_eq!(coords_at_pos(slice, range.head), coordinates.into());
             assert_eq!(range.head, range.anchor);
@@ -544,18 +874,34 @@ mod test {
         let moves_and_expected_coordinates = [
             // Places cursor at the fourth kana.
             ((Axis::H, Direction::Forward, 4), (0, 4)),
-            // Descent places cursor at the 4th character.
-            ((Axis::V, Direction::Forward, 1usize), (1, 4)),
-            // Moving back 1 character.
-            ((Axis::H, Direction::Backward, 1usize), (1, 3)),
+            // Descent places cursor at the 8th character.
+            ((Axis::V, Direction::Forward, 1usize), (1, 8)),
+            // Moving back 2 characters.
+            ((Axis::H, Direction::Backward, 2usize), (1, 6)),
             // Jumping back up 1 line.
             ((Axis::V, Direction::Backward, 1usize), (0, 3)),
         ];
 
         for ((axis, direction, amount), coordinates) in moves_and_expected_coordinates {
             range = match axis {
-                Axis::H => move_horizontally(slice, range, direction, amount, Movement::Move),
-                Axis::V => move_vertically(slice, range, direction, amount, Movement::Move),
+                Axis::H => move_horizontally(
+                    slice,
+                    range,
+                    direction,
+                    amount,
+                    Movement::Move,
+                    &TextFormat::default(),
+                    &mut TextAnnotations::default(),
+                ),
+                Axis::V => move_vertically_visual(
+                    slice,
+                    range,
+                    direction,
+                    amount,
+                    Movement::Move,
+                    &TextFormat::default(),
+                    &mut TextAnnotations::default(),
+                ),
             };
             assert_eq!(coords_at_pos(slice, range.head), coordinates.into());
             assert_eq!(range.head, range.anchor);
@@ -1179,4 +1525,266 @@ mod test {
             }
         }
     }
+
+    #[test]
+    fn test_behaviour_when_moving_to_end_of_prev_long_words() {
+        let tests = [
+            (
+                "Basic backward motion from the middle of a word",
+                vec![(1, Range::new(3, 3), Range::new(4, 0))],
+            ),
+            ("Starting from after boundary retreats the anchor",
+                vec![(1, Range::new(0, 9), Range::new(8, 0))],
+            ),
+            (
+                "Jump    to end of a word succeeded by whitespace",
+                vec![(1, Range::new(10, 10), Range::new(10, 4))],
+            ),
+            (
+                "    Jump to start of line from end of word preceded by whitespace",
+                vec![(1, Range::new(3, 4), Range::new(4, 0))],
+            ),
+            ("Previous anchor is irrelevant for backward motions",
+                vec![(1, Range::new(12, 5), Range::new(6, 0))]),
+            (
+                "    Starting from whitespace moves to first space in sequence",
+                vec![(1, Range::new(0, 4), Range::new(4, 0))],
+            ),
+            ("Identifiers_with_underscores are considered a single word",
+                vec![(1, Range::new(0, 20), Range::new(20, 0))]),
+            (
+                "Jumping\n    \nback through a newline selects whitespace",
+                vec![(1, Range::new(0, 13), Range::new(12, 8))],
+            ),
+            (
+                "Jumping to start of word from the end selects the word",
+                vec![(1, Range::new(6, 7), Range::new(7, 0))],
+            ),
+            (
+                "alphanumeric.!,and.?=punctuation are treated exactly the same",
+                vec![(1, Range::new(29, 30), Range::new(30, 0))],
+            ),
+            (
+                "...   ... punctuation and spaces behave as expected",
+                vec![
+                    (1, Range::new(0, 10), Range::new(9, 3)),
+                    (1, Range::new(10, 6), Range::new(7, 3)),
+                ],
+            ),
+            (".._.._ punctuation is joined by underscores into a single block",
+                vec![(1, Range::new(0, 6), Range::new(6, 0))]),
+            (
+                "Newlines\n\nare bridged seamlessly.",
+                vec![(1, Range::new(0, 10), Range::new(8, 0))],
+            ),
+            (
+                "Jumping    \n\n\n\n\nback from within a newline group selects previous block",
+                vec![(1, Range::new(0, 13), Range::new(11, 7))],
+            ),
+            (
+                "Failed motions do not modify the range",
+                vec![(0, Range::new(3, 0), Range::new(3, 0))],
+            ),
+            (
+                "Multiple motions at once resolve correctly",
+                vec![(3, Range::new(19, 19), Range::new(8, 0))],
+            ),
+            (
+                "Excessive motions are performed partially",
+                vec![(999, Range::new(40, 40), Range::new(9, 0))],
+            ),
+            (
+                "", // Edge case of moving backwards in empty string
+                vec![(1, Range::new(0, 0), Range::new(0, 0))],
+            ),
+            (
+                "\n\n\n\n\n", // Edge case of moving backwards in all newlines
+                vec![(1, Range::new(5, 5), Range::new(0, 0))],
+            ),
+            ("   \n   \nJumping back through alternated space blocks and newlines selects the space blocks",
+                vec![
+                    (1, Range::new(0, 8), Range::new(7, 4)),
+                    (1, Range::new(7, 4), Range::new(3, 0)),
+                ]),
+            ("ヒーリ..クス multibyte characters behave as normal characters, including when interacting with punctuation",
+                vec![
+                    (1, Range::new(0, 8), Range::new(7, 0)),
+                ]),
+        ];
+
+        for (sample, scenario) in tests {
+            for (count, begin, expected_end) in scenario.into_iter() {
+                let range = move_prev_long_word_end(Rope::from(sample).slice(..), begin, count);
+                assert_eq!(range, expected_end, "Case failed: [{}]", sample);
+            }
+        }
+    }
+
+    #[test]
+    fn test_behaviour_when_moving_to_prev_paragraph_single() {
+        let tests = [
+            ("#[|]#", "#[|]#"),
+            ("#[s|]#tart at\nfirst char\n", "#[|s]#tart at\nfirst char\n"),
+            ("start at\nlast char#[\n|]#", "#[|start at\nlast char\n]#"),
+            (
+                "goto\nfirst\n\n#[p|]#aragraph",
+                "#[|goto\nfirst\n\n]#paragraph",
+            ),
+            (
+                "goto\nfirst\n#[\n|]#paragraph",
+                "#[|goto\nfirst\n\n]#paragraph",
+            ),
+            (
+                "goto\nsecond\n\np#[a|]#ragraph",
+                "goto\nsecond\n\n#[|pa]#ragraph",
+            ),
+            (
+                "here\n\nhave\nmultiple\nparagraph\n\n\n\n\n#[|]#",
+                "here\n\n#[|have\nmultiple\nparagraph\n\n\n\n\n]#",
+            ),
+        ];
+
+        for (before, expected) in tests {
+            let (s, selection) = crate::test::print(before);
+            let text = Rope::from(s.as_str());
+            let selection =
+                selection.transform(|r| move_prev_paragraph(text.slice(..), r, 1, Movement::Move));
+            let actual = crate::test::plain(s.as_ref(), &selection);
+            assert_eq!(actual, expected, "\nbefore: `{:?}`", before);
+        }
+    }
+
+    #[test]
+    fn test_behaviour_when_moving_to_prev_paragraph_double() {
+        let tests = [
+            (
+                "on#[e|]#\n\ntwo\n\nthree\n\n",
+                "#[|one]#\n\ntwo\n\nthree\n\n",
+            ),
+            (
+                "one\n\ntwo\n\nth#[r|]#ee\n\n",
+                "one\n\n#[|two\n\nthr]#ee\n\n",
+            ),
+        ];
+
+        for (before, expected) in tests {
+            let (s, selection) = crate::test::print(before);
+            let text = Rope::from(s.as_str());
+            let selection =
+                selection.transform(|r| move_prev_paragraph(text.slice(..), r, 2, Movement::Move));
+            let actual = crate::test::plain(s.as_ref(), &selection);
+            assert_eq!(actual, expected, "\nbefore: `{:?}`", before);
+        }
+    }
+
+    #[test]
+    fn test_behaviour_when_moving_to_prev_paragraph_extend() {
+        let tests = [
+            (
+                "one\n\n#[|two\n\n]#three\n\n",
+                "#[|one\n\ntwo\n\n]#three\n\n",
+            ),
+            (
+                "#[|one\n\ntwo\n\n]#three\n\n",
+                "#[|one\n\ntwo\n\n]#three\n\n",
+            ),
+        ];
+
+        for (before, expected) in tests {
+            let (s, selection) = crate::test::print(before);
+            let text = Rope::from(s.as_str());
+            let selection = selection
+                .transform(|r| move_prev_paragraph(text.slice(..), r, 1, Movement::Extend));
+            let actual = crate::test::plain(s.as_ref(), &selection);
+            assert_eq!(actual, expected, "\nbefore: `{:?}`", before);
+        }
+    }
+
+    #[test]
+    fn test_behaviour_when_moving_to_next_paragraph_single() {
+        let tests = [
+            ("#[|]#", "#[|]#"),
+            ("#[s|]#tart at\nfirst char\n", "#[start at\nfirst char\n|]#"),
+            ("start at\nlast char#[\n|]#", "start at\nlast char#[\n|]#"),
+            (
+                "a\nb\n\n#[g|]#oto\nthird\n\nparagraph",
+                "a\nb\n\n#[goto\nthird\n\n|]#paragraph",
+            ),
+            (
+                "a\nb\n#[\n|]#goto\nthird\n\nparagraph",
+                "a\nb\n\n#[goto\nthird\n\n|]#paragraph",
+            ),
+            (
+                "a\nb#[\n|]#\n\ngoto\nsecond\n\nparagraph",
+                "a\nb#[\n\n|]#goto\nsecond\n\nparagraph",
+            ),
+            (
+                "here\n\nhave\n#[m|]#ultiple\nparagraph\n\n\n\n\n",
+                "here\n\nhave\n#[multiple\nparagraph\n\n\n\n\n|]#",
+            ),
+            (
+                "#[t|]#ext\n\n\nafter two blank lines\n\nmore text\n",
+                "#[text\n\n\n|]#after two blank lines\n\nmore text\n",
+            ),
+            (
+                "#[text\n\n\n|]#after two blank lines\n\nmore text\n",
+                "text\n\n\n#[after two blank lines\n\n|]#more text\n",
+            ),
+        ];
+
+        for (before, expected) in tests {
+            let (s, selection) = crate::test::print(before);
+            let text = Rope::from(s.as_str());
+            let selection =
+                selection.transform(|r| move_next_paragraph(text.slice(..), r, 1, Movement::Move));
+            let actual = crate::test::plain(s.as_ref(), &selection);
+            assert_eq!(actual, expected, "\nbefore: `{:?}`", before);
+        }
+    }
+
+    #[test]
+    fn test_behaviour_when_moving_to_next_paragraph_double() {
+        let tests = [
+            (
+                "one\n\ntwo\n\nth#[r|]#ee\n\n",
+                "one\n\ntwo\n\nth#[ree\n\n|]#",
+            ),
+            (
+                "on#[e|]#\n\ntwo\n\nthree\n\n",
+                "on#[e\n\ntwo\n\n|]#three\n\n",
+            ),
+        ];
+
+        for (before, expected) in tests {
+            let (s, selection) = crate::test::print(before);
+            let text = Rope::from(s.as_str());
+            let selection =
+                selection.transform(|r| move_next_paragraph(text.slice(..), r, 2, Movement::Move));
+            let actual = crate::test::plain(s.as_ref(), &selection);
+            assert_eq!(actual, expected, "\nbefore: `{:?}`", before);
+        }
+    }
+
+    #[test]
+    fn test_behaviour_when_moving_to_next_paragraph_extend() {
+        let tests = [
+            (
+                "one\n\n#[two\n\n|]#three\n\n",
+                "one\n\n#[two\n\nthree\n\n|]#",
+            ),
+            (
+                "one\n\n#[two\n\nthree\n\n|]#",
+                "one\n\n#[two\n\nthree\n\n|]#",
+            ),
+        ];
+
+        for (before, expected) in tests {
+            let (s, selection) = crate::test::print(before);
+            let text = Rope::from(s.as_str());
+            let selection = selection
+                .transform(|r| move_next_paragraph(text.slice(..), r, 1, Movement::Extend));
+            let actual = crate::test::plain(s.as_ref(), &selection);
+            assert_eq!(actual, expected, "\nbefore: `{:?}`", before);
+        }
+    }
 }

helix-core/src/object.rs

@@ -1,77 +1,137 @@
-use crate::{Range, RopeSlice, Selection, Syntax};
-use tree_sitter::Node;
+use crate::{movement::Direction, syntax::TreeCursor, Range, RopeSlice, Selection, Syntax};
 
 pub fn expand_selection(syntax: &Syntax, text: RopeSlice, selection: Selection) -> Selection {
-    select_node_impl(syntax, text, selection, |descendant, from, to| {
-        if descendant.start_byte() == from && descendant.end_byte() == to {
-            descendant.parent()
-        } else {
-            Some(descendant)
+    let cursor = &mut syntax.walk();
+
+    selection.transform(|range| {
+        let from = text.char_to_byte(range.from());
+        let to = text.char_to_byte(range.to());
+
+        let byte_range = from..to;
+        cursor.reset_to_byte_range(from, to);
+
+        while cursor.node().byte_range() == byte_range {
+            if !cursor.goto_parent() {
+                break;
+            }
         }
+
+        let node = cursor.node();
+        let from = text.byte_to_char(node.start_byte());
+        let to = text.byte_to_char(node.end_byte());
+
+        Range::new(to, from).with_direction(range.direction())
     })
 }
 
 pub fn shrink_selection(syntax: &Syntax, text: RopeSlice, selection: Selection) -> Selection {
-    select_node_impl(syntax, text, selection, |descendant, _from, _to| {
-        descendant.child(0).or(Some(descendant))
+    select_node_impl(
+        syntax,
+        text,
+        selection,
+        |cursor| {
+            cursor.goto_first_child();
+        },
+        None,
+    )
+}
+
+pub fn select_next_sibling(syntax: &Syntax, text: RopeSlice, selection: Selection) -> Selection {
+    select_node_impl(
+        syntax,
+        text,
+        selection,
+        |cursor| {
+            while !cursor.goto_next_sibling() {
+                if !cursor.goto_parent() {
+                    break;
+                }
+            }
+        },
+        Some(Direction::Forward),
+    )
+}
+
+pub fn select_all_siblings(syntax: &Syntax, text: RopeSlice, selection: Selection) -> Selection {
+    selection.transform_iter(|range| {
+        let mut cursor = syntax.walk();
+        let (from, to) = range.into_byte_range(text);
+        cursor.reset_to_byte_range(from, to);
+
+        if !cursor.goto_parent_with(|parent| parent.child_count() > 1) {
+            return vec![range].into_iter();
+        }
+
+        select_children(&mut cursor, text, range).into_iter()
     })
 }
 
-pub fn select_sibling<F>(
-    syntax: &Syntax,
+pub fn select_all_children(syntax: &Syntax, text: RopeSlice, selection: Selection) -> Selection {
+    selection.transform_iter(|range| {
+        let mut cursor = syntax.walk();
+        let (from, to) = range.into_byte_range(text);
+        cursor.reset_to_byte_range(from, to);
+        select_children(&mut cursor, text, range).into_iter()
+    })
+}
+
+fn select_children<'n>(
+    cursor: &'n mut TreeCursor<'n>,
     text: RopeSlice,
-    selection: Selection,
-    sibling_fn: &F,
-) -> Selection
-where
-    F: Fn(Node) -> Option<Node>,
-{
-    select_node_impl(syntax, text, selection, |descendant, _from, _to| {
-        find_sibling_recursive(descendant, sibling_fn)
-    })
+    range: Range,
+) -> Vec<Range> {
+    let children = cursor
+        .named_children()
+        .map(|child| Range::from_node(child, text, range.direction()))
+        .collect::<Vec<_>>();
+
+    if !children.is_empty() {
+        children
+    } else {
+        vec![range]
+    }
 }
 
-fn find_sibling_recursive<F>(node: Node, sibling_fn: F) -> Option<Node>
-where
-    F: Fn(Node) -> Option<Node>,
-{
-    sibling_fn(node).or_else(|| {
-        node.parent()
-            .and_then(|node| find_sibling_recursive(node, sibling_fn))
-    })
+pub fn select_prev_sibling(syntax: &Syntax, text: RopeSlice, selection: Selection) -> Selection {
+    select_node_impl(
+        syntax,
+        text,
+        selection,
+        |cursor| {
+            while !cursor.goto_prev_sibling() {
+                if !cursor.goto_parent() {
+                    break;
+                }
+            }
+        },
+        Some(Direction::Backward),
+    )
 }
 
 fn select_node_impl<F>(
     syntax: &Syntax,
     text: RopeSlice,
     selection: Selection,
-    select_fn: F,
+    motion: F,
+    direction: Option<Direction>,
 ) -> Selection
 where
-    F: Fn(Node, usize, usize) -> Option<Node>,
+    F: Fn(&mut TreeCursor),
 {
-    let tree = syntax.tree();
+    let cursor = &mut syntax.walk();
 
     selection.transform(|range| {
         let from = text.char_to_byte(range.from());
         let to = text.char_to_byte(range.to());
 
-        let node = match tree
-            .root_node()
-            .descendant_for_byte_range(from, to)
-            .and_then(|node| select_fn(node, from, to))
-        {
-            Some(node) => node,
-            None => return range,
-        };
+        cursor.reset_to_byte_range(from, to);
 
+        motion(cursor);
+
+        let node = cursor.node();
         let from = text.byte_to_char(node.start_byte());
         let to = text.byte_to_char(node.end_byte());
 
-        if range.head < range.anchor {
-            Range::new(to, from)
-        } else {
-            Range::new(from, to)
-        }
+        Range::new(from, to).with_direction(direction.unwrap_or_else(|| range.direction()))
     })
 }

helix-core/src/path.rs

@@ -1,93 +0,0 @@
-use etcetera::home_dir;
-use std::path::{Component, Path, PathBuf};
-
-/// Replaces users home directory from `path` with tilde `~` if the directory
-/// is available, otherwise returns the path unchanged.
-pub fn fold_home_dir(path: &Path) -> PathBuf {
-    if let Ok(home) = home_dir() {
-        if path.starts_with(&home) {
-            // it's ok to unwrap, the path starts with home dir
-            return PathBuf::from("~").join(path.strip_prefix(&home).unwrap());
-        }
-    }
-
-    path.to_path_buf()
-}
-
-/// Expands tilde `~` into users home directory if avilable, otherwise returns the path
-/// unchanged. The tilde will only be expanded when present as the first component of the path
-/// and only slash follows it.
-pub fn expand_tilde(path: &Path) -> PathBuf {
-    let mut components = path.components().peekable();
-    if let Some(Component::Normal(c)) = components.peek() {
-        if c == &"~" {
-            if let Ok(home) = home_dir() {
-                // it's ok to unwrap, the path starts with `~`
-                return home.join(path.strip_prefix("~").unwrap());
-            }
-        }
-    }
-
-    path.to_path_buf()
-}
-
-/// Normalize a path, removing things like `.` and `..`.
-///
-/// CAUTION: This does not resolve symlinks (unlike
-/// [`std::fs::canonicalize`]). This may cause incorrect or surprising
-/// behavior at times. This should be used carefully. Unfortunately,
-/// [`std::fs::canonicalize`] can be hard to use correctly, since it can often
-/// fail, or on Windows returns annoying device paths. This is a problem Cargo
-/// needs to improve on.
-/// Copied from cargo: <https://github.com/rust-lang/cargo/blob/070e459c2d8b79c5b2ac5218064e7603329c92ae/crates/cargo-util/src/paths.rs#L81>
-pub fn get_normalized_path(path: &Path) -> PathBuf {
-    let mut components = path.components().peekable();
-    let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() {
-        components.next();
-        PathBuf::from(c.as_os_str())
-    } else {
-        PathBuf::new()
-    };
-
-    for component in components {
-        match component {
-            Component::Prefix(..) => unreachable!(),
-            Component::RootDir => {
-                ret.push(component.as_os_str());
-            }
-            Component::CurDir => {}
-            Component::ParentDir => {
-                ret.pop();
-            }
-            Component::Normal(c) => {
-                ret.push(c);
-            }
-        }
-    }
-    ret
-}
-
-/// Returns the canonical, absolute form of a path with all intermediate components normalized.
-///
-/// This function is used instead of `std::fs::canonicalize` because we don't want to verify
-/// here if the path exists, just normalize it's components.
-pub fn get_canonicalized_path(path: &Path) -> std::io::Result<PathBuf> {
-    let path = expand_tilde(path);
-    let path = if path.is_relative() {
-        std::env::current_dir().map(|current_dir| current_dir.join(path))?
-    } else {
-        path
-    };
-
-    Ok(get_normalized_path(path.as_path()))
-}
-
-pub fn get_relative_path(path: &Path) -> PathBuf {
-    let path = if path.is_absolute() {
-        let cwdir = std::env::current_dir().expect("couldn't determine current directory");
-        path.strip_prefix(cwdir).unwrap_or(path)
-    } else {
-        path
-    };
-    fold_home_dir(path)
-}

helix-core/src/position.rs

@@ -1,9 +1,11 @@
-use std::borrow::Cow;
+use std::{borrow::Cow, cmp::Ordering};
 
 use crate::{
     chars::char_is_line_ending,
+    doc_formatter::{DocumentFormatter, TextFormat},
     graphemes::{ensure_grapheme_boundary_prev, grapheme_width, RopeGraphemes},
     line_ending::line_end_char_index,
+    text_annotations::TextAnnotations,
     RopeSlice,
 };
 
@@ -73,6 +75,13 @@ pub fn coords_at_pos(text: RopeSlice, pos: usize) -> Position {
 /// Takes \t, double-width characters (CJK) into account as well as text
 /// not in the document in the future.
 /// See [`coords_at_pos`] for an "objective" one.
+///
+/// This function should be used very rarely. Usually `visual_offset_from_anchor`
+/// or `visual_offset_from_block` is preferable. However when you want to compute the
+/// actual visual row/column in the text (not what is actually shown on screen)
+/// then you should use this function. For example aligning text should ignore virtual
+/// text and softwrap.
+#[deprecated = "Doesn't account for softwrap or decorations, use visual_offset_from_anchor instead"]
 pub fn visual_coords_at_pos(text: RopeSlice, pos: usize, tab_width: usize) -> Position {
     let line = text.char_to_line(pos);
 
@@ -93,6 +102,106 @@ pub fn visual_coords_at_pos(text: RopeSlice, pos: usize, tab_width: usize) -> Po
     Position::new(line, col)
 }
 
+/// Returns the visual offset from the start of the first visual line
+/// in the block that contains anchor.
+/// Text is always wrapped at blocks, they usually correspond to
+/// actual line breaks but for very long lines
+/// softwrapping positions are estimated with an O(1) algorithm
+/// to ensure consistent performance for large lines (currently unimplemented)
+///
+/// Usually you want to use `visual_offset_from_anchor` instead but this function
+/// can be useful (and faster) if
+/// * You already know the visual position of the block
+/// * You only care about the horizontal offset (column) and not the vertical offset (row)
+pub fn visual_offset_from_block(
+    text: RopeSlice,
+    anchor: usize,
+    pos: usize,
+    text_fmt: &TextFormat,
+    annotations: &TextAnnotations,
+) -> (Position, usize) {
+    let mut last_pos = Position::default();
+    let (formatter, block_start) =
+        DocumentFormatter::new_at_prev_checkpoint(text, text_fmt, annotations, anchor);
+    let mut char_pos = block_start;
+
+    for (grapheme, vpos) in formatter {
+        last_pos = vpos;
+        char_pos += grapheme.doc_chars();
+
+        if char_pos > pos {
+            return (last_pos, block_start);
+        }
+    }
+
+    (last_pos, block_start)
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum VisualOffsetError {
+    PosBeforeAnchorRow,
+    PosAfterMaxRow,
+}
+
+/// Returns the visual offset from the start of the visual line
+/// that contains anchor.
+pub fn visual_offset_from_anchor(
+    text: RopeSlice,
+    anchor: usize,
+    pos: usize,
+    text_fmt: &TextFormat,
+    annotations: &TextAnnotations,
+    max_rows: usize,
+) -> Result<(Position, usize), VisualOffsetError> {
+    let (formatter, block_start) =
+        DocumentFormatter::new_at_prev_checkpoint(text, text_fmt, annotations, anchor);
+    let mut char_pos = block_start;
+    let mut anchor_line = None;
+    let mut found_pos = None;
+    let mut last_pos = Position::default();
+
+    if pos < block_start {
+        return Err(VisualOffsetError::PosBeforeAnchorRow);
+    }
+
+    for (grapheme, vpos) in formatter {
+        last_pos = vpos;
+        char_pos += grapheme.doc_chars();
+
+        if char_pos > pos {
+            if let Some(anchor_line) = anchor_line {
+                last_pos.row -= anchor_line;
+                return Ok((last_pos, block_start));
+            } else {
+                found_pos = Some(last_pos);
+            }
+        }
+        if char_pos > anchor && anchor_line.is_none() {
+            if let Some(mut found_pos) = found_pos {
+                return if found_pos.row == last_pos.row {
+                    found_pos.row = 0;
+                    Ok((found_pos, block_start))
+                } else {
+                    Err(VisualOffsetError::PosBeforeAnchorRow)
+                };
+            } else {
+                anchor_line = Some(last_pos.row);
+            }
+        }
+
+        if let Some(anchor_line) = anchor_line {
+            if vpos.row >= anchor_line + max_rows {
+                return Err(VisualOffsetError::PosAfterMaxRow);
+            }
+        }
+    }
+
+    let anchor_line = anchor_line.unwrap_or(last_pos.row);
+    last_pos.row -= anchor_line;
+
+    Ok((last_pos, block_start))
+}
+
 /// Convert (line, column) coordinates to a character index.
 ///
 /// If the `line` coordinate is beyond the end of the file, the EOF
@@ -109,9 +218,6 @@ pub fn visual_coords_at_pos(text: RopeSlice, pos: usize, tab_width: usize) -> Po
 /// with left-side block-cursor positions, as this prevents the the block cursor
 /// from jumping to the next line.  Otherwise you typically want it to be `false`,
 /// such as when dealing with raw anchor/head positions.
-///
-/// TODO: this should be changed to work in terms of visual row/column, not
-/// graphemes.
 pub fn pos_at_coords(text: RopeSlice, coords: Position, limit_before_line_ending: bool) -> usize {
     let Position { mut row, col } = coords;
     if limit_before_line_ending {
@@ -135,6 +241,163 @@ pub fn pos_at_coords(text: RopeSlice, coords: Position, limit_before_line_ending
     line_start + col_char_offset
 }
 
+/// Convert visual (line, column) coordinates to a character index.
+///
+/// If the `line` coordinate is beyond the end of the file, the EOF
+/// position will be returned.
+///
+/// If the `column` coordinate is past the end of the given line, the
+/// line-end position (in this case, just before the line ending
+/// character) will be returned.
+/// This function should be used very rarely. Usually `char_idx_at_visual_offset` is preferable.
+/// However when you want to compute a char position from the visual row/column in the text
+/// (not what is actually shown on screen) then you should use this function.
+/// For example aligning text should ignore virtual text and softwrap.
+#[deprecated = "Doesn't account for softwrap or decorations, use char_idx_at_visual_offset instead"]
+pub fn pos_at_visual_coords(text: RopeSlice, coords: Position, tab_width: usize) -> usize {
+    let Position { mut row, col } = coords;
+    row = row.min(text.len_lines() - 1);
+    let line_start = text.line_to_char(row);
+    let line_end = line_end_char_index(&text, row);
+
+    let mut col_char_offset = 0;
+    let mut cols_remaining = col;
+    for grapheme in RopeGraphemes::new(text.slice(line_start..line_end)) {
+        let grapheme_width = if grapheme == "\t" {
+            tab_width - ((col - cols_remaining) % tab_width)
+        } else {
+            let grapheme = Cow::from(grapheme);
+            grapheme_width(&grapheme)
+        };
+
+        // If pos is in the middle of a wider grapheme (tab for example)
+        // return the starting offset.
+        if grapheme_width > cols_remaining {
+            break;
+        }
+
+        cols_remaining -= grapheme_width;
+        col_char_offset += grapheme.chars().count();
+    }
+
+    line_start + col_char_offset
+}
+
+/// Returns the char index on the visual line `row_offset` below the visual line of
+/// the provided char index `anchor` that is closest to the supplied visual `column`.
+///
+/// If the targeted visual line is entirely covered by virtual text the last
+/// char position before the virtual text and a virtual offset is returned instead.
+///
+/// If no (text) grapheme starts at exactly at the specified column the
+/// start of the grapheme to the left is returned. If there is no grapheme
+/// to the left (for example if the line starts with virtual text) then the positioning
+/// of the next grapheme to the right is returned.
+///
+/// If the `line` coordinate is beyond the end of the file, the EOF
+/// position will be returned.
+///
+/// If the `column` coordinate is past the end of the given line, the
+/// line-end position (in this case, just before the line ending
+/// character) will be returned.
+///
+/// # Returns
+///
+/// `(real_char_idx, virtual_lines)`
+///
+/// The nearest character idx "closest" (see above) to the specified visual offset
+/// on the visual line is returned if the visual line contains any text:
+/// If the visual line at the specified offset is a virtual line generated by a `LineAnnotation`
+/// the previous char_index is returned, together with the remaining vertical offset (`virtual_lines`)
+pub fn char_idx_at_visual_offset(
+    text: RopeSlice,
+    mut anchor: usize,
+    mut row_offset: isize,
+    column: usize,
+    text_fmt: &TextFormat,
+    annotations: &TextAnnotations,
+) -> (usize, usize) {
+    let mut pos = anchor;
+    // convert row relative to visual line containing anchor to row relative to a block containing anchor (anchor may change)
+    loop {
+        let (visual_pos_in_block, block_char_offset) =
+            visual_offset_from_block(text, anchor, pos, text_fmt, annotations);
+        row_offset += visual_pos_in_block.row as isize;
+        anchor = block_char_offset;
+        if row_offset >= 0 {
+            break;
+        }
+
+        if block_char_offset == 0 {
+            row_offset = 0;
+            break;
+        }
+        // the row_offset is negative so we need to look at the previous block
+        // set the anchor to the last char before the current block so that we can compute
+        // the distance of this block from the start of the previous block
+        pos = anchor;
+        anchor -= 1;
+    }
+
+    char_idx_at_visual_block_offset(
+        text,
+        anchor,
+        row_offset as usize,
+        column,
+        text_fmt,
+        annotations,
+    )
+}
+
+/// This function behaves the same as `char_idx_at_visual_offset`, except that
+/// the vertical offset `row` is always computed relative to the block that contains `anchor`
+/// instead of the visual line that contains `anchor`.
+/// Usually `char_idx_at_visual_offset` is more useful but this function can be
+/// used in some situations as an optimization when `visual_offset_from_block` was used
+///
+/// # Returns
+///
+/// `(real_char_idx, virtual_lines)`
+///
+/// See `char_idx_at_visual_offset` for details
+pub fn char_idx_at_visual_block_offset(
+    text: RopeSlice,
+    anchor: usize,
+    row: usize,
+    column: usize,
+    text_fmt: &TextFormat,
+    annotations: &TextAnnotations,
+) -> (usize, usize) {
+    let (formatter, mut char_idx) =
+        DocumentFormatter::new_at_prev_checkpoint(text, text_fmt, annotations, anchor);
+    let mut last_char_idx = char_idx;
+    let mut last_char_idx_on_line = None;
+    let mut last_row = 0;
+    for (grapheme, grapheme_pos) in formatter {
+        match grapheme_pos.row.cmp(&row) {
+            Ordering::Equal => {
+                if grapheme_pos.col + grapheme.width() > column {
+                    if !grapheme.is_virtual() {
+                        return (char_idx, 0);
+                    } else if let Some(char_idx) = last_char_idx_on_line {
+                        return (char_idx, 0);
+                    }
+                } else if !grapheme.is_virtual() {
+                    last_char_idx_on_line = Some(char_idx)
+                }
+            }
+            Ordering::Greater => return (last_char_idx, row - last_row),
+            _ => (),
+        }
+
+        last_char_idx = char_idx;
+        last_row = grapheme_pos.row;
+        char_idx += grapheme.doc_chars();
+    }
+
+    (char_idx, 0)
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
@@ -194,6 +457,7 @@ mod test {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_visual_coords_at_pos() {
         let text = Rope::from("ḧëḷḷö\nẅöṛḷḋ");
         let slice = text.slice(..);
@@ -241,6 +505,130 @@ mod test {
         assert_eq!(visual_coords_at_pos(slice, 2, 8), (0, 9).into());
     }
 
+    #[test]
+    fn test_visual_off_from_block() {
+        let text = Rope::from("ḧëḷḷö\nẅöṛḷḋ");
+        let slice = text.slice(..);
+        let annot = TextAnnotations::default();
+        let text_fmt = TextFormat::default();
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 0, &text_fmt, &annot).0,
+            (0, 0).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 5, &text_fmt, &annot).0,
+            (0, 5).into()
+        ); // position on \n
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 6, &text_fmt, &annot).0,
+            (1, 0).into()
+        ); // position on w
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 7, &text_fmt, &annot).0,
+            (1, 1).into()
+        ); // position on o
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 10, &text_fmt, &annot).0,
+            (1, 4).into()
+        ); // position on d
+
+        // Test with wide characters.
+        let text = Rope::from("今日はいい\n");
+        let slice = text.slice(..);
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 0, &text_fmt, &annot).0,
+            (0, 0).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 1, &text_fmt, &annot).0,
+            (0, 2).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 2, &text_fmt, &annot).0,
+            (0, 4).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 3, &text_fmt, &annot).0,
+            (0, 6).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 4, &text_fmt, &annot).0,
+            (0, 8).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 5, &text_fmt, &annot).0,
+            (0, 10).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 6, &text_fmt, &annot).0,
+            (1, 0).into()
+        );
+
+        // Test with grapheme clusters.
+        let text = Rope::from("a̐éö̲\r\n");
+        let slice = text.slice(..);
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 0, &text_fmt, &annot).0,
+            (0, 0).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 2, &text_fmt, &annot).0,
+            (0, 1).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 4, &text_fmt, &annot).0,
+            (0, 2).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 7, &text_fmt, &annot).0,
+            (0, 3).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 9, &text_fmt, &annot).0,
+            (1, 0).into()
+        );
+
+        // Test with wide-character grapheme clusters.
+        // TODO: account for cluster.
+        let text = Rope::from("किमपि\n");
+        let slice = text.slice(..);
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 0, &text_fmt, &annot).0,
+            (0, 0).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 2, &text_fmt, &annot).0,
+            (0, 2).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 3, &text_fmt, &annot).0,
+            (0, 3).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 5, &text_fmt, &annot).0,
+            (0, 5).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 6, &text_fmt, &annot).0,
+            (1, 0).into()
+        );
+
+        // Test with tabs.
+        let text = Rope::from("\tHello\n");
+        let slice = text.slice(..);
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 0, &text_fmt, &annot).0,
+            (0, 0).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 1, &text_fmt, &annot).0,
+            (0, 4).into()
+        );
+        assert_eq!(
+            visual_offset_from_block(slice, 0, 2, &text_fmt, &annot).0,
+            (0, 5).into()
+        );
+    }
     #[test]
     fn test_pos_at_coords() {
         let text = Rope::from("ḧëḷḷö\nẅöṛḷḋ");
@@ -305,4 +693,167 @@ mod test {
         assert_eq!(pos_at_coords(slice, (0, 10).into(), true), 0);
         assert_eq!(pos_at_coords(slice, (10, 10).into(), true), 0);
     }
+
+    #[test]
+    #[allow(deprecated)]
+    fn test_pos_at_visual_coords() {
+        let text = Rope::from("ḧëḷḷö\nẅöṛḷḋ");
+        let slice = text.slice(..);
+        assert_eq!(pos_at_visual_coords(slice, (0, 0).into(), 4), 0);
+        assert_eq!(pos_at_visual_coords(slice, (0, 5).into(), 4), 5); // position on \n
+        assert_eq!(pos_at_visual_coords(slice, (0, 6).into(), 4), 5); // position after \n
+        assert_eq!(pos_at_visual_coords(slice, (1, 0).into(), 4), 6); // position on w
+        assert_eq!(pos_at_visual_coords(slice, (1, 1).into(), 4), 7); // position on o
+        assert_eq!(pos_at_visual_coords(slice, (1, 4).into(), 4), 10); // position on d
+
+        // Test with wide characters.
+        let text = Rope::from("今日はいい\n");
+        let slice = text.slice(..);
+        assert_eq!(pos_at_visual_coords(slice, (0, 0).into(), 4), 0);
+        assert_eq!(pos_at_visual_coords(slice, (0, 1).into(), 4), 0);
+        assert_eq!(pos_at_visual_coords(slice, (0, 2).into(), 4), 1);
+        assert_eq!(pos_at_visual_coords(slice, (0, 3).into(), 4), 1);
+        assert_eq!(pos_at_visual_coords(slice, (0, 4).into(), 4), 2);
+        assert_eq!(pos_at_visual_coords(slice, (0, 5).into(), 4), 2);
+        assert_eq!(pos_at_visual_coords(slice, (0, 6).into(), 4), 3);
+        assert_eq!(pos_at_visual_coords(slice, (0, 7).into(), 4), 3);
+        assert_eq!(pos_at_visual_coords(slice, (0, 8).into(), 4), 4);
+        assert_eq!(pos_at_visual_coords(slice, (0, 9).into(), 4), 4);
+        // assert_eq!(pos_at_visual_coords(slice, (0, 10).into(), 4, false), 5);
+        // assert_eq!(pos_at_visual_coords(slice, (0, 10).into(), 4, true), 5);
+        assert_eq!(pos_at_visual_coords(slice, (1, 0).into(), 4), 6);
+
+        // Test with grapheme clusters.
+        let text = Rope::from("a̐éö̲\r\n");
+        let slice = text.slice(..);
+        assert_eq!(pos_at_visual_coords(slice, (0, 0).into(), 4), 0);
+        assert_eq!(pos_at_visual_coords(slice, (0, 1).into(), 4), 2);
+        assert_eq!(pos_at_visual_coords(slice, (0, 2).into(), 4), 4);
+        assert_eq!(pos_at_visual_coords(slice, (0, 3).into(), 4), 7); // \r\n is one char here
+        assert_eq!(pos_at_visual_coords(slice, (0, 4).into(), 4), 7);
+        assert_eq!(pos_at_visual_coords(slice, (1, 0).into(), 4), 9);
+
+        // Test with wide-character grapheme clusters.
+        let text = Rope::from("किमपि");
+        // 2 - 1 - 2 codepoints
+        // TODO: delete handling as per https://news.ycombinator.com/item?id=20058454
+        let slice = text.slice(..);
+        assert_eq!(pos_at_visual_coords(slice, (0, 0).into(), 4), 0);
+        assert_eq!(pos_at_visual_coords(slice, (0, 1).into(), 4), 0);
+        assert_eq!(pos_at_visual_coords(slice, (0, 2).into(), 4), 2);
+        assert_eq!(pos_at_visual_coords(slice, (0, 3).into(), 4), 3);
+
+        // Test with tabs.
+        let text = Rope::from("\tHello\n");
+        let slice = text.slice(..);
+        assert_eq!(pos_at_visual_coords(slice, (0, 0).into(), 4), 0);
+        assert_eq!(pos_at_visual_coords(slice, (0, 1).into(), 4), 0);
+        assert_eq!(pos_at_visual_coords(slice, (0, 2).into(), 4), 0);
+        assert_eq!(pos_at_visual_coords(slice, (0, 3).into(), 4), 0);
+        assert_eq!(pos_at_visual_coords(slice, (0, 4).into(), 4), 1);
+        assert_eq!(pos_at_visual_coords(slice, (0, 5).into(), 4), 2);
+
+        // Test out of bounds.
+        let text = Rope::new();
+        let slice = text.slice(..);
+        assert_eq!(pos_at_visual_coords(slice, (10, 0).into(), 4), 0);
+        assert_eq!(pos_at_visual_coords(slice, (0, 10).into(), 4), 0);
+        assert_eq!(pos_at_visual_coords(slice, (10, 10).into(), 4), 0);
+    }
+
+    #[test]
+    fn test_char_idx_at_visual_row_offset() {
+        let text = Rope::from("ḧëḷḷö\nẅöṛḷḋ\nfoo");
+        let slice = text.slice(..);
+        let mut text_fmt = TextFormat::default();
+        for i in 0isize..3isize {
+            for j in -2isize..=2isize {
+                if !(0..3).contains(&(i + j)) {
+                    continue;
+                }
+                println!("{i} {j}");
+                assert_eq!(
+                    char_idx_at_visual_offset(
+                        slice,
+                        slice.line_to_char(i as usize),
+                        j,
+                        3,
+                        &text_fmt,
+                        &TextAnnotations::default(),
+                    )
+                    .0,
+                    slice.line_to_char((i + j) as usize) + 3
+                );
+            }
+        }
+
+        text_fmt.soft_wrap = true;
+        let mut softwrapped_text = "foo ".repeat(10);
+        softwrapped_text.push('\n');
+        let last_char = softwrapped_text.len() - 1;
+
+        let text = Rope::from(softwrapped_text.repeat(3));
+        let slice = text.slice(..);
+        assert_eq!(
+            char_idx_at_visual_offset(
+                slice,
+                last_char,
+                0,
+                0,
+                &text_fmt,
+                &TextAnnotations::default(),
+            )
+            .0,
+            32
+        );
+        assert_eq!(
+            char_idx_at_visual_offset(
+                slice,
+                last_char,
+                -1,
+                0,
+                &text_fmt,
+                &TextAnnotations::default(),
+            )
+            .0,
+            16
+        );
+        assert_eq!(
+            char_idx_at_visual_offset(
+                slice,
+                last_char,
+                -2,
+                0,
+                &text_fmt,
+                &TextAnnotations::default(),
+            )
+            .0,
+            0
+        );
+        assert_eq!(
+            char_idx_at_visual_offset(
+                slice,
+                softwrapped_text.len() + last_char,
+                -2,
+                0,
+                &text_fmt,
+                &TextAnnotations::default(),
+            )
+            .0,
+            softwrapped_text.len()
+        );
+
+        assert_eq!(
+            char_idx_at_visual_offset(
+                slice,
+                softwrapped_text.len() + last_char,
+                -5,
+                0,
+                &text_fmt,
+                &TextAnnotations::default(),
+            )
+            .0,
+            0
+        );
+    }
 }

helix-core/src/register.rs

@@ -1,75 +0,0 @@
-use std::collections::HashMap;
-
-#[derive(Debug)]
-pub struct Register {
-    name: char,
-    values: Vec<String>,
-}
-
-impl Register {
-    pub const fn new(name: char) -> Self {
-        Self {
-            name,
-            values: Vec::new(),
-        }
-    }
-
-    pub fn new_with_values(name: char, values: Vec<String>) -> Self {
-        if name == '_' {
-            Self::new(name)
-        } else {
-            Self { name, values }
-        }
-    }
-
-    pub const fn name(&self) -> char {
-        self.name
-    }
-
-    pub fn read(&self) -> &[String] {
-        &self.values
-    }
-
-    pub fn write(&mut self, values: Vec<String>) {
-        if self.name != '_' {
-            self.values = values;
-        }
-    }
-
-    pub fn push(&mut self, value: String) {
-        if self.name != '_' {
-            self.values.push(value);
-        }
-    }
-}
-
-/// Currently just wraps a `HashMap` of `Register`s
-#[derive(Debug, Default)]
-pub struct Registers {
-    inner: HashMap<char, Register>,
-}
-
-impl Registers {
-    pub fn get(&self, name: char) -> Option<&Register> {
-        self.inner.get(&name)
-    }
-
-    pub fn get_mut(&mut self, name: char) -> &mut Register {
-        self.inner
-            .entry(name)
-            .or_insert_with(|| Register::new(name))
-    }
-
-    pub fn write(&mut self, name: char, values: Vec<String>) {
-        self.inner
-            .insert(name, Register::new_with_values(name, values));
-    }
-
-    pub fn read(&self, name: char) -> Option<&[String]> {
-        self.get(name).map(|reg| reg.read())
-    }
-
-    pub fn inner(&self) -> &HashMap<char, Register> {
-        &self.inner
-    }
-}

helix-core/src/rope_reader.rs

@@ -0,0 +1,37 @@
+use std::io;
+
+use ropey::iter::Chunks;
+use ropey::RopeSlice;
+
+pub struct RopeReader<'a> {
+    current_chunk: &'a [u8],
+    chunks: Chunks<'a>,
+}
+
+impl<'a> RopeReader<'a> {
+    pub fn new(rope: RopeSlice<'a>) -> RopeReader<'a> {
+        RopeReader {
+            current_chunk: &[],
+            chunks: rope.chunks(),
+        }
+    }
+}
+
+impl io::Read for RopeReader<'_> {
+    fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
+        let buf_len = buf.len();
+        loop {
+            let read_bytes = self.current_chunk.read(buf)?;
+            buf = &mut buf[read_bytes..];
+            if buf.is_empty() {
+                return Ok(buf_len);
+            }
+
+            if let Some(next_chunk) = self.chunks.next() {
+                self.current_chunk = next_chunk.as_bytes();
+            } else {
+                return Ok(buf_len - buf.len());
+            }
+        }
+    }
+}

helix-core/src/search.rs

@@ -1,6 +1,28 @@
 use crate::RopeSlice;
 
-pub fn find_nth_next(text: RopeSlice, ch: char, mut pos: usize, n: usize) -> Option<usize> {
+// TODO: switch to std::str::Pattern when it is stable.
+pub trait CharMatcher {
+    fn char_match(&self, ch: char) -> bool;
+}
+
+impl CharMatcher for char {
+    fn char_match(&self, ch: char) -> bool {
+        *self == ch
+    }
+}
+
+impl<F: Fn(&char) -> bool> CharMatcher for F {
+    fn char_match(&self, ch: char) -> bool {
+        (*self)(&ch)
+    }
+}
+
+pub fn find_nth_next<M: CharMatcher>(
+    text: RopeSlice,
+    char_matcher: M,
+    mut pos: usize,
+    n: usize,
+) -> Option<usize> {
     if pos >= text.len_chars() || n == 0 {
         return None;
     }
@@ -13,7 +35,7 @@ pub fn find_nth_next(text: RopeSlice, ch: char, mut pos: usize, n: usize) -> Opt
 
             pos += 1;
 
-            if c == ch {
+            if char_matcher.char_match(c) {
                 break;
             }
         }

helix-core/src/selection.rs

@@ -7,11 +7,14 @@ use crate::{
         ensure_grapheme_boundary_next, ensure_grapheme_boundary_prev, next_grapheme_boundary,
         prev_grapheme_boundary,
     },
+    line_ending::get_line_ending,
     movement::Direction,
-    Assoc, ChangeSet, RopeSlice,
+    Assoc, ChangeSet, RopeGraphemes, RopeSlice,
 };
+use helix_stdx::rope::{self, RopeSliceExt};
 use smallvec::{smallvec, SmallVec};
 use std::borrow::Cow;
+use tree_sitter::Node;
 
 /// A single selection range.
 ///
@@ -21,14 +24,14 @@ use std::borrow::Cow;
 /// can be in any order, or even share the same position.
 ///
 /// The anchor and head positions use gap indexing, meaning
-/// that their indices represent the the gaps *between* `char`s
+/// that their indices represent the gaps *between* `char`s
 /// rather than the `char`s themselves. For example, 1
 /// represents the position between the first and second `char`.
 ///
-/// Below are some example `Range` configurations to better
-/// illustrate.  The anchor and head indices are show as
-/// "(anchor, head)", followed by example text with "[" and "]"
-/// inserted to represent the anchor and head positions:
+/// Below are some examples of `Range` configurations.
+/// The anchor and head indices are shown as "(anchor, head)"
+/// tuples, followed by example text with "[" and "]" symbols
+/// representing the anchor and head positions:
 ///
 /// - (0, 3): `[Som]e text`.
 /// - (3, 0): `]Som[e text`.
@@ -38,7 +41,7 @@ use std::borrow::Cow;
 /// Ranges are considered to be inclusive on the left and
 /// exclusive on the right, regardless of anchor-head ordering.
 /// This means, for example, that non-zero-width ranges that
-/// are directly adjecent, sharing an edge, do not overlap.
+/// are directly adjacent, sharing an edge, do not overlap.
 /// However, a zero-width range will overlap with the shared
 /// left-edge of another range.
 ///
@@ -53,7 +56,9 @@ pub struct Range {
     pub anchor: usize,
     /// The head of the range, moved when extending.
     pub head: usize,
-    pub horiz: Option<u32>,
+    /// The previous visual offset (softwrapped lines and columns) from
+    /// the start of the line
+    pub old_visual_position: Option<(u32, u32)>,
 }
 
 impl Range {
@@ -61,7 +66,7 @@ impl Range {
         Self {
             anchor,
             head,
-            horiz: None,
+            old_visual_position: None,
         }
     }
 
@@ -69,6 +74,12 @@ impl Range {
         Self::new(head, head)
     }
 
+    pub fn from_node(node: Node, text: RopeSlice, direction: Direction) -> Self {
+        let from = text.byte_to_char(node.start_byte());
+        let to = text.byte_to_char(node.end_byte());
+        Range::new(from, to).with_direction(direction)
+    }
+
     /// Start of the range.
     #[inline]
     #[must_use]
@@ -122,12 +133,22 @@ impl Range {
         }
     }
 
-    // flips the direction of the selection
+    /// Flips the direction of the selection
     pub fn flip(&self) -> Self {
         Self {
             anchor: self.head,
             head: self.anchor,
-            horiz: self.horiz,
+            old_visual_position: self.old_visual_position,
+        }
+    }
+
+    /// Returns the selection if it goes in the direction of `direction`,
+    /// flipping the selection otherwise.
+    pub fn with_direction(self, direction: Direction) -> Self {
+        if self.direction() == direction {
+            self
+        } else {
+            self.flip()
         }
     }
 
@@ -149,34 +170,35 @@ impl Range {
         self.from() <= pos && pos < self.to()
     }
 
-    /// Map a range through a set of changes. Returns a new range representing the same position
-    /// after the changes are applied.
-    pub fn map(self, changes: &ChangeSet) -> Self {
+    /// Map a range through a set of changes. Returns a new range representing
+    /// the same position after the changes are applied. Note that this
+    /// function runs in O(N) (N is number of changes) and can therefore
+    /// cause performance problems if run for a large number of ranges as the
+    /// complexity is then O(MN) (for multicuror M=N usually). Instead use
+    /// [Selection::map] or [ChangeSet::update_positions] instead
+    pub fn map(mut self, changes: &ChangeSet) -> Self {
         use std::cmp::Ordering;
-        let (anchor, head) = match self.anchor.cmp(&self.head) {
-            Ordering::Equal => (
-                changes.map_pos(self.anchor, Assoc::After),
-                changes.map_pos(self.head, Assoc::After),
-            ),
-            Ordering::Less => (
-                changes.map_pos(self.anchor, Assoc::After),
-                changes.map_pos(self.head, Assoc::Before),
-            ),
-            Ordering::Greater => (
-                changes.map_pos(self.anchor, Assoc::Before),
-                changes.map_pos(self.head, Assoc::After),
-            ),
-        };
-
-        // We want to return a new `Range` with `horiz == None` every time,
-        // even if the anchor and head haven't changed, because we don't
-        // know if the *visual* position hasn't changed due to
-        // character-width or grapheme changes earlier in the text.
-        Self {
-            anchor,
-            head,
-            horiz: None,
+        if changes.is_empty() {
+            return self;
         }
+
+        let positions_to_map = match self.anchor.cmp(&self.head) {
+            Ordering::Equal => [
+                (&mut self.anchor, Assoc::After),
+                (&mut self.head, Assoc::After),
+            ],
+            Ordering::Less => [
+                (&mut self.anchor, Assoc::After),
+                (&mut self.head, Assoc::Before),
+            ],
+            Ordering::Greater => [
+                (&mut self.head, Assoc::After),
+                (&mut self.anchor, Assoc::Before),
+            ],
+        };
+        changes.update_positions(positions_to_map.into_iter());
+        self.old_visual_position = None;
+        self
     }
 
     /// Extend the range to cover at least `from` `to`.
@@ -188,13 +210,13 @@ impl Range {
             Self {
                 anchor: self.anchor.min(from),
                 head: self.head.max(to),
-                horiz: None,
+                old_visual_position: None,
             }
         } else {
             Self {
                 anchor: self.anchor.max(to),
                 head: self.head.min(from),
-                horiz: None,
+                old_visual_position: None,
             }
         }
     }
@@ -209,22 +231,36 @@ impl Range {
             Range {
                 anchor: self.anchor.max(other.anchor),
                 head: self.head.min(other.head),
-                horiz: None,
+                old_visual_position: None,
             }
         } else {
             Range {
                 anchor: self.from().min(other.from()),
                 head: self.to().max(other.to()),
-                horiz: None,
+                old_visual_position: None,
             }
         }
     }
 
     // groupAt
 
+    /// Returns the text inside this range given the text of the whole buffer.
+    ///
+    /// The returned `Cow` is a reference if the range of text is inside a single
+    /// chunk of the rope. Otherwise a copy of the text is returned. Consider
+    /// using `slice` instead if you do not need a `Cow` or `String` to avoid copying.
     #[inline]
     pub fn fragment<'a, 'b: 'a>(&'a self, text: RopeSlice<'b>) -> Cow<'b, str> {
-        text.slice(self.from()..self.to()).into()
+        self.slice(text).into()
+    }
+
+    /// Returns the text inside this range given the text of the whole buffer.
+    ///
+    /// The returned value is a reference to the passed slice. This method never
+    /// copies any contents.
+    #[inline]
+    pub fn slice<'a, 'b: 'a>(&'a self, text: RopeSlice<'b>) -> RopeSlice<'b> {
+        text.slice(self.from()..self.to())
     }
 
     //--------------------------------
@@ -255,8 +291,8 @@ impl Range {
         Range {
             anchor: new_anchor,
             head: new_head,
-            horiz: if new_anchor == self.anchor {
-                self.horiz
+            old_visual_position: if new_anchor == self.anchor {
+                self.old_visual_position
             } else {
                 None
             },
@@ -282,7 +318,7 @@ impl Range {
             Range {
                 anchor: self.anchor,
                 head: next_grapheme_boundary(slice, self.head),
-                horiz: self.horiz,
+                old_visual_position: self.old_visual_position,
             }
         } else {
             *self
@@ -339,6 +375,20 @@ impl Range {
     pub fn cursor_line(&self, text: RopeSlice) -> usize {
         text.char_to_line(self.cursor(text))
     }
+
+    /// Returns true if this Range covers a single grapheme in the given text
+    pub fn is_single_grapheme(&self, doc: RopeSlice) -> bool {
+        let mut graphemes = RopeGraphemes::new(doc.slice(self.from()..self.to()));
+        let first = graphemes.next();
+        let second = graphemes.next();
+        first.is_some() && second.is_none()
+    }
+
+    /// Converts this char range into an in order byte range, discarding
+    /// direction.
+    pub fn into_byte_range(&self, text: RopeSlice) -> (usize, usize) {
+        (text.char_to_byte(self.from()), text.char_to_byte(self.to()))
+    }
 }
 
 impl From<(usize, usize)> for Range {
@@ -346,7 +396,7 @@ impl From<(usize, usize)> for Range {
         Self {
             anchor,
             head,
-            horiz: None,
+            old_visual_position: None,
         }
     }
 }
@@ -417,17 +467,36 @@ impl Selection {
     /// Map selections over a set of changes. Useful for adjusting the selection position after
     /// applying changes to a document.
     pub fn map(self, changes: &ChangeSet) -> Self {
+        self.map_no_normalize(changes).normalize()
+    }
+
+    /// Map selections over a set of changes. Useful for adjusting the selection position after
+    /// applying changes to a document. Doesn't normalize the selection
+    pub fn map_no_normalize(mut self, changes: &ChangeSet) -> Self {
         if changes.is_empty() {
             return self;
         }
 
-        Self::new(
-            self.ranges
-                .into_iter()
-                .map(|range| range.map(changes))
-                .collect(),
-            self.primary_index,
-        )
+        let positions_to_map = self.ranges.iter_mut().flat_map(|range| {
+            use std::cmp::Ordering;
+            range.old_visual_position = None;
+            match range.anchor.cmp(&range.head) {
+                Ordering::Equal => [
+                    (&mut range.anchor, Assoc::After),
+                    (&mut range.head, Assoc::After),
+                ],
+                Ordering::Less => [
+                    (&mut range.anchor, Assoc::After),
+                    (&mut range.head, Assoc::Before),
+                ],
+                Ordering::Greater => [
+                    (&mut range.head, Assoc::After),
+                    (&mut range.anchor, Assoc::Before),
+                ],
+            }
+        });
+        changes.update_positions(positions_to_map);
+        self
     }
 
     pub fn ranges(&self) -> &[Range] {
@@ -450,7 +519,7 @@ impl Selection {
             ranges: smallvec![Range {
                 anchor,
                 head,
-                horiz: None
+                old_visual_position: None
             }],
             primary_index: 0,
         }
@@ -463,28 +532,63 @@ impl Selection {
 
     /// Normalizes a `Selection`.
     fn normalize(mut self) -> Self {
-        let primary = self.ranges[self.primary_index];
+        if self.len() < 2 {
+            return self;
+        }
+        let mut primary = self.ranges[self.primary_index];
         self.ranges.sort_unstable_by_key(Range::from);
+
+        self.ranges.dedup_by(|curr_range, prev_range| {
+            if prev_range.overlaps(curr_range) {
+                let new_range = curr_range.merge(*prev_range);
+                if prev_range == &primary || curr_range == &primary {
+                    primary = new_range;
+                }
+                *prev_range = new_range;
+                true
+            } else {
+                false
+            }
+        });
+
         self.primary_index = self
             .ranges
             .iter()
             .position(|&range| range == primary)
             .unwrap();
 
-        let mut prev_i = 0;
-        for i in 1..self.ranges.len() {
-            if self.ranges[prev_i].overlaps(&self.ranges[i]) {
-                self.ranges[prev_i] = self.ranges[prev_i].merge(self.ranges[i]);
-            } else {
-                prev_i += 1;
-                self.ranges[prev_i] = self.ranges[i];
-            }
-            if i == self.primary_index {
-                self.primary_index = prev_i;
-            }
-        }
+        self
+    }
 
-        self.ranges.truncate(prev_i + 1);
+    /// Replaces ranges with one spanning from first to last range.
+    pub fn merge_ranges(self) -> Self {
+        let first = self.ranges.first().unwrap();
+        let last = self.ranges.last().unwrap();
+        Selection::new(smallvec![first.merge(*last)], 0)
+    }
+
+    /// Merges all ranges that are consecutive.
+    pub fn merge_consecutive_ranges(mut self) -> Self {
+        let mut primary = self.ranges[self.primary_index];
+
+        self.ranges.dedup_by(|curr_range, prev_range| {
+            if prev_range.to() == curr_range.from() {
+                let new_range = curr_range.merge(*prev_range);
+                if prev_range == &primary || curr_range == &primary {
+                    primary = new_range;
+                }
+                *prev_range = new_range;
+                true
+            } else {
+                false
+            }
+        });
+
+        self.primary_index = self
+            .ranges
+            .iter()
+            .position(|&range| range == primary)
+            .unwrap();
 
         self
     }
@@ -495,23 +599,18 @@ impl Selection {
         assert!(!ranges.is_empty());
         debug_assert!(primary_index < ranges.len());
 
-        let mut selection = Self {
+        let selection = Self {
             ranges,
             primary_index,
         };
 
-        if selection.ranges.len() > 1 {
-            // TODO: only normalize if needed (any ranges out of order)
-            selection = selection.normalize();
-        }
-
-        selection
+        selection.normalize()
     }
 
     /// Takes a closure and maps each `Range` over the closure.
-    pub fn transform<F>(mut self, f: F) -> Self
+    pub fn transform<F>(mut self, mut f: F) -> Self
     where
-        F: Fn(Range) -> Range,
+        F: FnMut(Range) -> Range,
     {
         for range in self.ranges.iter_mut() {
             *range = f(*range)
@@ -519,6 +618,16 @@ impl Selection {
         self.normalize()
     }
 
+    /// Takes a closure and maps each `Range` over the closure to multiple `Range`s.
+    pub fn transform_iter<F, I>(mut self, f: F) -> Self
+    where
+        F: FnMut(Range) -> I,
+        I: Iterator<Item = Range>,
+    {
+        self.ranges = self.ranges.into_iter().flat_map(f).collect();
+        self.normalize()
+    }
+
     // Ensures the selection adheres to the following invariants:
     // 1. All ranges are grapheme aligned.
     // 2. All ranges are at least 1 character wide, unless at the
@@ -536,10 +645,22 @@ impl Selection {
         self.transform(|range| Range::point(range.cursor(text)))
     }
 
-    pub fn fragments<'a>(&'a self, text: RopeSlice<'a>) -> impl Iterator<Item = Cow<str>> + 'a {
+    pub fn fragments<'a>(
+        &'a self,
+        text: RopeSlice<'a>,
+    ) -> impl DoubleEndedIterator<Item = Cow<'a, str>> + ExactSizeIterator<Item = Cow<str>> + 'a
+    {
         self.ranges.iter().map(move |range| range.fragment(text))
     }
 
+    pub fn slices<'a>(
+        &'a self,
+        text: RopeSlice<'a>,
+    ) -> impl DoubleEndedIterator<Item = RopeSlice<'a>> + ExactSizeIterator<Item = RopeSlice<'a>> + 'a
+    {
+        self.ranges.iter().map(move |range| range.slice(text))
+    }
+
     #[inline(always)]
     pub fn iter(&self) -> std::slice::Iter<'_, Range> {
         self.ranges.iter()
@@ -552,11 +673,6 @@ impl Selection {
 
     // returns true if self ⊇ other
     pub fn contains(&self, other: &Selection) -> bool {
-        // can't contain other if it is larger
-        if other.len() > self.len() {
-            return false;
-        }
-
         let (mut iter_self, mut iter_other) = (self.iter(), other.iter());
         let (mut ele_self, mut ele_other) = (iter_self.next(), iter_other.next());
 
@@ -593,17 +709,35 @@ impl<'a> IntoIterator for &'a Selection {
     }
 }
 
+impl IntoIterator for Selection {
+    type Item = Range;
+    type IntoIter = smallvec::IntoIter<[Range; 1]>;
+
+    fn into_iter(self) -> smallvec::IntoIter<[Range; 1]> {
+        self.ranges.into_iter()
+    }
+}
+
+impl From<Range> for Selection {
+    fn from(range: Range) -> Self {
+        Self {
+            ranges: smallvec![range],
+            primary_index: 0,
+        }
+    }
+}
+
 // TODO: checkSelection -> check if valid for doc length && sorted
 
 pub fn keep_or_remove_matches(
     text: RopeSlice,
     selection: &Selection,
-    regex: &crate::regex::Regex,
+    regex: &rope::Regex,
     remove: bool,
 ) -> Option<Selection> {
     let result: SmallVec<_> = selection
         .iter()
-        .filter(|range| regex.is_match(&range.fragment(text)) ^ remove)
+        .filter(|range| regex.is_match(text.regex_input_at(range.from()..range.to())) ^ remove)
         .copied()
         .collect();
 
@@ -614,26 +748,27 @@ pub fn keep_or_remove_matches(
     None
 }
 
+// TODO: support to split on capture #N instead of whole match
 pub fn select_on_matches(
     text: RopeSlice,
     selection: &Selection,
-    regex: &crate::regex::Regex,
+    regex: &rope::Regex,
 ) -> Option<Selection> {
     let mut result = SmallVec::with_capacity(selection.len());
 
     for sel in selection {
-        // TODO: can't avoid occasional allocations since Regex can't operate on chunks yet
-        let fragment = sel.fragment(text);
-
-        let sel_start = sel.from();
-        let start_byte = text.char_to_byte(sel_start);
-
-        for mat in regex.find_iter(&fragment) {
+        for mat in regex.find_iter(text.regex_input_at(sel.from()..sel.to())) {
             // TODO: retain range direction
 
-            let start = text.byte_to_char(start_byte + mat.start());
-            let end = text.byte_to_char(start_byte + mat.end());
-            result.push(Range::new(start, end));
+            let start = text.byte_to_char(mat.start());
+            let end = text.byte_to_char(mat.end());
+
+            let range = Range::new(start, end);
+            // Make sure the match is not right outside of the selection.
+            // These invalid matches can come from using RegEx anchors like `^`, `$`
+            if range != Range::point(sel.to()) {
+                result.push(range);
+            }
         }
     }
 
@@ -645,12 +780,7 @@ pub fn select_on_matches(
     None
 }
 
-// TODO: support to split on capture #N instead of whole match
-pub fn split_on_matches(
-    text: RopeSlice,
-    selection: &Selection,
-    regex: &crate::regex::Regex,
-) -> Selection {
+pub fn split_on_newline(text: RopeSlice, selection: &Selection) -> Selection {
     let mut result = SmallVec::with_capacity(selection.len());
 
     for sel in selection {
@@ -660,21 +790,49 @@ pub fn split_on_matches(
             continue;
         }
 
-        // TODO: can't avoid occasional allocations since Regex can't operate on chunks yet
-        let fragment = sel.fragment(text);
-
         let sel_start = sel.from();
         let sel_end = sel.to();
 
-        let start_byte = text.char_to_byte(sel_start);
-
         let mut start = sel_start;
 
-        for mat in regex.find_iter(&fragment) {
+        for line in sel.slice(text).lines() {
+            let Some(line_ending) = get_line_ending(&line) else {
+                break;
+            };
+            let line_end = start + line.len_chars();
             // TODO: retain range direction
-            let end = text.byte_to_char(start_byte + mat.start());
+            result.push(Range::new(start, line_end - line_ending.len_chars()));
+            start = line_end;
+        }
+
+        if start < sel_end {
+            result.push(Range::new(start, sel_end));
+        }
+    }
+
+    // TODO: figure out a new primary index
+    Selection::new(result, 0)
+}
+
+pub fn split_on_matches(text: RopeSlice, selection: &Selection, regex: &rope::Regex) -> Selection {
+    let mut result = SmallVec::with_capacity(selection.len());
+
+    for sel in selection {
+        // Special case: zero-width selection.
+        if sel.from() == sel.to() {
+            result.push(*sel);
+            continue;
+        }
+
+        let sel_start = sel.from();
+        let sel_end = sel.to();
+        let mut start = sel_start;
+
+        for mat in regex.find_iter(text.regex_input_at(sel_start..sel_end)) {
+            // TODO: retain range direction
+            let end = text.byte_to_char(mat.start());
             result.push(Range::new(start, end));
-            start = text.byte_to_char(start_byte + mat.end());
+            start = text.byte_to_char(mat.end());
         }
 
         if start < sel_end {
@@ -830,7 +988,7 @@ mod test {
     }
 
     #[test]
-    fn test_graphem_aligned() {
+    fn test_grapheme_aligned() {
         let r = Rope::from_str("\r\nHi\r\n");
         let s = r.slice(..);
 
@@ -903,6 +1061,80 @@ mod test {
         assert_eq!(Range::new(6, 5).min_width_1(s), Range::new(6, 5));
     }
 
+    #[test]
+    fn test_select_on_matches() {
+        let r = Rope::from_str("Nobody expects the Spanish inquisition");
+        let s = r.slice(..);
+
+        let selection = Selection::single(0, r.len_chars());
+        assert_eq!(
+            select_on_matches(s, &selection, &rope::Regex::new(r"[A-Z][a-z]*").unwrap()),
+            Some(Selection::new(
+                smallvec![Range::new(0, 6), Range::new(19, 26)],
+                0
+            ))
+        );
+
+        let r = Rope::from_str("This\nString\n\ncontains multiple\nlines");
+        let s = r.slice(..);
+
+        let start_of_line = rope::RegexBuilder::new()
+            .syntax(rope::Config::new().multi_line(true))
+            .build(r"^")
+            .unwrap();
+        let end_of_line = rope::RegexBuilder::new()
+            .syntax(rope::Config::new().multi_line(true))
+            .build(r"$")
+            .unwrap();
+
+        // line without ending
+        assert_eq!(
+            select_on_matches(s, &Selection::single(0, 4), &start_of_line),
+            Some(Selection::single(0, 0))
+        );
+        assert_eq!(
+            select_on_matches(s, &Selection::single(0, 4), &end_of_line),
+            None
+        );
+        // line with ending
+        assert_eq!(
+            select_on_matches(s, &Selection::single(0, 5), &start_of_line),
+            Some(Selection::single(0, 0))
+        );
+        assert_eq!(
+            select_on_matches(s, &Selection::single(0, 5), &end_of_line),
+            Some(Selection::single(4, 4))
+        );
+        // line with start of next line
+        assert_eq!(
+            select_on_matches(s, &Selection::single(0, 6), &start_of_line),
+            Some(Selection::new(
+                smallvec![Range::point(0), Range::point(5)],
+                0
+            ))
+        );
+        assert_eq!(
+            select_on_matches(s, &Selection::single(0, 6), &end_of_line),
+            Some(Selection::single(4, 4))
+        );
+
+        // multiple lines
+        assert_eq!(
+            select_on_matches(
+                s,
+                &Selection::single(0, s.len_chars()),
+                &rope::RegexBuilder::new()
+                    .syntax(rope::Config::new().multi_line(true))
+                    .build(r"^[a-z ]*$")
+                    .unwrap()
+            ),
+            Some(Selection::new(
+                smallvec![Range::point(12), Range::new(13, 30), Range::new(31, 36)],
+                0
+            ))
+        );
+    }
+
     #[test]
     fn test_line_range() {
         let r = Rope::from_str("\r\nHi\r\nthere!");
@@ -985,13 +1217,15 @@ mod test {
 
     #[test]
     fn test_split_on_matches() {
-        use crate::regex::Regex;
-
         let text = Rope::from(" abcd efg wrs   xyz 123 456");
 
         let selection = Selection::new(smallvec![Range::new(0, 9), Range::new(11, 20),], 0);
 
-        let result = split_on_matches(text.slice(..), &selection, &Regex::new(r"\s+").unwrap());
+        let result = split_on_matches(
+            text.slice(..),
+            &selection,
+            &rope::Regex::new(r"\s+").unwrap(),
+        );
 
         assert_eq!(
             result.ranges(),
@@ -1020,6 +1254,52 @@ mod test {
             &["", "abcd", "efg", "rs", "xyz"]
         );
     }
+
+    #[test]
+    fn test_merge_consecutive_ranges() {
+        let selection = Selection::new(
+            smallvec![
+                Range::new(0, 1),
+                Range::new(1, 10),
+                Range::new(15, 20),
+                Range::new(25, 26),
+                Range::new(26, 30)
+            ],
+            4,
+        );
+
+        let result = selection.merge_consecutive_ranges();
+
+        assert_eq!(
+            result.ranges(),
+            &[Range::new(0, 10), Range::new(15, 20), Range::new(25, 30)]
+        );
+        assert_eq!(result.primary_index, 2);
+
+        let selection = Selection::new(smallvec![Range::new(0, 1)], 0);
+        let result = selection.merge_consecutive_ranges();
+
+        assert_eq!(result.ranges(), &[Range::new(0, 1)]);
+        assert_eq!(result.primary_index, 0);
+
+        let selection = Selection::new(
+            smallvec![
+                Range::new(0, 1),
+                Range::new(1, 5),
+                Range::new(5, 8),
+                Range::new(8, 10),
+                Range::new(10, 15),
+                Range::new(18, 25)
+            ],
+            3,
+        );
+
+        let result = selection.merge_consecutive_ranges();
+
+        assert_eq!(result.ranges(), &[Range::new(0, 15), Range::new(18, 25)]);
+        assert_eq!(result.primary_index, 0);
+    }
+
     #[test]
     fn test_selection_contains() {
         fn contains(a: Vec<(usize, usize)>, b: Vec<(usize, usize)>) -> bool {
@@ -1045,5 +1325,11 @@ mod test {
             vec!((3, 4), (7, 9))
         ));
         assert!(!contains(vec!((1, 1), (5, 6)), vec!((1, 6))));
+
+        // multiple ranges of other are all contained in some ranges of self,
+        assert!(contains(
+            vec!((1, 4), (7, 10)),
+            vec!((1, 2), (3, 4), (7, 9))
+        ));
     }
 }

helix-core/src/shellwords.rs

@@ -1,97 +1,199 @@
 use std::borrow::Cow;
 
-/// Get the vec of escaped / quoted / doublequoted filenames from the input str
-pub fn shellwords(input: &str) -> Vec<Cow<'_, str>> {
-    enum State {
-        Normal,
-        NormalEscaped,
-        Quoted,
-        QuoteEscaped,
-        Dquoted,
-        DquoteEscaped,
-    }
-
-    use State::*;
-
-    let mut state = Normal;
-    let mut args: Vec<Cow<str>> = Vec::new();
-    let mut escaped = String::with_capacity(input.len());
-
-    let mut start = 0;
-    let mut end = 0;
-
-    for (i, c) in input.char_indices() {
-        state = match state {
-            Normal => match c {
-                '\\' => {
-                    escaped.push_str(&input[start..i]);
-                    start = i + 1;
-                    NormalEscaped
-                }
-                '"' => {
-                    end = i;
-                    Dquoted
-                }
-                '\'' => {
-                    end = i;
-                    Quoted
-                }
-                c if c.is_ascii_whitespace() => {
-                    end = i;
-                    Normal
-                }
-                _ => Normal,
-            },
-            NormalEscaped => Normal,
-            Quoted => match c {
-                '\\' => {
-                    escaped.push_str(&input[start..i]);
-                    start = i + 1;
-                    QuoteEscaped
-                }
-                '\'' => {
-                    end = i;
-                    Normal
-                }
-                _ => Quoted,
-            },
-            QuoteEscaped => Quoted,
-            Dquoted => match c {
-                '\\' => {
-                    escaped.push_str(&input[start..i]);
-                    start = i + 1;
-                    DquoteEscaped
-                }
-                '"' => {
-                    end = i;
-                    Normal
-                }
-                _ => Dquoted,
-            },
-            DquoteEscaped => Dquoted,
-        };
-
-        if i >= input.len() - 1 && end == 0 {
-            end = i + 1;
-        }
-
-        if end > 0 {
-            let esc_trim = escaped.trim();
-            let inp = &input[start..end];
-
-            if !(esc_trim.is_empty() && inp.trim().is_empty()) {
-                if esc_trim.is_empty() {
-                    args.push(inp.into());
-                } else {
-                    args.push([escaped, inp.into()].concat().into());
-                    escaped = "".to_string();
-                }
+/// Auto escape for shellwords usage.
+pub fn escape(input: Cow<str>) -> Cow<str> {
+    if !input.chars().any(|x| x.is_ascii_whitespace()) {
+        input
+    } else if cfg!(unix) {
+        Cow::Owned(input.chars().fold(String::new(), |mut buf, c| {
+            if c.is_ascii_whitespace() {
+                buf.push('\\');
             }
-            start = i + 1;
-            end = 0;
+            buf.push(c);
+            buf
+        }))
+    } else {
+        Cow::Owned(format!("\"{}\"", input))
+    }
+}
+
+enum State {
+    OnWhitespace,
+    Unquoted,
+    UnquotedEscaped,
+    Quoted,
+    QuoteEscaped,
+    Dquoted,
+    DquoteEscaped,
+}
+
+pub struct Shellwords<'a> {
+    state: State,
+    /// Shellwords where whitespace and escapes has been resolved.
+    words: Vec<Cow<'a, str>>,
+    /// The parts of the input that are divided into shellwords. This can be
+    /// used to retrieve the original text for a given word by looking up the
+    /// same index in the Vec as the word in `words`.
+    parts: Vec<&'a str>,
+}
+
+impl<'a> From<&'a str> for Shellwords<'a> {
+    fn from(input: &'a str) -> Self {
+        use State::*;
+
+        let mut state = Unquoted;
+        let mut words = Vec::new();
+        let mut parts = Vec::new();
+        let mut escaped = String::with_capacity(input.len());
+
+        let mut part_start = 0;
+        let mut unescaped_start = 0;
+        let mut end = 0;
+
+        for (i, c) in input.char_indices() {
+            state = match state {
+                OnWhitespace => match c {
+                    '"' => {
+                        end = i;
+                        Dquoted
+                    }
+                    '\'' => {
+                        end = i;
+                        Quoted
+                    }
+                    '\\' => {
+                        if cfg!(unix) {
+                            escaped.push_str(&input[unescaped_start..i]);
+                            unescaped_start = i + 1;
+                            UnquotedEscaped
+                        } else {
+                            OnWhitespace
+                        }
+                    }
+                    c if c.is_ascii_whitespace() => {
+                        end = i;
+                        OnWhitespace
+                    }
+                    _ => Unquoted,
+                },
+                Unquoted => match c {
+                    '\\' => {
+                        if cfg!(unix) {
+                            escaped.push_str(&input[unescaped_start..i]);
+                            unescaped_start = i + 1;
+                            UnquotedEscaped
+                        } else {
+                            Unquoted
+                        }
+                    }
+                    c if c.is_ascii_whitespace() => {
+                        end = i;
+                        OnWhitespace
+                    }
+                    _ => Unquoted,
+                },
+                UnquotedEscaped => Unquoted,
+                Quoted => match c {
+                    '\\' => {
+                        if cfg!(unix) {
+                            escaped.push_str(&input[unescaped_start..i]);
+                            unescaped_start = i + 1;
+                            QuoteEscaped
+                        } else {
+                            Quoted
+                        }
+                    }
+                    '\'' => {
+                        end = i;
+                        OnWhitespace
+                    }
+                    _ => Quoted,
+                },
+                QuoteEscaped => Quoted,
+                Dquoted => match c {
+                    '\\' => {
+                        if cfg!(unix) {
+                            escaped.push_str(&input[unescaped_start..i]);
+                            unescaped_start = i + 1;
+                            DquoteEscaped
+                        } else {
+                            Dquoted
+                        }
+                    }
+                    '"' => {
+                        end = i;
+                        OnWhitespace
+                    }
+                    _ => Dquoted,
+                },
+                DquoteEscaped => Dquoted,
+            };
+
+            let c_len = c.len_utf8();
+            if i == input.len() - c_len && end == 0 {
+                end = i + c_len;
+            }
+
+            if end > 0 {
+                let esc_trim = escaped.trim();
+                let inp = &input[unescaped_start..end];
+
+                if !(esc_trim.is_empty() && inp.trim().is_empty()) {
+                    if esc_trim.is_empty() {
+                        words.push(inp.into());
+                        parts.push(inp);
+                    } else {
+                        words.push([escaped, inp.into()].concat().into());
+                        parts.push(&input[part_start..end]);
+                        escaped = "".to_string();
+                    }
+                }
+                unescaped_start = i + 1;
+                part_start = i + 1;
+                end = 0;
+            }
+        }
+
+        debug_assert!(words.len() == parts.len());
+
+        Self {
+            state,
+            words,
+            parts,
         }
     }
-    args
+}
+
+impl<'a> Shellwords<'a> {
+    /// Checks that the input ends with a whitespace character which is not escaped.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use helix_core::shellwords::Shellwords;
+    /// assert_eq!(Shellwords::from(" ").ends_with_whitespace(), true);
+    /// assert_eq!(Shellwords::from(":open ").ends_with_whitespace(), true);
+    /// assert_eq!(Shellwords::from(":open foo.txt ").ends_with_whitespace(), true);
+    /// assert_eq!(Shellwords::from(":open").ends_with_whitespace(), false);
+    /// #[cfg(unix)]
+    /// assert_eq!(Shellwords::from(":open a\\ ").ends_with_whitespace(), false);
+    /// #[cfg(unix)]
+    /// assert_eq!(Shellwords::from(":open a\\ b.txt").ends_with_whitespace(), false);
+    /// ```
+    pub fn ends_with_whitespace(&self) -> bool {
+        matches!(self.state, State::OnWhitespace)
+    }
+
+    /// Returns the list of shellwords calculated from the input string.
+    pub fn words(&self) -> &[Cow<'a, str>] {
+        &self.words
+    }
+
+    /// Returns a list of strings which correspond to [`Self::words`] but represent the original
+    /// text in the input string - including escape characters - without separating whitespace.
+    pub fn parts(&self) -> &[&'a str] {
+        &self.parts
+    }
 }
 
 #[cfg(test)]
@@ -99,9 +201,30 @@ mod test {
     use super::*;
 
     #[test]
+    #[cfg(windows)]
     fn test_normal() {
         let input = r#":o single_word twó wörds \three\ \"with\ escaping\\"#;
-        let result = shellwords(input);
+        let shellwords = Shellwords::from(input);
+        let result = shellwords.words().to_vec();
+        let expected = vec![
+            Cow::from(":o"),
+            Cow::from("single_word"),
+            Cow::from("twó"),
+            Cow::from("wörds"),
+            Cow::from("\\three\\"),
+            Cow::from("\\"),
+            Cow::from("with\\ escaping\\\\"),
+        ];
+        // TODO test is_owned and is_borrowed, once they get stabilized.
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    #[cfg(unix)]
+    fn test_normal() {
+        let input = r#":o single_word twó wörds \three\ \"with\ escaping\\"#;
+        let shellwords = Shellwords::from(input);
+        let result = shellwords.words().to_vec();
         let expected = vec![
             Cow::from(":o"),
             Cow::from("single_word"),
@@ -114,10 +237,12 @@ mod test {
     }
 
     #[test]
+    #[cfg(unix)]
     fn test_quoted() {
         let quoted =
             r#":o 'single_word' 'twó wörds' '' ' ''\three\' \"with\ escaping\\' 'quote incomplete"#;
-        let result = shellwords(quoted);
+        let shellwords = Shellwords::from(quoted);
+        let result = shellwords.words().to_vec();
         let expected = vec![
             Cow::from(":o"),
             Cow::from("single_word"),
@@ -129,9 +254,11 @@ mod test {
     }
 
     #[test]
+    #[cfg(unix)]
     fn test_dquoted() {
         let dquoted = r#":o "single_word" "twó wörds" "" "  ""\three\' \"with\ escaping\\" "dquote incomplete"#;
-        let result = shellwords(dquoted);
+        let shellwords = Shellwords::from(dquoted);
+        let result = shellwords.words().to_vec();
         let expected = vec![
             Cow::from(":o"),
             Cow::from("single_word"),
@@ -143,9 +270,11 @@ mod test {
     }
 
     #[test]
+    #[cfg(unix)]
     fn test_mixed() {
         let dquoted = r#":o single_word 'twó wörds' "\three\' \"with\ escaping\\""no space before"'and after' $#%^@ "%^&(%^" ')(*&^%''a\\\\\b' '"#;
-        let result = shellwords(dquoted);
+        let shellwords = Shellwords::from(dquoted);
+        let result = shellwords.words().to_vec();
         let expected = vec![
             Cow::from(":o"),
             Cow::from("single_word"),
@@ -161,4 +290,61 @@ mod test {
         ];
         assert_eq!(expected, result);
     }
+
+    #[test]
+    fn test_lists() {
+        let input =
+            r#":set statusline.center ["file-type","file-encoding"] '["list", "in", "quotes"]'"#;
+        let shellwords = Shellwords::from(input);
+        let result = shellwords.words().to_vec();
+        let expected = vec![
+            Cow::from(":set"),
+            Cow::from("statusline.center"),
+            Cow::from(r#"["file-type","file-encoding"]"#),
+            Cow::from(r#"["list", "in", "quotes"]"#),
+        ];
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    #[cfg(unix)]
+    fn test_escaping_unix() {
+        assert_eq!(escape("foobar".into()), Cow::Borrowed("foobar"));
+        assert_eq!(escape("foo bar".into()), Cow::Borrowed("foo\\ bar"));
+        assert_eq!(escape("foo\tbar".into()), Cow::Borrowed("foo\\\tbar"));
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn test_escaping_windows() {
+        assert_eq!(escape("foobar".into()), Cow::Borrowed("foobar"));
+        assert_eq!(escape("foo bar".into()), Cow::Borrowed("\"foo bar\""));
+    }
+
+    #[test]
+    #[cfg(unix)]
+    fn test_parts() {
+        assert_eq!(Shellwords::from(":o a").parts(), &[":o", "a"]);
+        assert_eq!(Shellwords::from(":o a\\ ").parts(), &[":o", "a\\ "]);
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn test_parts() {
+        assert_eq!(Shellwords::from(":o a").parts(), &[":o", "a"]);
+        assert_eq!(Shellwords::from(":o a\\ ").parts(), &[":o", "a\\"]);
+    }
+
+    #[test]
+    fn test_multibyte_at_end() {
+        assert_eq!(Shellwords::from("𒀀").parts(), &["𒀀"]);
+        assert_eq!(
+            Shellwords::from(":sh echo 𒀀").parts(),
+            &[":sh", "echo", "𒀀"]
+        );
+        assert_eq!(
+            Shellwords::from(":sh echo 𒀀 hello world𒀀").parts(),
+            &[":sh", "echo", "𒀀", "hello", "world𒀀"]
+        );
+    }
 }

helix-core/src/state.rs

@@ -1,17 +0,0 @@
-use crate::{Rope, Selection};
-
-#[derive(Debug, Clone)]
-pub struct State {
-    pub doc: Rope,
-    pub selection: Selection,
-}
-
-impl State {
-    #[must_use]
-    pub fn new(doc: Rope) -> Self {
-        Self {
-            doc,
-            selection: Selection::point(0),
-        }
-    }
-}

helix-core/src/surround.rs

@@ -1,6 +1,6 @@
 use std::fmt::Display;
 
-use crate::{search, Range, Selection};
+use crate::{movement::Direction, search, Range, Selection};
 use ropey::RopeSlice;
 
 pub const PAIRS: &[(char, char)] = &[
@@ -13,7 +13,7 @@ pub const PAIRS: &[(char, char)] = &[
     ('（', '）'),
 ];
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum Error {
     PairNotFound,
     CursorOverlap,
@@ -52,6 +52,74 @@ pub fn get_pair(ch: char) -> (char, char) {
         .unwrap_or((ch, ch))
 }
 
+pub fn find_nth_closest_pairs_pos(
+    text: RopeSlice,
+    range: Range,
+    mut skip: usize,
+) -> Result<(usize, usize)> {
+    let is_open_pair = |ch| PAIRS.iter().any(|(open, _)| *open == ch);
+    let is_close_pair = |ch| PAIRS.iter().any(|(_, close)| *close == ch);
+
+    let mut stack = Vec::with_capacity(2);
+    let pos = range.from();
+    let mut close_pos = pos.saturating_sub(1);
+
+    for ch in text.chars_at(pos) {
+        close_pos += 1;
+
+        if is_open_pair(ch) {
+            // Track open pairs encountered so that we can step over
+            // the corresponding close pairs that will come up further
+            // down the loop. We want to find a lone close pair whose
+            // open pair is before the cursor position.
+            stack.push(ch);
+            continue;
+        }
+
+        if !is_close_pair(ch) {
+            // We don't care if this character isn't a brace pair item,
+            // so short circuit here.
+            continue;
+        }
+
+        let (open, close) = get_pair(ch);
+
+        if stack.last() == Some(&open) {
+            // If we are encountering the closing pair for an opener
+            // we just found while traversing, then its inside the
+            // selection and should be skipped over.
+            stack.pop();
+            continue;
+        }
+
+        match find_nth_open_pair(text, open, close, close_pos, 1) {
+            // Before we accept this pair, we want to ensure that the
+            // pair encloses the range rather than just the cursor.
+            Some(open_pos)
+                if open_pos <= pos.saturating_add(1)
+                    && close_pos >= range.to().saturating_sub(1) =>
+            {
+                // Since we have special conditions for when to
+                // accept, we can't just pass the skip parameter on
+                // through to the find_nth_*_pair methods, so we
+                // track skips manually here.
+                if skip > 1 {
+                    skip -= 1;
+                    continue;
+                }
+
+                return match range.direction() {
+                    Direction::Forward => Ok((open_pos, close_pos)),
+                    Direction::Backward => Ok((close_pos, open_pos)),
+                };
+            }
+            _ => continue,
+        }
+    }
+
+    Err(Error::PairNotFound)
+}
+
 /// Find the position of surround pairs of `ch` which can be either a closing
 /// or opening pair. `n` will skip n - 1 pairs (eg. n=2 will discard (only)
 /// the first pair found and keep looking)
@@ -99,6 +167,10 @@ fn find_nth_open_pair(
     mut pos: usize,
     n: usize,
 ) -> Option<usize> {
+    if pos >= text.len_chars() {
+        return None;
+    }
+
     let mut chars = text.chars_at(pos + 1);
 
     // Adjusts pos for the first iteration, and handles the case of the
@@ -173,21 +245,27 @@ fn find_nth_close_pair(
 /// Find position of surround characters around every cursor. Returns None
 /// if any positions overlap. Note that the positions are in a flat Vec.
 /// Use get_surround_pos().chunks(2) to get matching pairs of surround positions.
-/// `ch` can be either closing or opening pair.
+/// `ch` can be either closing or opening pair. If `ch` is None, surround pairs
+/// are automatically detected around each cursor (note that this may result
+/// in them selecting different surround characters for each selection).
 pub fn get_surround_pos(
     text: RopeSlice,
     selection: &Selection,
-    ch: char,
+    ch: Option<char>,
     skip: usize,
 ) -> Result<Vec<usize>> {
     let mut change_pos = Vec::new();
 
     for &range in selection {
-        let (open_pos, close_pos) = find_nth_pairs_pos(text, ch, range, skip)?;
+        let (open_pos, close_pos) = match ch {
+            Some(ch) => find_nth_pairs_pos(text, ch, range, skip)?,
+            None => find_nth_closest_pairs_pos(text, range, skip)?,
+        };
         if change_pos.contains(&open_pos) || change_pos.contains(&close_pos) {
             return Err(Error::CursorOverlap);
         }
-        change_pos.extend_from_slice(&[open_pos, close_pos]);
+        // ensure the positions are always paired in the forward direction
+        change_pos.extend_from_slice(&[open_pos.min(close_pos), close_pos.max(open_pos)]);
     }
     Ok(change_pos)
 }
@@ -200,141 +278,150 @@ mod test {
     use ropey::Rope;
     use smallvec::SmallVec;
 
-    #[allow(clippy::type_complexity)]
-    fn check_find_nth_pair_pos(
-        text: &str,
-        cases: Vec<(usize, char, usize, Result<(usize, usize)>)>,
-    ) {
-        let doc = Rope::from(text);
-        let slice = doc.slice(..);
-
-        for (cursor_pos, ch, n, expected_range) in cases {
-            let range = find_nth_pairs_pos(slice, ch, (cursor_pos, cursor_pos + 1).into(), n);
-            assert_eq!(
-                range, expected_range,
-                "Expected {:?}, got {:?}",
-                expected_range, range
-            );
-        }
-    }
-
-    #[test]
-    fn test_find_nth_pairs_pos() {
-        check_find_nth_pair_pos(
-            "some (text) here",
-            vec![
-                // cursor on [t]ext
-                (6, '(', 1, Ok((5, 10))),
-                (6, ')', 1, Ok((5, 10))),
-                // cursor on so[m]e
-                (2, '(', 1, Err(Error::PairNotFound)),
-                // cursor on bracket itself
-                (5, '(', 1, Ok((5, 10))),
-                (10, '(', 1, Ok((5, 10))),
-            ],
-        );
-    }
-
-    #[test]
-    fn test_find_nth_pairs_pos_skip() {
-        check_find_nth_pair_pos(
-            "(so (many (good) text) here)",
-            vec![
-                // cursor on go[o]d
-                (13, '(', 1, Ok((10, 15))),
-                (13, '(', 2, Ok((4, 21))),
-                (13, '(', 3, Ok((0, 27))),
-            ],
-        );
-    }
-
-    #[test]
-    fn test_find_nth_pairs_pos_same() {
-        check_find_nth_pair_pos(
-            "'so 'many 'good' text' here'",
-            vec![
-                // cursor on go[o]d
-                (13, '\'', 1, Ok((10, 15))),
-                (13, '\'', 2, Ok((4, 21))),
-                (13, '\'', 3, Ok((0, 27))),
-                // cursor on the quotes
-                (10, '\'', 1, Err(Error::CursorOnAmbiguousPair)),
-            ],
-        )
-    }
-
-    #[test]
-    fn test_find_nth_pairs_pos_step() {
-        check_find_nth_pair_pos(
-            "((so)((many) good (text))(here))",
-            vec![
-                // cursor on go[o]d
-                (15, '(', 1, Ok((5, 24))),
-                (15, '(', 2, Ok((0, 31))),
-            ],
-        )
-    }
-
-    #[test]
-    fn test_find_nth_pairs_pos_mixed() {
-        check_find_nth_pair_pos(
-            "(so [many {good} text] here)",
-            vec![
-                // cursor on go[o]d
-                (13, '{', 1, Ok((10, 15))),
-                (13, '[', 1, Ok((4, 21))),
-                (13, '(', 1, Ok((0, 27))),
-            ],
-        )
-    }
-
     #[test]
     fn test_get_surround_pos() {
-        let doc = Rope::from("(some) (chars)\n(newline)");
-        let slice = doc.slice(..);
-        let selection = Selection::new(
-            SmallVec::from_slice(&[Range::point(2), Range::point(9), Range::point(20)]),
-            0,
-        );
+        #[rustfmt::skip]
+        let (doc, selection, expectations) =
+            rope_with_selections_and_expectations(
+                "(some) (chars)\n(newline)",
+                "_ ^  _ _ ^   _\n_    ^  _"
+            );
 
-        // cursor on s[o]me, c[h]ars, newl[i]ne
         assert_eq!(
-            get_surround_pos(slice, &selection, '(', 1)
-                .unwrap()
-                .as_slice(),
-            &[0, 5, 7, 13, 15, 23]
+            get_surround_pos(doc.slice(..), &selection, Some('('), 1).unwrap(),
+            expectations
         );
     }
 
     #[test]
-    fn test_get_surround_pos_bail() {
-        let doc = Rope::from("[some]\n(chars)xx\n(newline)");
-        let slice = doc.slice(..);
+    fn test_get_surround_pos_bail_different_surround_chars() {
+        #[rustfmt::skip]
+        let (doc, selection, _) =
+            rope_with_selections_and_expectations(
+                "[some]\n(chars)xx\n(newline)",
+                "  ^   \n  ^      \n         "
+            );
 
-        let selection =
-            Selection::new(SmallVec::from_slice(&[Range::point(2), Range::point(9)]), 0);
-        // cursor on s[o]me, c[h]ars
         assert_eq!(
-            get_surround_pos(slice, &selection, '(', 1),
-            Err(Error::PairNotFound) // different surround chars
+            get_surround_pos(doc.slice(..), &selection, Some('('), 1),
+            Err(Error::PairNotFound)
         );
+    }
+
+    #[test]
+    fn test_get_surround_pos_bail_overlapping_surround_chars() {
+        #[rustfmt::skip]
+        let (doc, selection, _) =
+            rope_with_selections_and_expectations(
+                "[some]\n(chars)xx\n(newline)",
+                "      \n       ^ \n      ^  "
+            );
 
-        let selection = Selection::new(
-            SmallVec::from_slice(&[Range::point(14), Range::point(24)]),
-            0,
-        );
-        // cursor on [x]x, newli[n]e
         assert_eq!(
-            get_surround_pos(slice, &selection, '(', 1),
+            get_surround_pos(doc.slice(..), &selection, Some('('), 1),
             Err(Error::PairNotFound) // overlapping surround chars
         );
+    }
+
+    #[test]
+    fn test_get_surround_pos_bail_cursor_overlap() {
+        #[rustfmt::skip]
+        let (doc, selection, _) =
+            rope_with_selections_and_expectations(
+                "[some]\n(chars)xx\n(newline)",
+                "  ^^  \n         \n         "
+            );
 
-        let selection =
-            Selection::new(SmallVec::from_slice(&[Range::point(2), Range::point(3)]), 0);
-        // cursor on s[o][m]e
         assert_eq!(
-            get_surround_pos(slice, &selection, '[', 1),
+            get_surround_pos(doc.slice(..), &selection, Some('['), 1),
             Err(Error::CursorOverlap)
         );
     }
+
+    #[test]
+    fn test_find_nth_pairs_pos_quote_success() {
+        #[rustfmt::skip]
+        let (doc, selection, expectations) =
+            rope_with_selections_and_expectations(
+                "some 'quoted text' on this 'line'\n'and this one'",
+                "     _        ^  _               \n              "
+            );
+
+        assert_eq!(2, expectations.len());
+        assert_eq!(
+            find_nth_pairs_pos(doc.slice(..), '\'', selection.primary(), 1)
+                .expect("find should succeed"),
+            (expectations[0], expectations[1])
+        )
+    }
+
+    #[test]
+    fn test_find_nth_pairs_pos_nested_quote_success() {
+        #[rustfmt::skip]
+        let (doc, selection, expectations) =
+            rope_with_selections_and_expectations(
+                "some 'nested 'quoted' text' on this 'line'\n'and this one'",
+                "     _           ^        _               \n              "
+            );
+
+        assert_eq!(2, expectations.len());
+        assert_eq!(
+            find_nth_pairs_pos(doc.slice(..), '\'', selection.primary(), 2)
+                .expect("find should succeed"),
+            (expectations[0], expectations[1])
+        )
+    }
+
+    #[test]
+    fn test_find_nth_pairs_pos_inside_quote_ambiguous() {
+        #[rustfmt::skip]
+        let (doc, selection, _) =
+            rope_with_selections_and_expectations(
+                "some 'nested 'quoted' text' on this 'line'\n'and this one'",
+                "                    ^                     \n              "
+            );
+
+        assert_eq!(
+            find_nth_pairs_pos(doc.slice(..), '\'', selection.primary(), 1),
+            Err(Error::CursorOnAmbiguousPair)
+        )
+    }
+
+    #[test]
+    fn test_find_nth_closest_pairs_pos_index_range_panic() {
+        #[rustfmt::skip]
+        let (doc, selection, _) =
+            rope_with_selections_and_expectations(
+                "(a)c)",
+                "^^^^^"
+            );
+
+        assert_eq!(
+            find_nth_closest_pairs_pos(doc.slice(..), selection.primary(), 1),
+            Err(Error::PairNotFound)
+        )
+    }
+
+    // Create a Rope and a matching Selection using a specification language.
+    // ^ is a single-point selection.
+    // _ is an expected index. These are returned as a Vec<usize> for use in assertions.
+    fn rope_with_selections_and_expectations(
+        text: &str,
+        spec: &str,
+    ) -> (Rope, Selection, Vec<usize>) {
+        if text.len() != spec.len() {
+            panic!("specification must match text length -- are newlines aligned?");
+        }
+
+        let rope = Rope::from(text);
+
+        let selections: SmallVec<[Range; 1]> = spec
+            .match_indices('^')
+            .map(|(i, _)| Range::point(i))
+            .collect();
+
+        let expectations: Vec<usize> = spec.match_indices('_').map(|(i, _)| i).collect();
+
+        (rope, Selection::new(selections, 0), expectations)
+    }
 }