diff --git a/.appveyor.yml b/.appveyor.yml
deleted file mode 100644
index d463b7a2..00000000
--- a/.appveyor.yml
+++ /dev/null
@@ -1,50 +0,0 @@
-build: false
-install:
-  # Terminate early unless building either a tag or a PR.
-  - if "%APPVEYOR_REPO_TAG%" == "false" if not "%APPVEYOR_REPO_BRANCH%" == "master" appveyor exit
-
-  # Install rust
-  - appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
-  - IF "%PLATFORM%" == "x86" rustup-init -y --default-toolchain stable --default-host i686-pc-windows-msvc
-  - IF "%PLATFORM%" == "x64" rustup-init -y --default-toolchain stable --default-host x86_64-pc-windows-msvc
-  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
-  - rustc -vV
-  - cargo -vV
-
-  # Install dependencies
-  - git submodule update --init
-
-platform:
-  - x64
-  - x86
-
-test_script:
-  # Fetch and regenerate the fixture parsers
-  - script\fetch-fixtures.cmd
-  - cargo build --release
-  - script\generate-fixtures.cmd
-
-  # Run tests
-  - script\test.cmd
-  - script\benchmark.cmd
-
-before_deploy:
-  - move target\release\tree-sitter.exe tree-sitter.exe
-  - 7z a -tgzip tree-sitter-windows-%PLATFORM%.gz tree-sitter.exe
-  - appveyor PushArtifact tree-sitter-windows-%PLATFORM%.gz
-
-deploy:
-  description: ''
-  provider: GitHub
-  auth_token:
-    secure: VC9ntV5+inKoNteZyLQksKzWMKXF46P+Jx3JHKVSfF+o1rWtZn2iIHAVsQv5LaUi
-  artifact: /tree-sitter-windows-.*/
-  draft: true
-  force_update: true
-  on:
-    APPVEYOR_REPO_TAG: true
-
-cache:
-  - target
-  - test\fixtures\grammars
-  - C:\Users\appveyor\.cargo
diff --git a/.gitattributes b/.gitattributes
index 4fcce330..44bf45c7 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,2 +1,5 @@
 /lib/src/unicode/*.h linguist-vendored
 /lib/src/unicode/LICENSE linguist-vendored
+
+/cli/src/generate/prepare_grammar/*.json -diff
+Cargo.lock -diff
diff --git a/.github/scripts/cross.sh b/.github/scripts/cross.sh
new file mode 100755
index 00000000..a52f0873
--- /dev/null
+++ b/.github/scripts/cross.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# set -x
+set -e
+
+if [ "$BUILD_CMD" != "cross" ]; then
+    echo "cross.sh - is a helper to assist only in cross compiling environments" >&2
+    echo "To use this tool set the BUILD_CMD env var to the \"cross\" value" >&2
+    exit 111
+fi
+
+if [ -z "$CROSS_IMAGE" ]; then
+    echo "The CROSS_IMAGE env var should be provided" >&2
+    exit 111
+fi
+
+docker run --rm -v /home/runner:/home/runner -w "$PWD" "$CROSS_IMAGE" "$@"
diff --git a/.github/scripts/make.sh b/.github/scripts/make.sh
new file mode 100755
index 00000000..79192541
--- /dev/null
+++ b/.github/scripts/make.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+
+# set -x
+set -e
+
+if [ "$BUILD_CMD" == "cross" ]; then
+    if [ -z "$CC" ]; then
+        echo "make.sh: CC is not set" >&2
+        exit 111
+    fi
+    if [ -z "$AR" ]; then
+        echo "make.sh: AR is not set" >&2
+        exit 111
+    fi
+
+    cross.sh make CC=$CC AR=$AR "$@"
+else
+    make "$@"
+fi
diff --git a/.github/scripts/tree-sitter.sh b/.github/scripts/tree-sitter.sh
new file mode 100755
index 00000000..0cac9153
--- /dev/null
+++ b/.github/scripts/tree-sitter.sh
@@ -0,0 +1,28 @@
+#!/bin/bash
+
+# set -x
+set -e
+
+if [ -z "$ROOT" ]; then
+    echo "The ROOT env var should be set to absolute path of a repo root folder" >&2
+    exit 111
+fi
+
+if [ -z "$TARGET" ]; then
+    echo "The TARGET env var should be equal to a \`cargo build --target <TARGET>\` command value" >&2
+    exit 111
+fi
+
+tree_sitter="$ROOT"/target/"$TARGET"/release/tree-sitter
+
+if [ "$BUILD_CMD" == "cross" ]; then
+    if [ -z "$CROSS_RUNNER" ]; then
+        echo "The CROSS_RUNNER env var should be set to a CARGO_TARGET_*_RUNNER env var value" >&2
+        echo "that is available in a docker image used by the cross tool under the hood" >&2
+        exit 111
+    fi
+
+    cross.sh $CROSS_RUNNER "$tree_sitter" "$@"
+else
+    "$tree_sitter" "$@"
+fi
diff --git a/.github/workflows/CICD.yml b/.github/workflows/CICD.yml
new file mode 100644
index 00000000..fcdb6ea9
--- /dev/null
+++ b/.github/workflows/CICD.yml
@@ -0,0 +1,85 @@
+name: CICD
+
+on:
+  workflow_dispatch:
+  pull_request:
+    types:
+      - opened
+      - reopened
+      - synchronize
+      - ready_for_review
+  push:
+    branches-ignore:
+      - release/v*
+
+concurrency:
+  group: >
+    ${{ github.workflow }} @ ${{
+      github.ref == 'refs/heads/master' && github.ref_name || ''
+    }}${{
+      github.ref == 'refs/heads/master' && github.sha
+      || github.event.pull_request.head.label || github.head_ref || github.ref
+    }}
+  cancel-in-progress: true
+
+jobs:
+  init:
+    name: Init
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get PR head ref
+        if: ${{ github.event_name == 'pull_request' }}
+        id: pr_head_ref
+        run: |
+          echo "ref=refs/pull/${{ github.event.pull_request.number }}/head" >> $GITHUB_OUTPUT
+    outputs:
+      ref: >-
+        ${{
+          (github.event_name == 'pull_request' && startsWith(github.head_ref, 'release/v'))
+          && steps.pr_head_ref.outputs.ref
+          || github.ref
+        }}
+
+  fast_checks:
+    name: Fast checks
+    uses: ./.github/workflows/fast_checks.yml
+
+  full_checks:
+    name: Full Rust checks
+    needs: fast_checks
+    uses: ./.github/workflows/full_rust_checks.yml
+
+  min_version:
+    name: Minimum supported rust version
+    needs: fast_checks
+    uses: ./.github/workflows/msrv.yml
+    with:
+      package: tree-sitter-cli
+
+  sanitize:
+    name: Sanitize
+    needs: [init, fast_checks]
+    uses: ./.github/workflows/sanitize.yml
+
+  build:
+    name: Build & Test
+    needs: [init, fast_checks]
+    uses: ./.github/workflows/build.yml
+    with:
+      ref: ${{ needs.init.outputs.ref }}
+
+  release:
+    name: Release
+    needs: [init, fast_checks, full_checks, min_version, build, sanitize]
+    if: >
+      github.event_name == 'pull_request' &&
+      startsWith(github.head_ref, 'release/v') &&
+      !github.event.pull_request.draft
+    uses: ./.github/workflows/release.yml
+    with:
+      ref: ${{ needs.init.outputs.ref }}
+
+  publish:
+    name: Publish
+    needs: release
+    uses: ./.github/workflows/publish.yml
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
new file mode 100644
index 00000000..8087251d
--- /dev/null
+++ b/.github/workflows/build.yml
@@ -0,0 +1,267 @@
+name: Build & Test
+
+env:
+  CARGO_TERM_COLOR: always
+  RUSTFLAGS: "-D warnings"
+  CROSS_DEBUG: 1
+
+on:
+  workflow_call:
+    inputs:
+      ref:
+        default: ${{ github.ref }}
+        type: string
+      run-tests:
+        default: true
+        type: boolean
+  workflow_dispatch:
+    inputs:
+      run-tests:
+        description: Run tests
+        default: true
+        type: boolean
+      rust-test-threads:
+        description: Number of Rust test threads
+        default: ""
+        type: string
+
+jobs:
+  build:
+    name: ${{ matrix.platform }} (${{ matrix.target }}) (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+        - linux-arm64       #
+        - linux-arm         #
+        - linux-armhf       #
+        - linux-armv5te     #
+        - linux-armv7l      #
+        - linux-x64         #
+        - linux-x86         #
+        - linux-i586        #
+        - linux-mips        #
+        - linux-mips64      #
+        - linux-mipsel      #
+        - linux-mips64el    #
+        - linux-powerpc     #
+        - linux-powerpc64   #
+        - linux-powerpc64el #
+      # - linux-riscv64gc   # #2712
+        - linux-s390x       #
+        - linux-sparc64     #
+        - linux-thumbv7neon #
+        - windows-arm64     #
+        - windows-x64       # <-- No C library build - requires an additional adapted Makefile for `cl.exe` compiler
+        - windows-x86       #     -- // --
+        - macos-arm64       # <-- MacOS M1/M2 - no tests, only CLI build to be published on release artifacts
+        - macos-x64         #
+
+        include:
+        # When adding a new `target`:
+        # 1. Define a new platform alias above
+        # 2. Add a new record to a matrix map in `cli/npm/install.js`
+        - { platform: linux-arm64       , target: aarch64-unknown-linux-gnu           , os: ubuntu-latest  , use-cross: true }
+        - { platform: linux-arm         , target: arm-unknown-linux-gnueabi           , os: ubuntu-latest  , use-cross: true }
+        - { platform: linux-armhf       , target: arm-unknown-linux-gnueabihf         , os: ubuntu-latest  , use-cross: true }
+        - { platform: linux-armv5te     , target: armv5te-unknown-linux-gnueabi       , os: ubuntu-latest  , use-cross: true }
+        - { platform: linux-armv7l      , target: armv7-unknown-linux-gnueabihf       , os: ubuntu-latest  , use-cross: true }
+        - { platform: linux-x64         , target: x86_64-unknown-linux-gnu            , os: ubuntu-20.04                     } #2272
+        - { platform: linux-x86         , target: i686-unknown-linux-gnu              , os: ubuntu-latest  , use-cross: true }
+        - { platform: linux-i586        , target: i586-unknown-linux-gnu              , os: ubuntu-latest  , use-cross: true }
+        - { platform: linux-mips        , target: mips-unknown-linux-gnu              , os: ubuntu-latest  , use-cross: true }
+        - { platform: linux-mips64      , target: mips64-unknown-linux-gnuabi64       , os: ubuntu-latest  , use-cross: true }
+        - { platform: linux-mipsel      , target: mipsel-unknown-linux-gnu            , os: ubuntu-latest  , use-cross: true }
+        - { platform: linux-mips64el    , target: mips64el-unknown-linux-gnuabi64     , os: ubuntu-latest  , use-cross: true }
+        - { platform: linux-powerpc     , target: powerpc-unknown-linux-gnu           , os: ubuntu-latest  , use-cross: true }
+        - { platform: linux-powerpc64   , target: powerpc64-unknown-linux-gnu         , os: ubuntu-latest  , use-cross: true }
+        - { platform: linux-powerpc64el , target: powerpc64le-unknown-linux-gnu       , os: ubuntu-latest  , use-cross: true }
+      # - { platform: linux-riscv64gc   , target: riscv64gc-unknown-linux-gnu         , os: ubuntu-latest  , use-cross: true } #2712
+        - { platform: linux-s390x       , target: s390x-unknown-linux-gnu             , os: ubuntu-latest  , use-cross: true }
+        - { platform: linux-sparc64     , target: sparc64-unknown-linux-gnu           , os: ubuntu-latest  , use-cross: true }
+        - { platform: linux-thumbv7neon , target: thumbv7neon-unknown-linux-gnueabihf , os: ubuntu-latest  , use-cross: true }
+        - { platform: windows-arm64     , target: aarch64-pc-windows-msvc             , os: windows-latest                   }
+        - { platform: windows-x64       , target: x86_64-pc-windows-msvc              , os: windows-latest                   }
+        - { platform: windows-x86       , target: i686-pc-windows-msvc                , os: windows-latest                   }
+        - { platform: macos-arm64       , target: aarch64-apple-darwin                , os: macos-latest                     }
+        - { platform: macos-x64         , target: x86_64-apple-darwin                 , os: macos-latest                     }
+
+        # Cross compilers for C library
+        - { platform: linux-arm64       , cc: aarch64-linux-gnu-gcc             , ar: aarch64-linux-gnu-ar           }
+        - { platform: linux-arm         , cc: arm-linux-gnueabi-gcc             , ar: arm-linux-gnueabi-ar           }
+        - { platform: linux-armhf       , cc: arm-unknown-linux-gnueabihf-gcc   , ar: arm-unknown-linux-gnueabihf-ar }
+        - { platform: linux-armv5te     , cc: arm-linux-gnueabi-gcc             , ar: arm-linux-gnueabi-ar           }
+        - { platform: linux-armv7l      , cc: arm-linux-gnueabihf-gcc           , ar: arm-linux-gnueabihf-ar         }
+        - { platform: linux-x86         , cc: i686-linux-gnu-gcc                , ar: i686-linux-gnu-ar              }
+        - { platform: linux-i586        , cc: i686-linux-gnu-gcc                , ar: i686-linux-gnu-ar              }
+        - { platform: linux-mips        , cc: mips-linux-gnu-gcc                , ar: mips-linux-gnu-ar              }
+        - { platform: linux-mips64      , cc: mips64-linux-gnuabi64-gcc         , ar: mips64-linux-gnuabi64-ar       }
+        - { platform: linux-mipsel      , cc: mipsel-linux-gnu-gcc              , ar: mipsel-linux-gnu-ar            }
+        - { platform: linux-mips64el    , cc: mips64el-linux-gnuabi64-gcc       , ar: mips64el-linux-gnuabi64-ar     }
+        - { platform: linux-powerpc     , cc: powerpc-linux-gnu-gcc             , ar: powerpc-linux-gnu-ar           }
+        - { platform: linux-powerpc64   , cc: powerpc64-linux-gnu-gcc           , ar: powerpc64-linux-gnu-ar         }
+        - { platform: linux-powerpc64el , cc: powerpc64le-linux-gnu-gcc         , ar: powerpc64le-linux-gnu-ar       }
+      # - { platform: linux-riscv64gc   , cc: riscv64-linux-gnu-gcc             , ar: riscv64-linux-gnu-ar           } #2712
+        - { platform: linux-s390x       , cc: s390x-linux-gnu-gcc               , ar: s390x-linux-gnu-ar             }
+        - { platform: linux-sparc64     , cc: sparc64-linux-gnu-gcc             , ar: sparc64-linux-gnu-ar           }
+        - { platform: linux-thumbv7neon , cc: arm-linux-gnueabihf-gcc           , ar: arm-linux-gnueabihf-ar         }
+
+        # Rust toolchains
+        - { platform: linux-mips        , rust-toolchain: 1.71.1 }
+        - { platform: linux-mips64      , rust-toolchain: 1.71.1 }
+        - { platform: linux-mipsel      , rust-toolchain: 1.71.1 }
+        - { platform: linux-mips64el    , rust-toolchain: 1.71.1 }
+
+        # See #2041 tree-sitter issue
+        - { platform: windows-x64   , rust-test-threads: 1 }
+        - { platform: windows-x86   , rust-test-threads: 1 }
+
+        # CLI only build
+        - { platform: windows-arm64 , cli-only: true }
+        - { platform: macos-arm64   , cli-only: true }
+
+    env:
+      BUILD_CMD: cargo
+      EMSCRIPTEN_VERSION: ""
+      EXE: ${{ contains(matrix.target, 'windows') && '.exe' || '' }}
+
+    defaults:
+      run:
+        shell: bash
+
+    steps:
+    - name: Checkout source code
+      uses: actions/checkout@v3
+      with:
+        ref: ${{ inputs.ref }}
+
+    - name: Read Emscripten version
+      run: |
+        echo "EMSCRIPTEN_VERSION=$(cat cli/loader/emscripten-version)" >> $GITHUB_ENV
+
+    - name: Install Emscripten
+      if: ${{ !matrix.cli-only && !matrix.use-cross }}
+      uses: mymindstorm/setup-emsdk@v12
+      with:
+        version: ${{ env.EMSCRIPTEN_VERSION }}
+
+    - name: Install Rust toolchain
+      uses: dtolnay/rust-toolchain@stable
+      with:
+        targets: ${{ matrix.target }}
+        toolchain: ${{ matrix.rust-toolchain || 'stable' }}
+
+    - name: Install cross
+      if: ${{ matrix.use-cross }}
+      uses: taiki-e/install-action@v2
+      with:
+        tool: cross
+
+    - name: Build custom cross image
+      if: ${{ matrix.use-cross && matrix.os == 'ubuntu-latest' }}
+      run: |
+        cd ..
+
+        target="${{ matrix.target }}"
+        image=ghcr.io/cross-rs/$target:custom
+        echo "CROSS_IMAGE=$image"                              >> $GITHUB_ENV
+
+        echo "[target.$target]"                                >> Cross.toml
+        echo "image = \"$image\""                              >> Cross.toml
+        echo "CROSS_CONFIG=$PWD/Cross.toml"                    >> $GITHUB_ENV
+
+        echo "FROM ghcr.io/cross-rs/$target:edge"              >> Dockerfile
+        echo "ENV DEBIAN_FRONTEND=noninteractive"              >> Dockerfile
+        echo "RUN apt-get update && apt-get install -y nodejs" >> Dockerfile
+        docker build -t $image .
+
+    - name: Setup env extras
+      env:
+        RUST_TEST_THREADS: ${{ matrix.rust-test-threads || inputs.rust-test-threads || '' }}
+        USE_CROSS: ${{ matrix.use-cross }}
+        TARGET: ${{ matrix.target }}
+        CC: ${{ matrix.cc }}
+        AR: ${{ matrix.ar }}
+        IS_WINDOWS: ${{ contains(matrix.os, 'windows') }}
+      run: |
+        PATH="$PWD/.github/scripts:$PATH"
+        echo "$PWD/.github/scripts" >> $GITHUB_PATH
+
+        echo "TREE_SITTER=tree-sitter.sh" >> $GITHUB_ENV
+        echo "TARGET=$TARGET" >> $GITHUB_ENV
+        echo "ROOT=$PWD" >> $GITHUB_ENV
+
+        [ -n "$RUST_TEST_THREADS" ] && \
+        echo "RUST_TEST_THREADS=$RUST_TEST_THREADS" >> $GITHUB_ENV
+
+        [ -n "$CC" ] && echo "CC=$CC" >> $GITHUB_ENV
+        [ -n "$AR" ] && echo "AR=$AR" >> $GITHUB_ENV
+
+        [ "$IS_WINDOWS" = "false" ] && echo "CFLAGS=-Werror" >> $GITHUB_ENV
+
+        if [ "$USE_CROSS" == "true" ]; then
+          echo "BUILD_CMD=cross" >> $GITHUB_ENV
+          runner=$(BUILD_CMD=cross cross.sh bash -c "env | sed -nr '/^CARGO_TARGET_.*_RUNNER=/s///p'")
+          [ -n "$runner" ] && echo "CROSS_RUNNER=$runner" >> $GITHUB_ENV
+        fi
+
+    - name: Build C library
+      if: ${{ !contains(matrix.os, 'windows') }} # Requires an additional adapted Makefile for `cl.exe` compiler
+      run: make.sh -j
+
+    - name: Build wasm library
+      if: ${{ !matrix.cli-only && !matrix.use-cross }} # No sense to build on the same Github runner hosts many times
+      run: script/build-wasm
+
+    - name: Build CLI
+      run: $BUILD_CMD build --release --target=${{ matrix.target }}
+
+    - name: Info about CLI
+      if: ${{ startsWith(matrix.platform, 'linux') }}
+      run: |
+        min_glibc=$(objdump -p target/$TARGET/release/tree-sitter${{ env.EXE }} | sed -nr 's/.*(GLIBC_.+).*/\1/p' | sort -uV | tail -n1)
+        echo "🔗 Minimal **glibc** version required for CLI: ${min_glibc}">> $GITHUB_STEP_SUMMARY
+
+    - name: Fetch fixtures
+      if: ${{ inputs.run-tests && !matrix.cli-only }} # Don't fetch fixtures for only CLI building targets
+      run: script/fetch-fixtures
+
+    - name: Generate fixtures
+      if: ${{ inputs.run-tests && !matrix.cli-only }} # Can't natively run CLI on Github runner's host
+      run: script/generate-fixtures
+
+    - name: Generate WASM fixtures
+      if: ${{ inputs.run-tests && !matrix.cli-only && !matrix.use-cross }} # See comment for the "Build wasm library" step
+      run: script/generate-fixtures-wasm
+
+    - name: Run main tests
+      if: ${{ inputs.run-tests && !matrix.cli-only }} # Can't natively run CLI on Github runner's host
+      run: $BUILD_CMD test --target=${{ matrix.target }}
+
+    - name: Run wasm tests
+      if: ${{ inputs.run-tests && !matrix.cli-only && !matrix.use-cross }} # See comment for the "Build wasm library" step
+      run: script/test-wasm
+
+    - name: Run benchmarks
+      if: ${{ inputs.run-tests && !matrix.cli-only && !matrix.use-cross }} # Cross-compiled benchmarks make no sense
+      run: $BUILD_CMD bench benchmark -p tree-sitter-cli --target=${{ matrix.target }}
+
+    - name: Upload CLI artifact
+      uses: actions/upload-artifact@v3
+      with:
+        name: tree-sitter.${{ matrix.platform }}
+        path: target/${{ matrix.target }}/release/tree-sitter${{ env.EXE }}
+        if-no-files-found: error
+        retention-days: 7
+
+    - name: Upload WASM artifacts
+      if: ${{ matrix.platform == 'linux-x64' }}
+      uses: actions/upload-artifact@v3
+      with:
+        name: tree-sitter.wasm
+        path: |
+          lib/binding_web/tree-sitter.js
+          lib/binding_web/tree-sitter.wasm
+        if-no-files-found: error
+        retention-days: 7
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
deleted file mode 100644
index 361b4b4c..00000000
--- a/.github/workflows/ci.yml
+++ /dev/null
@@ -1,149 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches:
-      - master
-    tags:
-      - v*
-  pull_request:
-    branches:
-      - "**"
-
-env:
-  CARGO_TERM_COLOR: always
-  CARGO_INCREMENTAL: 0
-
-jobs:
-  unix-tests:
-    name: Unix tests
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: true
-      matrix:
-        os:
-          - macos-latest
-          - ubuntu-latest
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v2
-
-      # Work around https://github.com/actions/cache/issues/403.
-      - name: Use GNU tar
-        if: matrix.os == 'macos-latest'
-        run: |
-          echo PATH="/usr/local/opt/gnu-tar/libexec/gnubin:$PATH" >> $GITHUB_ENV
-
-      - name: Read Emscripten version
-        run: |
-          printf 'EMSCRIPTEN_VERSION=%s\n' "$(cat cli/loader/emscripten-version)" >> $GITHUB_ENV
-
-      - name: Cache artifacts
-        id: cache
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-${{ hashFiles('Cargo.lock') }}-emscripten-${{ env.EMSCRIPTEN_VERSION }}
-
-      - name: Install rust
-        if: steps.cache.outputs.cache-hit != 'true'
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-
-      - name: Check Rust code formatting
-        run: cargo fmt -- --check
-
-      - name: Install emscripten
-        uses: mymindstorm/setup-emsdk@v10
-        with:
-          version: ${{ env.EMSCRIPTEN_VERSION }}
-
-      - name: Build C library
-        run: make
-
-      - name: Build wasm library
-        run: script/build-wasm
-
-      - name: Build CLI
-        run: |
-          RUSTFLAGS="-D warnings"
-          cargo build --release
-
-      - name: Set up fixture parsers
-        run: |
-          script/fetch-fixtures
-          script/generate-fixtures
-          script/generate-fixtures-wasm
-
-      - name: Run main tests
-        run: cargo test
-
-      - name: Run wasm tests
-        run: script/test-wasm
-
-      - name: Run benchmarks
-        run: script/benchmark
-
-      - name: Compress CLI binary
-        if: startsWith(github.ref, 'refs/tags/v')
-        run: |
-          cp target/release/tree-sitter .
-          export platform=$(echo ${{ runner.os }} | awk '{print tolower($0)}')
-          gzip --suffix "-${platform}-x64.gz" tree-sitter
-
-      - name: Release
-        uses: softprops/action-gh-release@v1
-        if: startsWith(github.ref, 'refs/tags/v')
-        with:
-          draft: true
-          files: |
-            tree-sitter-*.gz
-            lib/binding_web/tree-sitter.js
-            lib/binding_web/tree-sitter.wasm
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  windows-tests:
-    name: Windows tests
-    runs-on: windows-latest
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v2
-
-      - name: Cache artifacts
-        id: cache
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-${{ hashFiles('Cargo.lock') }}
-
-      - name: Install rust
-        if: steps.cache.outputs.cache-hit != 'true'
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-
-      - name: Check Rust code formatting
-        run: cargo fmt -- --check
-
-      - name: Build CLI
-        run: |
-          $env:RUSTFLAGS="-D warnings"
-          cargo build --release
-
-      - name: Set up fixture parsers
-        run: |
-          script/fetch-fixtures.cmd
-          script/generate-fixtures.cmd
-
-      - name: Run main tests
-        run: script/test
diff --git a/.github/workflows/fast_checks.yml b/.github/workflows/fast_checks.yml
new file mode 100644
index 00000000..ea474799
--- /dev/null
+++ b/.github/workflows/fast_checks.yml
@@ -0,0 +1,31 @@
+name: Fast checks to fail fast on any simple code issues
+
+env:
+  CARGO_TERM_COLOR: always
+  RUSTFLAGS: "-D warnings"
+
+on:
+  workflow_call:
+
+jobs:
+  check_rust_formatting:
+    name: Check Rust formating
+    runs-on: ubuntu-latest
+    steps:
+
+    - name: Checkout source code
+      uses: actions/checkout@v3
+
+    - name: Run cargo fmt
+      run: cargo fmt -- --check
+
+  check_c_warnings:
+    name: Check C warnings
+    runs-on: ubuntu-latest
+    steps:
+
+    - name: Checkout source code
+      uses: actions/checkout@v3
+
+    - name: Make C library to check that it's able to compile without warnings
+      run: make -j CFLAGS="-Werror"
diff --git a/.github/workflows/full_rust_checks.yml b/.github/workflows/full_rust_checks.yml
new file mode 100644
index 00000000..2cc5f77d
--- /dev/null
+++ b/.github/workflows/full_rust_checks.yml
@@ -0,0 +1,32 @@
+name: Full Rust codebase checks
+
+env:
+  CARGO_TERM_COLOR: always
+  RUSTFLAGS: "-D warnings"
+
+on:
+  workflow_call:
+
+jobs:
+  run:
+    name: Run checks
+    runs-on: ubuntu-latest
+    steps:
+
+    - name: Checkout source code
+      uses: actions/checkout@v3
+
+    - name: Install rust toolchain
+      uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: stable
+        components: clippy, rustfmt
+
+    - name: Run cargo fmt
+      run: cargo fmt -- --check
+
+    # - name: Run clippy
+    #   run: cargo clippy --all-targets
+
+    - name: Run cargo check
+      run: cargo check --workspace --examples --tests --benches --bins
diff --git a/.github/workflows/msrv.yml b/.github/workflows/msrv.yml
new file mode 100644
index 00000000..3697930e
--- /dev/null
+++ b/.github/workflows/msrv.yml
@@ -0,0 +1,42 @@
+name: Minimum supported rust version
+
+env:
+  CARGO_TERM_COLOR: always
+  RUSTFLAGS: "-D warnings"
+
+on:
+  workflow_call:
+    inputs:
+      package:
+        description: Target cargo package name
+        required: true
+        type: string
+
+
+jobs:
+  run:
+    name: Run checks
+    runs-on: ubuntu-latest
+    steps:
+
+    - name: Checkout source code
+      uses: actions/checkout@v3
+
+    - name: Get the MSRV from the package metadata
+      id: msrv
+      run: cargo metadata --no-deps --format-version 1 | jq -r '"version=" + (.packages[] | select(.name == "${{ inputs.package }}").rust_version)' >> $GITHUB_OUTPUT
+
+    - name: Install rust toolchain (v${{ steps.msrv.outputs.version }})
+      uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: ${{ steps.msrv.outputs.version }}
+        components: clippy, rustfmt
+
+    - name: Run cargo fmt
+      run: cargo fmt -- --check
+
+    # - name: Run clippy (on minimum supported rust version to prevent warnings we can't fix)
+    #   run: cargo clippy --all-targets
+
+    # - name: Run main tests
+    #   run: cargo test
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
new file mode 100644
index 00000000..e1ad3e05
--- /dev/null
+++ b/.github/workflows/publish.yml
@@ -0,0 +1,21 @@
+name: Publish to registries
+
+on:
+  workflow_call:
+
+jobs:
+  crates_io:
+    name: Publish to Crates.io
+    runs-on: ubuntu-latest
+    steps:
+      - name: Publish packages
+        run: |
+          echo "::warning::TODO: add a Crates.io publish logic"
+
+  npm:
+    name: Publish to npmjs.com
+    runs-on: ubuntu-latest
+    steps:
+      - name: Publish packages
+        run: |
+          echo "::warning::TODO: add a npmjs.com publish logic"
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 00000000..adf1021b
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,113 @@
+name: Release
+
+on:
+  workflow_call:
+    inputs:
+      ref:
+        default: ${{ github.ref }}
+        type: string
+
+jobs:
+  permissions:
+    name: Check permissions
+    runs-on: ubuntu-latest
+    outputs:
+      release_allowed: >
+        ${{
+          github.repository_owner == 'tree-sitter' &&
+          steps.maintainer.outputs.is_maintainer == 'true' &&
+          steps.local_branch.outputs.is_local == 'true'
+        }}
+    steps:
+
+    - name: Initated by a maintainer
+      id: maintainer
+      env:
+        GH_TOKEN: ${{ github.token }}
+        repo: ${{ github.repository }}
+        actor: ${{ github.actor }}
+      run: |
+        maintainer=$(
+          gh api "/repos/${repo}/collaborators" |
+          jq ".[] | {login, maintainer: .permissions | .maintain} | select(.login == \"${actor}\") | .maintainer"
+        );
+        if [ "$maintainer" == "true" ]; then
+          echo "@${actor} has maintainer level permissions :rocket:" >> $GITHUB_STEP_SUMMARY;
+          echo "is_maintainer=true" >> $GITHUB_OUTPUT
+        fi
+
+    - name: The ref branch is local
+      id: local_branch
+      env:
+        is_local: ${{ github.event.pull_request.head.repo.full_name == github.repository }}
+      run: |
+        echo "is_local=${is_local}" >> $GITHUB_OUTPUT
+
+  release:
+    name: Release
+    needs: permissions
+    if: needs.permissions.outputs.release_allowed
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+
+      - name: Checkout source code
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ inputs.ref }}
+
+      - name: Download build artifacts
+        uses: actions/download-artifact@v3
+        with:
+          path: artifacts
+
+      - name: Display structure of downloaded files
+        run: ls -lR
+        working-directory: artifacts
+
+      - name: Prepare release artifacts
+        run: |
+          mkdir -p target
+          mv artifacts/tree-sitter.wasm/* target/
+          rm -r artifacts/tree-sitter.wasm
+          for platform in $(cd artifacts; ls | sed 's/^tree-sitter\.//'); do
+            exe=$(ls artifacts/tree-sitter.$platform/tree-sitter*)
+            gzip --stdout --name $exe > target/tree-sitter-$platform.gz
+          done
+          rm -rf artifacts
+          ls -l target/
+
+      - name: Get tag name from a release/v* branch name
+        id: tag_name
+        env:
+          tag: ${{ github.head_ref }}
+        run: echo "tag=${tag#release/}" >> $GITHUB_OUTPUT
+
+      - name: Add a release tag
+        env:
+          ref: ${{ inputs.ref }}
+          tag: ${{ steps.tag_name.outputs.tag }}
+          message: "Release ${{ steps.tag_name.outputs.tag }}"
+        run: |
+          git config user.name "$(git log -1 --pretty='%cn')"
+          git config user.email "$(git log -1 --pretty='%ce')"
+          git tag -a "$tag" HEAD -m "$message"
+          git push origin "$tag"
+
+      - name: Create release
+        uses: softprops/action-gh-release@v1
+        with:
+          name: ${{ steps.tag_name.outputs.tag }}
+          tag_name: ${{ steps.tag_name.outputs.tag }}
+          fail_on_unmatched_files: true
+          files: |
+            target/tree-sitter-*.gz
+            target/tree-sitter.wasm
+            target/tree-sitter.js
+
+      - name: Merge release PR
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh pr merge ${{ github.event.pull_request.html_url }} --match-head-commit $(git rev-parse HEAD) --merge --delete-branch
diff --git a/.github/workflows/sanitize.yml b/.github/workflows/sanitize.yml
new file mode 100644
index 00000000..2ece182b
--- /dev/null
+++ b/.github/workflows/sanitize.yml
@@ -0,0 +1,50 @@
+name: Sanitize
+
+env:
+  CARGO_TERM_COLOR: always
+  RUSTFLAGS: "-D warnings"
+
+on:
+  workflow_call:
+
+jobs:
+  check_undefined_behaviour:
+    name: Sanitizer checks
+    runs-on: ubuntu-latest
+    env:
+      TREE_SITTER: ${{ github.workspace }}/target/release/tree-sitter
+    steps:
+    - name: Checkout source code
+      uses: actions/checkout@v3
+
+    - name: Install UBSAN library
+      run: sudo apt-get update -y && sudo apt-get install -y libubsan1
+
+    - name: Install Rust toolchain
+      uses: dtolnay/rust-toolchain@stable
+
+    - name: Build CLI
+      run: cargo build --release
+
+    - name: Fetch fixtures
+      run: script/fetch-fixtures
+
+    - name: Generate fixtures
+      run: script/generate-fixtures
+
+    - name: Run main tests with undefined behaviour sanitizer (UBSAN)
+      env:
+        UBSAN_OPTIONS: halt_on_error=1
+        CFLAGS: -fsanitize=undefined
+        RUSTFLAGS: ${{ env.RUSTFLAGS }} -lubsan
+      run: cargo test -- --test-threads 1
+
+    - name: Run main tests with address sanitizer (ASAN)
+      env:
+        ASAN_OPTIONS: halt_on_error=1
+        CFLAGS: -fsanitize=address
+        RUSTFLAGS: ${{ env.RUSTFLAGS }} -Zsanitizer=address --cfg=sanitizing
+      run: |
+        rustup install nightly
+        rustup component add rust-src --toolchain nightly-x86_64-unknown-linux-gnu
+        cargo +nightly test -Z build-std --target x86_64-unknown-linux-gnu -- --test-threads 1
diff --git a/.gitignore b/.gitignore
index 834fd20f..53550dd7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,6 +7,7 @@ log*.html
 
 fuzz-results
 
+/tree-sitter.pc
 test/fixtures/grammars/*
 !test/fixtures/grammars/.gitkeep
 package-lock.json
@@ -24,4 +25,6 @@ docs/assets/js/tree-sitter.js
 *.obj
 *.exp
 *.lib
-*.wasm
\ No newline at end of file
+*.wasm
+.swiftpm
+zig-*
diff --git a/Cargo.lock b/Cargo.lock
index 345c7a8c..fd1e06cb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -13,9 +13,9 @@ dependencies = [
 
 [[package]]
 name = "ahash"
-version = "0.7.6"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
+checksum = "5a824f2aa7e75a0c98c5a504fceb80649e9c35265d44525b5f94de4771a395cd"
 dependencies = [
  "getrandom",
  "once_cell",
@@ -24,22 +24,13 @@ dependencies = [
 
 [[package]]
 name = "aho-corasick"
-version = "0.7.19"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4f55bd91a0978cbfd91c457a164bab8b4001c833b7f323132c0a4e1922dd44e"
+checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
 dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "android_system_properties"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "ansi_term"
 version = "0.12.1"
@@ -51,15 +42,15 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.66"
+version = "1.0.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "216261ddc8289130e551ddcd5ce8a064710c0d064a4d2895c67151c92b5443f6"
+checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
 
 [[package]]
 name = "arrayvec"
-version = "0.7.2"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
+checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
 
 [[package]]
 name = "ascii"
@@ -93,6 +84,29 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "bindgen"
+version = "0.66.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2b84e06fc203107bfbad243f4aba2af864eb7db3b1cf46ea0a023b0b433d2a7"
+dependencies = [
+ "bitflags 2.4.1",
+ "cexpr",
+ "clang-sys",
+ "lazy_static",
+ "lazycell",
+ "log",
+ "peeking_take_while",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn 2.0.38",
+ "which",
+]
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -100,22 +114,52 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
-name = "bumpalo"
-version = "3.11.1"
+name = "bitflags"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba"
+checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07"
+
+[[package]]
+name = "bumpalo"
+version = "3.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec"
 
 [[package]]
 name = "byteorder"
-version = "1.4.3"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223"
 
 [[package]]
 name = "cc"
-version = "1.0.73"
+version = "1.0.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
 
 [[package]]
 name = "cfg-if"
@@ -124,22 +168,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
-name = "chrono"
-version = "0.4.22"
+name = "chunked_transfer"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfd4d1b31faaa3a89d7934dbded3111da0d2ef28e3ebccdb4f0179f5929d1ef1"
-dependencies = [
- "iana-time-zone",
- "num-integer",
- "num-traits",
- "winapi",
-]
+checksum = "cca491388666e04d7248af3f60f0c40cfb0991c72205595d7c396e3510207d1a"
 
 [[package]]
-name = "chunked_transfer"
-version = "1.4.0"
+name = "clang-sys"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fff857943da45f546682664a79488be82e69e43c1a7a2307679ab9afb3a66d2e"
+checksum = "c688fc74432808e3eb684cae8830a86be1d66a2bd58e1f248ed0960a590baf6f"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
 
 [[package]]
 name = "clap"
@@ -149,7 +192,7 @@ checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
 dependencies = [
  "ansi_term",
  "atty",
- "bitflags",
+ "bitflags 1.3.2",
  "strsim",
  "textwrap",
  "unicode-width",
@@ -157,20 +200,30 @@ dependencies = [
 ]
 
 [[package]]
-name = "codespan-reporting"
-version = "0.11.1"
+name = "combine"
+version = "4.6.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
+checksum = "35ed6e9d84f0b51a7f52daf1c7d71dd136fd7a3f41a8462b8cdb8c78d920fad4"
 dependencies = [
- "termcolor",
- "unicode-width",
+ "bytes",
+ "memchr",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
 ]
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.3"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
+checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa"
 
 [[package]]
 name = "cpp_demangle"
@@ -229,8 +282,8 @@ source = "git+https://github.com/maxbrunsfeld/wasmtime?rev=669e0aaab1181b23fcc4e
 dependencies = [
  "cranelift-entity",
  "fxhash",
- "hashbrown",
- "indexmap",
+ "hashbrown 0.12.3",
+ "indexmap 1.9.3",
  "log",
  "smallvec",
 ]
@@ -295,56 +348,22 @@ dependencies = [
 
 [[package]]
 name = "ctor"
-version = "0.1.26"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d2301688392eb071b0bf1a37be05c469d3cc4dbbd95df672fe28ab021e6a096"
+checksum = "37e366bff8cd32dd8754b0991fb66b279dc48f598c3a18914852a6673deef583"
 dependencies = [
  "quote",
- "syn",
+ "syn 2.0.38",
 ]
 
 [[package]]
-name = "cxx"
-version = "1.0.80"
+name = "ctrlc"
+version = "3.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b7d4e43b25d3c994662706a1d4fcfc32aaa6afd287502c111b237093bb23f3a"
+checksum = "82e95fbd621905b854affdc67943b043a0fbb6ed7385fd5a25650d19a8a6cfdf"
 dependencies = [
- "cc",
- "cxxbridge-flags",
- "cxxbridge-macro",
- "link-cplusplus",
-]
-
-[[package]]
-name = "cxx-build"
-version = "1.0.80"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84f8829ddc213e2c1368e51a2564c552b65a8cb6a28f31e576270ac81d5e5827"
-dependencies = [
- "cc",
- "codespan-reporting",
- "once_cell",
- "proc-macro2",
- "quote",
- "scratch",
- "syn",
-]
-
-[[package]]
-name = "cxxbridge-flags"
-version = "1.0.80"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e72537424b474af1460806647c41d4b6d35d09ef7fe031c5c2fa5766047cc56a"
-
-[[package]]
-name = "cxxbridge-macro"
-version = "1.0.80"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "309e4fb93eed90e1e14bea0da16b209f81813ba9fc7830c20ed151dd7bc0a4d7"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "nix",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -365,7 +384,16 @@ version = "3.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "30baa043103c9d0c2a57cf537cc2f35623889dc0d405e6c3cccfadbc81c71309"
 dependencies = [
- "dirs-sys",
+ "dirs-sys 0.3.7",
+]
+
+[[package]]
+name = "dirs"
+version = "5.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
+dependencies = [
+ "dirs-sys 0.4.1",
 ]
 
 [[package]]
@@ -380,16 +408,28 @@ dependencies = [
 ]
 
 [[package]]
-name = "either"
-version = "1.8.0"
+name = "dirs-sys"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
+checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "either"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
 
 [[package]]
 name = "env_logger"
-version = "0.9.1"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c90bf5f19754d10198ccb95b70664fc925bd1fc090a0fd9a6ebc54acc8cd6272"
+checksum = "a12e6657c4c97ebab115a42dcee77225f7f482cdd841cf7088c657a42e9e00e7"
 dependencies = [
  "atty",
  "humantime",
@@ -398,6 +438,12 @@ dependencies = [
  "termcolor",
 ]
 
+[[package]]
+name = "equivalent"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+
 [[package]]
 name = "errno"
 version = "0.2.8"
@@ -409,6 +455,16 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "errno"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3e13f66a2f95e32a39eaa81f6b95d42878ca0e1db0c7543723dfe12557e860"
+dependencies = [
+ "libc",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "errno-dragonfly"
 version = "0.1.2"
@@ -427,18 +483,15 @@ checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
 
 [[package]]
 name = "fastrand"
-version = "1.8.0"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
-dependencies = [
- "instant",
-]
+checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5"
 
 [[package]]
 name = "form_urlencoded"
-version = "1.1.0"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8"
+checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652"
 dependencies = [
  "percent-encoding",
 ]
@@ -454,9 +507,9 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.8"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
+checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
 dependencies = [
  "cfg-if",
  "libc",
@@ -470,15 +523,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "22030e2c5a68ec659fde1e949a745124b48e6fa8b045b7ed5bd1fe4ccc5c4e5d"
 dependencies = [
  "fallible-iterator",
- "indexmap",
+ "indexmap 1.9.3",
  "stable_deref_trait",
 ]
 
 [[package]]
 name = "glob"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
 
 [[package]]
 name = "hashbrown"
@@ -489,6 +542,12 @@ dependencies = [
  "ahash",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f93e7192158dbcda357bdec5fb5788eebf8bbac027f3f33e719d29135ae84156"
+
 [[package]]
 name = "hermit-abi"
 version = "0.1.19"
@@ -499,49 +558,40 @@ dependencies = [
 ]
 
 [[package]]
-name = "html-escape"
-version = "0.2.11"
+name = "home"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8e7479fa1ef38eb49fb6a42c426be515df2d063f06cb8efd3e50af073dbc26c"
+checksum = "5444c27eef6923071f7ebcc33e3444508466a76f7a2b93da00ed6e19f30c1ddb"
+dependencies = [
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "html-escape"
+version = "0.2.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d1ad449764d627e22bfd7cd5e8868264fc9236e07c752972b4080cd351cb476"
 dependencies = [
  "utf8-width",
 ]
 
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
 [[package]]
 name = "humantime"
 version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
 
-[[package]]
-name = "iana-time-zone"
-version = "0.1.51"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5a6ef98976b22b3b7f2f3a806f858cb862044cfa66805aa3ad84cb3d3b785ed"
-dependencies = [
- "android_system_properties",
- "core-foundation-sys",
- "iana-time-zone-haiku",
- "js-sys",
- "wasm-bindgen",
- "winapi",
-]
-
-[[package]]
-name = "iana-time-zone-haiku"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca"
-dependencies = [
- "cxx",
- "cxx-build",
-]
-
 [[package]]
 name = "idna"
-version = "0.3.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
+checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c"
 dependencies = [
  "unicode-bidi",
  "unicode-normalization",
@@ -549,29 +599,36 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "1.9.1"
+version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
 dependencies = [
  "autocfg",
- "hashbrown",
+ "hashbrown 0.12.3",
  "serde",
 ]
 
 [[package]]
-name = "instant"
-version = "0.1.12"
+name = "indexmap"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+checksum = "8adf3ddd720272c6ea8bf59463c04e0f93d0bbf7c5439b691bca2987e0270897"
 dependencies = [
- "cfg-if",
+ "equivalent",
+ "hashbrown 0.14.2",
 ]
 
 [[package]]
-name = "io-lifetimes"
-version = "0.7.4"
+name = "indoc"
+version = "2.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6e481ccbe3dea62107216d0d1138bb8ad8e5e5c43009a098bd1990272c497b0"
+checksum = "1e186cfbae8084e513daff4240b4797e342f988cecda4fb6c939150f96315fd8"
+
+[[package]]
+name = "io-lifetimes"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ce5ef949d49ee85593fc4d3f3f95ad61657076395cbbce23e2121fc5542074"
 
 [[package]]
 name = "itertools"
@@ -584,15 +641,37 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.4"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4217ad341ebadf8d8e724e264f13e593e0648f5b3e94b3896a5df283be015ecc"
+checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38"
+
+[[package]]
+name = "jni"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+dependencies = [
+ "cesu8",
+ "cfg-if",
+ "combine",
+ "jni-sys",
+ "log",
+ "thiserror",
+ "walkdir",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
 
 [[package]]
 name = "js-sys"
-version = "0.3.60"
+version = "0.3.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47"
+checksum = "c5f195fe497f702db0f318b07fdd68edb16955aed830df8363d837542f8f935a"
 dependencies = [
  "wasm-bindgen",
 ]
@@ -604,30 +683,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
-name = "libc"
-version = "0.2.136"
+name = "lazycell"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55edcf6c0bb319052dea84732cf99db461780fd5e8d3eb46ab6ff312ab31f197"
+checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
+
+[[package]]
+name = "libc"
+version = "0.2.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a08173bc88b7955d1b3145aa561539096c421ac8debde8cbc3612ec635fee29b"
 
 [[package]]
 name = "libloading"
-version = "0.7.3"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efbc0f03f9a775e9f6aed295c6a1ba2253c5757a9e03d55c6caa46a681abcddd"
+checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
 dependencies = [
  "cfg-if",
  "winapi",
 ]
 
-[[package]]
-name = "link-cplusplus"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9272ab7b96c9046fbc5bc56c06c117cb639fe2d509df0c421cad82d2915cf369"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "linux-raw-sys"
 version = "0.0.46"
@@ -635,13 +711,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d4d2456c373231a208ad294c33dc5bff30051eafd954cd4caae83a712b12854d"
 
 [[package]]
-name = "log"
-version = "0.4.17"
+name = "linux-raw-sys"
+version = "0.4.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
-dependencies = [
- "cfg-if",
-]
+checksum = "da2479e8c062e40bf0066ffa0bc823de0a9368974af99c9f6df941d2c231e03f"
+
+[[package]]
+name = "log"
+version = "0.4.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
 
 [[package]]
 name = "mach"
@@ -653,10 +732,19 @@ dependencies = [
 ]
 
 [[package]]
-name = "memchr"
-version = "2.5.0"
+name = "malloc_buf"
+version = "0.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "memchr"
+version = "2.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167"
 
 [[package]]
 name = "memoffset"
@@ -668,22 +756,45 @@ dependencies = [
 ]
 
 [[package]]
-name = "num-integer"
-version = "0.1.45"
+name = "minimal-lexical"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "ndk-context"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"
+
+[[package]]
+name = "nix"
+version = "0.27.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2eb04e9c688eff1c89d72b407f168cf79bb9e867a9d3323ed6c01519eb9cc053"
 dependencies = [
- "autocfg",
- "num-traits",
+ "bitflags 2.4.1",
+ "cfg-if",
+ "libc",
 ]
 
 [[package]]
-name = "num-traits"
-version = "0.2.15"
+name = "nom"
+version = "7.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
 dependencies = [
- "autocfg",
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "objc"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1"
+dependencies = [
+ "malloc_buf",
 ]
 
 [[package]]
@@ -693,61 +804,78 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "21158b2c33aa6d4561f1c0a6ea283ca92bc54802a93b263e910746d679a7eb53"
 dependencies = [
  "crc32fast",
- "hashbrown",
- "indexmap",
+ "hashbrown 0.12.3",
+ "indexmap 1.9.3",
  "memchr",
 ]
 
 [[package]]
 name = "once_cell"
-version = "1.15.0"
+version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e82dad04139b71a90c080c8463fe0dc7902db5192d939bd0950f074d014339e1"
+checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
 
 [[package]]
-name = "output_vt100"
-version = "0.1.3"
+name = "option-ext"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "628223faebab4e3e40667ee0b2336d34a5b960ff60ea743ddfdbcf7770bcfb66"
-dependencies = [
- "winapi",
-]
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
 [[package]]
 name = "paste"
-version = "1.0.9"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1de2e551fb905ac83f73f7aedf2f0cb4a0da7e35efa24a202a936269f1f18e1"
+checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c"
+
+[[package]]
+name = "path-slash"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e91099d4268b0e11973f036e885d652fb0b21fedcf69738c627f94db6a44f42"
+
+[[package]]
+name = "peeking_take_while"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
 
 [[package]]
 name = "percent-encoding"
-version = "2.2.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
+checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94"
 
 [[package]]
 name = "ppv-lite86"
-version = "0.2.16"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
 [[package]]
 name = "pretty_assertions"
-version = "0.7.2"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cab0e7c02cf376875e9335e0ba1da535775beb5450d21e1dffca068818ed98b"
+checksum = "af7cee1a6c8a5b9208b3cb1061f10c0cb689087b3d8ce85fb9d2dd7a29b6ba66"
 dependencies = [
- "ansi_term",
- "ctor",
  "diff",
- "output_vt100",
+ "yansi",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae005bd773ab59b4725093fd7df83fd7892f7d8eafb48dbd7de6e024e4215f9d"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.38",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.47"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ea3d908b0e36316caf9e9e2c4625cdde190a7e6f440d794667ed17a1855e725"
+checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da"
 dependencies = [
  "unicode-ident",
 ]
@@ -763,9 +891,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.21"
+version = "1.0.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
+checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
 dependencies = [
  "proc-macro2",
 ]
@@ -800,13 +928,28 @@ dependencies = [
  "getrandom",
 ]
 
+[[package]]
+name = "raw-window-handle"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2ff9a1f06a88b01621b7ae906ef0211290d1c8a168a15542486a8f61c0833b9"
+
 [[package]]
 name = "redox_syscall"
 version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+dependencies = [
+ "bitflags 1.3.2",
 ]
 
 [[package]]
@@ -816,15 +959,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
 dependencies = [
  "getrandom",
- "redox_syscall",
+ "redox_syscall 0.2.16",
  "thiserror",
 ]
 
 [[package]]
 name = "regalloc2"
-version = "0.4.1"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69025b4a161879ba90719837c06621c3d73cffa147a000aeacf458f6a9572485"
+checksum = "91b2eab54204ea0117fe9a060537e0b07a4e72f7c7d182361ecc346cab2240e5"
 dependencies = [
  "fxhash",
  "log",
@@ -834,35 +977,44 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.6.0"
+version = "1.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c4eb3267174b8c6c2f654116623910a0fef09c4753f8dd83db29c48a0df988b"
+checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax",
+ "regex-automata",
+ "regex-syntax 0.8.2",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax 0.8.2",
 ]
 
 [[package]]
 name = "regex-syntax"
-version = "0.6.27"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244"
+checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
 
 [[package]]
-name = "remove_dir_all"
-version = "0.5.3"
+name = "regex-syntax"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
-dependencies = [
- "winapi",
-]
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
 
 [[package]]
 name = "rustc-demangle"
-version = "0.1.21"
+version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342"
+checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
 
 [[package]]
 name = "rustc-hash"
@@ -872,23 +1024,36 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "rustix"
-version = "0.35.12"
+version = "0.35.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "985947f9b6423159c4726323f373be0a21bdb514c5af06a849cb3d2dce2d01e8"
+checksum = "5363f616a5244fd47fc1dd0a0b24c28a5c0154f5010c16332a7ad6f78f2e8b62"
 dependencies = [
- "bitflags",
- "errno",
+ "bitflags 1.3.2",
+ "errno 0.2.8",
  "io-lifetimes",
  "libc",
- "linux-raw-sys",
- "windows-sys",
+ "linux-raw-sys 0.0.46",
+ "windows-sys 0.42.0",
+]
+
+[[package]]
+name = "rustix"
+version = "0.38.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b426b0506e5d50a7d8dafcf2e81471400deb602392c7dd110815afb4eaf02a3"
+dependencies = [
+ "bitflags 2.4.1",
+ "errno 0.3.5",
+ "libc",
+ "linux-raw-sys 0.4.10",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "ryu"
-version = "1.0.11"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4501abdff3ae82a1c1b477a17252eb69cee9e66eb915c1abaa4f44d873df9f09"
+checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741"
 
 [[package]]
 name = "same-file"
@@ -899,55 +1064,64 @@ dependencies = [
  "winapi-util",
 ]
 
-[[package]]
-name = "scratch"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8132065adcfd6e02db789d9285a0deb2f3fcb04002865ab67d5fb103533898"
-
 [[package]]
 name = "semver"
-version = "1.0.14"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e25dfac463d778e353db5be2449d1cce89bd6fd23c9f1ea21310ce6e5a1b29c4"
+checksum = "836fa6a3e1e547f9a2c4040802ec865b5d85f4014efe00555d7090a3dcaa1090"
 
 [[package]]
 name = "serde"
-version = "1.0.147"
+version = "1.0.171"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d193d69bae983fc11a79df82342761dfbf28a99fc8d203dca4c3c1b590948965"
+checksum = "30e27d1e4fd7659406c492fd6cfaf2066ba8773de45ca75e855590f856dc34a9"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.147"
+version = "1.0.171"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f1d362ca8fc9c3e3a7484440752472d68a6caa98f1ab81d99b5dfe517cec852"
+checksum = "389894603bd18c46fa56231694f8d827779c0951a667087194cf9de94ed24682"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.38",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.87"
+version = "1.0.107"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ce777b7b150d76b9cf60d28b55f5847135a003f7d7350c6be7a773508ce7d45"
+checksum = "6b420ce6e3d8bd882e9b243c6eed35dbc9a6110c9769e74b584e0d68d1f20c65"
 dependencies = [
- "indexmap",
+ "indexmap 2.0.2",
  "itoa",
  "ryu",
  "serde",
 ]
 
 [[package]]
-name = "slice-group-by"
-version = "0.3.0"
+name = "serde_spanned"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03b634d87b960ab1a38c4fe143b508576f075e7c978bfad18217645ebfdfa2ec"
+checksum = "12022b835073e5b11e90a14f86838ceb1c8fb0325b72416845c487ac0fa95e80"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "shlex"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7cee0529a6d40f580e7a5e6c495c8fbfe21b7b52795ed4bb5e62cdf92bc6380"
+
+[[package]]
+name = "slice-group-by"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "826167069c09b99d56f31e9ae5c99049e932a98c9dc2dac47645b08dbbf76ba7"
 
 [[package]]
 name = "smallbitvec"
@@ -957,9 +1131,9 @@ checksum = "75ce4f9dc4a41b4c3476cc925f1efb11b66df373a8fde5d4b8915fa91b5d995e"
 
 [[package]]
 name = "smallvec"
-version = "1.10.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
+checksum = "942b4a808e05215192e39f4ab80813e599068285906cc91aa64f923db842bd5a"
 
 [[package]]
 name = "stable_deref_trait"
@@ -975,9 +1149,20 @@ checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
 
 [[package]]
 name = "syn"
-version = "1.0.103"
+version = "1.0.109"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a864042229133ada95abf3b54fdc62ef5ccabe9515b64717bcb9a1919e59445d"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e96b79aaa137db8f61e26363a0c9b47d8b4ec75da28b7d1d614c2303e232408b"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -986,29 +1171,28 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.4"
+version = "0.12.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c02424087780c9b71cc96799eaeddff35af2bc513278cda5c99fc1f5d026d3c1"
+checksum = "14c39fd04924ca3a864207c66fc2cd7d22d7c016007f9ce846cbb9326331930a"
 
 [[package]]
 name = "tempfile"
-version = "3.3.0"
+version = "3.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
+checksum = "7ef1adac450ad7f4b3c28589471ade84f25f731a7a0fe30d71dfa9f60fd808e5"
 dependencies = [
  "cfg-if",
  "fastrand",
- "libc",
- "redox_syscall",
- "remove_dir_all",
- "winapi",
+ "redox_syscall 0.4.1",
+ "rustix 0.38.21",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "termcolor"
-version = "1.1.3"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+checksum = "6093bad37da69aab9d123a8091e4be0aa4a03e4d601ec641c327398315f62b64"
 dependencies = [
  "winapi-util",
 ]
@@ -1024,35 +1208,34 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.37"
+version = "1.0.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10deb33631e3c9018b9baf9dcbbc4f737320d2b576bac10f6aefa048fa407e3e"
+checksum = "f9a7210f5c9a7156bb50aa36aed4c95afb51df0df00713949448cf9e97d382d2"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.37"
+version = "1.0.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "982d17546b47146b28f7c22e3d08465f6b8903d0ea13c1660d9d84a6e7adcdbb"
+checksum = "266b2e40bc00e5a6c09c3584011e08b06f123c00362c92b975ba9843aaaa14b8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.38",
 ]
 
 [[package]]
 name = "tiny_http"
-version = "0.8.2"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ce51b50006056f590c9b7c3808c3bd70f0d1101666629713866c227d6e58d39"
+checksum = "389915df6413a2e74fb181895f933386023c71110878cd0825588928e64cdc82"
 dependencies = [
  "ascii",
- "chrono",
  "chunked_transfer",
+ "httpdate",
  "log",
- "url",
 ]
 
 [[package]]
@@ -1066,23 +1249,49 @@ dependencies = [
 
 [[package]]
 name = "tinyvec_macros"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "toml"
-version = "0.5.9"
+version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d82e1a7758622a465f8cee077614c73484dac5b836c02ff6a40d5d1010324d7"
+checksum = "dd79e69d3b627db300ff956027cc6c3798cef26d22526befdfcd12feeb6d2257"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
 dependencies = [
  "serde",
 ]
 
 [[package]]
-name = "tree-sitter"
-version = "0.20.9"
+name = "toml_edit"
+version = "0.19.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
 dependencies = [
+ "indexmap 2.0.2",
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "winnow",
+]
+
+[[package]]
+name = "tree-sitter"
+version = "0.20.10"
+dependencies = [
+ "bindgen",
  "cc",
  "regex",
  "wasmtime",
@@ -1091,24 +1300,28 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter-cli"
-version = "0.20.7"
+version = "0.20.8"
 dependencies = [
  "ansi_term",
  "anyhow",
  "atty",
  "clap",
  "ctor",
+ "ctrlc",
  "difference",
- "dirs",
+ "dirs 5.0.1",
  "glob",
  "html-escape",
- "indexmap",
+ "indexmap 2.0.2",
+ "indoc",
  "lazy_static",
  "log",
+ "memchr",
+ "path-slash",
  "pretty_assertions",
  "rand",
  "regex",
- "regex-syntax",
+ "regex-syntax 0.7.5",
  "rustc-hash",
  "semver",
  "serde",
@@ -1122,6 +1335,8 @@ dependencies = [
  "tree-sitter-highlight",
  "tree-sitter-loader",
  "tree-sitter-tags",
+ "tree-sitter-tests-proc-macro",
+ "unindent",
  "walkdir",
  "webbrowser",
  "which",
@@ -1132,15 +1347,16 @@ name = "tree-sitter-config"
 version = "0.19.0"
 dependencies = [
  "anyhow",
- "dirs",
+ "dirs 3.0.2",
  "serde",
  "serde_json",
 ]
 
 [[package]]
 name = "tree-sitter-highlight"
-version = "0.20.1"
+version = "0.20.2"
 dependencies = [
+ "lazy_static",
  "regex",
  "thiserror",
  "tree-sitter",
@@ -1152,7 +1368,7 @@ version = "0.20.0"
 dependencies = [
  "anyhow",
  "cc",
- "dirs",
+ "dirs 3.0.2",
  "libloading",
  "once_cell",
  "regex",
@@ -1174,17 +1390,27 @@ dependencies = [
  "tree-sitter",
 ]
 
+[[package]]
+name = "tree-sitter-tests-proc-macro"
+version = "0.0.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rand",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "unicode-bidi"
-version = "0.3.8"
+version = "0.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "099b7128301d285f79ddd55b9a83d5e6b9e97c92e0ea0daebee7263e932de992"
+checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.5"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
 [[package]]
 name = "unicode-normalization"
@@ -1197,15 +1423,21 @@ dependencies = [
 
 [[package]]
 name = "unicode-width"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"
+
+[[package]]
+name = "unindent"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"
 
 [[package]]
 name = "url"
-version = "2.3.1"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643"
+checksum = "143b538f18257fac9cad154828a57c6bf5157e1aa604d4816b5995bf6de87ae5"
 dependencies = [
  "form_urlencoded",
  "idna",
@@ -1232,12 +1464,11 @@ checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
 [[package]]
 name = "walkdir"
-version = "2.3.2"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
+checksum = "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee"
 dependencies = [
  "same-file",
- "winapi",
  "winapi-util",
 ]
 
@@ -1249,9 +1480,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.83"
+version = "0.2.87"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268"
+checksum = "7706a72ab36d8cb1f80ffbf0e071533974a60d0a308d01a5d0375bf60499a342"
 dependencies = [
  "cfg-if",
  "wasm-bindgen-macro",
@@ -1259,24 +1490,24 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.83"
+version = "0.2.87"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142"
+checksum = "5ef2b6d3c510e9625e5fe6f509ab07d66a760f0885d858736483c32ed7809abd"
 dependencies = [
  "bumpalo",
  "log",
  "once_cell",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.38",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.83"
+version = "0.2.87"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810"
+checksum = "dee495e55982a3bd48105a7b947fd2a9b4a8ae3010041b9e0faab3f9cd028f1d"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -1284,22 +1515,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.83"
+version = "0.2.87"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c"
+checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.38",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.83"
+version = "0.2.87"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f"
+checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1"
 
 [[package]]
 name = "wasmparser"
@@ -1307,7 +1538,7 @@ version = "0.92.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da34cec2a8c23db906cdf8b26e988d7a7f0d549eb5d51299129647af61a1b37"
 dependencies = [
- "indexmap",
+ "indexmap 1.9.3",
 ]
 
 [[package]]
@@ -1318,7 +1549,7 @@ dependencies = [
  "anyhow",
  "bincode",
  "cfg-if",
- "indexmap",
+ "indexmap 1.9.3",
  "libc",
  "log",
  "object",
@@ -1332,7 +1563,7 @@ dependencies = [
  "wasmtime-environ",
  "wasmtime-jit",
  "wasmtime-runtime",
- "windows-sys",
+ "windows-sys 0.36.1",
 ]
 
 [[package]]
@@ -1392,7 +1623,7 @@ dependencies = [
  "anyhow",
  "cranelift-entity",
  "gimli",
- "indexmap",
+ "indexmap 1.9.3",
  "log",
  "object",
  "serde",
@@ -1422,7 +1653,7 @@ dependencies = [
  "wasmtime-environ",
  "wasmtime-jit-icache-coherence",
  "wasmtime-runtime",
- "windows-sys",
+ "windows-sys 0.36.1",
 ]
 
 [[package]]
@@ -1440,7 +1671,7 @@ source = "git+https://github.com/maxbrunsfeld/wasmtime?rev=669e0aaab1181b23fcc4e
 dependencies = [
  "cfg-if",
  "libc",
- "windows-sys",
+ "windows-sys 0.36.1",
 ]
 
 [[package]]
@@ -1451,19 +1682,19 @@ dependencies = [
  "anyhow",
  "cc",
  "cfg-if",
- "indexmap",
+ "indexmap 1.9.3",
  "libc",
  "log",
  "mach",
  "memoffset",
  "paste",
  "rand",
- "rustix",
+ "rustix 0.35.16",
  "thiserror",
  "wasmtime-asm-macros",
  "wasmtime-environ",
  "wasmtime-jit-debug",
- "windows-sys",
+ "windows-sys 0.36.1",
 ]
 
 [[package]]
@@ -1479,9 +1710,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.60"
+version = "0.3.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcda906d8be16e728fd5adc5b729afad4e444e106ab28cd1c7256e54fa61510f"
+checksum = "9b85cbef8c220a6abc02aefd892dfc0fc23afb1c6a426316ec33253a3877249b"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -1489,32 +1720,33 @@ dependencies = [
 
 [[package]]
 name = "webbrowser"
-version = "0.5.5"
+version = "0.8.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecad156490d6b620308ed411cfee90d280b3cbd13e189ea0d3fada8acc89158a"
+checksum = "82b2391658b02c27719fc5a0a73d6e696285138e8b12fba9d4baa70451023c71"
 dependencies = [
+ "core-foundation",
+ "home",
+ "jni",
+ "log",
+ "ndk-context",
+ "objc",
+ "raw-window-handle",
+ "url",
  "web-sys",
- "widestring",
- "winapi",
 ]
 
 [[package]]
 name = "which"
-version = "4.3.0"
+version = "4.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c831fbbee9e129a8cf93e7747a82da9d95ba8e16621cae60ec2cdc849bacb7b"
+checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7"
 dependencies = [
  "either",
- "libc",
+ "home",
  "once_cell",
+ "rustix 0.38.21",
 ]
 
-[[package]]
-name = "widestring"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c168940144dd21fd8046987c16a46a33d5fc84eec29ef9dcddc2ac9e31526b7c"
-
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -1533,9 +1765,9 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596"
 dependencies = [
  "winapi",
 ]
@@ -1552,39 +1784,201 @@ version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ea04155a16a59f9eab786fe12a4a450e75cdb175f9e0d80da1e17db09f55b8d2"
 dependencies = [
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_msvc",
+ "windows_aarch64_msvc 0.36.1",
+ "windows_i686_gnu 0.36.1",
+ "windows_i686_msvc 0.36.1",
+ "windows_x86_64_gnu 0.36.1",
+ "windows_x86_64_msvc 0.36.1",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9bb8c3fd39ade2d67e9874ac4f3db21f0d710bee00fe7cab16949ec184eeaa47"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "180e6ccf01daf4c426b846dfc66db1fc518f074baa793aa7d9b9aaeffad6a3b6"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2e7917148b2812d1eeafaeb22a97e4813dfa60a3f8f78ebe204bcc88f12f024"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4dcd171b8776c41b97521e5da127a2d86ad280114807d0b2ab1e462bc764d9e1"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c811ca4a8c853ef420abd8592ba53ddbbac90410fab6903b3e79972a631f7680"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "winnow"
+version = "0.5.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3b801d0e0a6726477cc207f60162da452f3a95adb368399bef20a946e06f65c"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "yansi"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
diff --git a/Cargo.toml b/Cargo.toml
index 38830584..bc2aedaa 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,4 +1,21 @@
 [workspace]
 default-members = ["cli"]
-
 members = ["cli", "lib"]
+resolver = "2"
+
+[workspace.package]
+rust-version = "1.65"
+
+[profile.release]
+strip = true      # Automatically strip symbols from the binary.
+lto = true        # Link-time optimization.
+opt-level = 3     # Optimization level 3.
+codegen-units = 1 # Maximum size reduction optimizations.
+
+[profile.size]
+inherits = "release"
+opt-level = "s"      # Optimize for size.
+
+[profile.profile]
+inherits = "release"
+strip = false
diff --git a/LICENSE b/LICENSE
index 4c220022..3f674119 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018-2021 Max Brunsfeld
+Copyright (c) 2018-2023 Max Brunsfeld
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/Makefile b/Makefile
index 15505db0..6030852e 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-VERSION := 0.6.3
+VERSION := 0.20.10
 
 # install directory layout
 PREFIX ?= /usr/local
@@ -18,8 +18,8 @@ endif
 OBJ := $(SRC:.c=.o)
 
 # define default flags, and override to append mandatory flags
-CFLAGS ?= -O3 -Wall -Wextra -Werror
-override CFLAGS += -std=gnu99 -fPIC -Ilib/src -Ilib/src/wasm -Ilib/include
+override CFLAGS := -O3 -std=gnu99 -fPIC -fvisibility=hidden -Wall -Wextra -Wshadow $(CFLAGS)
+override CFLAGS += -Ilib/src -Ilib/src/wasm -Ilib/include
 
 # ABI versioning
 SONAME_MAJOR := 0
@@ -50,20 +50,27 @@ libtree-sitter.$(SOEXTVER): $(OBJ)
 	$(CC) $(LDFLAGS) $(LINKSHARED) $^ $(LDLIBS) -o $@
 	ln -sf $@ libtree-sitter.$(SOEXT)
 	ln -sf $@ libtree-sitter.$(SOEXTVER_MAJOR)
+ifneq ($(STRIP),)
+	$(STRIP) $@
+endif
 
 install: all
-	install -d '$(DESTDIR)$(LIBDIR)'
-	install -m755 libtree-sitter.a '$(DESTDIR)$(LIBDIR)'/libtree-sitter.a
-	install -m755 libtree-sitter.$(SOEXTVER) '$(DESTDIR)$(LIBDIR)'/libtree-sitter.$(SOEXTVER)
-	ln -sf libtree-sitter.$(SOEXTVER) '$(DESTDIR)$(LIBDIR)'/libtree-sitter.$(SOEXTVER_MAJOR)
-	ln -sf libtree-sitter.$(SOEXTVER) '$(DESTDIR)$(LIBDIR)'/libtree-sitter.$(SOEXT)
-	install -d '$(DESTDIR)$(INCLUDEDIR)'/tree_sitter
-	install -m644 lib/include/tree_sitter/*.h '$(DESTDIR)$(INCLUDEDIR)'/tree_sitter/
-	install -d '$(DESTDIR)$(PCLIBDIR)'
 	sed -e 's|@LIBDIR@|$(LIBDIR)|;s|@INCLUDEDIR@|$(INCLUDEDIR)|;s|@VERSION@|$(VERSION)|' \
 	    -e 's|=$(PREFIX)|=$${prefix}|' \
 	    -e 's|@PREFIX@|$(PREFIX)|' \
-	    tree-sitter.pc.in > '$(DESTDIR)$(PCLIBDIR)'/tree-sitter.pc
+	    tree-sitter.pc.in > tree-sitter.pc
+
+	install -d '$(DESTDIR)$(LIBDIR)'
+	install -m644 libtree-sitter.a '$(DESTDIR)$(LIBDIR)'/
+	install -m755 libtree-sitter.$(SOEXTVER) '$(DESTDIR)$(LIBDIR)'/
+	ln -sf libtree-sitter.$(SOEXTVER) '$(DESTDIR)$(LIBDIR)'/libtree-sitter.$(SOEXTVER_MAJOR)
+	ln -sf libtree-sitter.$(SOEXTVER) '$(DESTDIR)$(LIBDIR)'/libtree-sitter.$(SOEXT)
+
+	install -d '$(DESTDIR)$(INCLUDEDIR)'/tree_sitter
+	install -m644 lib/include/tree_sitter/api.h '$(DESTDIR)$(INCLUDEDIR)'/tree_sitter/
+
+	install -d '$(DESTDIR)$(PCLIBDIR)'
+	install -m644 tree-sitter.pc '$(DESTDIR)$(PCLIBDIR)'/
 
 clean:
 	rm -f lib/src/*.o libtree-sitter.a libtree-sitter.$(SOEXT) libtree-sitter.$(SOEXTVER_MAJOR) libtree-sitter.$(SOEXTVER)
diff --git a/Package.swift b/Package.swift
new file mode 100644
index 00000000..7966e529
--- /dev/null
+++ b/Package.swift
@@ -0,0 +1,39 @@
+// swift-tools-version: 5.8
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "TreeSitter",
+    products: [
+        // Products define the executables and libraries a package produces, and make them visible to other packages.
+        .library(
+            name: "TreeSitter",
+            targets: ["TreeSitter"]),
+    ],
+    targets: [
+        .target(name: "TreeSitter",
+                path: "lib",
+                exclude: [
+                    "binding_rust",
+                    "binding_web",
+                    "Cargo.toml",
+                    "README.md",
+                    "src/unicode/README.md",
+                    "src/unicode/LICENSE",
+                    "src/unicode/ICU_SHA",
+                    "src/get_changed_ranges.c",
+                    "src/tree_cursor.c",
+                    "src/stack.c",
+                    "src/node.c",
+                    "src/lexer.c",
+                    "src/parser.c",
+                    "src/language.c",
+                    "src/alloc.c",
+                    "src/subtree.c",
+                    "src/tree.c",
+                    "src/query.c"
+                ],
+                sources: ["src/lib.c"]),
+    ]
+)
diff --git a/README.md b/README.md
index 2d1e911d..e74c6e45 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,11 @@
 # tree-sitter
 
-[![Build Status](https://github.com/tree-sitter/tree-sitter/workflows/CI/badge.svg)](https://github.com/tree-sitter/tree-sitter/actions)
-[![Build status](https://ci.appveyor.com/api/projects/status/vtmbd6i92e97l55w/branch/master?svg=true)](https://ci.appveyor.com/project/maxbrunsfeld/tree-sitter/branch/master)
+[![CICD badge]][CICD]
 [![DOI](https://zenodo.org/badge/14164618.svg)](https://zenodo.org/badge/latestdoi/14164618)
 
+[CICD badge]: https://github.com/tree-sitter/tree-sitter/actions/workflows/CICD.yml/badge.svg
+[CICD]: https://github.com/tree-sitter/tree-sitter/actions/workflows/CICD.yml
+
 Tree-sitter is a parser generator tool and an incremental parsing library. It can build a concrete syntax tree for a source file and efficiently update the syntax tree as the source file is edited. Tree-sitter aims to be:
 
 - **General** enough to parse any programming language
diff --git a/build.zig b/build.zig
new file mode 100644
index 00000000..8b6a7c33
--- /dev/null
+++ b/build.zig
@@ -0,0 +1,16 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    var lib = b.addStaticLibrary(.{
+        .name = "tree-sitter",
+        .target = b.standardTargetOptions(.{}),
+        .optimize = b.standardOptimizeOption(.{}),
+    });
+
+    lib.linkLibC();
+    lib.addCSourceFile(.{ .file = .{ .path = "lib/src/lib.c" }, .flags = &.{} });
+    lib.addIncludePath(.{ .path = "lib/include" });
+    lib.addIncludePath(.{ .path = "lib/src" });
+
+    b.installArtifact(lib);
+}
diff --git a/cli/Cargo.toml b/cli/Cargo.toml
index 10ee301a..0a877454 100644
--- a/cli/Cargo.toml
+++ b/cli/Cargo.toml
@@ -1,47 +1,53 @@
 [package]
 name = "tree-sitter-cli"
 description = "CLI tool for developing, testing, and using Tree-sitter parsers"
-version = "0.20.7"
+version = "0.20.8"
 authors = ["Max Brunsfeld <maxbrunsfeld@gmail.com>"]
-edition = "2018"
+edition = "2021"
 license = "MIT"
 readme = "README.md"
 keywords = ["incremental", "parsing"]
 categories = ["command-line-utilities", "parsing"]
 repository = "https://github.com/tree-sitter/tree-sitter"
+rust-version.workspace = true
 
 [[bin]]
 name = "tree-sitter"
 path = "src/main.rs"
+doc = false
 
 [[bench]]
 name = "benchmark"
 harness = false
 
 [dependencies]
-ansi_term = "0.12"
-anyhow = "1.0"
-atty = "0.2"
+ansi_term = "0.12.1"
+anyhow = "1.0.72"
+atty = "0.2.14"
 clap = "2.32"
-difference = "2.0"
-dirs = "3.0"
-glob = "0.3.0"
-html-escape = "0.2.6"
-indexmap = "1"
-lazy_static = "1.2.0"
-regex = "1"
-regex-syntax = "0.6.4"
-rustc-hash = "1"
-semver = "1.0"
-serde = { version = "1.0.130", features = ["derive"] }
+ctrlc = { version = "3.4.0", features = ["termination"] }
+difference = "2.0.0"
+dirs = "5.0.1"
+glob = "0.3.1"
+html-escape = "0.2.13"
+indexmap = "2.0.0"
+lazy_static = "1.4.0"
+memchr = "2.6.3"
+path-slash = "0.2.1"
+regex = "1.9.1"
+regex-syntax = "0.7.4"
+rustc-hash = "1.1.0"
+semver = "1.0.18"
+# Due to https://github.com/serde-rs/serde/issues/2538
+serde = { version = "1.0, < 1.0.172", features = ["derive"] }
 smallbitvec = "2.5.1"
-tiny_http = "0.8"
-walkdir = "2.3"
-webbrowser = "0.5.1"
-which = "4.1.0"
+tiny_http = "0.12.0"
+walkdir = "2.3.3"
+webbrowser = "0.8.10"
+which = "4.4.0"
 
 [dependencies.tree-sitter]
-version = "0.20.3"
+version = "0.20.10"
 path = "../lib"
 features = ["wasm"]
 
@@ -67,14 +73,18 @@ version = "1.0"
 features = ["preserve_order"]
 
 [dependencies.log]
-version = "0.4.6"
+version = "0.4.19"
 features = ["std"]
 
 [dev-dependencies]
-rand = "0.8"
-tempfile = "3"
-pretty_assertions = "0.7.2"
-ctor = "0.1"
+tree_sitter_proc_macro = { path = "src/tests/proc_macro", package = "tree-sitter-tests-proc-macro" }
+
+rand = "0.8.5"
+tempfile = "3.6.0"
+pretty_assertions = "1.4.0"
+ctor = "0.2.4"
+unindent = "0.2.2"
+indoc = "2.0.3"
 
 [build-dependencies]
-toml = "0.5"
+toml = "0.7.6"
diff --git a/cli/README.md b/cli/README.md
index fe45b17b..eb93bcfa 100644
--- a/cli/README.md
+++ b/cli/README.md
@@ -1,9 +1,11 @@
-Tree-sitter CLI
-===============
+# Tree-sitter CLI
 
-[![Build Status](https://travis-ci.org/tree-sitter/tree-sitter.svg?branch=master)](https://travis-ci.org/tree-sitter/tree-sitter)
-[![Build status](https://ci.appveyor.com/api/projects/status/vtmbd6i92e97l55w/branch/master?svg=true)](https://ci.appveyor.com/project/maxbrunsfeld/tree-sitter/branch/master)
-[![Crates.io](https://img.shields.io/crates/v/tree-sitter-cli.svg)](https://crates.io/crates/tree-sitter-cli)
+[![crates.io badge]][crates.io] [![npmjs.com badge]][npmjs.com]
+
+[crates.io]: https://crates.io/crates/tree-sitter-cli
+[crates.io badge]: https://img.shields.io/crates/v/tree-sitter-cli.svg?color=%23B48723
+[npmjs.com]: https://www.npmjs.org/package/tree-sitter-cli
+[npmjs.com badge]: https://img.shields.io/npm/v/tree-sitter-cli.svg?color=%23BF4A4A
 
 The Tree-sitter CLI allows you to develop, test, and use Tree-sitter grammars from the command line. It works on MacOS, Linux, and Windows.
 
@@ -21,7 +23,7 @@ or with `npm`:
 npm install tree-sitter-cli
 ```
 
-You can also download a pre-built binary for your platform from [the releases page](https://github.com/tree-sitter/tree-sitter/releases/latest).
+You can also download a pre-built binary for your platform from [the releases page].
 
 ### Dependencies
 
@@ -32,8 +34,11 @@ The `tree-sitter` binary itself has no dependencies, but specific commands have
 
 ### Commands
 
-* `generate` - The `tree-sitter generate` command will generate a Tree-sitter parser based on the grammar in the current working directory. See [the documentation](http://tree-sitter.github.io/tree-sitter/creating-parsers) for more information.
+* `generate` - The `tree-sitter generate` command will generate a Tree-sitter parser based on the grammar in the current working directory. See [the documentation] for more information.
 
-* `test` - The `tree-sitter test` command will run the unit tests for the Tree-sitter parser in the current working directory. See [the documentation](http://tree-sitter.github.io/tree-sitter/creating-parsers) for more information.
+* `test` - The `tree-sitter test` command will run the unit tests for the Tree-sitter parser in the current working directory. See [the documentation] for more information.
 
 * `parse` - The `tree-sitter parse` command will parse a file (or list of files) using Tree-sitter parsers.
+
+[the documentation]: https://tree-sitter.github.io/tree-sitter/creating-parsers
+[the releases page]: https://github.com/tree-sitter/tree-sitter/releases/latest
diff --git a/cli/benches/benchmark.rs b/cli/benches/benchmark.rs
index efb73f3a..ae82081a 100644
--- a/cli/benches/benchmark.rs
+++ b/cli/benches/benchmark.rs
@@ -104,6 +104,7 @@ fn main() {
 
             parse(&path, max_path_length, |source| {
                 Query::new(language, str::from_utf8(source).unwrap())
+                    .with_context(|| format!("Query file path: {path:?}"))
                     .expect("Failed to parse query");
             });
         }
diff --git a/cli/build.rs b/cli/build.rs
index 6f9b772b..53617cf0 100644
--- a/cli/build.rs
+++ b/cli/build.rs
@@ -1,3 +1,4 @@
+use std::ffi::OsStr;
 use std::path::{Path, PathBuf};
 use std::{env, fs};
 
@@ -60,7 +61,39 @@ fn read_git_sha() -> Option<String> {
         // If we're on a branch, read the SHA from the ref file.
         if head_content.starts_with("ref: ") {
             head_content.replace_range(0.."ref: ".len(), "");
-            let ref_filename = git_dir_path.join(&head_content);
+            let ref_filename = {
+                // Go to real non-worktree gitdir
+                let git_dir_path = git_dir_path
+                    .parent()
+                    .map(|p| {
+                        p.file_name()
+                            .map(|n| n == OsStr::new("worktrees"))
+                            .and_then(|x| x.then(|| p.parent()))
+                    })
+                    .flatten()
+                    .flatten()
+                    .unwrap_or(&git_dir_path);
+
+                let file = git_dir_path.join(&head_content);
+                if file.is_file() {
+                    file
+                } else {
+                    let packed_refs = git_dir_path.join("packed-refs");
+                    if let Ok(packed_refs_content) = fs::read_to_string(&packed_refs) {
+                        for line in packed_refs_content.lines() {
+                            if let Some((hash, r#ref)) = line.split_once(' ') {
+                                if r#ref == head_content {
+                                    if let Some(path) = packed_refs.to_str() {
+                                        println!("cargo:rerun-if-changed={}", path);
+                                    }
+                                    return Some(hash.to_string());
+                                }
+                            }
+                        }
+                    }
+                    return None;
+                }
+            };
             if let Some(path) = ref_filename.to_str() {
                 println!("cargo:rerun-if-changed={}", path);
             }
diff --git a/cli/config/Cargo.toml b/cli/config/Cargo.toml
index ab3808ad..01847e93 100644
--- a/cli/config/Cargo.toml
+++ b/cli/config/Cargo.toml
@@ -9,12 +9,14 @@ readme = "README.md"
 keywords = ["incremental", "parsing"]
 categories = ["command-line-utilities", "parsing"]
 repository = "https://github.com/tree-sitter/tree-sitter"
+rust-version.workspace = true
 
 [dependencies]
 anyhow = "1.0"
 dirs = "3.0"
-serde = { version = "1.0.130", features = ["derive"] }
+# Due to https://github.com/serde-rs/serde/issues/2538
+serde = { version = "1.0, < 1.0.172", features = ["derive"] }
 
 [dependencies.serde_json]
-version = "1.0.45"
+version = "1.0"
 features = ["preserve_order"]
diff --git a/cli/config/README.md b/cli/config/README.md
index 8cbfbcf4..e7d7b39b 100644
--- a/cli/config/README.md
+++ b/cli/config/README.md
@@ -1,5 +1,7 @@
-# `tree-sitter-config`
+# Tree-sitter Config
+
+Manages Tree-sitter's configuration file.
 
 You can use a configuration file to control the behavior of the `tree-sitter`
-command-line program.  This crate implements the logic for finding and the
+command-line program. This crate implements the logic for finding and the
 parsing the contents of the configuration file.
diff --git a/cli/config/src/lib.rs b/cli/config/src/lib.rs
index 0a5eba54..83b85358 100644
--- a/cli/config/src/lib.rs
+++ b/cli/config/src/lib.rs
@@ -1,4 +1,4 @@
-//! Manages tree-sitter's configuration file.
+#![doc = include_str!("../README.md")]
 
 use anyhow::{anyhow, Context, Result};
 use serde::{Deserialize, Serialize};
@@ -25,6 +25,9 @@ impl Config {
         if let Ok(path) = env::var("TREE_SITTER_DIR") {
             let mut path = PathBuf::from(path);
             path.push("config.json");
+            if !path.exists() {
+                return Ok(None);
+            }
             if path.is_file() {
                 return Ok(Some(path));
             }
@@ -37,7 +40,8 @@ impl Config {
 
         let legacy_path = dirs::home_dir()
             .ok_or(anyhow!("Cannot determine home directory"))?
-            .join(".tree-sitter/config.json");
+            .join(".tree-sitter")
+            .join("config.json");
         if legacy_path.is_file() {
             return Ok(Some(legacy_path));
         }
@@ -48,7 +52,8 @@ impl Config {
     fn xdg_config_file() -> Result<PathBuf> {
         let xdg_path = dirs::config_dir()
             .ok_or(anyhow!("Cannot determine config directory"))?
-            .join("tree-sitter/config.json");
+            .join("tree-sitter")
+            .join("config.json");
         Ok(xdg_path)
     }
 
@@ -79,7 +84,13 @@ impl Config {
     ///
     /// (Note that this is typically only done by the `tree-sitter init-config` command.)
     pub fn initial() -> Result<Config> {
-        let location = Self::xdg_config_file()?;
+        let location = if let Ok(path) = env::var("TREE_SITTER_DIR") {
+            let mut path = PathBuf::from(path);
+            path.push("config.json");
+            path
+        } else {
+            Self::xdg_config_file()?
+        };
         let config = serde_json::json!({});
         Ok(Config { location, config })
     }
diff --git a/cli/loader/Cargo.toml b/cli/loader/Cargo.toml
index ed6c9e8a..113e8399 100644
--- a/cli/loader/Cargo.toml
+++ b/cli/loader/Cargo.toml
@@ -9,6 +9,7 @@ readme = "README.md"
 keywords = ["incremental", "parsing"]
 categories = ["command-line-utilities", "parsing"]
 repository = "https://github.com/tree-sitter/tree-sitter"
+rust-version.workspace = true
 
 [features]
 wasm = ["tree-sitter/wasm"]
@@ -20,7 +21,8 @@ dirs = "3.0"
 libloading = "0.7"
 once_cell = "1.7"
 regex = "1"
-serde = { version = "1.0.130", features = ["derive"] }
+# Due to https://github.com/serde-rs/serde/issues/2538
+serde = { version = "1.0, < 1.0.172", features = ["derive"] }
 which = "4.1.0"
 
 [dependencies.serde_json]
diff --git a/cli/loader/README.md b/cli/loader/README.md
index 9889ec71..a3c18674 100644
--- a/cli/loader/README.md
+++ b/cli/loader/README.md
@@ -1,6 +1,6 @@
-# `tree-sitter-loader`
+# Tree-sitter Loader
 
 The `tree-sitter` command-line program will dynamically find and build grammars
 at runtime, if you have cloned the grammars' repositories to your local
-filesystem.  This helper crate implements that logic, so that you can use it in
+filesystem. This helper crate implements that logic, so that you can use it in
 your own program analysis tools, as well.
diff --git a/cli/loader/emscripten-version b/cli/loader/emscripten-version
index 199eda56..1f1a3970 100644
--- a/cli/loader/emscripten-version
+++ b/cli/loader/emscripten-version
@@ -1 +1 @@
-3.1.25
+3.1.37
diff --git a/cli/loader/src/lib.rs b/cli/loader/src/lib.rs
index a0fb3249..619aa05e 100644
--- a/cli/loader/src/lib.rs
+++ b/cli/loader/src/lib.rs
@@ -1,3 +1,5 @@
+#![doc = include_str!("../README.md")]
+
 use anyhow::{anyhow, Context, Error, Result};
 use libloading::{Library, Symbol};
 use once_cell::unsync::OnceCell;
@@ -11,7 +13,7 @@ use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::sync::Mutex;
 use std::time::SystemTime;
-use std::{fs, mem};
+use std::{env, fs, mem};
 use tree_sitter::{Language, QueryError, QueryErrorKind};
 use tree_sitter_highlight::HighlightConfiguration;
 use tree_sitter_tags::{Error as TagsError, TagsConfiguration};
@@ -72,12 +74,12 @@ impl Config {
 }
 
 #[cfg(unix)]
-const DYLIB_EXTENSION: &'static str = "so";
+const DYLIB_EXTENSION: &str = "so";
 
 #[cfg(windows)]
 const DYLIB_EXTENSION: &'static str = "dll";
 
-const BUILD_TARGET: &'static str = env!("BUILD_TARGET");
+const BUILD_TARGET: &str = env!("BUILD_TARGET");
 
 pub struct LanguageConfiguration<'a> {
     pub scope: Option<String>,
@@ -90,6 +92,7 @@ pub struct LanguageConfiguration<'a> {
     pub injections_filenames: Option<Vec<String>>,
     pub locals_filenames: Option<Vec<String>>,
     pub tags_filenames: Option<Vec<String>>,
+    pub language_name: String,
     language_id: usize,
     highlight_config: OnceCell<Option<HighlightConfiguration>>,
     tags_config: OnceCell<Option<TagsConfiguration>>,
@@ -102,6 +105,7 @@ pub struct Loader {
     languages_by_id: Vec<(PathBuf, OnceCell<Language>)>,
     language_configurations: Vec<LanguageConfiguration<'static>>,
     language_configuration_ids_by_file_type: HashMap<String, Vec<usize>>,
+    language_configuration_in_current_path: Option<usize>,
     highlight_names: Box<Mutex<Vec<String>>>,
     use_all_highlight_names: bool,
     debug_build: bool,
@@ -115,9 +119,13 @@ unsafe impl Sync for Loader {}
 
 impl Loader {
     pub fn new() -> Result<Self> {
-        let parser_lib_path = dirs::cache_dir()
-            .ok_or(anyhow!("Cannot determine cache directory"))?
-            .join("tree-sitter/lib");
+        let parser_lib_path = match env::var("TREE_SITTER_LIBDIR") {
+            Ok(path) => PathBuf::from(path),
+            _ => dirs::cache_dir()
+                .ok_or(anyhow!("Cannot determine cache directory"))?
+                .join("tree-sitter")
+                .join("lib"),
+        };
         Ok(Self::with_parser_lib_path(parser_lib_path))
     }
 
@@ -127,6 +135,7 @@ impl Loader {
             languages_by_id: Vec::new(),
             language_configurations: Vec::new(),
             language_configuration_ids_by_file_type: HashMap::new(),
+            language_configuration_in_current_path: None,
             highlight_names: Box::new(Mutex::new(Vec::new())),
             use_all_highlight_names: true,
             debug_build: false,
@@ -136,7 +145,7 @@ impl Loader {
         }
     }
 
-    pub fn configure_highlights(&mut self, names: &Vec<String>) {
+    pub fn configure_highlights(&mut self, names: &[String]) {
         self.use_all_highlight_names = false;
         let mut highlights = self.highlight_names.lock().unwrap();
         highlights.clear();
@@ -152,8 +161,7 @@ impl Loader {
             eprintln!("Warning: You have not configured any parser directories!");
             eprintln!("Please run `tree-sitter init-config` and edit the resulting");
             eprintln!("configuration file to indicate where we should look for");
-            eprintln!("language grammars.");
-            eprintln!("");
+            eprintln!("language grammars.\n");
         }
         for parser_container_dir in &config.parser_directories {
             if let Ok(entries) = fs::read_dir(parser_container_dir) {
@@ -163,6 +171,7 @@ impl Loader {
                         if parser_dir_name.starts_with("tree-sitter-") {
                             self.find_language_configurations_at_path(
                                 &parser_container_dir.join(parser_dir_name),
+                                false,
                             )
                             .ok();
                         }
@@ -174,7 +183,7 @@ impl Loader {
     }
 
     pub fn languages_at_path(&mut self, path: &Path) -> Result<Vec<Language>> {
-        if let Ok(configurations) = self.find_language_configurations_at_path(path) {
+        if let Ok(configurations) = self.find_language_configurations_at_path(path, true) {
             let mut language_ids = configurations
                 .iter()
                 .map(|c| c.language_id)
@@ -365,7 +374,7 @@ impl Loader {
             library_path.set_extension(DYLIB_EXTENSION);
         }
 
-        let recompile = needs_recompile(&library_path, &parser_path, &scanner_path)
+        let recompile = needs_recompile(&library_path, &parser_path, scanner_path.as_deref())
             .with_context(|| "Failed to compare source and binary timestamps")?;
 
         if let Some(wasm_store) = self.wasm_store.lock().unwrap().as_mut() {
@@ -411,7 +420,7 @@ impl Loader {
         header_path: &Path,
         parser_path: &Path,
         scanner_path: &Option<PathBuf>,
-        output_path: &PathBuf,
+        library_path: &PathBuf,
     ) -> Result<(), Error> {
         let mut config = cc::Build::new();
         config
@@ -419,13 +428,15 @@ impl Loader {
             .opt_level(2)
             .cargo_metadata(false)
             .target(BUILD_TARGET)
-            .host(BUILD_TARGET);
+            .host(BUILD_TARGET)
+            .flag_if_supported("-Werror=implicit-function-declaration");
         let compiler = config.get_compiler();
         let mut command = Command::new(compiler.path());
         for (key, value) in compiler.env() {
             command.env(key, value);
         }
-        if cfg!(windows) {
+
+        if compiler.is_like_msvc() {
             command.args(&["/nologo", "/LD", "/I"]).arg(header_path);
             if self.debug_build {
                 command.arg("/Od");
@@ -438,17 +449,20 @@ impl Loader {
             }
             command
                 .arg("/link")
-                .arg(format!("/out:{}", output_path.to_str().unwrap()));
+                .arg(format!("/out:{}", library_path.to_str().unwrap()));
         } else {
             command
                 .arg("-shared")
-                .arg("-fPIC")
                 .arg("-fno-exceptions")
                 .arg("-g")
                 .arg("-I")
                 .arg(header_path)
                 .arg("-o")
-                .arg(output_path);
+                .arg(&library_path);
+
+            if !cfg!(windows) {
+                command.arg("-fPIC");
+            }
 
             if self.debug_build {
                 command.arg("-O0");
@@ -469,6 +483,7 @@ impl Loader {
             }
             command.arg("-xc").arg(parser_path);
         }
+
         let output = command
             .output()
             .with_context(|| "Failed to execute C compiler")?;
@@ -479,6 +494,37 @@ impl Loader {
                 String::from_utf8_lossy(&output.stderr)
             ));
         }
+
+        #[cfg(any(target_os = "macos", target_os = "linux"))]
+        if scanner_path.is_some() {
+            let command = Command::new("nm")
+                .arg("-W")
+                .arg("-U")
+                .arg(&library_path)
+                .output();
+            if let Ok(output) = command {
+                if output.status.success() {
+                    let mut found_non_static = false;
+                    for line in String::from_utf8_lossy(&output.stdout).lines() {
+                        if line.contains(" T ") && !line.contains("tree_sitter_") {
+                            if let Some(function_name) =
+                                line.split_whitespace().collect::<Vec<_>>().get(2)
+                            {
+                                if !found_non_static {
+                                    found_non_static = true;
+                                    eprintln!("Warning: Found non-static non-tree-sitter functions in external scannner");
+                                }
+                                eprintln!("  `{function_name}`");
+                            }
+                        }
+                    }
+                    if found_non_static {
+                        eprintln!("Consider making these functions static, they can cause conflicts when another tree-sitter project uses the same function name");
+                    }
+                }
+            }
+        }
+
         Ok(())
     }
 
@@ -581,6 +627,7 @@ impl Loader {
     pub fn highlight_config_for_injection_string<'a>(
         &'a self,
         string: &str,
+        apply_all_captures: bool,
     ) -> Option<&'a HighlightConfiguration> {
         match self.language_configuration_for_injection_string(string) {
             Err(e) => {
@@ -591,38 +638,36 @@ impl Loader {
                 None
             }
             Ok(None) => None,
-            Ok(Some((language, configuration))) => match configuration.highlight_config(language) {
-                Err(e) => {
-                    eprintln!(
-                        "Failed to load property sheet for injection string '{}': {}",
-                        string, e
-                    );
-                    None
+            Ok(Some((language, configuration))) => {
+                match configuration.highlight_config(language, apply_all_captures, None) {
+                    Err(e) => {
+                        eprintln!(
+                            "Failed to load property sheet for injection string '{}': {}",
+                            string, e
+                        );
+                        None
+                    }
+                    Ok(None) => None,
+                    Ok(Some(config)) => Some(config),
                 }
-                Ok(None) => None,
-                Ok(Some(config)) => Some(config),
-            },
+            }
         }
     }
 
-    pub fn find_language_configurations_at_path<'a>(
-        &'a mut self,
+    pub fn find_language_configurations_at_path(
+        &mut self,
         parser_path: &Path,
+        set_current_path_config: bool,
     ) -> Result<&[LanguageConfiguration]> {
-        #[derive(Deserialize)]
+        #[derive(Default, Deserialize)]
         #[serde(untagged)]
         enum PathsJSON {
+            #[default]
             Empty,
             Single(String),
             Multiple(Vec<String>),
         }
 
-        impl Default for PathsJSON {
-            fn default() -> Self {
-                PathsJSON::Empty
-            }
-        }
-
         impl PathsJSON {
             fn into_vec(self) -> Option<Vec<String>> {
                 match self {
@@ -663,6 +708,11 @@ impl Loader {
             tree_sitter: Vec<LanguageConfigurationJSON>,
         }
 
+        #[derive(Deserialize)]
+        struct GrammarJSON {
+            name: String,
+        }
+
         let initial_language_configuration_count = self.language_configurations.len();
 
         if let Ok(package_json_contents) = fs::read_to_string(&parser_path.join("package.json")) {
@@ -674,6 +724,13 @@ impl Loader {
                     // the package.json, but defaults to the directory containing the package.json.
                     let language_path = parser_path.join(config_json.path);
 
+                    let grammar_path = language_path.join("src").join("grammar.json");
+                    let mut grammar_file = fs::File::open(grammar_path)
+                        .with_context(|| "Failed to read grammar.json")?;
+                    let grammar_json: GrammarJSON =
+                        serde_json::from_reader(BufReader::new(&mut grammar_file))
+                            .with_context(|| "Failed to parse grammar.json")?;
+
                     // Determine if a previous language configuration in this package.json file
                     // already uses the same language.
                     let mut language_id = None;
@@ -693,6 +750,7 @@ impl Loader {
 
                     let configuration = LanguageConfiguration {
                         root_path: parser_path.to_path_buf(),
+                        language_name: grammar_json.name.clone(),
                         scope: config_json.scope,
                         language_id,
                         file_types: config_json.file_types.unwrap_or(Vec::new()),
@@ -705,19 +763,26 @@ impl Loader {
                         highlights_filenames: config_json.highlights.into_vec(),
                         highlight_config: OnceCell::new(),
                         tags_config: OnceCell::new(),
-                        highlight_names: &*self.highlight_names,
+                        highlight_names: &self.highlight_names,
                         use_all_highlight_names: self.use_all_highlight_names,
                     };
 
                     for file_type in &configuration.file_types {
                         self.language_configuration_ids_by_file_type
                             .entry(file_type.to_string())
-                            .or_insert(Vec::new())
+                            .or_default()
                             .push(self.language_configurations.len());
                     }
 
                     self.language_configurations
                         .push(unsafe { mem::transmute(configuration) });
+
+                    if set_current_path_config
+                        && self.language_configuration_in_current_path.is_none()
+                    {
+                        self.language_configuration_in_current_path =
+                            Some(self.language_configurations.len() - 1);
+                    }
                 }
             }
         }
@@ -725,8 +790,15 @@ impl Loader {
         if self.language_configurations.len() == initial_language_configuration_count
             && parser_path.join("src").join("grammar.json").exists()
         {
+            let grammar_path = parser_path.join("src").join("grammar.json");
+            let mut grammar_file =
+                fs::File::open(grammar_path).with_context(|| "Failed to read grammar.json")?;
+            let grammar_json: GrammarJSON =
+                serde_json::from_reader(BufReader::new(&mut grammar_file))
+                    .with_context(|| "Failed to parse grammar.json")?;
             let configuration = LanguageConfiguration {
                 root_path: parser_path.to_owned(),
+                language_name: grammar_json.name,
                 language_id: self.languages_by_id.len(),
                 file_types: Vec::new(),
                 scope: None,
@@ -739,7 +811,7 @@ impl Loader {
                 tags_filenames: None,
                 highlight_config: OnceCell::new(),
                 tags_config: OnceCell::new(),
-                highlight_names: &*self.highlight_names,
+                highlight_names: &self.highlight_names,
                 use_all_highlight_names: self.use_all_highlight_names,
             };
             self.language_configurations
@@ -764,11 +836,11 @@ impl Loader {
         if let Some(scope) = scope {
             if let Some(config) = self
                 .language_configuration_for_scope(scope)
-                .with_context(|| format!("Failed to load language for scope '{}'", scope))?
+                .with_context(|| format!("Failed to load language for scope '{scope}'"))?
             {
                 Ok(config.0)
             } else {
-                return Err(anyhow!("Unknown scope '{}'", scope));
+                Err(anyhow!("Unknown scope '{scope}'"))
             }
         } else if let Some((lang, _)) = self
             .language_configuration_for_file_name(path)
@@ -780,8 +852,10 @@ impl Loader {
             })?
         {
             Ok(lang)
+        } else if let Some(id) = self.language_configuration_in_current_path {
+            Ok(self.language_for_id(self.language_configurations[id].language_id)?)
         } else if let Some(lang) = self
-            .languages_at_path(&current_dir)
+            .languages_at_path(current_dir)
             .with_context(|| "Failed to load language in current directory")?
             .first()
             .cloned()
@@ -803,25 +877,76 @@ impl Loader {
 }
 
 impl<'a> LanguageConfiguration<'a> {
-    pub fn highlight_config(&self, language: Language) -> Result<Option<&HighlightConfiguration>> {
+    pub fn highlight_config(
+        &self,
+        language: Language,
+        apply_all_captures: bool,
+        paths: Option<&[String]>,
+    ) -> Result<Option<&HighlightConfiguration>> {
+        let (highlights_filenames, injections_filenames, locals_filenames) = match paths {
+            Some(paths) => (
+                Some(
+                    paths
+                        .iter()
+                        .filter(|p| p.ends_with("highlights.scm"))
+                        .cloned()
+                        .collect::<Vec<_>>(),
+                ),
+                Some(
+                    paths
+                        .iter()
+                        .filter(|p| p.ends_with("tags.scm"))
+                        .cloned()
+                        .collect::<Vec<_>>(),
+                ),
+                Some(
+                    paths
+                        .iter()
+                        .filter(|p| p.ends_with("locals.scm"))
+                        .cloned()
+                        .collect::<Vec<_>>(),
+                ),
+            ),
+            None => (None, None, None),
+        };
         return self
             .highlight_config
             .get_or_try_init(|| {
-                let (highlights_query, highlight_ranges) =
-                    self.read_queries(&self.highlights_filenames, "highlights.scm")?;
-                let (injections_query, injection_ranges) =
-                    self.read_queries(&self.injections_filenames, "injections.scm")?;
-                let (locals_query, locals_ranges) =
-                    self.read_queries(&self.locals_filenames, "locals.scm")?;
+                let (highlights_query, highlight_ranges) = self.read_queries(
+                    if highlights_filenames.is_some() {
+                        highlights_filenames.as_deref()
+                    } else {
+                        self.highlights_filenames.as_deref()
+                    },
+                    "highlights.scm",
+                )?;
+                let (injections_query, injection_ranges) = self.read_queries(
+                    if injections_filenames.is_some() {
+                        injections_filenames.as_deref()
+                    } else {
+                        self.injections_filenames.as_deref()
+                    },
+                    "injections.scm",
+                )?;
+                let (locals_query, locals_ranges) = self.read_queries(
+                    if locals_filenames.is_some() {
+                        locals_filenames.as_deref()
+                    } else {
+                        self.locals_filenames.as_deref()
+                    },
+                    "locals.scm",
+                )?;
 
                 if highlights_query.is_empty() {
                     Ok(None)
                 } else {
                     let mut result = HighlightConfiguration::new(
                         language,
+                        &self.language_name,
                         &highlights_query,
                         &injections_query,
                         &locals_query,
+                        apply_all_captures,
                     )
                     .map_err(|error| match error.kind {
                         QueryErrorKind::Language => Error::from(error),
@@ -853,12 +978,12 @@ impl<'a> LanguageConfiguration<'a> {
                     let mut all_highlight_names = self.highlight_names.lock().unwrap();
                     if self.use_all_highlight_names {
                         for capture_name in result.query.capture_names() {
-                            if !all_highlight_names.contains(capture_name) {
-                                all_highlight_names.push(capture_name.clone());
+                            if !all_highlight_names.iter().any(|x| x == capture_name) {
+                                all_highlight_names.push(capture_name.to_string());
                             }
                         }
                     }
-                    result.configure(&all_highlight_names.as_slice());
+                    result.configure(all_highlight_names.as_slice());
                     Ok(Some(result))
                 }
             })
@@ -869,9 +994,9 @@ impl<'a> LanguageConfiguration<'a> {
         self.tags_config
             .get_or_try_init(|| {
                 let (tags_query, tags_ranges) =
-                    self.read_queries(&self.tags_filenames, "tags.scm")?;
+                    self.read_queries(self.tags_filenames.as_deref(), "tags.scm")?;
                 let (locals_query, locals_ranges) =
-                    self.read_queries(&self.locals_filenames, "locals.scm")?;
+                    self.read_queries(self.locals_filenames.as_deref(), "locals.scm")?;
                 if tags_query.is_empty() {
                     Ok(None)
                 } else {
@@ -894,7 +1019,6 @@ impl<'a> LanguageConfiguration<'a> {
                                         locals_query.len(),
                                     )
                                 }
-                                .into()
                             } else {
                                 error.into()
                             }
@@ -904,9 +1028,9 @@ impl<'a> LanguageConfiguration<'a> {
             .map(Option::as_ref)
     }
 
-    fn include_path_in_query_error<'b>(
+    fn include_path_in_query_error(
         mut error: QueryError,
-        ranges: &'b Vec<(String, Range<usize>)>,
+        ranges: &[(String, Range<usize>)],
         source: &str,
         start_offset: usize,
     ) -> Error {
@@ -914,7 +1038,7 @@ impl<'a> LanguageConfiguration<'a> {
         let (path, range) = ranges
             .iter()
             .find(|(_, range)| range.contains(&offset_within_section))
-            .unwrap();
+            .unwrap_or(ranges.last().unwrap());
         error.offset = offset_within_section - range.start;
         error.row = source[range.start..offset_within_section]
             .chars()
@@ -925,12 +1049,12 @@ impl<'a> LanguageConfiguration<'a> {
 
     fn read_queries(
         &self,
-        paths: &Option<Vec<String>>,
+        paths: Option<&[String]>,
         default_path: &str,
     ) -> Result<(String, Vec<(String, Range<usize>)>)> {
         let mut query = String::new();
         let mut path_ranges = Vec::new();
-        if let Some(paths) = paths.as_ref() {
+        if let Some(paths) = paths {
             for path in paths {
                 let abs_path = self.root_path.join(path);
                 let prev_query_len = query.len();
@@ -955,7 +1079,7 @@ impl<'a> LanguageConfiguration<'a> {
 fn needs_recompile(
     lib_path: &Path,
     parser_c_path: &Path,
-    scanner_path: &Option<PathBuf>,
+    scanner_path: Option<&Path>,
 ) -> Result<bool> {
     if !lib_path.exists() {
         return Ok(true);
diff --git a/cli/npm/.gitignore b/cli/npm/.gitignore
index 942b33a1..65e04cff 100644
--- a/cli/npm/.gitignore
+++ b/cli/npm/.gitignore
@@ -3,3 +3,4 @@ tree-sitter.exe
 *.gz
 *.tgz
 LICENSE
+README.md
diff --git a/cli/npm/dsl.d.ts b/cli/npm/dsl.d.ts
index f2ee57f1..63f9ed49 100644
--- a/cli/npm/dsl.d.ts
+++ b/cli/npm/dsl.d.ts
@@ -1,19 +1,19 @@
-type AliasRule = {type: 'ALIAS'; named: boolean; content: Rule; value: string};
-type BlankRule = {type: 'BLANK'};
-type ChoiceRule = {type: 'CHOICE'; members: Rule[]};
-type FieldRule = {type: 'FIELD'; name: string; content: Rule};
-type ImmediateTokenRule = {type: 'IMMEDIATE_TOKEN'; content: Rule};
-type PatternRule = {type: 'PATTERN'; value: string};
-type PrecDynamicRule = {type: 'PREC_DYNAMIC'; content: Rule; value: number};
-type PrecLeftRule = {type: 'PREC_LEFT'; content: Rule; value: number};
-type PrecRightRule = {type: 'PREC_RIGHT'; content: Rule; value: number};
-type PrecRule = {type: 'PREC'; content: Rule; value: number};
-type Repeat1Rule = {type: 'REPEAT1'; content: Rule};
-type RepeatRule = {type: 'REPEAT'; content: Rule};
-type SeqRule = {type: 'SEQ'; members: Rule[]};
-type StringRule = {type: 'STRING'; value: string};
-type SymbolRule<Name extends string> = {type: 'SYMBOL'; name: Name};
-type TokenRule = {type: 'TOKEN'; content: Rule};
+type AliasRule = { type: 'ALIAS'; named: boolean; content: Rule; value: string };
+type BlankRule = { type: 'BLANK' };
+type ChoiceRule = { type: 'CHOICE'; members: Rule[] };
+type FieldRule = { type: 'FIELD'; name: string; content: Rule };
+type ImmediateTokenRule = { type: 'IMMEDIATE_TOKEN'; content: Rule };
+type PatternRule = { type: 'PATTERN'; value: string };
+type PrecDynamicRule = { type: 'PREC_DYNAMIC'; content: Rule; value: number };
+type PrecLeftRule = { type: 'PREC_LEFT'; content: Rule; value: number };
+type PrecRightRule = { type: 'PREC_RIGHT'; content: Rule; value: number };
+type PrecRule = { type: 'PREC'; content: Rule; value: number };
+type Repeat1Rule = { type: 'REPEAT1'; content: Rule };
+type RepeatRule = { type: 'REPEAT'; content: Rule };
+type SeqRule = { type: 'SEQ'; members: Rule[] };
+type StringRule = { type: 'STRING'; value: string };
+type SymbolRule<Name extends string> = { type: 'SYMBOL'; name: Name };
+type TokenRule = { type: 'TOKEN'; content: Rule };
 
 type Rule =
   | AliasRule
@@ -42,14 +42,15 @@ type GrammarSymbols<RuleName extends string> = {
 
 type RuleBuilder<RuleName extends string> = (
   $: GrammarSymbols<RuleName>,
+  previous: Rule,
 ) => RuleOrLiteral;
 
 type RuleBuilders<
   RuleName extends string,
   BaseGrammarRuleName extends string
 > = {
-  [name in RuleName]: RuleBuilder<RuleName | BaseGrammarRuleName>;
-};
+    [name in RuleName]: RuleBuilder<RuleName | BaseGrammarRuleName>;
+  };
 
 interface Grammar<
   RuleName extends string,
@@ -68,11 +69,17 @@ interface Grammar<
   rules: Rules;
 
   /**
-   * An array of arrays of precedence names. Each inner array represents
-   * a *descending* ordering. Names listed earlier in one of these arrays
-   * have higher precedence than any names listed later in the same array.
+   * An array of arrays of precedence names or rules. Each inner array represents
+   * a *descending* ordering. Names/rules listed earlier in one of these arrays
+   * have higher precedence than any names/rules listed later in the same array.
+   *
+   * Using rules is just a shorthand way for using a name then calling prec()
+   * with that name. It is just a convenience.
    */
-  precedences?: () => String[][],
+  precedences?: (
+    $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
+    previous: Rule[][],
+  ) => RuleOrLiteral[][],
 
   /**
    * An array of arrays of rule names. Each inner array represents a set of
@@ -86,6 +93,7 @@ interface Grammar<
    */
   conflicts?: (
     $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
+    previous: Rule[][],
   ) => RuleOrLiteral[][];
 
   /**
@@ -102,7 +110,7 @@ interface Grammar<
   externals?: (
     $: Record<string, SymbolRule<string>>,
     previous: Rule[],
-  ) => SymbolRule<string>[];
+  ) => RuleOrLiteral[];
 
   /**
    * An array of tokens that may appear anywhere in the language. This
@@ -126,6 +134,7 @@ interface Grammar<
    */
   inline?: (
     $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
+    previous: Rule[],
   ) => RuleOrLiteral[];
 
   /**
@@ -134,10 +143,11 @@ interface Grammar<
    *
    * @param $ grammar rules
    *
-   * @see http://tree-sitter.github.io/tree-sitter/using-parsers#static-node-types
+   * @see https://tree-sitter.github.io/tree-sitter/using-parsers#static-node-types
    */
   supertypes?: (
     $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
+    previous: Rule[],
   ) => RuleOrLiteral[];
 
   /**
@@ -153,8 +163,8 @@ interface Grammar<
 
 type GrammarSchema<RuleName extends string> = {
   [K in keyof Grammar<RuleName>]: K extends 'rules'
-    ? Record<RuleName, Rule>
-    : Grammar<RuleName>[K];
+  ? Record<RuleName, Rule>
+  : Grammar<RuleName>[K];
 };
 
 /**
diff --git a/cli/npm/install.js b/cli/npm/install.js
index 2790b47d..b2db3d7d 100755
--- a/cli/npm/install.js
+++ b/cli/npm/install.js
@@ -6,25 +6,54 @@ const http = require('http');
 const https = require('https');
 const packageJSON = require('./package.json');
 
-// Determine the URL of the file.
-const platformName = {
-  'darwin': 'macos',
-  'linux': 'linux',
-  'win32': 'windows'
-}[process.platform];
-
-let archName = {
-  'x64': 'x64',
-  'x86': 'x86',
-  'ia32': 'x86'
-}[process.arch];
-
-// ARM macs can run x64 binaries via Rosetta. Rely on that for now.
-if (platformName === 'macos' && process.arch === 'arm64') {
-  archName = 'x64';
+// Look to a results table in https://github.com/tree-sitter/tree-sitter/issues/2196
+const matrix = {
+  platform: {
+    'darwin': {
+      name: 'macos',
+      arch: {
+        'arm64': { name: 'arm64' },
+        'x64': { name: 'x64' },
+      }
+    },
+    'linux': {
+      name: 'linux',
+      arch: {
+        'arm64': { name: 'arm64' },
+        'arm': { name: 'arm' },
+        'armv7l': { name: 'armv7l' },
+        'x64': { name: 'x64' },
+        'x86': { name: 'x86' },
+        'i586': { name: 'i586' },
+        'mips': { name: 'mips' },
+        'mips64': { name: 'mips64' },
+        'mipsel': { name: 'mipsel' },
+        'mips64el': { name: 'mips64el' },
+        'ppc': { name: 'powerpc' },
+        'ppc64': { name: 'powerpc64' },
+        'ppc64el': { name: 'powerpc64el' },
+        'riscv64gc': { name: 'riscv64gc' },
+        's390x': { name: 's390x' },
+        'sparc64': { name: 'sparc64' },
+      }
+    },
+    'win32': {
+      name: 'windows',
+      arch: {
+        'arm64': { name: 'arm64' },
+        'x64': { name: 'x64' },
+        'x86': { name: 'x86' },
+        'ia32': { name: 'x86' },
+      }
+    },
+  },
 }
 
-if (!platformName || !archName) {
+// Determine the URL of the file.
+const platform = matrix.platform[process.platform];
+const arch = platform && platform.arch[process.arch];
+
+if (!platform || !platform.name || !arch || !arch.name) {
   console.error(
     `Cannot install tree-sitter-cli for platform ${process.platform}, architecture ${process.arch}`
   );
@@ -32,7 +61,7 @@ if (!platformName || !archName) {
 }
 
 const releaseURL = `https://github.com/tree-sitter/tree-sitter/releases/download/v${packageJSON.version}`;
-const assetName = `tree-sitter-${platformName}-${archName}.gz`;
+const assetName = `tree-sitter-${platform.name}-${arch.name}.gz`;
 const assetURL = `${releaseURL}/${assetName}`;
 
 // Remove previously-downloaded files.
diff --git a/cli/npm/package.json b/cli/npm/package.json
index dfa53ab4..e60c3936 100644
--- a/cli/npm/package.json
+++ b/cli/npm/package.json
@@ -1,11 +1,11 @@
 {
   "name": "tree-sitter-cli",
-  "version": "0.20.7",
+  "version": "0.20.8",
   "author": "Max Brunsfeld",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "http://github.com/tree-sitter/tree-sitter.git"
+    "url": "https://github.com/tree-sitter/tree-sitter.git"
   },
   "description": "CLI for generating fast incremental parsers",
   "keywords": [
@@ -15,7 +15,8 @@
   "main": "lib/api/index.js",
   "scripts": {
     "install": "node install.js",
-    "prepack": "cp ../../LICENSE ."
+    "prepack": "cp ../../LICENSE ../README.md .",
+    "postpack": "rm LICENSE README.md"
   },
   "bin": {
     "tree-sitter": "cli.js"
diff --git a/cli/src/generate/build_tables/build_parse_table.rs b/cli/src/generate/build_tables/build_parse_table.rs
index 10320263..d19d44de 100644
--- a/cli/src/generate/build_tables/build_parse_table.rs
+++ b/cli/src/generate/build_tables/build_parse_table.rs
@@ -57,6 +57,7 @@ struct ParseTableBuilder<'a> {
     parse_state_info_by_id: Vec<ParseStateInfo<'a>>,
     parse_state_queue: VecDeque<ParseStateQueueEntry>,
     non_terminal_extra_states: Vec<(Symbol, usize)>,
+    actual_conflicts: HashSet<Vec<Symbol>>,
     parse_table: ParseTable,
 }
 
@@ -132,6 +133,20 @@ impl<'a> ParseTableBuilder<'a> {
             )?;
         }
 
+        if !self.actual_conflicts.is_empty() {
+            println!("Warning: unnecessary conflicts");
+            for conflict in &self.actual_conflicts {
+                println!(
+                    "  {}",
+                    conflict
+                        .iter()
+                        .map(|symbol| format!("`{}`", self.symbol_name(symbol)))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                );
+            }
+        }
+
         Ok((self.parse_table, self.parse_state_info_by_id))
     }
 
@@ -582,6 +597,7 @@ impl<'a> ParseTableBuilder<'a> {
             .expected_conflicts
             .contains(&actual_conflict)
         {
+            self.actual_conflicts.remove(&actual_conflict);
             return Ok(());
         }
 
@@ -964,6 +980,7 @@ pub(crate) fn build_parse_table<'a>(
     inlines: &'a InlinedProductionMap,
     variable_info: &'a Vec<VariableInfo>,
 ) -> Result<(ParseTable, Vec<TokenSet>, Vec<ParseStateInfo<'a>>)> {
+    let actual_conflicts = syntax_grammar.expected_conflicts.iter().cloned().collect();
     let item_set_builder = ParseItemSetBuilder::new(syntax_grammar, lexical_grammar, inlines);
     let mut following_tokens = vec![TokenSet::new(); lexical_grammar.variables.len()];
     populate_following_tokens(
@@ -979,6 +996,7 @@ pub(crate) fn build_parse_table<'a>(
         item_set_builder,
         variable_info,
         non_terminal_extra_states: Vec::new(),
+        actual_conflicts,
         state_ids_by_item_set: IndexMap::default(),
         core_ids_by_core: HashMap::new(),
         parse_state_info_by_id: Vec::new(),
diff --git a/cli/src/generate/build_tables/token_conflicts.rs b/cli/src/generate/build_tables/token_conflicts.rs
index 223d3481..485fdc96 100644
--- a/cli/src/generate/build_tables/token_conflicts.rs
+++ b/cli/src/generate/build_tables/token_conflicts.rs
@@ -390,12 +390,12 @@ mod tests {
                 Variable {
                     name: "token_0".to_string(),
                     kind: VariableType::Named,
-                    rule: Rule::pattern("[a-f]1|0x\\d"),
+                    rule: Rule::pattern("[a-f]1|0x\\d", ""),
                 },
                 Variable {
                     name: "token_1".to_string(),
                     kind: VariableType::Named,
-                    rule: Rule::pattern("d*ef"),
+                    rule: Rule::pattern("d*ef", ""),
                 },
             ],
         })
@@ -426,7 +426,7 @@ mod tests {
                 Variable {
                     name: "identifier".to_string(),
                     kind: VariableType::Named,
-                    rule: Rule::pattern("\\w+"),
+                    rule: Rule::pattern("\\w+", ""),
                 },
                 Variable {
                     name: "instanceof".to_string(),
@@ -471,7 +471,7 @@ mod tests {
     #[test]
     fn test_token_conflicts_with_separators() {
         let grammar = expand_tokens(ExtractedLexicalGrammar {
-            separators: vec![Rule::pattern("\\s")],
+            separators: vec![Rule::pattern("\\s", "")],
             variables: vec![
                 Variable {
                     name: "x".to_string(),
@@ -498,7 +498,7 @@ mod tests {
     #[test]
     fn test_token_conflicts_with_open_ended_tokens() {
         let grammar = expand_tokens(ExtractedLexicalGrammar {
-            separators: vec![Rule::pattern("\\s")],
+            separators: vec![Rule::pattern("\\s", "")],
             variables: vec![
                 Variable {
                     name: "x".to_string(),
@@ -508,7 +508,7 @@ mod tests {
                 Variable {
                     name: "anything".to_string(),
                     kind: VariableType::Named,
-                    rule: Rule::prec(Precedence::Integer(-1), Rule::pattern(".*")),
+                    rule: Rule::prec(Precedence::Integer(-1), Rule::pattern(".*", "")),
                 },
             ],
         })
diff --git a/cli/src/generate/dsl.js b/cli/src/generate/dsl.js
index 4281cee1..4fdfbef1 100644
--- a/cli/src/generate/dsl.js
+++ b/cli/src/generate/dsl.js
@@ -181,7 +181,11 @@ function normalize(value) {
         value
       };
     case RegExp:
-      return {
+      return value.flags ? {
+        type: 'PATTERN',
+        value: value.source,
+        flags: value.flags
+      } : {
         type: 'PATTERN',
         value: value.source
       };
diff --git a/cli/src/generate/grammar-schema.json b/cli/src/generate/grammar-schema.json
index 5ca35370..952aac80 100644
--- a/cli/src/generate/grammar-schema.json
+++ b/cli/src/generate/grammar-schema.json
@@ -63,7 +63,7 @@
     },
 
     "supertypes": {
-      "description": "A list of hidden rule names that should be considered supertypes in the generated node types file. See http://tree-sitter.github.io/tree-sitter/using-parsers#static-node-types.",
+      "description": "A list of hidden rule names that should be considered supertypes in the generated node types file. See https://tree-sitter.github.io/tree-sitter/using-parsers#static-node-types.",
       "type": "array",
       "items": {
         "description": "the name of a rule in `rules` or `extras`",
diff --git a/cli/src/generate/mod.rs b/cli/src/generate/mod.rs
index 4838828b..3c0aeda1 100644
--- a/cli/src/generate/mod.rs
+++ b/cli/src/generate/mod.rs
@@ -21,10 +21,10 @@ use anyhow::{anyhow, Context, Result};
 use lazy_static::lazy_static;
 use regex::{Regex, RegexBuilder};
 use semver::Version;
-use std::fs;
 use std::io::Write;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
+use std::{env, fs};
 
 lazy_static! {
     static ref JSON_COMMENT_REGEX: Regex = RegexBuilder::new("^\\s*//.*")
@@ -44,25 +44,27 @@ pub fn generate_parser_in_directory(
     abi_version: usize,
     generate_bindings: bool,
     report_symbol_name: Option<&str>,
+    js_runtime: Option<&str>,
 ) -> Result<()> {
     let src_path = repo_path.join("src");
     let header_path = src_path.join("tree_sitter");
 
+    // Read the grammar.json.
+    let grammar_json = match grammar_path {
+        Some(path) => load_grammar_file(path.as_ref(), js_runtime)?,
+        None => {
+            let grammar_js_path = grammar_path.map_or(repo_path.join("grammar.js"), |s| s.into());
+            load_grammar_file(&grammar_js_path, js_runtime)?
+        }
+    };
+
     // Ensure that the output directories exist.
     fs::create_dir_all(&src_path)?;
     fs::create_dir_all(&header_path)?;
 
-    // Read the grammar.json.
-    let grammar_json;
-    match grammar_path {
-        Some(path) => {
-            grammar_json = load_grammar_file(path.as_ref())?;
-        }
-        None => {
-            let grammar_js_path = grammar_path.map_or(repo_path.join("grammar.js"), |s| s.into());
-            grammar_json = load_grammar_file(&grammar_js_path)?;
-            fs::write(&src_path.join("grammar.json"), &grammar_json)?;
-        }
+    if grammar_path.is_none() {
+        fs::write(&src_path.join("grammar.json"), &grammar_json)
+            .with_context(|| format!("Failed to write grammar.json to {:?}", src_path))?;
     }
 
     // Parse and preprocess the grammar.
@@ -155,10 +157,18 @@ fn generate_parser_for_grammar_with_opts(
     })
 }
 
-pub fn load_grammar_file(grammar_path: &Path) -> Result<String> {
+pub fn load_grammar_file(grammar_path: &Path, js_runtime: Option<&str>) -> Result<String> {
+    if grammar_path.is_dir() {
+        return Err(anyhow!(
+            "Path to a grammar file with `.js` or `.json` extension is required"
+        ));
+    }
     match grammar_path.extension().and_then(|e| e.to_str()) {
-        Some("js") => Ok(load_js_grammar_file(grammar_path)?),
-        Some("json") => Ok(fs::read_to_string(grammar_path)?),
+        Some("js") => Ok(load_js_grammar_file(grammar_path, js_runtime)
+            .with_context(|| "Failed to load grammar.js")?),
+        Some("json") => {
+            Ok(fs::read_to_string(grammar_path).with_context(|| "Failed to load grammar.json")?)
+        }
         _ => Err(anyhow!(
             "Unknown grammar file extension: {:?}",
             grammar_path
@@ -166,21 +176,24 @@ pub fn load_grammar_file(grammar_path: &Path) -> Result<String> {
     }
 }
 
-fn load_js_grammar_file(grammar_path: &Path) -> Result<String> {
+fn load_js_grammar_file(grammar_path: &Path, js_runtime: Option<&str>) -> Result<String> {
     let grammar_path = fs::canonicalize(grammar_path)?;
-    let mut node_process = Command::new("node")
+
+    let js_runtime = js_runtime.unwrap_or("node");
+
+    let mut node_process = Command::new(js_runtime)
         .env("TREE_SITTER_GRAMMAR_PATH", grammar_path)
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
         .spawn()
-        .expect("Failed to run `node`");
+        .with_context(|| format!("Failed to run `{js_runtime}`"))?;
 
     let mut node_stdin = node_process
         .stdin
         .take()
-        .expect("Failed to open stdin for node");
+        .with_context(|| "Failed to open stdin for node")?;
     let cli_version = Version::parse(env!("CARGO_PKG_VERSION"))
-        .expect("Could not parse this package's version as semver.");
+        .with_context(|| "Could not parse this package's version as semver.")?;
     write!(
         node_stdin,
         "global.TREE_SITTER_CLI_VERSION_MAJOR = {};
@@ -188,22 +201,22 @@ fn load_js_grammar_file(grammar_path: &Path) -> Result<String> {
         global.TREE_SITTER_CLI_VERSION_PATCH = {};",
         cli_version.major, cli_version.minor, cli_version.patch,
     )
-    .expect("Failed to write tree-sitter version to node's stdin");
+    .with_context(|| "Failed to write tree-sitter version to node's stdin")?;
     let javascript_code = include_bytes!("./dsl.js");
     node_stdin
         .write(javascript_code)
-        .expect("Failed to write grammar dsl to node's stdin");
+        .with_context(|| "Failed to write grammar dsl to node's stdin")?;
     drop(node_stdin);
     let output = node_process
         .wait_with_output()
-        .expect("Failed to read output from node");
+        .with_context(|| "Failed to read output from node")?;
     match output.status.code() {
         None => panic!("Node process was killed"),
         Some(0) => {}
         Some(code) => return Err(anyhow!("Node process exited with status {}", code)),
     }
-
-    let mut result = String::from_utf8(output.stdout).expect("Got invalid UTF8 from node");
+    let mut result =
+        String::from_utf8(output.stdout).with_context(|| "Got invalid UTF8 from node")?;
     result.push('\n');
     Ok(result)
 }
diff --git a/cli/src/generate/node_types.rs b/cli/src/generate/node_types.rs
index 43918980..2b44cfd2 100644
--- a/cli/src/generate/node_types.rs
+++ b/cli/src/generate/node_types.rs
@@ -1172,12 +1172,12 @@ mod tests {
                 Variable {
                     name: "identifier".to_string(),
                     kind: VariableType::Named,
-                    rule: Rule::pattern("\\w+"),
+                    rule: Rule::pattern("\\w+", ""),
                 },
                 Variable {
                     name: "foo_identifier".to_string(),
                     kind: VariableType::Named,
-                    rule: Rule::pattern("[\\w-]+"),
+                    rule: Rule::pattern("[\\w-]+", ""),
                 },
             ],
             ..Default::default()
@@ -1275,8 +1275,8 @@ mod tests {
                 name: "script".to_string(),
                 kind: VariableType::Named,
                 rule: Rule::seq(vec![
-                    Rule::field("a".to_string(), Rule::pattern("hi")),
-                    Rule::field("b".to_string(), Rule::pattern("bye")),
+                    Rule::field("a".to_string(), Rule::pattern("hi", "")),
+                    Rule::field("b".to_string(), Rule::pattern("bye", "")),
                 ]),
             }],
             ..Default::default()
diff --git a/cli/src/generate/parse_grammar.rs b/cli/src/generate/parse_grammar.rs
index 7fda0b71..e8eca095 100644
--- a/cli/src/generate/parse_grammar.rs
+++ b/cli/src/generate/parse_grammar.rs
@@ -19,6 +19,7 @@ enum RuleJSON {
     },
     PATTERN {
         value: String,
+        flags: Option<String>,
     },
     SYMBOL {
         name: String,
@@ -143,7 +144,21 @@ fn parse_rule(json: RuleJSON) -> Rule {
         } => Rule::alias(parse_rule(*content), value, named),
         RuleJSON::BLANK => Rule::Blank,
         RuleJSON::STRING { value } => Rule::String(value),
-        RuleJSON::PATTERN { value } => Rule::Pattern(value),
+        RuleJSON::PATTERN { value, flags } => Rule::Pattern(
+            value,
+            flags.map_or(String::new(), |f| {
+                f.chars()
+                    .filter(|c| {
+                        if *c != 'i' {
+                            eprintln!("Warning: unsupported flag {c}");
+                            false
+                        } else {
+                            *c != 'u' // silently ignore unicode flag
+                        }
+                    })
+                    .collect()
+            }),
+        ),
         RuleJSON::SYMBOL { name } => Rule::NamedSymbol(name),
         RuleJSON::CHOICE { members } => Rule::choice(members.into_iter().map(parse_rule).collect()),
         RuleJSON::FIELD { content, name } => Rule::field(name, parse_rule(*content)),
diff --git a/cli/src/generate/prepare_grammar/expand_tokens.rs b/cli/src/generate/prepare_grammar/expand_tokens.rs
index d6c73d9a..fdbd004f 100644
--- a/cli/src/generate/prepare_grammar/expand_tokens.rs
+++ b/cli/src/generate/prepare_grammar/expand_tokens.rs
@@ -139,10 +139,10 @@ pub(crate) fn expand_tokens(mut grammar: ExtractedLexicalGrammar) -> Result<Lexi
 impl NfaBuilder {
     fn expand_rule(&mut self, rule: &Rule, mut next_state_id: u32) -> Result<bool> {
         match rule {
-            Rule::Pattern(s) => {
+            Rule::Pattern(s, f) => {
                 let s = preprocess_regex(s);
                 let ast = parse::Parser::new().parse(&s)?;
-                self.expand_regex(&ast, next_state_id)
+                self.expand_regex(&ast, next_state_id, f.contains('i'))
             }
             Rule::String(s) => {
                 for c in s.chars().rev() {
@@ -210,12 +210,42 @@ impl NfaBuilder {
         }
     }
 
-    fn expand_regex(&mut self, ast: &Ast, mut next_state_id: u32) -> Result<bool> {
+    fn expand_regex(
+        &mut self,
+        ast: &Ast,
+        mut next_state_id: u32,
+        case_insensitive: bool,
+    ) -> Result<bool> {
+        fn inverse_char(c: char) -> char {
+            match c {
+                'a'..='z' => (c as u8 - b'a' + b'A') as char,
+                'A'..='Z' => (c as u8 - b'A' + b'a') as char,
+                c => c,
+            }
+        }
+
+        fn with_inverse_char(mut chars: CharacterSet) -> CharacterSet {
+            for char in chars.clone().chars() {
+                let inverted = inverse_char(char);
+                if char != inverted {
+                    chars = chars.add_char(inverted);
+                }
+            }
+            chars
+        }
+
         match ast {
             Ast::Empty(_) => Ok(false),
             Ast::Flags(_) => Err(anyhow!("Regex error: Flags are not supported")),
             Ast::Literal(literal) => {
-                self.push_advance(CharacterSet::from_char(literal.c), next_state_id);
+                let mut char_set = CharacterSet::from_char(literal.c);
+                if case_insensitive {
+                    let inverted = inverse_char(literal.c);
+                    if literal.c != inverted {
+                        char_set = char_set.add_char(inverted);
+                    }
+                }
+                self.push_advance(char_set, next_state_id);
                 Ok(true)
             }
             Ast::Dot(_) => {
@@ -229,6 +259,9 @@ impl NfaBuilder {
                     if class.negated {
                         chars = chars.negate();
                     }
+                    if case_insensitive {
+                        chars = with_inverse_char(chars);
+                    }
                     self.push_advance(chars, next_state_id);
                     Ok(true)
                 }
@@ -237,6 +270,9 @@ impl NfaBuilder {
                     if class.negated {
                         chars = chars.negate();
                     }
+                    if case_insensitive {
+                        chars = with_inverse_char(chars);
+                    }
                     self.push_advance(chars, next_state_id);
                     Ok(true)
                 }
@@ -245,48 +281,56 @@ impl NfaBuilder {
                     if class.negated {
                         chars = chars.negate();
                     }
+                    if case_insensitive {
+                        chars = with_inverse_char(chars);
+                    }
                     self.push_advance(chars, next_state_id);
                     Ok(true)
                 }
             },
             Ast::Repetition(repetition) => match repetition.op.kind {
                 RepetitionKind::ZeroOrOne => {
-                    self.expand_zero_or_one(&repetition.ast, next_state_id)
+                    self.expand_zero_or_one(&repetition.ast, next_state_id, case_insensitive)
                 }
                 RepetitionKind::OneOrMore => {
-                    self.expand_one_or_more(&repetition.ast, next_state_id)
+                    self.expand_one_or_more(&repetition.ast, next_state_id, case_insensitive)
                 }
                 RepetitionKind::ZeroOrMore => {
-                    self.expand_zero_or_more(&repetition.ast, next_state_id)
+                    self.expand_zero_or_more(&repetition.ast, next_state_id, case_insensitive)
                 }
                 RepetitionKind::Range(RepetitionRange::Exactly(count)) => {
-                    self.expand_count(&repetition.ast, count, next_state_id)
+                    self.expand_count(&repetition.ast, count, next_state_id, case_insensitive)
                 }
                 RepetitionKind::Range(RepetitionRange::AtLeast(min)) => {
-                    if self.expand_zero_or_more(&repetition.ast, next_state_id)? {
-                        self.expand_count(&repetition.ast, min, next_state_id)
+                    if self.expand_zero_or_more(&repetition.ast, next_state_id, case_insensitive)? {
+                        self.expand_count(&repetition.ast, min, next_state_id, case_insensitive)
                     } else {
                         Ok(false)
                     }
                 }
                 RepetitionKind::Range(RepetitionRange::Bounded(min, max)) => {
-                    let mut result = self.expand_count(&repetition.ast, min, next_state_id)?;
+                    let mut result =
+                        self.expand_count(&repetition.ast, min, next_state_id, case_insensitive)?;
                     for _ in min..max {
                         if result {
                             next_state_id = self.nfa.last_state_id();
                         }
-                        if self.expand_zero_or_one(&repetition.ast, next_state_id)? {
+                        if self.expand_zero_or_one(
+                            &repetition.ast,
+                            next_state_id,
+                            case_insensitive,
+                        )? {
                             result = true;
                         }
                     }
                     Ok(result)
                 }
             },
-            Ast::Group(group) => self.expand_regex(&group.ast, next_state_id),
+            Ast::Group(group) => self.expand_regex(&group.ast, next_state_id, case_insensitive),
             Ast::Alternation(alternation) => {
                 let mut alternative_state_ids = Vec::new();
                 for ast in alternation.asts.iter() {
-                    if self.expand_regex(&ast, next_state_id)? {
+                    if self.expand_regex(&ast, next_state_id, case_insensitive)? {
                         alternative_state_ids.push(self.nfa.last_state_id());
                     } else {
                         alternative_state_ids.push(next_state_id);
@@ -304,7 +348,7 @@ impl NfaBuilder {
             Ast::Concat(concat) => {
                 let mut result = false;
                 for ast in concat.asts.iter().rev() {
-                    if self.expand_regex(&ast, next_state_id)? {
+                    if self.expand_regex(&ast, next_state_id, case_insensitive)? {
                         result = true;
                         next_state_id = self.nfa.last_state_id();
                     }
@@ -335,13 +379,18 @@ impl NfaBuilder {
         }
     }
 
-    fn expand_one_or_more(&mut self, ast: &Ast, next_state_id: u32) -> Result<bool> {
+    fn expand_one_or_more(
+        &mut self,
+        ast: &Ast,
+        next_state_id: u32,
+        case_insensitive: bool,
+    ) -> Result<bool> {
         self.nfa.states.push(NfaState::Accept {
             variable_index: 0,
             precedence: 0,
         }); // Placeholder for split
         let split_state_id = self.nfa.last_state_id();
-        if self.expand_regex(&ast, split_state_id)? {
+        if self.expand_regex(&ast, split_state_id, case_insensitive)? {
             self.nfa.states[split_state_id as usize] =
                 NfaState::Split(self.nfa.last_state_id(), next_state_id);
             Ok(true)
@@ -351,8 +400,13 @@ impl NfaBuilder {
         }
     }
 
-    fn expand_zero_or_one(&mut self, ast: &Ast, next_state_id: u32) -> Result<bool> {
-        if self.expand_regex(ast, next_state_id)? {
+    fn expand_zero_or_one(
+        &mut self,
+        ast: &Ast,
+        next_state_id: u32,
+        case_insensitive: bool,
+    ) -> Result<bool> {
+        if self.expand_regex(ast, next_state_id, case_insensitive)? {
             self.push_split(next_state_id);
             Ok(true)
         } else {
@@ -360,8 +414,13 @@ impl NfaBuilder {
         }
     }
 
-    fn expand_zero_or_more(&mut self, ast: &Ast, next_state_id: u32) -> Result<bool> {
-        if self.expand_one_or_more(&ast, next_state_id)? {
+    fn expand_zero_or_more(
+        &mut self,
+        ast: &Ast,
+        next_state_id: u32,
+        case_insensitive: bool,
+    ) -> Result<bool> {
+        if self.expand_one_or_more(&ast, next_state_id, case_insensitive)? {
             self.push_split(next_state_id);
             Ok(true)
         } else {
@@ -369,10 +428,16 @@ impl NfaBuilder {
         }
     }
 
-    fn expand_count(&mut self, ast: &Ast, count: u32, mut next_state_id: u32) -> Result<bool> {
+    fn expand_count(
+        &mut self,
+        ast: &Ast,
+        count: u32,
+        mut next_state_id: u32,
+        case_insensitive: bool,
+    ) -> Result<bool> {
         let mut result = false;
         for _ in 0..count {
-            if self.expand_regex(ast, next_state_id)? {
+            if self.expand_regex(ast, next_state_id, case_insensitive)? {
                 result = true;
                 next_state_id = self.nfa.last_state_id();
             }
@@ -475,7 +540,9 @@ impl NfaBuilder {
                 .add_char(' ')
                 .add_char('\t')
                 .add_char('\r')
-                .add_char('\n'),
+                .add_char('\n')
+                .add_char('\x0B')
+                .add_char('\x0C'),
             ClassPerlKind::Word => CharacterSet::empty()
                 .add_char('_')
                 .add_range('A', 'Z')
@@ -563,7 +630,7 @@ mod tests {
         let table = [
             // regex with sequences and alternatives
             Row {
-                rules: vec![Rule::pattern("(a|b|c)d(e|f|g)h?")],
+                rules: vec![Rule::pattern("(a|b|c)d(e|f|g)h?", "")],
                 separators: vec![],
                 examples: vec![
                     ("ade1", Some((0, "ade"))),
@@ -574,13 +641,13 @@ mod tests {
             },
             // regex with repeats
             Row {
-                rules: vec![Rule::pattern("a*")],
+                rules: vec![Rule::pattern("a*", "")],
                 separators: vec![],
                 examples: vec![("aaa1", Some((0, "aaa"))), ("b", Some((0, "")))],
             },
             // regex with repeats in sequences
             Row {
-                rules: vec![Rule::pattern("a((bc)+|(de)*)f")],
+                rules: vec![Rule::pattern("a((bc)+|(de)*)f", "")],
                 separators: vec![],
                 examples: vec![
                     ("af1", Some((0, "af"))),
@@ -591,13 +658,13 @@ mod tests {
             },
             // regex with character ranges
             Row {
-                rules: vec![Rule::pattern("[a-fA-F0-9]+")],
+                rules: vec![Rule::pattern("[a-fA-F0-9]+", "")],
                 separators: vec![],
                 examples: vec![("A1ff0.", Some((0, "A1ff0")))],
             },
             // regex with perl character classes
             Row {
-                rules: vec![Rule::pattern("\\w\\d\\s")],
+                rules: vec![Rule::pattern("\\w\\d\\s", "")],
                 separators: vec![],
                 examples: vec![("_0  ", Some((0, "_0 ")))],
             },
@@ -611,7 +678,7 @@ mod tests {
             Row {
                 rules: vec![Rule::repeat(Rule::seq(vec![
                     Rule::string("{"),
-                    Rule::pattern("[a-f]+"),
+                    Rule::pattern("[a-f]+", ""),
                     Rule::string("}"),
                 ]))],
                 separators: vec![],
@@ -624,9 +691,9 @@ mod tests {
             // longest match rule
             Row {
                 rules: vec![
-                    Rule::pattern("a|bc"),
-                    Rule::pattern("aa"),
-                    Rule::pattern("bcd"),
+                    Rule::pattern("a|bc", ""),
+                    Rule::pattern("aa", ""),
+                    Rule::pattern("bcd", ""),
                 ],
                 separators: vec![],
                 examples: vec![
@@ -640,7 +707,7 @@ mod tests {
             },
             // regex with an alternative including the empty string
             Row {
-                rules: vec![Rule::pattern("a(b|)+c")],
+                rules: vec![Rule::pattern("a(b|)+c", "")],
                 separators: vec![],
                 examples: vec![
                     ("ac.", Some((0, "ac"))),
@@ -650,8 +717,8 @@ mod tests {
             },
             // separators
             Row {
-                rules: vec![Rule::pattern("[a-f]+")],
-                separators: vec![Rule::string("\\\n"), Rule::pattern("\\s")],
+                rules: vec![Rule::pattern("[a-f]+", "")],
+                separators: vec![Rule::string("\\\n"), Rule::pattern("\\s", "")],
                 examples: vec![
                     ("  a", Some((0, "a"))),
                     ("  \nb", Some((0, "b"))),
@@ -662,11 +729,11 @@ mod tests {
             // shorter tokens with higher precedence
             Row {
                 rules: vec![
-                    Rule::prec(Precedence::Integer(2), Rule::pattern("abc")),
-                    Rule::prec(Precedence::Integer(1), Rule::pattern("ab[cd]e")),
-                    Rule::pattern("[a-e]+"),
+                    Rule::prec(Precedence::Integer(2), Rule::pattern("abc", "")),
+                    Rule::prec(Precedence::Integer(1), Rule::pattern("ab[cd]e", "")),
+                    Rule::pattern("[a-e]+", ""),
                 ],
-                separators: vec![Rule::string("\\\n"), Rule::pattern("\\s")],
+                separators: vec![Rule::string("\\\n"), Rule::pattern("\\s", "")],
                 examples: vec![
                     ("abceef", Some((0, "abc"))),
                     ("abdeef", Some((1, "abde"))),
@@ -676,13 +743,13 @@ mod tests {
             // immediate tokens with higher precedence
             Row {
                 rules: vec![
-                    Rule::prec(Precedence::Integer(1), Rule::pattern("[^a]+")),
+                    Rule::prec(Precedence::Integer(1), Rule::pattern("[^a]+", "")),
                     Rule::immediate_token(Rule::prec(
                         Precedence::Integer(2),
-                        Rule::pattern("[^ab]+"),
+                        Rule::pattern("[^ab]+", ""),
                     )),
                 ],
-                separators: vec![Rule::pattern("\\s")],
+                separators: vec![Rule::pattern("\\s", "")],
                 examples: vec![("cccb", Some((1, "ccc")))],
             },
             Row {
@@ -704,7 +771,7 @@ mod tests {
             // nested choices within sequences
             Row {
                 rules: vec![Rule::seq(vec![
-                    Rule::pattern("[0-9]+"),
+                    Rule::pattern("[0-9]+", ""),
                     Rule::choice(vec![
                         Rule::Blank,
                         Rule::choice(vec![Rule::seq(vec![
@@ -713,7 +780,7 @@ mod tests {
                                 Rule::Blank,
                                 Rule::choice(vec![Rule::string("+"), Rule::string("-")]),
                             ]),
-                            Rule::pattern("[0-9]+"),
+                            Rule::pattern("[0-9]+", ""),
                         ])]),
                     ]),
                 ])],
@@ -730,7 +797,7 @@ mod tests {
             },
             // nested groups
             Row {
-                rules: vec![Rule::seq(vec![Rule::pattern(r#"([^x\\]|\\(.|\n))+"#)])],
+                rules: vec![Rule::seq(vec![Rule::pattern(r#"([^x\\]|\\(.|\n))+"#, "")])],
                 separators: vec![],
                 examples: vec![("abcx", Some((0, "abc"))), ("abc\\0x", Some((0, "abc\\0")))],
             },
@@ -738,11 +805,11 @@ mod tests {
             Row {
                 rules: vec![
                     // Escaped forward slash (used in JS because '/' is the regex delimiter)
-                    Rule::pattern(r#"\/"#),
+                    Rule::pattern(r#"\/"#, ""),
                     // Escaped quotes
-                    Rule::pattern(r#"\"\'"#),
+                    Rule::pattern(r#"\"\'"#, ""),
                     // Quote preceded by a literal backslash
-                    Rule::pattern(r#"[\\']+"#),
+                    Rule::pattern(r#"[\\']+"#, ""),
                 ],
                 separators: vec![],
                 examples: vec![
@@ -754,8 +821,8 @@ mod tests {
             // unicode property escapes
             Row {
                 rules: vec![
-                    Rule::pattern(r#"\p{L}+\P{L}+"#),
-                    Rule::pattern(r#"\p{White_Space}+\P{White_Space}+[\p{White_Space}]*"#),
+                    Rule::pattern(r#"\p{L}+\P{L}+"#, ""),
+                    Rule::pattern(r#"\p{White_Space}+\P{White_Space}+[\p{White_Space}]*"#, ""),
                 ],
                 separators: vec![],
                 examples: vec![
@@ -765,17 +832,17 @@ mod tests {
             },
             // unicode property escapes in bracketed sets
             Row {
-                rules: vec![Rule::pattern(r#"[\p{L}\p{Nd}]+"#)],
+                rules: vec![Rule::pattern(r#"[\p{L}\p{Nd}]+"#, "")],
                 separators: vec![],
                 examples: vec![("abΨ12٣٣, ok", Some((0, "abΨ12٣٣")))],
             },
             // unicode character escapes
             Row {
                 rules: vec![
-                    Rule::pattern(r#"\u{00dc}"#),
-                    Rule::pattern(r#"\U{000000dd}"#),
-                    Rule::pattern(r#"\u00de"#),
-                    Rule::pattern(r#"\U000000df"#),
+                    Rule::pattern(r#"\u{00dc}"#, ""),
+                    Rule::pattern(r#"\U{000000dd}"#, ""),
+                    Rule::pattern(r#"\u00de"#, ""),
+                    Rule::pattern(r#"\U000000df"#, ""),
                 ],
                 separators: vec![],
                 examples: vec![
@@ -789,13 +856,13 @@ mod tests {
             Row {
                 rules: vec![
                     // Un-escaped curly braces
-                    Rule::pattern(r#"u{[0-9a-fA-F]+}"#),
+                    Rule::pattern(r#"u{[0-9a-fA-F]+}"#, ""),
                     // Already-escaped curly braces
-                    Rule::pattern(r#"\{[ab]{3}\}"#),
+                    Rule::pattern(r#"\{[ab]{3}\}"#, ""),
                     // Unicode codepoints
-                    Rule::pattern(r#"\u{1000A}"#),
+                    Rule::pattern(r#"\u{1000A}"#, ""),
                     // Unicode codepoints (lowercase)
-                    Rule::pattern(r#"\u{1000b}"#),
+                    Rule::pattern(r#"\u{1000b}"#, ""),
                 ],
                 separators: vec![],
                 examples: vec![
@@ -807,7 +874,7 @@ mod tests {
             },
             // Emojis
             Row {
-                rules: vec![Rule::pattern(r"\p{Emoji}+")],
+                rules: vec![Rule::pattern(r"\p{Emoji}+", "")],
                 separators: vec![],
                 examples: vec![
                     ("🐎", Some((0, "🐎"))),
@@ -820,7 +887,7 @@ mod tests {
             },
             // Intersection
             Row {
-                rules: vec![Rule::pattern(r"[[0-7]&&[4-9]]+")],
+                rules: vec![Rule::pattern(r"[[0-7]&&[4-9]]+", "")],
                 separators: vec![],
                 examples: vec![
                     ("456", Some((0, "456"))),
@@ -833,7 +900,7 @@ mod tests {
             },
             // Difference
             Row {
-                rules: vec![Rule::pattern(r"[[0-9]--[4-7]]+")],
+                rules: vec![Rule::pattern(r"[[0-9]--[4-7]]+", "")],
                 separators: vec![],
                 examples: vec![
                     ("123", Some((0, "123"))),
@@ -846,7 +913,7 @@ mod tests {
             },
             // Symmetric difference
             Row {
-                rules: vec![Rule::pattern(r"[[0-7]~~[4-9]]+")],
+                rules: vec![Rule::pattern(r"[[0-7]~~[4-9]]+", "")],
                 separators: vec![],
                 examples: vec![
                     ("123", Some((0, "123"))),
@@ -867,7 +934,7 @@ mod tests {
                 // [6-7]:                    y y
                 // [3-9]--[5-7]:       y y y     y y
                 // final regex:  y y   y y       y y
-                rules: vec![Rule::pattern(r"[[[0-5]--[2-4]]~~[[3-9]--[6-7]]]+")],
+                rules: vec![Rule::pattern(r"[[[0-5]--[2-4]]~~[[3-9]--[6-7]]]+", "")],
                 separators: vec![],
                 examples: vec![
                     ("01", Some((0, "01"))),
diff --git a/cli/src/generate/prepare_grammar/extract_default_aliases.rs b/cli/src/generate/prepare_grammar/extract_default_aliases.rs
index d39bf8dd..ee44f489 100644
--- a/cli/src/generate/prepare_grammar/extract_default_aliases.rs
+++ b/cli/src/generate/prepare_grammar/extract_default_aliases.rs
@@ -31,7 +31,7 @@ pub(super) fn extract_default_aliases(
     for variable in syntax_grammar.variables.iter() {
         for production in variable.productions.iter() {
             for step in production.steps.iter() {
-                let mut status = match step.symbol.kind {
+                let status = match step.symbol.kind {
                     SymbolType::External => &mut external_status_list[step.symbol.index],
                     SymbolType::NonTerminal => &mut non_terminal_status_list[step.symbol.index],
                     SymbolType::Terminal => &mut terminal_status_list[step.symbol.index],
@@ -63,7 +63,7 @@ pub(super) fn extract_default_aliases(
     }
 
     for symbol in syntax_grammar.extra_symbols.iter() {
-        let mut status = match symbol.kind {
+        let status = match symbol.kind {
             SymbolType::External => &mut external_status_list[symbol.index],
             SymbolType::NonTerminal => &mut non_terminal_status_list[symbol.index],
             SymbolType::Terminal => &mut terminal_status_list[symbol.index],
diff --git a/cli/src/generate/prepare_grammar/extract_tokens.rs b/cli/src/generate/prepare_grammar/extract_tokens.rs
index 928f914c..54991829 100644
--- a/cli/src/generate/prepare_grammar/extract_tokens.rs
+++ b/cli/src/generate/prepare_grammar/extract_tokens.rs
@@ -49,7 +49,7 @@ pub(super) fn extract_tokens(
         }) = variable.rule
         {
             if i > 0 && extractor.extracted_usage_counts[index] == 1 {
-                let mut lexical_variable = &mut lexical_variables[index];
+                let lexical_variable = &mut lexical_variables[index];
                 lexical_variable.kind = variable.kind;
                 lexical_variable.name = variable.name;
                 symbol_replacer.replacements.insert(i, index);
@@ -209,7 +209,7 @@ impl TokenExtractor {
                 } else {
                     Rule::Metadata {
                         params: params.clone(),
-                        rule: Box::new(self.extract_tokens_in_rule((&rule).clone())),
+                        rule: Box::new(self.extract_tokens_in_rule(&rule)),
                     }
                 }
             }
@@ -320,7 +320,7 @@ mod test {
                 "rule_0",
                 Rule::repeat(Rule::seq(vec![
                     Rule::string("a"),
-                    Rule::pattern("b"),
+                    Rule::pattern("b", ""),
                     Rule::choice(vec![
                         Rule::non_terminal(1),
                         Rule::non_terminal(2),
@@ -331,8 +331,8 @@ mod test {
                     ]),
                 ])),
             ),
-            Variable::named("rule_1", Rule::pattern("e")),
-            Variable::named("rule_2", Rule::pattern("b")),
+            Variable::named("rule_1", Rule::pattern("e", "")),
+            Variable::named("rule_2", Rule::pattern("b", "")),
             Variable::named(
                 "rule_3",
                 Rule::seq(vec![Rule::non_terminal(2), Rule::Blank]),
@@ -378,12 +378,12 @@ mod test {
             lexical_grammar.variables,
             vec![
                 Variable::anonymous("a", Rule::string("a")),
-                Variable::auxiliary("rule_0_token1", Rule::pattern("b")),
+                Variable::auxiliary("rule_0_token1", Rule::pattern("b", "")),
                 Variable::auxiliary(
                     "rule_0_token2",
                     Rule::repeat(Rule::choice(vec![Rule::string("c"), Rule::string("d"),]))
                 ),
-                Variable::named("rule_1", Rule::pattern("e")),
+                Variable::named("rule_1", Rule::pattern("e", "")),
             ]
         );
     }
@@ -411,7 +411,7 @@ mod test {
     fn test_extracting_extra_symbols() {
         let mut grammar = build_grammar(vec![
             Variable::named("rule_0", Rule::string("x")),
-            Variable::named("comment", Rule::pattern("//.*")),
+            Variable::named("comment", Rule::pattern("//.*", "")),
         ]);
         grammar.extra_symbols = vec![Rule::string(" "), Rule::non_terminal(1)];
 
diff --git a/cli/src/generate/prepare_grammar/process_inlines.rs b/cli/src/generate/prepare_grammar/process_inlines.rs
index 206ef8d3..9452e35a 100644
--- a/cli/src/generate/prepare_grammar/process_inlines.rs
+++ b/cli/src/generate/prepare_grammar/process_inlines.rs
@@ -203,6 +203,12 @@ pub(super) fn process_inlines(
                     lexical_grammar.variables[symbol.index].name,
                 ))
             }
+            SymbolType::NonTerminal if symbol.index == 0 => {
+                return Err(anyhow!(
+                    "Rule `{}` cannot be inlined because it is the first rule",
+                    grammar.variables[symbol.index].name,
+                ))
+            }
             _ => {}
         }
     }
diff --git a/cli/src/generate/render.rs b/cli/src/generate/render.rs
index cb9f6c72..69fa3c48 100644
--- a/cli/src/generate/render.rs
+++ b/cli/src/generate/render.rs
@@ -129,6 +129,7 @@ impl Generator {
         }
 
         self.add_lex_modes_list();
+        self.add_parse_table();
 
         if !self.syntax_grammar.external_tokens.is_empty() {
             self.add_external_token_enum();
@@ -136,7 +137,6 @@ impl Generator {
             self.add_external_scanner_states_list();
         }
 
-        self.add_parse_table();
         self.add_parser_export();
 
         self.buffer
@@ -152,49 +152,51 @@ impl Generator {
             self.symbol_ids[&Symbol::end()].clone(),
         );
 
-        self.symbol_map = self
-            .parse_table
-            .symbols
-            .iter()
-            .map(|symbol| {
-                let mut mapping = symbol;
+        self.symbol_map = HashMap::new();
 
-                // There can be multiple symbols in the grammar that have the same name and kind,
-                // due to simple aliases. When that happens, ensure that they map to the same
-                // public-facing symbol. If one of the symbols is not aliased, choose that one
-                // to be the public-facing symbol. Otherwise, pick the symbol with the lowest
-                // numeric value.
-                if let Some(alias) = self.default_aliases.get(symbol) {
-                    let kind = alias.kind();
-                    for other_symbol in &self.parse_table.symbols {
-                        if let Some(other_alias) = self.default_aliases.get(other_symbol) {
-                            if other_symbol < mapping && other_alias == alias {
-                                mapping = other_symbol;
+        for symbol in self.parse_table.symbols.iter() {
+            let mut mapping = symbol;
+
+            // There can be multiple symbols in the grammar that have the same name and kind,
+            // due to simple aliases. When that happens, ensure that they map to the same
+            // public-facing symbol. If one of the symbols is not aliased, choose that one
+            // to be the public-facing symbol. Otherwise, pick the symbol with the lowest
+            // numeric value.
+            if let Some(alias) = self.default_aliases.get(symbol) {
+                let kind = alias.kind();
+                for other_symbol in &self.parse_table.symbols {
+                    if let Some(other_alias) = self.default_aliases.get(other_symbol) {
+                        if other_symbol < mapping && other_alias == alias {
+                            mapping = other_symbol;
+                        }
+                    } else if self.metadata_for_symbol(*other_symbol) == (&alias.value, kind) {
+                        mapping = other_symbol;
+                        break;
+                    }
+                }
+            }
+            // Two anonymous tokens with different flags but the same string value
+            // should be represented with the same symbol in the public API. Examples:
+            // *  "<" and token(prec(1, "<"))
+            // *  "(" and token.immediate("(")
+            else if symbol.is_terminal() {
+                let metadata = self.metadata_for_symbol(*symbol);
+                for other_symbol in &self.parse_table.symbols {
+                    let other_metadata = self.metadata_for_symbol(*other_symbol);
+                    if other_metadata == metadata {
+                        if let Some(mapped) = self.symbol_map.get(other_symbol) {
+                            if mapped == symbol {
+                                break;
                             }
-                        } else if self.metadata_for_symbol(*other_symbol) == (&alias.value, kind) {
-                            mapping = other_symbol;
-                            break;
-                        }
-                    }
-                }
-                // Two anonymous tokens with different flags but the same string value
-                // should be represented with the same symbol in the public API. Examples:
-                // *  "<" and token(prec(1, "<"))
-                // *  "(" and token.immediate("(")
-                else if symbol.is_terminal() {
-                    let metadata = self.metadata_for_symbol(*symbol);
-                    for other_symbol in &self.parse_table.symbols {
-                        let other_metadata = self.metadata_for_symbol(*other_symbol);
-                        if other_metadata == metadata {
-                            mapping = other_symbol;
-                            break;
                         }
+                        mapping = other_symbol;
+                        break;
                     }
                 }
+            }
 
-                (*symbol, *mapping)
-            })
-            .collect();
+            self.symbol_map.insert(*symbol, *mapping);
+        }
 
         for production_info in &self.parse_table.production_infos {
             // Build a list of all field names
@@ -254,7 +256,7 @@ impl Generator {
     }
 
     fn add_includes(&mut self) {
-        add_line!(self, "#include <tree_sitter/parser.h>");
+        add_line!(self, "#include \"tree_sitter/parser.h\"");
         add_line!(self, "");
     }
 
@@ -336,7 +338,7 @@ impl Generator {
     }
 
     fn add_symbol_enum(&mut self) {
-        add_line!(self, "enum {{");
+        add_line!(self, "enum ts_symbol_identifiers {{");
         indent!(self);
         self.symbol_order.insert(Symbol::end(), 0);
         let mut i = 1;
@@ -408,7 +410,7 @@ impl Generator {
     }
 
     fn add_field_name_enum(&mut self) {
-        add_line!(self, "enum {{");
+        add_line!(self, "enum ts_field_identifiers {{");
         indent!(self);
         for (i, field_name) in self.field_names.iter().enumerate() {
             add_line!(self, "{} = {},", self.field_id(field_name), i + 1);
@@ -764,7 +766,6 @@ impl Generator {
         indent!(self);
 
         add_line!(self, "START_LEXER();");
-        add_line!(self, "eof = lexer->eof(lexer);");
         add_line!(self, "switch (state) {{");
 
         indent!(self);
@@ -879,14 +880,23 @@ impl Generator {
                     add!(self, " ||{}", line_break);
                 }
                 if range.end == range.start {
+                    if range.start == '\0' {
+                        add!(self, "!eof && ");
+                    }
                     add!(self, "lookahead == ");
                     self.add_character(range.start);
                 } else if range.end as u32 == range.start as u32 + 1 {
+                    if range.start == '\0' {
+                        add!(self, "!eof && ");
+                    }
                     add!(self, "lookahead == ");
                     self.add_character(range.start);
                     add!(self, " ||{}lookahead == ", line_break);
                     self.add_character(range.end);
                 } else {
+                    if range.start == '\0' {
+                        add!(self, "!eof && ");
+                    }
                     add!(self, "(");
                     self.add_character(range.start);
                     add!(self, " <= lookahead && lookahead <= ");
@@ -1016,7 +1026,7 @@ impl Generator {
     }
 
     fn add_external_token_enum(&mut self) {
-        add_line!(self, "enum {{");
+        add_line!(self, "enum ts_external_scanner_symbol_identifiers {{");
         indent!(self);
         for i in 0..self.syntax_grammar.external_tokens.len() {
             add_line!(
@@ -1525,54 +1535,93 @@ impl Generator {
     fn sanitize_identifier(&self, name: &str) -> String {
         let mut result = String::with_capacity(name.len());
         for c in name.chars() {
-            if ('a' <= c && c <= 'z')
-                || ('A' <= c && c <= 'Z')
-                || ('0' <= c && c <= '9')
-                || c == '_'
-            {
+            if c.is_ascii_alphanumeric() || c == '_' {
                 result.push(c);
             } else {
-                let replacement = match c {
-                    '~' => "TILDE",
-                    '`' => "BQUOTE",
-                    '!' => "BANG",
-                    '@' => "AT",
-                    '#' => "POUND",
-                    '$' => "DOLLAR",
-                    '%' => "PERCENT",
-                    '^' => "CARET",
-                    '&' => "AMP",
-                    '*' => "STAR",
-                    '(' => "LPAREN",
-                    ')' => "RPAREN",
-                    '-' => "DASH",
-                    '+' => "PLUS",
-                    '=' => "EQ",
-                    '{' => "LBRACE",
-                    '}' => "RBRACE",
-                    '[' => "LBRACK",
-                    ']' => "RBRACK",
-                    '\\' => "BSLASH",
-                    '|' => "PIPE",
-                    ':' => "COLON",
-                    ';' => "SEMI",
-                    '"' => "DQUOTE",
-                    '\'' => "SQUOTE",
-                    '<' => "LT",
-                    '>' => "GT",
-                    ',' => "COMMA",
-                    '.' => "DOT",
-                    '?' => "QMARK",
-                    '/' => "SLASH",
-                    '\n' => "LF",
-                    '\r' => "CR",
-                    '\t' => "TAB",
-                    _ => continue,
-                };
-                if !result.is_empty() && !result.ends_with("_") {
-                    result.push('_');
+                'special_chars: {
+                    let replacement = match c {
+                        ' ' if name.len() == 1 => "SPACE",
+                        '~' => "TILDE",
+                        '`' => "BQUOTE",
+                        '!' => "BANG",
+                        '@' => "AT",
+                        '#' => "POUND",
+                        '$' => "DOLLAR",
+                        '%' => "PERCENT",
+                        '^' => "CARET",
+                        '&' => "AMP",
+                        '*' => "STAR",
+                        '(' => "LPAREN",
+                        ')' => "RPAREN",
+                        '-' => "DASH",
+                        '+' => "PLUS",
+                        '=' => "EQ",
+                        '{' => "LBRACE",
+                        '}' => "RBRACE",
+                        '[' => "LBRACK",
+                        ']' => "RBRACK",
+                        '\\' => "BSLASH",
+                        '|' => "PIPE",
+                        ':' => "COLON",
+                        ';' => "SEMI",
+                        '"' => "DQUOTE",
+                        '\'' => "SQUOTE",
+                        '<' => "LT",
+                        '>' => "GT",
+                        ',' => "COMMA",
+                        '.' => "DOT",
+                        '?' => "QMARK",
+                        '/' => "SLASH",
+                        '\n' => "LF",
+                        '\r' => "CR",
+                        '\t' => "TAB",
+                        '\0' => "NULL",
+                        '\u{0001}' => "SOH",
+                        '\u{0002}' => "STX",
+                        '\u{0003}' => "ETX",
+                        '\u{0004}' => "EOT",
+                        '\u{0005}' => "ENQ",
+                        '\u{0006}' => "ACK",
+                        '\u{0007}' => "BEL",
+                        '\u{0008}' => "BS",
+                        '\u{000b}' => "VTAB",
+                        '\u{000c}' => "FF",
+                        '\u{000e}' => "SO",
+                        '\u{000f}' => "SI",
+                        '\u{0010}' => "DLE",
+                        '\u{0011}' => "DC1",
+                        '\u{0012}' => "DC2",
+                        '\u{0013}' => "DC3",
+                        '\u{0014}' => "DC4",
+                        '\u{0015}' => "NAK",
+                        '\u{0016}' => "SYN",
+                        '\u{0017}' => "ETB",
+                        '\u{0018}' => "CAN",
+                        '\u{0019}' => "EM",
+                        '\u{001a}' => "SUB",
+                        '\u{001b}' => "ESC",
+                        '\u{001c}' => "FS",
+                        '\u{001d}' => "GS",
+                        '\u{001e}' => "RS",
+                        '\u{001f}' => "US",
+                        '\u{007F}' => "DEL",
+                        '\u{FEFF}' => "BOM",
+                        '\u{0080}'..='\u{FFFF}' => {
+                            result.push_str(&format!("u{:04x}", c as u32));
+                            break 'special_chars;
+                        }
+                        '\u{10000}'..='\u{10FFFF}' => {
+                            result.push_str(&format!("U{:08x}", c as u32));
+                            break 'special_chars;
+                        }
+                        '0'..='9' | 'a'..='z' | 'A'..='Z' | '_' => unreachable!(),
+                        ' ' => break 'special_chars,
+                    };
+                    if !result.is_empty() && !result.ends_with("_") {
+                        result.push('_');
+                    }
+                    result += replacement;
                 }
-                result += replacement;
             }
         }
         result
@@ -1585,10 +1634,19 @@ impl Generator {
                 '\"' => result += "\\\"",
                 '?' => result += "\\?",
                 '\\' => result += "\\\\",
+                '\u{0007}' => result += "\\a",
+                '\u{0008}' => result += "\\b",
+                '\u{000b}' => result += "\\v",
                 '\u{000c}' => result += "\\f",
                 '\n' => result += "\\n",
                 '\r' => result += "\\r",
                 '\t' => result += "\\t",
+                '\0' => result += "\\0",
+                '\u{0001}'..='\u{001f}' => result += &format!("\\x{:02x}", c as u32),
+                '\u{007F}'..='\u{FFFF}' => result += &format!("\\u{:04x}", c as u32),
+                '\u{10000}'..='\u{10FFFF}' => {
+                    result.push_str(&format!("\\U{:08x}", c as u32));
+                }
                 _ => result.push(c),
             }
         }
diff --git a/cli/src/generate/rules.rs b/cli/src/generate/rules.rs
index 0e3ff898..c6f0dd33 100644
--- a/cli/src/generate/rules.rs
+++ b/cli/src/generate/rules.rs
@@ -56,7 +56,7 @@ pub(crate) struct Symbol {
 pub(crate) enum Rule {
     Blank,
     String(String),
-    Pattern(String),
+    Pattern(String, String),
     NamedSymbol(String),
     Symbol(Symbol),
     Choice(Vec<Rule>),
@@ -187,8 +187,8 @@ impl Rule {
         Rule::String(value.to_string())
     }
 
-    pub fn pattern(value: &'static str) -> Self {
-        Rule::Pattern(value.to_string())
+    pub fn pattern(value: &'static str, flags: &'static str) -> Self {
+        Rule::Pattern(value.to_string(), flags.to_string())
     }
 }
 
diff --git a/cli/src/highlight.rs b/cli/src/highlight.rs
index 6cf1580e..a7a98936 100644
--- a/cli/src/highlight.rs
+++ b/cli/src/highlight.rs
@@ -1,4 +1,3 @@
-use super::util;
 use ansi_term::Color;
 use anyhow::Result;
 use lazy_static::lazy_static;
@@ -281,7 +280,7 @@ fn style_to_css(style: ansi_term::Style) -> String {
 
 fn write_color(buffer: &mut String, color: Color) {
     if let Color::RGB(r, g, b) = &color {
-        write!(buffer, "color: #{:x?}{:x?}{:x?}", r, g, b).unwrap()
+        write!(buffer, "color: #{r:02x}{g:02x}{b:02x}").unwrap()
     } else {
         write!(
             buffer,
@@ -349,7 +348,7 @@ pub fn ansi(
     let mut highlighter = Highlighter::new();
 
     let events = highlighter.highlight(config, source, cancellation_flag, |string| {
-        loader.highlight_config_for_injection_string(string)
+        loader.highlight_config_for_injection_string(string, config.apply_all_captures)
     })?;
 
     let mut style_stack = vec![theme.default_style().ansi];
@@ -385,17 +384,17 @@ pub fn html(
     config: &HighlightConfiguration,
     quiet: bool,
     print_time: bool,
+    cancellation_flag: Option<&AtomicUsize>,
 ) -> Result<()> {
     use std::io::Write;
 
     let stdout = io::stdout();
     let mut stdout = stdout.lock();
     let time = Instant::now();
-    let cancellation_flag = util::cancel_on_stdin();
     let mut highlighter = Highlighter::new();
 
-    let events = highlighter.highlight(config, source, Some(&cancellation_flag), |string| {
-        loader.highlight_config_for_injection_string(string)
+    let events = highlighter.highlight(config, source, cancellation_flag, |string| {
+        loader.highlight_config_for_injection_string(string, config.apply_all_captures)
     })?;
 
     let mut renderer = HtmlRenderer::new();
@@ -448,7 +447,7 @@ mod tests {
         env::set_var("COLORTERM", "");
         parse_style(&mut style, Value::String(DARK_CYAN.to_string()));
         assert_eq!(style.ansi.foreground, Some(Color::Fixed(36)));
-        assert_eq!(style.css, Some("style=\'color: #0af87\'".to_string()));
+        assert_eq!(style.css, Some("style=\'color: #00af87\'".to_string()));
 
         // junglegreen is not an ANSI color and is preserved when the terminal supports it
         env::set_var("COLORTERM", "truecolor");
diff --git a/cli/src/lib.rs b/cli/src/lib.rs
index d36417c2..549db773 100644
--- a/cli/src/lib.rs
+++ b/cli/src/lib.rs
@@ -1,3 +1,5 @@
+#![doc = include_str!("../README.md")]
+
 pub mod generate;
 pub mod highlight;
 pub mod logger;
@@ -14,3 +16,7 @@ pub mod wasm;
 
 #[cfg(test)]
 mod tests;
+
+// To run compile fail tests
+#[cfg(doctest)]
+mod tests;
diff --git a/cli/src/main.rs b/cli/src/main.rs
index f6bb88a1..0e59a150 100644
--- a/cli/src/main.rs
+++ b/cli/src/main.rs
@@ -1,12 +1,14 @@
-use anyhow::{anyhow, Context, Result};
+use anyhow::{anyhow, Context, Error, Result};
 use clap::{App, AppSettings, Arg, SubCommand};
 use glob::glob;
-use std::path::Path;
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
 use std::{env, fs, u64};
-use tree_sitter::{Parser, WasmStore};
+use tree_sitter::{ffi, Parser, Point, WasmStore};
 use tree_sitter_cli::{
-    generate, highlight, logger, parse, playground, query, tags, test, test_highlight, test_tags,
-    util, wasm,
+    generate, highlight, logger,
+    parse::{self, ParseFileOptions, ParseOutput},
+    playground, query, tags, test, test_highlight, test_tags, util, wasm,
 };
 use tree_sitter_config::Config;
 use tree_sitter_highlight::Highlighter;
@@ -82,6 +84,9 @@ fn run() -> Result<()> {
     let wasm_arg = Arg::with_name("wasm")
         .long("wasm")
         .help("compile parsers to wasm instead of native dynamic libraries");
+    let apply_all_captures_arg = Arg::with_name("apply-all-captures")
+        .help("Apply all captures to highlights")
+        .long("apply-all-captures");
 
     let matches = App::new("tree-sitter")
         .author("Max Brunsfeld <maxbrunsfeld@gmail.com>")
@@ -113,13 +118,33 @@ fn run() -> Result<()> {
                         )),
                 )
                 .arg(Arg::with_name("no-bindings").long("no-bindings"))
+                .arg(
+                    Arg::with_name("build")
+                        .long("build")
+                        .short("b")
+                        .help("Compile all defined languages in the current dir"),
+                )
+                .arg(&debug_build_arg)
+                .arg(
+                    Arg::with_name("libdir")
+                        .long("libdir")
+                        .takes_value(true)
+                        .value_name("path"),
+                )
                 .arg(
                     Arg::with_name("report-states-for-rule")
                         .long("report-states-for-rule")
                         .value_name("rule-name")
                         .takes_value(true),
                 )
-                .arg(Arg::with_name("no-minimize").long("no-minimize")),
+                .arg(
+                    Arg::with_name("js-runtime")
+                        .long("js-runtime")
+                        .takes_value(true)
+                        .value_name("executable")
+                        .env("TREE_SITTER_JS_RUNTIME")
+                        .help("Use a JavaScript runtime other than node"),
+                ),
         )
         .subcommand(
             SubCommand::with_name("parse")
@@ -132,7 +157,8 @@ fn run() -> Result<()> {
                 .arg(&debug_build_arg)
                 .arg(&debug_graph_arg)
                 .arg(&wasm_arg)
-                .arg(Arg::with_name("debug-xml").long("xml").short("x"))
+                .arg(Arg::with_name("output-dot").long("dot"))
+                .arg(Arg::with_name("output-xml").long("xml").short("x"))
                 .arg(
                     Arg::with_name("stat")
                         .help("Show parsing statistic")
@@ -155,6 +181,12 @@ fn run() -> Result<()> {
                         .takes_value(true)
                         .multiple(true)
                         .number_of_values(1),
+                )
+                .arg(
+                    Arg::with_name("encoding")
+                        .help("The encoding of the input files")
+                        .long("encoding")
+                        .takes_value(true),
                 ),
         )
         .subcommand(
@@ -167,6 +199,8 @@ fn run() -> Result<()> {
                         .index(1)
                         .required(true),
                 )
+                .arg(&time_arg)
+                .arg(&quiet_arg)
                 .arg(&paths_file_arg)
                 .arg(&paths_arg.clone().index(2))
                 .arg(
@@ -175,6 +209,12 @@ fn run() -> Result<()> {
                         .long("byte-range")
                         .takes_value(true),
                 )
+                .arg(
+                    Arg::with_name("row-range")
+                        .help("The range of rows in which the query will be executed")
+                        .long("row-range")
+                        .takes_value(true),
+                )
                 .arg(&scope_arg)
                 .arg(Arg::with_name("captures").long("captures").short("c"))
                 .arg(Arg::with_name("test").long("test")),
@@ -208,7 +248,8 @@ fn run() -> Result<()> {
                 .arg(&debug_arg)
                 .arg(&debug_build_arg)
                 .arg(&debug_graph_arg)
-                .arg(&wasm_arg),
+                .arg(&wasm_arg)
+                .arg(&apply_all_captures_arg),
         )
         .subcommand(
             SubCommand::with_name("highlight")
@@ -219,11 +260,31 @@ fn run() -> Result<()> {
                         .long("html")
                         .short("H"),
                 )
+                .arg(
+                    Arg::with_name("check")
+                        .help("Check that highlighting captures conform strictly to standards")
+                        .long("check"),
+                )
+                .arg(
+                    Arg::with_name("captures-path")
+                        .help("Path to a file with captures")
+                        .long("captures-path")
+                        .takes_value(true),
+                )
+                .arg(
+                    Arg::with_name("query-paths")
+                        .help("Paths to files with queries")
+                        .long("query-paths")
+                        .takes_value(true)
+                        .multiple(true)
+                        .number_of_values(1),
+                )
                 .arg(&scope_arg)
                 .arg(&time_arg)
                 .arg(&quiet_arg)
                 .arg(&paths_file_arg)
-                .arg(&paths_arg),
+                .arg(&paths_arg)
+                .arg(&apply_all_captures_arg),
         )
         .subcommand(
             SubCommand::with_name("build-wasm")
@@ -279,6 +340,10 @@ fn run() -> Result<()> {
 
         ("generate", Some(matches)) => {
             let grammar_path = matches.value_of("grammar-path");
+            let debug_build = matches.is_present("debug-build");
+            let build = matches.is_present("build");
+            let libdir = matches.value_of("libdir");
+            let js_runtime = matches.value_of("js-runtime");
             let report_symbol_name = matches.value_of("report-states-for-rule").or_else(|| {
                 if matches.is_present("report-states") {
                     Some("")
@@ -289,16 +354,18 @@ fn run() -> Result<()> {
             if matches.is_present("log") {
                 logger::init();
             }
-            let abi_version =
-                matches
-                    .value_of("abi-version")
-                    .map_or(DEFAULT_GENERATE_ABI_VERSION, |version| {
-                        if version == "latest" {
-                            tree_sitter::LANGUAGE_VERSION
-                        } else {
-                            version.parse().expect("invalid abi version flag")
-                        }
-                    });
+            let abi_version = matches.value_of("abi-version").map_or(
+                Ok::<_, Error>(DEFAULT_GENERATE_ABI_VERSION),
+                |version| {
+                    Ok(if version == "latest" {
+                        tree_sitter::LANGUAGE_VERSION
+                    } else {
+                        version
+                            .parse()
+                            .with_context(|| "invalid abi version flag")?
+                    })
+                },
+            )?;
             let generate_bindings = !matches.is_present("no-bindings");
             generate::generate_parser_in_directory(
                 &current_dir,
@@ -306,7 +373,15 @@ fn run() -> Result<()> {
                 abi_version,
                 generate_bindings,
                 report_symbol_name,
+                js_runtime,
             )?;
+            if build {
+                if let Some(path) = libdir {
+                    loader = loader::Loader::with_parser_lib_path(PathBuf::from(path));
+                }
+                loader.use_debug_build(debug_build);
+                loader.languages_at_path(&current_dir)?;
+            }
         }
 
         ("test", Some(matches)) => {
@@ -317,6 +392,12 @@ fn run() -> Result<()> {
             let filter = matches.value_of("filter");
             let wasm = matches.is_present("wasm");
             let mut parser = Parser::new();
+            let apply_all_captures = matches.is_present("apply-all-captures");
+
+            if debug {
+                // For augmenting debug logging in external scanners
+                env::set_var("TREE_SITTER_DEBUG", "1");
+            }
 
             loader.use_debug_build(debug_build);
 
@@ -364,7 +445,12 @@ fn run() -> Result<()> {
                 if let Some(store) = store.take() {
                     highlighter.parser().set_wasm_store(store).unwrap();
                 }
-                test_highlight::test_highlights(&loader, &mut highlighter, &test_highlight_dir)?;
+                test_highlight::test_highlights(
+                    &loader,
+                    &mut highlighter,
+                    &test_highlight_dir,
+                    apply_all_captures,
+                )?;
                 store = highlighter.parser().take_wasm_store();
             }
 
@@ -382,14 +468,33 @@ fn run() -> Result<()> {
             let debug = matches.is_present("debug");
             let debug_graph = matches.is_present("debug-graph");
             let debug_build = matches.is_present("debug-build");
-            let debug_xml = matches.is_present("debug-xml");
-            let quiet = matches.is_present("quiet");
+
+            let output = if matches.is_present("output-dot") {
+                ParseOutput::Dot
+            } else if matches.is_present("output-xml") {
+                ParseOutput::Xml
+            } else if matches.is_present("quiet") {
+                ParseOutput::Quiet
+            } else {
+                ParseOutput::Normal
+            };
+
+            let encoding =
+                matches
+                    .values_of("encoding")
+                    .map_or(Ok(None), |mut e| match e.next() {
+                        Some("utf16") => Ok(Some(ffi::TSInputEncodingUTF16)),
+                        Some("utf8") => Ok(Some(ffi::TSInputEncodingUTF8)),
+                        Some(_) => Err(anyhow!("Invalid encoding. Expected one of: utf8, utf16")),
+                        None => Ok(None),
+                    })?;
+
             let time = matches.is_present("time");
             let wasm = matches.is_present("wasm");
             let edits = matches
                 .values_of("edits")
                 .map_or(Vec::new(), |e| e.collect());
-            let cancellation_flag = util::cancel_on_stdin();
+            let cancellation_flag = util::cancel_on_signal();
             let mut parser = Parser::new();
 
             if debug {
@@ -430,19 +535,21 @@ fn run() -> Result<()> {
                     .set_language(language)
                     .context("incompatible language")?;
 
-                let this_file_errored = parse::parse_file_at_path(
-                    &mut parser,
+                let opts = ParseFileOptions {
+                    language,
                     path,
-                    &edits,
+                    edits: &edits,
                     max_path_length,
-                    quiet,
-                    time,
+                    output,
+                    print_time: time,
                     timeout,
                     debug,
                     debug_graph,
-                    debug_xml,
-                    Some(&cancellation_flag),
-                )?;
+                    cancellation_flag: Some(&cancellation_flag),
+                    encoding,
+                };
+
+                let this_file_errored = parse::parse_file_at_path(&mut parser, opts)?;
 
                 if should_track_stats {
                     stats.total_parses += 1;
@@ -465,6 +572,8 @@ fn run() -> Result<()> {
 
         ("query", Some(matches)) => {
             let ordered_captures = matches.values_of("captures").is_some();
+            let quiet = matches.values_of("quiet").is_some();
+            let time = matches.values_of("time").is_some();
             let paths = collect_paths(matches.value_of("paths-file"), matches.values_of("paths"))?;
             let loader_config = config.get()?;
             loader.find_all_languages(&loader_config)?;
@@ -474,9 +583,17 @@ fn run() -> Result<()> {
                 matches.value_of("scope"),
             )?;
             let query_path = Path::new(matches.value_of("query-path").unwrap());
-            let range = matches.value_of("byte-range").map(|br| {
-                let r: Vec<&str> = br.split(":").collect();
-                r[0].parse().unwrap()..r[1].parse().unwrap()
+            let byte_range = matches.value_of("byte-range").and_then(|arg| {
+                let mut parts = arg.split(":");
+                let start = parts.next()?.parse().ok()?;
+                let end = parts.next().unwrap().parse().ok()?;
+                Some(start..end)
+            });
+            let point_range = matches.value_of("row-range").and_then(|arg| {
+                let mut parts = arg.split(":");
+                let start = parts.next()?.parse().ok()?;
+                let end = parts.next().unwrap().parse().ok()?;
+                Some(Point::new(start, 0)..Point::new(end, 0))
             });
             let should_test = matches.is_present("test");
             query::query_files_at_paths(
@@ -484,8 +601,11 @@ fn run() -> Result<()> {
                 paths,
                 query_path,
                 ordered_captures,
-                range,
+                byte_range,
+                point_range,
                 should_test,
+                quiet,
+                time,
             )?;
         }
 
@@ -511,13 +631,15 @@ fn run() -> Result<()> {
             let time = matches.is_present("time");
             let quiet = matches.is_present("quiet");
             let html_mode = quiet || matches.is_present("html");
+            let should_check = matches.is_present("check");
             let paths = collect_paths(matches.value_of("paths-file"), matches.values_of("paths"))?;
+            let apply_all_captures = matches.is_present("apply-all-captures");
 
             if html_mode && !quiet {
                 println!("{}", highlight::HTML_HEADER);
             }
 
-            let cancellation_flag = util::cancel_on_stdin();
+            let cancellation_flag = util::cancel_on_signal();
 
             let mut lang = None;
             if let Some(scope) = matches.value_of("scope") {
@@ -527,6 +649,15 @@ fn run() -> Result<()> {
                 }
             }
 
+            let query_paths = matches.values_of("query-paths").map_or(None, |e| {
+                Some(
+                    e.collect::<Vec<_>>()
+                        .into_iter()
+                        .map(|s| s.to_string())
+                        .collect::<Vec<_>>(),
+                )
+            });
+
             for path in paths {
                 let path = Path::new(&path);
                 let (language, language_config) = match lang {
@@ -540,7 +671,45 @@ fn run() -> Result<()> {
                     },
                 };
 
-                if let Some(highlight_config) = language_config.highlight_config(language)? {
+                if let Some(highlight_config) = language_config.highlight_config(
+                    language,
+                    apply_all_captures,
+                    query_paths.as_deref(),
+                )? {
+                    if should_check {
+                        let names = if let Some(path) = matches.value_of("captures-path") {
+                            let path = Path::new(path);
+                            let file = fs::read_to_string(path)?;
+                            let capture_names = file
+                                .lines()
+                                .filter_map(|line| {
+                                    if line.trim().is_empty() || line.trim().starts_with(';') {
+                                        return None;
+                                    }
+                                    line.split(';').next().map(|s| s.trim().trim_matches('"'))
+                                })
+                                .collect::<HashSet<_>>();
+                            highlight_config.nonconformant_capture_names(&capture_names)
+                        } else {
+                            highlight_config.nonconformant_capture_names(&HashSet::new())
+                        };
+                        if names.is_empty() {
+                            eprintln!("All highlight captures conform to standards.");
+                        } else {
+                            eprintln!(
+                                "Non-standard highlight {} detected:",
+                                if names.len() > 1 {
+                                    "captures"
+                                } else {
+                                    "capture"
+                                }
+                            );
+                            for name in names {
+                                eprintln!("* {}", name);
+                            }
+                        }
+                    }
+
                     let source = fs::read(path)?;
                     if html_mode {
                         highlight::html(
@@ -550,6 +719,7 @@ fn run() -> Result<()> {
                             highlight_config,
                             quiet,
                             time,
+                            Some(&cancellation_flag),
                         )?;
                     } else {
                         highlight::ansi(
@@ -582,7 +752,7 @@ fn run() -> Result<()> {
 
         ("playground", Some(matches)) => {
             let open_in_browser = !matches.is_present("quiet");
-            playground::serve(&current_dir, open_in_browser);
+            playground::serve(&current_dir, open_in_browser)?;
         }
 
         ("dump-languages", Some(_)) => {
diff --git a/cli/src/parse.rs b/cli/src/parse.rs
index 4b2ca8fc..99d28a74 100644
--- a/cli/src/parse.rs
+++ b/cli/src/parse.rs
@@ -5,7 +5,7 @@ use std::path::Path;
 use std::sync::atomic::AtomicUsize;
 use std::time::Instant;
 use std::{fmt, fs, usize};
-use tree_sitter::{InputEdit, LogType, Parser, Point, Tree};
+use tree_sitter::{ffi, InputEdit, Language, LogType, Parser, Point, Tree};
 
 #[derive(Debug)]
 pub struct Edit {
@@ -30,36 +30,47 @@ impl fmt::Display for Stats {
     }
 }
 
-pub fn parse_file_at_path(
-    parser: &mut Parser,
-    path: &Path,
-    edits: &Vec<&str>,
-    max_path_length: usize,
-    quiet: bool,
-    print_time: bool,
-    timeout: u64,
-    debug: bool,
-    debug_graph: bool,
-    debug_xml: bool,
-    cancellation_flag: Option<&AtomicUsize>,
-) -> Result<bool> {
+#[derive(Copy, Clone)]
+pub enum ParseOutput {
+    Normal,
+    Quiet,
+    Xml,
+    Dot,
+}
+
+pub struct ParseFileOptions<'a> {
+    pub language: Language,
+    pub path: &'a Path,
+    pub edits: &'a [&'a str],
+    pub max_path_length: usize,
+    pub output: ParseOutput,
+    pub print_time: bool,
+    pub timeout: u64,
+    pub debug: bool,
+    pub debug_graph: bool,
+    pub cancellation_flag: Option<&'a AtomicUsize>,
+    pub encoding: Option<u32>,
+}
+
+pub fn parse_file_at_path(parser: &mut Parser, opts: ParseFileOptions) -> Result<bool> {
     let mut _log_session = None;
-    let mut source_code =
-        fs::read(path).with_context(|| format!("Error reading source file {:?}", path))?;
+    parser.set_language(opts.language)?;
+    let mut source_code = fs::read(opts.path)
+        .with_context(|| format!("Error reading source file {:?}", opts.path))?;
 
     // If the `--cancel` flag was passed, then cancel the parse
     // when the user types a newline.
-    unsafe { parser.set_cancellation_flag(cancellation_flag) };
+    unsafe { parser.set_cancellation_flag(opts.cancellation_flag) };
 
     // Set a timeout based on the `--time` flag.
-    parser.set_timeout_micros(timeout);
+    parser.set_timeout_micros(opts.timeout);
 
     // Render an HTML graph if `--debug-graph` was passed
-    if debug_graph {
+    if opts.debug_graph {
         _log_session = Some(util::log_graphs(parser, "log.html")?);
     }
     // Log to stderr if `--debug` was passed
-    else if debug {
+    else if opts.debug {
         parser.set_logger(Some(Box::new(|log_type, message| {
             if log_type == LogType::Lex {
                 io::stderr().write(b"  ").unwrap();
@@ -69,22 +80,44 @@ pub fn parse_file_at_path(
     }
 
     let time = Instant::now();
-    let tree = parser.parse(&source_code, None);
+
+    #[inline(always)]
+    fn is_utf16_bom(bom_bytes: &[u8]) -> bool {
+        bom_bytes == [0xFF, 0xFE] || bom_bytes == [0xFE, 0xFF]
+    }
+
+    let tree = match opts.encoding {
+        Some(encoding) if encoding == ffi::TSInputEncodingUTF16 => {
+            let source_code_utf16 = source_code
+                .chunks_exact(2)
+                .map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]]))
+                .collect::<Vec<_>>();
+            parser.parse_utf16(&source_code_utf16, None)
+        }
+        None if source_code.len() >= 2 && is_utf16_bom(&source_code[0..2]) => {
+            let source_code_utf16 = source_code
+                .chunks_exact(2)
+                .map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]]))
+                .collect::<Vec<_>>();
+            parser.parse_utf16(&source_code_utf16, None)
+        }
+        _ => parser.parse(&source_code, None),
+    };
 
     let stdout = io::stdout();
     let mut stdout = stdout.lock();
 
     if let Some(mut tree) = tree {
-        if debug_graph && !edits.is_empty() {
+        if opts.debug_graph && !opts.edits.is_empty() {
             println!("BEFORE:\n{}", String::from_utf8_lossy(&source_code));
         }
 
-        for (i, edit) in edits.iter().enumerate() {
+        for (i, edit) in opts.edits.iter().enumerate() {
             let edit = parse_edit_flag(&source_code, edit)?;
-            perform_edit(&mut tree, &mut source_code, &edit);
+            perform_edit(&mut tree, &mut source_code, &edit)?;
             tree = parser.parse(&source_code, Some(&tree)).unwrap();
 
-            if debug_graph {
+            if opts.debug_graph {
                 println!("AFTER {}:\n{}", i, String::from_utf8_lossy(&source_code));
             }
         }
@@ -93,7 +126,7 @@ pub fn parse_file_at_path(
         let duration_ms = duration.as_secs() * 1000 + duration.subsec_nanos() as u64 / 1000000;
         let mut cursor = tree.walk();
 
-        if !quiet {
+        if matches!(opts.output, ParseOutput::Normal) {
             let mut needs_newline = false;
             let mut indent_level = 0;
             let mut did_visit_children = false;
@@ -149,7 +182,7 @@ pub fn parse_file_at_path(
             println!("");
         }
 
-        if debug_xml {
+        if matches!(opts.output, ParseOutput::Xml) {
             let mut needs_newline = false;
             let mut indent_level = 0;
             let mut did_visit_children = false;
@@ -204,6 +237,10 @@ pub fn parse_file_at_path(
             println!("");
         }
 
+        if matches!(opts.output, ParseOutput::Dot) {
+            util::print_tree_graph(&tree, "log.html").unwrap();
+        }
+
         let mut first_error = None;
         loop {
             let node = cursor.node();
@@ -221,13 +258,13 @@ pub fn parse_file_at_path(
             }
         }
 
-        if first_error.is_some() || print_time {
+        if first_error.is_some() || opts.print_time {
             write!(
                 &mut stdout,
                 "{:width$}\t{} ms",
-                path.to_str().unwrap(),
+                opts.path.to_str().unwrap(),
                 duration_ms,
-                width = max_path_length
+                width = opts.max_path_length
             )?;
             if let Some(node) = first_error {
                 let start = node.start_position();
@@ -256,29 +293,29 @@ pub fn parse_file_at_path(
         }
 
         return Ok(first_error.is_some());
-    } else if print_time {
+    } else if opts.print_time {
         let duration = time.elapsed();
         let duration_ms = duration.as_secs() * 1000 + duration.subsec_nanos() as u64 / 1000000;
         writeln!(
             &mut stdout,
             "{:width$}\t{} ms (timed out)",
-            path.to_str().unwrap(),
+            opts.path.to_str().unwrap(),
             duration_ms,
-            width = max_path_length
+            width = opts.max_path_length
         )?;
     }
 
     Ok(false)
 }
 
-pub fn perform_edit(tree: &mut Tree, input: &mut Vec<u8>, edit: &Edit) -> InputEdit {
+pub fn perform_edit(tree: &mut Tree, input: &mut Vec<u8>, edit: &Edit) -> Result<InputEdit> {
     let start_byte = edit.position;
     let old_end_byte = edit.position + edit.deleted_length;
     let new_end_byte = edit.position + edit.inserted_text.len();
-    let start_position = position_for_offset(input, start_byte);
-    let old_end_position = position_for_offset(input, old_end_byte);
+    let start_position = position_for_offset(input, start_byte)?;
+    let old_end_position = position_for_offset(input, old_end_byte)?;
     input.splice(start_byte..old_end_byte, edit.inserted_text.iter().cloned());
-    let new_end_position = position_for_offset(input, new_end_byte);
+    let new_end_position = position_for_offset(input, new_end_byte)?;
     let edit = InputEdit {
         start_byte,
         old_end_byte,
@@ -288,7 +325,7 @@ pub fn perform_edit(tree: &mut Tree, input: &mut Vec<u8>, edit: &Edit) -> InputE
         new_end_position,
     };
     tree.edit(&edit);
-    edit
+    Ok(edit)
 }
 
 fn parse_edit_flag(source_code: &Vec<u8>, flag: &str) -> Result<Edit> {
@@ -317,7 +354,7 @@ fn parse_edit_flag(source_code: &Vec<u8>, flag: &str) -> Result<Edit> {
         let row = usize::from_str_radix(row, 10).map_err(|_| error())?;
         let column = parts.next().ok_or_else(error)?;
         let column = usize::from_str_radix(column, 10).map_err(|_| error())?;
-        offset_for_position(source_code, Point { row, column })
+        offset_for_position(source_code, Point { row, column })?
     } else {
         usize::from_str_radix(position, 10).map_err(|_| error())?
     };
@@ -332,31 +369,48 @@ fn parse_edit_flag(source_code: &Vec<u8>, flag: &str) -> Result<Edit> {
     })
 }
 
-fn offset_for_position(input: &Vec<u8>, position: Point) -> usize {
-    let mut current_position = Point { row: 0, column: 0 };
-    for (i, c) in input.iter().enumerate() {
-        if *c as char == '\n' {
-            current_position.row += 1;
-            current_position.column = 0;
-        } else {
-            current_position.column += 1;
-        }
-        if current_position > position {
-            return i;
+pub fn offset_for_position(input: &[u8], position: Point) -> Result<usize> {
+    let mut row = 0;
+    let mut offset = 0;
+    let mut iter = memchr::memchr_iter(b'\n', input);
+    loop {
+        if let Some(pos) = iter.next() {
+            if row < position.row {
+                row += 1;
+                offset = pos;
+                continue;
+            }
         }
+        offset += 1;
+        break;
     }
-    return input.len();
+    if position.row - row > 0 {
+        return Err(anyhow!("Failed to address a row: {}", position.row));
+    }
+    if let Some(pos) = iter.next() {
+        if (pos - offset < position.column) || (input[offset] == b'\n' && position.column > 0) {
+            return Err(anyhow!("Failed to address a column: {}", position.column));
+        };
+    } else if input.len() - offset < position.column {
+        return Err(anyhow!("Failed to address a column over the end"));
+    }
+    Ok(offset + position.column)
 }
 
-fn position_for_offset(input: &Vec<u8>, offset: usize) -> Point {
-    let mut result = Point { row: 0, column: 0 };
-    for c in &input[0..offset] {
-        if *c as char == '\n' {
-            result.row += 1;
-            result.column = 0;
-        } else {
-            result.column += 1;
-        }
+pub fn position_for_offset(input: &[u8], offset: usize) -> Result<Point> {
+    if offset > input.len() {
+        return Err(anyhow!("Failed to address an offset: {offset}"));
     }
-    result
+    let mut result = Point { row: 0, column: 0 };
+    let mut last = 0;
+    for pos in memchr::memchr_iter(b'\n', &input[..offset]) {
+        result.row += 1;
+        last = pos;
+    }
+    result.column = if result.row > 0 {
+        offset - last - 1
+    } else {
+        offset
+    };
+    Ok(result)
 }
diff --git a/cli/src/playground.html b/cli/src/playground.html
index 22c874df..b69f9351 100644
--- a/cli/src/playground.html
+++ b/cli/src/playground.html
@@ -3,8 +3,8 @@
   <title>tree-sitter THE_LANGUAGE_NAME</title>
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.45.0/codemirror.min.css">
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/clusterize.js/0.18.0/clusterize.min.css">
-  <link rel="icon" type="image/png" href="http://tree-sitter.github.io/tree-sitter/assets/images/favicon-32x32.png" sizes="32x32" />
-  <link rel="icon" type="image/png" href="http://tree-sitter.github.io/tree-sitter/assets/images/favicon-16x16.png" sizes="16x16" />
+  <link rel="icon" type="image/png" href="https://tree-sitter.github.io/tree-sitter/assets/images/favicon-32x32.png" sizes="32x32" />
+  <link rel="icon" type="image/png" href="https://tree-sitter.github.io/tree-sitter/assets/images/favicon-16x16.png" sizes="16x16" />
 </head>
 
 <body>
diff --git a/cli/src/playground.rs b/cli/src/playground.rs
index 5650ee47..cff25509 100644
--- a/cli/src/playground.rs
+++ b/cli/src/playground.rs
@@ -1,4 +1,5 @@
 use super::wasm;
+use anyhow::{anyhow, Context, Result};
 use std::{
     borrow::Cow,
     env, fs,
@@ -7,12 +8,11 @@ use std::{
     str::{self, FromStr as _},
 };
 use tiny_http::{Header, Response, Server};
-use webbrowser;
 
 macro_rules! optional_resource {
     ($name: tt, $path: tt) => {
         #[cfg(TREE_SITTER_EMBED_WASM_BINDING)]
-        fn $name(tree_sitter_dir: &Option<PathBuf>) -> Cow<'static, [u8]> {
+        fn $name(tree_sitter_dir: Option<&PathBuf>) -> Cow<'static, [u8]> {
             if let Some(tree_sitter_dir) = tree_sitter_dir {
                 Cow::Owned(fs::read(tree_sitter_dir.join($path)).unwrap())
             } else {
@@ -21,7 +21,7 @@ macro_rules! optional_resource {
         }
 
         #[cfg(not(TREE_SITTER_EMBED_WASM_BINDING))]
-        fn $name(tree_sitter_dir: &Option<PathBuf>) -> Cow<'static, [u8]> {
+        fn $name(tree_sitter_dir: Option<&PathBuf>) -> Cow<'static, [u8]> {
             if let Some(tree_sitter_dir) = tree_sitter_dir {
                 Cow::Owned(fs::read(tree_sitter_dir.join($path)).unwrap())
             } else {
@@ -35,7 +35,7 @@ optional_resource!(get_playground_js, "docs/assets/js/playground.js");
 optional_resource!(get_lib_js, "lib/binding_web/tree-sitter.js");
 optional_resource!(get_lib_wasm, "lib/binding_web/tree-sitter.wasm");
 
-fn get_main_html(tree_sitter_dir: &Option<PathBuf>) -> Cow<'static, [u8]> {
+fn get_main_html(tree_sitter_dir: Option<&PathBuf>) -> Cow<'static, [u8]> {
     if let Some(tree_sitter_dir) = tree_sitter_dir {
         Cow::Owned(fs::read(tree_sitter_dir.join("cli/src/playground.html")).unwrap())
     } else {
@@ -43,23 +43,10 @@ fn get_main_html(tree_sitter_dir: &Option<PathBuf>) -> Cow<'static, [u8]> {
     }
 }
 
-pub fn serve(grammar_path: &Path, open_in_browser: bool) {
-    let port = env::var("TREE_SITTER_PLAYGROUND_PORT")
-        .map(|v| v.parse::<u16>().expect("Invalid port specification"))
-        .unwrap_or_else(
-            |_| get_available_port().expect(
-                "Couldn't find an available port, try providing a port number via the TREE_SITTER_PLAYGROUND_PORT \
-                 environment variable"
-            )
-        );
-    let addr = format!(
-        "{}:{}",
-        env::var("TREE_SITTER_PLAYGROUND_ADDR").unwrap_or("127.0.0.1".to_owned()),
-        port
-    );
+pub fn serve(grammar_path: &Path, open_in_browser: bool) -> Result<()> {
+    let server = get_server()?;
     let (grammar_name, language_wasm) = wasm::load_language_wasm_file(&grammar_path).unwrap();
-    let server = Server::http(&addr).expect("Failed to start web server");
-    let url = format!("http://{}", addr);
+    let url = format!("http://{}", server.server_addr());
     println!("Started playground on: {}", url);
     if open_in_browser {
         if let Err(_) = webbrowser::open(&url) {
@@ -68,13 +55,13 @@ pub fn serve(grammar_path: &Path, open_in_browser: bool) {
     }
 
     let tree_sitter_dir = env::var("TREE_SITTER_BASE_DIR").map(PathBuf::from).ok();
-    let main_html = str::from_utf8(&get_main_html(&tree_sitter_dir))
+    let main_html = str::from_utf8(&get_main_html(tree_sitter_dir.as_ref()))
         .unwrap()
         .replace("THE_LANGUAGE_NAME", &grammar_name)
         .into_bytes();
-    let playground_js = get_playground_js(&tree_sitter_dir);
-    let lib_js = get_lib_js(&tree_sitter_dir);
-    let lib_wasm = get_lib_wasm(&tree_sitter_dir);
+    let playground_js = get_playground_js(tree_sitter_dir.as_ref());
+    let lib_js = get_lib_js(tree_sitter_dir.as_ref());
+    let lib_wasm = get_lib_wasm(tree_sitter_dir.as_ref());
 
     let html_header = Header::from_str("Content-Type: text/html").unwrap();
     let js_header = Header::from_str("Content-Type: application/javascript").unwrap();
@@ -107,8 +94,12 @@ pub fn serve(grammar_path: &Path, open_in_browser: bool) {
             }
             _ => response(b"Not found", &html_header).with_status_code(404),
         };
-        request.respond(res).expect("Failed to write HTTP response");
+        request
+            .respond(res)
+            .with_context(|| "Failed to write HTTP response")?;
     }
+
+    Ok(())
 }
 
 fn redirect<'a>(url: &'a str) -> Response<&'a [u8]> {
@@ -123,10 +114,30 @@ fn response<'a>(data: &'a [u8], header: &Header) -> Response<&'a [u8]> {
         .with_header(header.clone())
 }
 
-fn get_available_port() -> Option<u16> {
-    (8000..12000).find(port_is_available)
+fn get_server() -> Result<Server> {
+    let addr = env::var("TREE_SITTER_PLAYGROUND_ADDR").unwrap_or("127.0.0.1".to_owned());
+    let port = env::var("TREE_SITTER_PLAYGROUND_PORT")
+        .map(|v| {
+            v.parse::<u16>()
+                .with_context(|| "Invalid port specification")
+        })
+        .ok();
+    let listener = match port {
+        Some(port) => {
+            bind_to(&*addr, port?).with_context(|| "Failed to bind to the specified port")?
+        }
+        None => get_listener_on_available_port(&*addr)
+            .with_context(|| "Failed to find a free port to bind to it")?,
+    };
+    let server =
+        Server::from_listener(listener, None).map_err(|_| anyhow!("Failed to start web server"))?;
+    Ok(server)
 }
 
-fn port_is_available(port: &u16) -> bool {
-    TcpListener::bind(("127.0.0.1", *port)).is_ok()
+fn get_listener_on_available_port(addr: &str) -> Option<TcpListener> {
+    (8000..12000).find_map(|port| bind_to(addr, port))
+}
+
+fn bind_to(addr: &str, port: u16) -> Option<TcpListener> {
+    TcpListener::bind(format!("{addr}:{port}")).ok()
 }
diff --git a/cli/src/query.rs b/cli/src/query.rs
index 73d6dd28..fc24cb05 100644
--- a/cli/src/query.rs
+++ b/cli/src/query.rs
@@ -5,16 +5,20 @@ use std::{
     io::{self, Write},
     ops::Range,
     path::Path,
+    time::Instant,
 };
-use tree_sitter::{Language, Parser, Query, QueryCursor};
+use tree_sitter::{Language, Parser, Point, Query, QueryCursor};
 
 pub fn query_files_at_paths(
     language: Language,
     paths: Vec<String>,
     query_path: &Path,
     ordered_captures: bool,
-    range: Option<Range<usize>>,
+    byte_range: Option<Range<usize>>,
+    point_range: Option<Range<Point>>,
     should_test: bool,
+    quiet: bool,
+    print_time: bool,
 ) -> Result<()> {
     let stdout = io::stdout();
     let mut stdout = stdout.lock();
@@ -24,9 +28,12 @@ pub fn query_files_at_paths(
     let query = Query::new(language, &query_source).with_context(|| "Query compilation failed")?;
 
     let mut query_cursor = QueryCursor::new();
-    if let Some(range) = range {
+    if let Some(range) = byte_range {
         query_cursor.set_byte_range(range);
     }
+    if let Some(range) = point_range {
+        query_cursor.set_point_range(range);
+    }
 
     let mut parser = Parser::new();
     parser.set_language(language)?;
@@ -40,22 +47,25 @@ pub fn query_files_at_paths(
             fs::read(&path).with_context(|| format!("Error reading source file {:?}", path))?;
         let tree = parser.parse(&source_code, None).unwrap();
 
+        let start = Instant::now();
         if ordered_captures {
             for (mat, capture_index) in
                 query_cursor.captures(&query, tree.root_node(), source_code.as_slice())
             {
                 let capture = mat.captures[capture_index];
                 let capture_name = &query.capture_names()[capture.index as usize];
-                writeln!(
-                    &mut stdout,
-                    "    pattern: {:>2}, capture: {} - {}, start: {}, end: {}, text: `{}`",
-                    mat.pattern_index,
-                    capture.index,
-                    capture_name,
-                    capture.node.start_position(),
-                    capture.node.end_position(),
-                    capture.node.utf8_text(&source_code).unwrap_or("")
-                )?;
+                if !quiet {
+                    writeln!(
+                        &mut stdout,
+                        "    pattern: {:>2}, capture: {} - {}, start: {}, end: {}, text: `{}`",
+                        mat.pattern_index,
+                        capture.index,
+                        capture_name,
+                        capture.node.start_position(),
+                        capture.node.end_position(),
+                        capture.node.utf8_text(&source_code).unwrap_or("")
+                    )?;
+                }
                 results.push(query_testing::CaptureInfo {
                     name: capture_name.to_string(),
                     start: capture.node.start_position(),
@@ -64,27 +74,31 @@ pub fn query_files_at_paths(
             }
         } else {
             for m in query_cursor.matches(&query, tree.root_node(), source_code.as_slice()) {
-                writeln!(&mut stdout, "  pattern: {}", m.pattern_index)?;
+                if !quiet {
+                    writeln!(&mut stdout, "  pattern: {}", m.pattern_index)?;
+                }
                 for capture in m.captures {
                     let start = capture.node.start_position();
                     let end = capture.node.end_position();
                     let capture_name = &query.capture_names()[capture.index as usize];
-                    if end.row == start.row {
-                        writeln!(
-                            &mut stdout,
-                            "    capture: {} - {}, start: {}, end: {}, text: `{}`",
-                            capture.index,
-                            capture_name,
-                            start,
-                            end,
-                            capture.node.utf8_text(&source_code).unwrap_or("")
-                        )?;
-                    } else {
-                        writeln!(
-                            &mut stdout,
-                            "    capture: {}, start: {}, end: {}",
-                            capture_name, start, end,
-                        )?;
+                    if !quiet {
+                        if end.row == start.row {
+                            writeln!(
+                                &mut stdout,
+                                "    capture: {} - {}, start: {}, end: {}, text: `{}`",
+                                capture.index,
+                                capture_name,
+                                start,
+                                end,
+                                capture.node.utf8_text(&source_code).unwrap_or("")
+                            )?;
+                        } else {
+                            writeln!(
+                                &mut stdout,
+                                "    capture: {}, start: {}, end: {}",
+                                capture_name, start, end,
+                            )?;
+                        }
                     }
                     results.push(query_testing::CaptureInfo {
                         name: capture_name.to_string(),
@@ -103,6 +117,9 @@ pub fn query_files_at_paths(
         if should_test {
             query_testing::assert_expected_captures(results, path, &mut parser, language)?
         }
+        if print_time {
+            writeln!(&mut stdout, "{:?}", start.elapsed())?;
+        }
     }
 
     Ok(())
diff --git a/cli/src/query_testing.rs b/cli/src/query_testing.rs
index 9950f12f..1f88d619 100644
--- a/cli/src/query_testing.rs
+++ b/cli/src/query_testing.rs
@@ -18,9 +18,20 @@ pub struct CaptureInfo {
 #[derive(Debug, PartialEq, Eq)]
 pub struct Assertion {
     pub position: Point,
+    pub negative: bool,
     pub expected_capture_name: String,
 }
 
+impl Assertion {
+    pub fn new(row: usize, col: usize, negative: bool, expected_capture_name: String) -> Self {
+        Self {
+            position: Point::new(row, col),
+            negative,
+            expected_capture_name,
+        }
+    }
+}
+
 /// Parse the given source code, finding all of the comments that contain
 /// highlighting assertions. Return a vector of (position, expected highlight name)
 /// pairs.
@@ -54,6 +65,7 @@ pub fn parse_position_comments(
                         // to its own column.
                         let mut has_left_caret = false;
                         let mut has_arrow = false;
+                        let mut negative = false;
                         let mut arrow_end = 0;
                         for (i, c) in text.char_indices() {
                             arrow_end = i + 1;
@@ -69,6 +81,19 @@ pub fn parse_position_comments(
                             has_left_caret = c == '<';
                         }
 
+                        // find any ! after arrows but before capture name
+                        if has_arrow {
+                            for (i, c) in text[arrow_end..].char_indices() {
+                                if c == '!' {
+                                    negative = true;
+                                    arrow_end += i + 1;
+                                    break;
+                                } else if !c.is_whitespace() {
+                                    break;
+                                }
+                            }
+                        }
+
                         // If the comment node contains an arrow and a highlight name, record the
                         // highlight name and the position.
                         if let (true, Some(mat)) =
@@ -76,7 +101,8 @@ pub fn parse_position_comments(
                         {
                             assertion_ranges.push((node.start_position(), node.end_position()));
                             result.push(Assertion {
-                                position: position,
+                                position,
+                                negative,
                                 expected_capture_name: mat.as_str().to_string(),
                             });
                         }
diff --git a/cli/src/tags.rs b/cli/src/tags.rs
index 457955dd..f9f788ab 100644
--- a/cli/src/tags.rs
+++ b/cli/src/tags.rs
@@ -23,7 +23,7 @@ pub fn generate_tags(
     }
 
     let mut context = TagsContext::new();
-    let cancellation_flag = util::cancel_on_stdin();
+    let cancellation_flag = util::cancel_on_signal();
     let stdout = io::stdout();
     let mut stdout = stdout.lock();
 
diff --git a/cli/src/test.rs b/cli/src/test.rs
index 1ab57dcf..80643aef 100644
--- a/cli/src/test.rs
+++ b/cli/src/test.rs
@@ -16,11 +16,11 @@ use walkdir::WalkDir;
 
 lazy_static! {
     static ref HEADER_REGEX: ByteRegex =
-        ByteRegexBuilder::new(r"^===+(?P<suffix1>[^=\r\n][^\r\n]*)?\r?\n(?P<test_name>([^=\r\n][^\r\n]*\r?\n)+)===+(?P<suffix2>[^=\r\n][^\r\n]*)?\r?\n")
+        ByteRegexBuilder::new(r"^(?P<equals>(?:=+){3,})(?P<suffix1>[^=\r\n][^\r\n]*)?\r?\n(?P<test_name>([^=\r\n][^\r\n]*\r?\n)+)===+(?P<suffix2>[^=\r\n][^\r\n]*)?\r?\n")
             .multi_line(true)
             .build()
             .unwrap();
-    static ref DIVIDER_REGEX: ByteRegex = ByteRegexBuilder::new(r"^---+(?P<suffix>[^-\r\n][^\r\n]*)?\r?\n")
+    static ref DIVIDER_REGEX: ByteRegex = ByteRegexBuilder::new(r"^(?P<hyphens>(?:-+){3,})(?P<suffix>[^-\r\n][^\r\n]*)?\r?\n")
         .multi_line(true)
         .build()
         .unwrap();
@@ -40,6 +40,8 @@ pub enum TestEntry {
         name: String,
         input: Vec<u8>,
         output: String,
+        header_delim_len: usize,
+        divider_delim_len: usize,
         has_fields: bool,
     },
 }
@@ -177,13 +179,15 @@ fn run_tests(
     mut indent_level: i32,
     failures: &mut Vec<(String, String, String)>,
     update: bool,
-    corrected_entries: &mut Vec<(String, String, String)>,
+    corrected_entries: &mut Vec<(String, String, String, usize, usize)>,
 ) -> Result<()> {
     match test_entry {
         TestEntry::Example {
             name,
             input,
             output,
+            header_delim_len,
+            divider_delim_len,
             has_fields,
         } => {
             if let Some(filter) = filter {
@@ -191,7 +195,13 @@ fn run_tests(
                     if update {
                         let input = String::from_utf8(input).unwrap();
                         let output = format_sexp(&output);
-                        corrected_entries.push((name, input, output));
+                        corrected_entries.push((
+                            name,
+                            input,
+                            output,
+                            header_delim_len,
+                            divider_delim_len,
+                        ));
                     }
                     return Ok(());
                 }
@@ -201,21 +211,31 @@ fn run_tests(
             if !has_fields {
                 actual = strip_sexp_fields(actual);
             }
-            for _ in 0..indent_level {
-                print!("  ");
-            }
+            print!("{}", "  ".repeat(indent_level as usize));
             if actual == output {
                 println!("✓ {}", Colour::Green.paint(&name));
                 if update {
                     let input = String::from_utf8(input).unwrap();
                     let output = format_sexp(&output);
-                    corrected_entries.push((name, input, output));
+                    corrected_entries.push((
+                        name,
+                        input,
+                        output,
+                        header_delim_len,
+                        divider_delim_len,
+                    ));
                 }
             } else {
                 if update {
                     let input = String::from_utf8(input).unwrap();
                     let output = format_sexp(&actual);
-                    corrected_entries.push((name.clone(), input, output));
+                    corrected_entries.push((
+                        name.clone(),
+                        input,
+                        output,
+                        header_delim_len,
+                        divider_delim_len,
+                    ));
                     println!("✓ {}", Colour::Blue.paint(&name));
                 } else {
                     println!("✗ {}", Colour::Red.paint(&name));
@@ -229,9 +249,7 @@ fn run_tests(
             file_path,
         } => {
             if indent_level > 0 {
-                for _ in 0..indent_level {
-                    print!("  ");
-                }
+                print!("{}", "  ".repeat(indent_level as usize));
                 println!("{}:", name);
             }
 
@@ -312,27 +330,32 @@ fn format_sexp_indented(sexp: &String, initial_indent_level: u32) -> String {
     formatted
 }
 
-fn write_tests(file_path: &Path, corrected_entries: &Vec<(String, String, String)>) -> Result<()> {
+fn write_tests(
+    file_path: &Path,
+    corrected_entries: &Vec<(String, String, String, usize, usize)>,
+) -> Result<()> {
     let mut buffer = fs::File::create(file_path)?;
     write_tests_to_buffer(&mut buffer, corrected_entries)
 }
 
 fn write_tests_to_buffer(
     buffer: &mut impl Write,
-    corrected_entries: &Vec<(String, String, String)>,
+    corrected_entries: &Vec<(String, String, String, usize, usize)>,
 ) -> Result<()> {
-    for (i, (name, input, output)) in corrected_entries.iter().enumerate() {
+    for (i, (name, input, output, header_delim_len, divider_delim_len)) in
+        corrected_entries.iter().enumerate()
+    {
         if i > 0 {
             write!(buffer, "\n")?;
         }
         write!(
             buffer,
             "{}\n{}\n{}\n{}\n{}\n\n{}\n",
-            "=".repeat(80),
+            "=".repeat(*header_delim_len),
             name,
-            "=".repeat(80),
+            "=".repeat(*header_delim_len),
             input,
-            "-".repeat(80),
+            "-".repeat(*divider_delim_len),
             output.trim()
         )?;
     }
@@ -351,9 +374,18 @@ pub fn parse_tests(path: &Path) -> io::Result<TestEntry> {
             let entry = entry?;
             let hidden = entry.file_name().to_str().unwrap_or("").starts_with(".");
             if !hidden {
-                children.push(parse_tests(&entry.path())?);
+                children.push(entry.path());
             }
         }
+        children.sort_by(|a, b| {
+            a.file_name()
+                .unwrap_or_default()
+                .cmp(&b.file_name().unwrap_or_default())
+        });
+        let children = children
+            .iter()
+            .map(|path| parse_tests(path))
+            .collect::<io::Result<Vec<TestEntry>>>()?;
         Ok(TestEntry::Group {
             name,
             children,
@@ -387,6 +419,7 @@ fn parse_test_content(name: String, content: String, file_path: Option<PathBuf>)
     // Ignore any matches whose suffix does not match the first header
     // suffix in the file.
     let header_matches = HEADER_REGEX.captures_iter(&bytes).filter_map(|c| {
+        let header_delim_len = c.name("equals").map(|n| n.as_bytes().len()).unwrap_or(80);
         let suffix1 = c
             .name("suffix1")
             .map(|m| String::from_utf8_lossy(m.as_bytes()));
@@ -398,13 +431,17 @@ fn parse_test_content(name: String, content: String, file_path: Option<PathBuf>)
             let test_name = c
                 .name("test_name")
                 .map(|c| String::from_utf8_lossy(c.as_bytes()).trim_end().to_string());
-            Some((header_range, test_name))
+            let res = Some((header_delim_len, header_range, test_name));
+            res
         } else {
             None
         }
     });
 
-    for (header_range, test_name) in header_matches.chain(Some((bytes.len()..bytes.len(), None))) {
+    let mut prev_header_len = 80;
+    for (header_delim_len, header_range, test_name) in
+        header_matches.chain(Some((80, bytes.len()..bytes.len(), None)))
+    {
         // Find the longest line of dashes following each test description. That line
         // separates the input from the expected output. Ignore any matches whose suffix
         // does not match the first suffix in the file.
@@ -412,19 +449,25 @@ fn parse_test_content(name: String, content: String, file_path: Option<PathBuf>)
             let divider_range = DIVIDER_REGEX
                 .captures_iter(&bytes[prev_header_end..header_range.start])
                 .filter_map(|m| {
+                    let divider_delim_len =
+                        m.name("hyphens").map(|m| m.as_bytes().len()).unwrap_or(80);
                     let suffix = m
                         .name("suffix")
                         .map(|m| String::from_utf8_lossy(m.as_bytes()));
                     if suffix == first_suffix {
                         let range = m.get(0).unwrap().range();
-                        Some((prev_header_end + range.start)..(prev_header_end + range.end))
+                        let res = Some((
+                            divider_delim_len,
+                            (prev_header_end + range.start)..(prev_header_end + range.end),
+                        ));
+                        res
                     } else {
                         None
                     }
                 })
-                .max_by_key(|range| range.len());
+                .max_by_key(|(_, range)| range.len());
 
-            if let Some(divider_range) = divider_range {
+            if let Some((divider_delim_len, divider_range)) = divider_range {
                 if let Ok(output) = str::from_utf8(&bytes[divider_range.end..header_range.start]) {
                     let mut input = bytes[prev_header_end..divider_range.start].to_vec();
 
@@ -449,12 +492,15 @@ fn parse_test_content(name: String, content: String, file_path: Option<PathBuf>)
                         name: prev_name,
                         input,
                         output,
+                        header_delim_len: prev_header_len,
+                        divider_delim_len,
                         has_fields,
                     });
                 }
             }
         }
         prev_name = test_name.unwrap_or(String::new());
+        prev_header_len = header_delim_len;
         prev_header_end = header_range.end;
     }
     TestEntry::Group {
@@ -505,12 +551,16 @@ d
                         name: "The first test".to_string(),
                         input: "\na b c\n".as_bytes().to_vec(),
                         output: "(a (b c))".to_string(),
+                        header_delim_len: 15,
+                        divider_delim_len: 3,
                         has_fields: false,
                     },
                     TestEntry::Example {
                         name: "The second test".to_string(),
                         input: "d".as_bytes().to_vec(),
                         output: "(d)".to_string(),
+                        header_delim_len: 16,
+                        divider_delim_len: 3,
                         has_fields: false,
                     },
                 ],
@@ -559,12 +609,16 @@ abc
                         name: "Code with dashes".to_string(),
                         input: "abc\n---\ndefg\n----\nhijkl".as_bytes().to_vec(),
                         output: "(a (b))".to_string(),
+                        header_delim_len: 18,
+                        divider_delim_len: 7,
                         has_fields: false,
                     },
                     TestEntry::Example {
                         name: "Code ending with dashes".to_string(),
                         input: "abc\n-----------".as_bytes().to_vec(),
                         output: "(c (d))".to_string(),
+                        header_delim_len: 25,
+                        divider_delim_len: 19,
                         has_fields: false,
                     },
                 ],
@@ -608,11 +662,15 @@ abc
                 "title 1".to_string(),
                 "input 1".to_string(),
                 "output 1".to_string(),
+                80,
+                80,
             ),
             (
                 "title 2".to_string(),
                 "input 2".to_string(),
                 "output 2".to_string(),
+                80,
+                80,
             ),
         ];
         write_tests_to_buffer(&mut buffer, &corrected_entries).unwrap();
@@ -689,18 +747,24 @@ code
                         name: "sexp with comment".to_string(),
                         input: "code".as_bytes().to_vec(),
                         output: "(a (b))".to_string(),
+                        header_delim_len: 18,
+                        divider_delim_len: 3,
                         has_fields: false,
                     },
                     TestEntry::Example {
                         name: "sexp with comment between".to_string(),
                         input: "code".as_bytes().to_vec(),
                         output: "(a (b))".to_string(),
+                        header_delim_len: 18,
+                        divider_delim_len: 3,
                         has_fields: false,
                     },
                     TestEntry::Example {
                         name: "sexp with ';'".to_string(),
                         input: "code".as_bytes().to_vec(),
                         output: "(MISSING \";\")".to_string(),
+                        header_delim_len: 25,
+                        divider_delim_len: 3,
                         has_fields: false,
                     }
                 ],
@@ -773,18 +837,24 @@ NOT A TEST HEADER
                         name: "First test".to_string(),
                         input: expected_input.clone(),
                         output: "(a)".to_string(),
+                        header_delim_len: 18,
+                        divider_delim_len: 3,
                         has_fields: false,
                     },
                     TestEntry::Example {
                         name: "Second test".to_string(),
                         input: expected_input.clone(),
                         output: "(a)".to_string(),
+                        header_delim_len: 18,
+                        divider_delim_len: 3,
                         has_fields: false,
                     },
                     TestEntry::Example {
                         name: "Test name with = symbol".to_string(),
                         input: expected_input.clone(),
                         output: "(a)".to_string(),
+                        header_delim_len: 25,
+                        divider_delim_len: 3,
                         has_fields: false,
                     }
                 ],
@@ -828,12 +898,16 @@ code with ----
                         name: "name\nwith\nnewlines".to_string(),
                         input: b"a".to_vec(),
                         output: "(b)".to_string(),
+                        header_delim_len: 15,
+                        divider_delim_len: 3,
                         has_fields: false,
                     },
                     TestEntry::Example {
                         name: "name with === signs".to_string(),
                         input: b"code with ----".to_vec(),
                         output: "(d)".to_string(),
+                        header_delim_len: 20,
+                        divider_delim_len: 3,
                         has_fields: false,
                     }
                 ]
diff --git a/cli/src/test_highlight.rs b/cli/src/test_highlight.rs
index 5411fcb1..7e1a2927 100644
--- a/cli/src/test_highlight.rs
+++ b/cli/src/test_highlight.rs
@@ -42,41 +42,74 @@ pub fn test_highlights(
     loader: &Loader,
     highlighter: &mut Highlighter,
     directory: &Path,
+    apply_all_captures: bool,
+) -> Result<()> {
+    println!("syntax highlighting:");
+    test_highlights_indented(loader, highlighter, directory, apply_all_captures, 2)
+}
+
+fn test_highlights_indented(
+    loader: &Loader,
+    highlighter: &mut Highlighter,
+    directory: &Path,
+    apply_all_captures: bool,
+    indent_level: usize,
 ) -> Result<()> {
     let mut failed = false;
 
-    println!("syntax highlighting:");
     for highlight_test_file in fs::read_dir(directory)? {
         let highlight_test_file = highlight_test_file?;
         let test_file_path = highlight_test_file.path();
         let test_file_name = highlight_test_file.file_name();
-        let (language, language_config) = loader
-            .language_configuration_for_file_name(&test_file_path)?
-            .ok_or_else(|| anyhow!("No language found for path {:?}", test_file_path))?;
-        let highlight_config = language_config
-            .highlight_config(language)?
-            .ok_or_else(|| anyhow!("No highlighting config found for {:?}", test_file_path))?;
-        match test_highlight(
-            &loader,
-            highlighter,
-            highlight_config,
-            fs::read(&test_file_path)?.as_slice(),
-        ) {
-            Ok(assertion_count) => {
-                println!(
-                    "  ✓ {} ({} assertions)",
-                    Colour::Green.paint(test_file_name.to_string_lossy().as_ref()),
-                    assertion_count
-                );
-            }
-            Err(e) => {
-                println!(
-                    "  ✗ {}",
-                    Colour::Red.paint(test_file_name.to_string_lossy().as_ref())
-                );
-                println!("    {}", e);
+        print!(
+            "{indent:indent_level$}",
+            indent = "",
+            indent_level = indent_level * 2
+        );
+        if test_file_path.is_dir() && !test_file_path.read_dir()?.next().is_none() {
+            println!("{}:", test_file_name.into_string().unwrap());
+            if let Err(_) = test_highlights_indented(
+                loader,
+                highlighter,
+                &test_file_path,
+                apply_all_captures,
+                indent_level + 1,
+            ) {
                 failed = true;
             }
+        } else {
+            let (language, language_config) = loader
+                .language_configuration_for_file_name(&test_file_path)?
+                .ok_or_else(|| anyhow!("No language found for path {:?}", test_file_path))?;
+            let highlight_config = language_config
+                .highlight_config(language, apply_all_captures, None)?
+                .ok_or_else(|| anyhow!("No highlighting config found for {:?}", test_file_path))?;
+            match test_highlight(
+                &loader,
+                highlighter,
+                highlight_config,
+                fs::read(&test_file_path)?.as_slice(),
+            ) {
+                Ok(assertion_count) => {
+                    println!(
+                        "✓ {} ({} assertions)",
+                        Colour::Green.paint(test_file_name.to_string_lossy().as_ref()),
+                        assertion_count
+                    );
+                }
+                Err(e) => {
+                    println!(
+                        "✗ {}",
+                        Colour::Red.paint(test_file_name.to_string_lossy().as_ref())
+                    );
+                    println!(
+                        "{indent:indent_level$}  {e}",
+                        indent = "",
+                        indent_level = indent_level * 2
+                    );
+                    failed = true;
+                }
+            }
         }
     }
 
@@ -94,9 +127,10 @@ pub fn iterate_assertions(
     // Iterate through all of the highlighting assertions, checking each one against the
     // actual highlights.
     let mut i = 0;
-    let mut actual_highlights = Vec::<&String>::new();
+    let mut actual_highlights = Vec::new();
     for Assertion {
         position,
+        negative,
         expected_capture_name: expected_highlight,
     } in assertions
     {
@@ -120,12 +154,13 @@ pub fn iterate_assertions(
                         break 'highlight_loop;
                     }
 
-                    // If the highlight matches the assertion, this test passes. Otherwise,
+                    // If the highlight matches the assertion, or if the highlight doesn't
+                    // match the assertion but it's negative, this test passes. Otherwise,
                     // add this highlight to the list of actual highlights that span the
                     // assertion's position, in order to generate an error message in the event
                     // of a failure.
                     let highlight_name = &highlight_names[(highlight.2).0];
-                    if *highlight_name == *expected_highlight {
+                    if (*highlight_name == *expected_highlight) == !negative {
                         passed = true;
                         break 'highlight_loop;
                     } else {
@@ -165,68 +200,7 @@ pub fn test_highlight(
     let assertions =
         parse_position_comments(highlighter.parser(), highlight_config.language, source)?;
 
-    iterate_assertions(&assertions, &highlights, &highlight_names)?;
-
-    // Iterate through all of the highlighting assertions, checking each one against the
-    // actual highlights.
-    let mut i = 0;
-    let mut actual_highlights = Vec::<&String>::new();
-    for Assertion {
-        position,
-        expected_capture_name: expected_highlight,
-    } in &assertions
-    {
-        let mut passed = false;
-        actual_highlights.clear();
-
-        'highlight_loop: loop {
-            // The assertions are ordered by position, so skip past all of the highlights that
-            // end at or before this assertion's position.
-            if let Some(highlight) = highlights.get(i) {
-                if highlight.1 <= *position {
-                    i += 1;
-                    continue;
-                }
-
-                // Iterate through all of the highlights that start at or before this assertion's,
-                // position, looking for one that matches the assertion.
-                let mut j = i;
-                while let (false, Some(highlight)) = (passed, highlights.get(j)) {
-                    if highlight.0 > *position {
-                        break 'highlight_loop;
-                    }
-
-                    // If the highlight matches the assertion, this test passes. Otherwise,
-                    // add this highlight to the list of actual highlights that span the
-                    // assertion's position, in order to generate an error message in the event
-                    // of a failure.
-                    let highlight_name = &highlight_names[(highlight.2).0];
-                    if *highlight_name == *expected_highlight {
-                        passed = true;
-                        break 'highlight_loop;
-                    } else {
-                        actual_highlights.push(highlight_name);
-                    }
-
-                    j += 1;
-                }
-            } else {
-                break;
-            }
-        }
-
-        if !passed {
-            return Err(Failure {
-                row: position.row,
-                column: position.column,
-                expected_highlight: expected_highlight.clone(),
-                actual_highlights: actual_highlights.into_iter().cloned().collect(),
-            }
-            .into());
-        }
-    }
-
-    Ok(assertions.len())
+    iterate_assertions(&assertions, &highlights, &highlight_names)
 }
 
 pub fn get_highlight_positions(
@@ -244,7 +218,7 @@ pub fn get_highlight_positions(
     let source = String::from_utf8_lossy(source);
     let mut char_indices = source.char_indices();
     for event in highlighter.highlight(highlight_config, source.as_bytes(), None, |string| {
-        loader.highlight_config_for_injection_string(string)
+        loader.highlight_config_for_injection_string(string, highlight_config.apply_all_captures)
     })? {
         match event? {
             HighlightEvent::HighlightStart(h) => highlight_stack.push(h),
diff --git a/cli/src/test_tags.rs b/cli/src/test_tags.rs
index 28694db9..0bf13fe2 100644
--- a/cli/src/test_tags.rs
+++ b/cli/src/test_tags.rs
@@ -95,6 +95,7 @@ pub fn test_tag(
     let mut actual_tags = Vec::<&String>::new();
     for Assertion {
         position,
+        negative,
         expected_capture_name: expected_tag,
     } in &assertions
     {
@@ -116,7 +117,7 @@ pub fn test_tag(
                     }
 
                     let tag_name = &tag.2;
-                    if *tag_name == *expected_tag {
+                    if (*tag_name == *expected_tag) == !negative {
                         passed = true;
                         break 'tag_loop;
                     } else {
@@ -124,6 +125,9 @@ pub fn test_tag(
                     }
 
                     j += 1;
+                    if tag == tags.last().unwrap() {
+                        break 'tag_loop;
+                    }
                 }
             } else {
                 break;
diff --git a/cli/src/tests/async_context_test.rs b/cli/src/tests/async_context_test.rs
new file mode 100644
index 00000000..08226387
--- /dev/null
+++ b/cli/src/tests/async_context_test.rs
@@ -0,0 +1,279 @@
+use super::helpers::fixtures::get_language;
+use std::future::Future;
+use std::pin::{pin, Pin};
+use std::ptr;
+use std::task::{self, Context, Poll, RawWaker, RawWakerVTable, Waker};
+use tree_sitter::Parser;
+
+#[test]
+fn test_node_in_fut() {
+    let (ret, pended) = tokio_like_spawn(async {
+        let mut parser = Parser::new();
+        let language = get_language("bash");
+        parser.set_language(language).unwrap();
+
+        let tree = parser.parse("#", None).unwrap();
+
+        let root = tree.root_node();
+        let root_ref = &root;
+
+        let fut_val_fn = || async {
+            // eprintln!("fut_val_fn: {}", root.child(0).unwrap().kind());
+            yield_now().await;
+            root.child(0).unwrap().kind()
+        };
+
+        yield_now().await;
+
+        let fut_ref_fn = || async {
+            // eprintln!("fut_ref_fn: {}", root_ref.child(0).unwrap().kind());
+            yield_now().await;
+            root_ref.child(0).unwrap().kind()
+        };
+
+        let f1 = fut_val_fn().await;
+        let f2 = fut_ref_fn().await;
+        assert_eq!(f1, f2);
+
+        let fut_val = async {
+            // eprintln!("fut_val: {}", root.child(0).unwrap().kind());
+            yield_now().await;
+            root.child(0).unwrap().kind()
+        };
+
+        let fut_ref = async {
+            // eprintln!("fut_ref: {}", root_ref.child(0).unwrap().kind());
+            yield_now().await;
+            root_ref.child(0).unwrap().kind()
+        };
+
+        let f1 = fut_val.await;
+        let f2 = fut_ref.await;
+        assert_eq!(f1, f2);
+
+        f1
+    })
+    .join();
+    // eprintln!("pended: {pended:?}");
+    assert_eq!(ret, "comment");
+    assert_eq!(pended, 5);
+}
+
+#[test]
+fn test_node_and_cursor_ref_in_fut() {
+    let (_, pended) = tokio_like_spawn(async {
+        let mut parser = Parser::new();
+        let language = get_language("bash");
+        parser.set_language(language).unwrap();
+
+        let tree = parser.parse("#", None).unwrap();
+
+        let root = tree.root_node();
+        let root_ref = &root;
+
+        let mut cursor = tree.walk();
+        let cursor_ref = &mut cursor;
+
+        cursor_ref.goto_first_child();
+
+        let fut_val = async {
+            yield_now().await;
+            root.to_sexp();
+        };
+
+        yield_now().await;
+
+        let fut_ref = async {
+            yield_now().await;
+            root_ref.to_sexp();
+            cursor_ref.goto_first_child();
+        };
+
+        fut_val.await;
+        fut_ref.await;
+
+        cursor_ref.goto_first_child();
+    })
+    .join();
+    assert_eq!(pended, 3);
+}
+
+#[test]
+fn test_node_and_cursor_ref_in_fut_with_fut_fabrics() {
+    let (_, pended) = tokio_like_spawn(async {
+        let mut parser = Parser::new();
+        let language = get_language("bash");
+        parser.set_language(language).unwrap();
+
+        let tree = parser.parse("#", None).unwrap();
+
+        let root = tree.root_node();
+        let root_ref = &root;
+
+        let mut cursor = tree.walk();
+        let cursor_ref = &mut cursor;
+
+        cursor_ref.goto_first_child();
+
+        let fut_val = || async {
+            yield_now().await;
+            root.to_sexp();
+        };
+
+        yield_now().await;
+
+        let fut_ref = || async move {
+            yield_now().await;
+            root_ref.to_sexp();
+            cursor_ref.goto_first_child();
+        };
+
+        fut_val().await;
+        fut_val().await;
+        fut_ref().await;
+    })
+    .join();
+    assert_eq!(pended, 4);
+}
+
+#[test]
+fn test_node_and_cursor_ref_in_fut_with_inner_spawns() {
+    let (ret, pended) = tokio_like_spawn(async {
+        let mut parser = Parser::new();
+        let language = get_language("bash");
+        parser.set_language(language).unwrap();
+
+        let tree = parser.parse("#", None).unwrap();
+
+        let mut cursor = tree.walk();
+        let cursor_ref = &mut cursor;
+
+        cursor_ref.goto_first_child();
+
+        let fut_val = || {
+            let tree = tree.clone();
+            async move {
+                let root = tree.root_node();
+                let mut cursor = tree.walk();
+                let cursor_ref = &mut cursor;
+                yield_now().await;
+                root.to_sexp();
+                cursor_ref.goto_first_child();
+            }
+        };
+
+        yield_now().await;
+
+        let fut_ref = || {
+            let tree = tree.clone();
+            async move {
+                let root = tree.root_node();
+                let root_ref = &root;
+                let mut cursor = tree.walk();
+                let cursor_ref = &mut cursor;
+                yield_now().await;
+                root_ref.to_sexp();
+                cursor_ref.goto_first_child();
+            }
+        };
+
+        let (_, p1) = tokio_like_spawn(fut_val()).await.unwrap();
+        let (_, p2) = tokio_like_spawn(fut_ref()).await.unwrap();
+
+        cursor_ref.goto_first_child();
+
+        fut_val().await;
+        fut_val().await;
+        fut_ref().await;
+
+        cursor_ref.goto_first_child();
+
+        p1 + p2
+    })
+    .join();
+    assert_eq!(pended, 4);
+    assert_eq!(ret, 2);
+}
+
+fn tokio_like_spawn<T>(future: T) -> JoinHandle<(T::Output, usize)>
+where
+    T: Future + Send + 'static,
+    T::Output: Send + 'static,
+{
+    // No runtime, just noop waker
+
+    let waker = noop_waker();
+    let mut cx = task::Context::from_waker(&waker);
+
+    let mut pending = 0;
+    let mut future = pin!(future);
+    let ret = loop {
+        match future.as_mut().poll(&mut cx) {
+            Poll::Pending => pending += 1,
+            Poll::Ready(r) => {
+                // eprintln!("ready, pended: {pending}");
+                break r;
+            }
+        }
+    };
+    JoinHandle::new((ret, pending))
+}
+
+async fn yield_now() {
+    struct SimpleYieldNow {
+        yielded: bool,
+    }
+
+    impl Future for SimpleYieldNow {
+        type Output = ();
+
+        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
+            cx.waker().clone().wake();
+            if self.yielded {
+                return Poll::Ready(());
+            }
+            self.yielded = true;
+            Poll::Pending
+        }
+    }
+
+    SimpleYieldNow { yielded: false }.await
+}
+
+pub fn noop_waker() -> Waker {
+    const VTABLE: RawWakerVTable = RawWakerVTable::new(
+        // Cloning just returns a new no-op raw waker
+        |_| RAW,
+        // `wake` does nothing
+        |_| {},
+        // `wake_by_ref` does nothing
+        |_| {},
+        // Dropping does nothing as we don't allocate anything
+        |_| {},
+    );
+    const RAW: RawWaker = RawWaker::new(ptr::null(), &VTABLE);
+    unsafe { Waker::from_raw(RAW) }
+}
+
+struct JoinHandle<T> {
+    data: Option<T>,
+}
+
+impl<T> JoinHandle<T> {
+    fn new(data: T) -> Self {
+        Self { data: Some(data) }
+    }
+
+    fn join(&mut self) -> T {
+        self.data.take().unwrap()
+    }
+}
+
+impl<T: Unpin> Future for JoinHandle<T> {
+    type Output = std::result::Result<T, ()>;
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let data = self.get_mut().data.take().unwrap();
+        Poll::Ready(Ok(data))
+    }
+}
diff --git a/cli/src/tests/corpus_test.rs b/cli/src/tests/corpus_test.rs
index 401a99a5..589b1839 100644
--- a/cli/src/tests/corpus_test.rs
+++ b/cli/src/tests/corpus_test.rs
@@ -1,7 +1,8 @@
 use super::helpers::{
     allocations,
     edits::{get_random_edit, invert_edit},
-    fixtures::{fixtures_dir, get_language, get_test_language},
+    fixtures::{fixtures_dir, get_language, get_test_language, SCRATCH_BASE_DIR},
+    new_seed,
     random::Rand,
     scope_sequence::ScopeSequence,
     EDIT_COUNT, EXAMPLE_FILTER, ITERATION_COUNT, LANGUAGE_FILTER, LOG_ENABLED, LOG_GRAPH_ENABLED,
@@ -13,70 +14,81 @@ use crate::{
     test::{parse_tests, print_diff, print_diff_key, strip_sexp_fields, TestEntry},
     util,
 };
-use std::fs;
+use std::{collections::HashMap, env, fs};
 use tree_sitter::{LogType, Node, Parser, Point, Range, Tree};
+use tree_sitter_proc_macro::test_with_seed;
 
-#[test]
-fn test_bash_corpus() {
-    test_language_corpus("bash");
+#[test_with_seed(retry=10, seed=*START_SEED, seed_fn=new_seed)]
+fn test_corpus_for_bash(seed: usize) {
+    test_language_corpus(
+        "bash",
+        seed,
+        Some(&[
+            // Fragile tests where edit customization changes
+            // lead to significant parse tree structure changes.
+            "bash - corpus - commands - Nested Heredocs",
+            "bash - corpus - commands - Quoted Heredocs",
+            "bash - corpus - commands - Heredocs with weird characters",
+        ]),
+    );
 }
 
-#[test]
-fn test_c_corpus() {
-    test_language_corpus("c");
+#[test_with_seed(retry=10, seed=*START_SEED, seed_fn=new_seed)]
+fn test_corpus_for_c(seed: usize) {
+    test_language_corpus("c", seed, None);
 }
 
-#[test]
-fn test_cpp_corpus() {
-    test_language_corpus("cpp");
+#[test_with_seed(retry=10, seed=*START_SEED, seed_fn=new_seed)]
+fn test_corpus_for_cpp(seed: usize) {
+    test_language_corpus("cpp", seed, None);
 }
 
-#[test]
-fn test_embedded_template_corpus() {
-    test_language_corpus("embedded-template");
+#[test_with_seed(retry=10, seed=*START_SEED, seed_fn=new_seed)]
+fn test_corpus_for_embedded_template(seed: usize) {
+    test_language_corpus("embedded-template", seed, None);
 }
 
-#[test]
-fn test_go_corpus() {
-    test_language_corpus("go");
+#[test_with_seed(retry=10, seed=*START_SEED, seed_fn=new_seed)]
+fn test_corpus_for_go(seed: usize) {
+    test_language_corpus("go", seed, None);
 }
 
-#[test]
-fn test_html_corpus() {
-    test_language_corpus("html");
+#[test_with_seed(retry=10, seed=*START_SEED, seed_fn=new_seed)]
+fn test_corpus_for_html(seed: usize) {
+    test_language_corpus("html", seed, None);
 }
 
-#[test]
-fn test_javascript_corpus() {
-    test_language_corpus("javascript");
+#[test_with_seed(retry=10, seed=*START_SEED, seed_fn=new_seed)]
+fn test_corpus_for_javascript(seed: usize) {
+    test_language_corpus("javascript", seed, None);
 }
 
-#[test]
-fn test_json_corpus() {
-    test_language_corpus("json");
+#[test_with_seed(retry=10, seed=*START_SEED, seed_fn=new_seed)]
+fn test_corpus_for_json(seed: usize) {
+    test_language_corpus("json", seed, None);
 }
 
-#[test]
-fn test_php_corpus() {
-    test_language_corpus("php");
+#[test_with_seed(retry=10, seed=*START_SEED, seed_fn=new_seed)]
+fn test_corpus_for_php(seed: usize) {
+    test_language_corpus("php", seed, None);
 }
 
-#[test]
-fn test_python_corpus() {
-    test_language_corpus("python");
+#[test_with_seed(retry=10, seed=*START_SEED, seed_fn=new_seed)]
+fn test_corpus_for_python(seed: usize) {
+    test_language_corpus("python", seed, None);
 }
 
-#[test]
-fn test_ruby_corpus() {
-    test_language_corpus("ruby");
+#[test_with_seed(retry=10, seed=*START_SEED, seed_fn=new_seed)]
+fn test_corpus_for_ruby(seed: usize) {
+    test_language_corpus("ruby", seed, None);
 }
 
-#[test]
-fn test_rust_corpus() {
-    test_language_corpus("rust");
+#[test_with_seed(retry=10, seed=*START_SEED, seed_fn=new_seed)]
+fn test_corpus_for_rust(seed: usize) {
+    test_language_corpus("rust", seed, None);
 }
 
-fn test_language_corpus(language_name: &str) {
+fn test_language_corpus(language_name: &str, start_seed: usize, skipped: Option<&[&str]>) {
     let grammars_dir = fixtures_dir().join("grammars");
     let error_corpus_dir = fixtures_dir().join("error_corpus");
     let template_corpus_dir = fixtures_dir().join("template_corpus");
@@ -98,10 +110,30 @@ fn test_language_corpus(language_name: &str) {
         t
     }));
 
+    let mut skipped = skipped.map(|x| HashMap::<&str, usize>::from_iter(x.iter().map(|x| (*x, 0))));
+
     let language = get_language(language_name);
     let mut failure_count = 0;
-    for test in tests {
-        println!("  {} example - {}", language_name, test.name);
+
+    let log_seed = env::var("TREE_SITTER_LOG_SEED").is_ok();
+    let dump_edits = env::var("TREE_SITTER_DUMP_EDITS").is_ok();
+
+    if log_seed {
+        println!("  start seed: {}", start_seed);
+    }
+
+    println!();
+    for (test_index, test) in tests.iter().enumerate() {
+        let test_name = format!("{language_name} - {}", test.name);
+        if let Some(skipped) = skipped.as_mut() {
+            if let Some(counter) = skipped.get_mut(test_name.as_str()) {
+                println!("  {test_index}. {test_name} - SKIPPED");
+                *counter += 1;
+                continue;
+            }
+        }
+
+        println!("  {test_index}. {test_name}");
 
         let passed = allocations::record(|| {
             let mut log_session = None;
@@ -116,10 +148,7 @@ fn test_language_corpus(language_name: &str) {
             }
 
             if actual_output != test.output {
-                println!(
-                    "Incorrect initial parse for {} - {}",
-                    language_name, test.name,
-                );
+                println!("Incorrect initial parse for {test_name}");
                 print_diff_key();
                 print_diff(&actual_output, &test.output);
                 println!("");
@@ -140,7 +169,7 @@ fn test_language_corpus(language_name: &str) {
         drop(parser);
 
         for trial in 0..*ITERATION_COUNT {
-            let seed = *START_SEED + trial;
+            let seed = start_seed + trial;
             let passed = allocations::record(|| {
                 let mut rand = Rand::new(seed);
                 let mut log_session = None;
@@ -158,10 +187,21 @@ fn test_language_corpus(language_name: &str) {
                 for _ in 0..1 + rand.unsigned(*EDIT_COUNT) {
                     let edit = get_random_edit(&mut rand, &input);
                     undo_stack.push(invert_edit(&input, &edit));
-                    perform_edit(&mut tree, &mut input, &edit);
+                    perform_edit(&mut tree, &mut input, &edit).unwrap();
                 }
 
-                // println!("    seed: {}", seed);
+                if log_seed {
+                    println!("   {test_index}.{trial:<2} seed: {}", seed);
+                }
+
+                if dump_edits {
+                    fs::write(
+                        SCRATCH_BASE_DIR
+                            .join(format!("edit.{seed}.{test_index}.{trial} {test_name}")),
+                        &input,
+                    )
+                    .unwrap();
+                }
 
                 if *LOG_GRAPH_ENABLED {
                     eprintln!("{}\n", String::from_utf8_lossy(&input));
@@ -173,16 +213,13 @@ fn test_language_corpus(language_name: &str) {
                 // Check that the new tree is consistent.
                 check_consistent_sizes(&tree2, &input);
                 if let Err(message) = check_changed_ranges(&tree, &tree2, &input) {
-                    println!(
-                        "\nUnexpected scope change in seed {}\n{}\n\n",
-                        seed, message
-                    );
+                    println!("\nUnexpected scope change in seed {seed} with start seed {start_seed}\n{message}\n\n",);
                     return false;
                 }
 
                 // Undo all of the edits and re-parse again.
                 while let Some(edit) = undo_stack.pop() {
-                    perform_edit(&mut tree2, &mut input, &edit);
+                    perform_edit(&mut tree2, &mut input, &edit).unwrap();
                 }
                 if *LOG_GRAPH_ENABLED {
                     eprintln!("{}\n", String::from_utf8_lossy(&input));
@@ -198,10 +235,7 @@ fn test_language_corpus(language_name: &str) {
                 }
 
                 if actual_output != test.output {
-                    println!(
-                        "Incorrect parse for {} - {} - seed {}",
-                        language_name, test.name, seed
-                    );
+                    println!("Incorrect parse for {test_name} - seed {seed}");
                     print_diff_key();
                     print_diff(&actual_output, &test.output);
                     println!("");
@@ -211,7 +245,7 @@ fn test_language_corpus(language_name: &str) {
                 // Check that the edited tree is consistent.
                 check_consistent_sizes(&tree3, &input);
                 if let Err(message) = check_changed_ranges(&tree2, &tree3, &input) {
-                    eprintln!("Unexpected scope change in seed {}\n{}\n\n", seed, message);
+                    println!("Unexpected scope change in seed {seed} with start seed {start_seed}\n{message}\n\n");
                     return false;
                 }
 
@@ -228,6 +262,18 @@ fn test_language_corpus(language_name: &str) {
     if failure_count > 0 {
         panic!("{} {} corpus tests failed", failure_count, language_name);
     }
+
+    if let Some(skipped) = skipped.as_mut() {
+        skipped.retain(|_, v| *v == 0);
+
+        if skipped.len() > 0 {
+            println!("Non matchable skip definitions:");
+            for k in skipped.keys() {
+                println!("  {k}");
+            }
+            panic!("Non matchable skip definitions needs to be removed");
+        }
+    }
 }
 
 #[test]
@@ -255,7 +301,7 @@ fn test_feature_corpus_files() {
             grammar_path = test_path.join("grammar.json");
         }
         let error_message_path = test_path.join("expected_error.txt");
-        let grammar_json = generate::load_grammar_file(&grammar_path).unwrap();
+        let grammar_json = generate::load_grammar_file(&grammar_path, None).unwrap();
         let generate_result = generate::generate_parser_for_grammar(&grammar_json);
 
         if error_message_path.exists() {
@@ -424,7 +470,12 @@ fn set_included_ranges(parser: &mut Parser, input: &[u8], delimiters: Option<(&s
         let mut ranges = Vec::new();
         let mut ix = 0;
         while ix < input.len() {
-            let Some(mut start_ix) = input[ix..].windows(2).position(|win| win == start.as_bytes()) else { break };
+            let Some(mut start_ix) = input[ix..]
+                .windows(2)
+                .position(|win| win == start.as_bytes())
+            else {
+                break;
+            };
             start_ix += ix + start.len();
             let end_ix = input[start_ix..]
                 .windows(2)
@@ -492,6 +543,7 @@ fn flatten_tests(test: TestEntry) -> Vec<FlattenedTest> {
                 input,
                 output,
                 has_fields,
+                ..
             } => {
                 if !prefix.is_empty() {
                     name.insert_str(0, " - ");
diff --git a/cli/src/tests/github_issue_test.rs b/cli/src/tests/github_issue_test.rs
new file mode 100644
index 00000000..bfc135ca
--- /dev/null
+++ b/cli/src/tests/github_issue_test.rs
@@ -0,0 +1,42 @@
+// Tests in this mod need be executed with enabled UBSAN library:
+// ```
+// UBSAN_OPTIONS="halt_on_error=1" \
+// CFLAGS="-fsanitize=undefined"   \
+// RUSTFLAGS="-lubsan"             \
+// cargo test --target $(rustc -vV | sed -nr 's/^host: //p') -- --test-threads 1
+// ```
+
+use super::helpers::query_helpers::assert_query_matches;
+use crate::tests::helpers::fixtures::get_language;
+use indoc::indoc;
+use tree_sitter::Query;
+
+#[test]
+fn issue_2162_out_of_bound() {
+    let language = get_language("java");
+    assert!(Query::new(language, "(package_declaration _ (_) @name _)").is_ok());
+}
+
+#[test]
+fn issue_2107_first_child_group_anchor_had_no_effect() {
+    let language = get_language("c");
+    let source_code = indoc! {r#"
+        void fun(int a, char b, int c) { };
+    "#};
+    let query = indoc! {r#"
+        (parameter_list
+            .
+            (
+                (parameter_declaration) @constant
+                (#match? @constant "^int")
+            )
+        )
+    "#};
+    let query = Query::new(language, query).unwrap();
+    assert_query_matches(
+        language,
+        &query,
+        source_code,
+        &[(0, vec![("constant", "int a")])],
+    );
+}
diff --git a/cli/src/tests/helpers/allocations.rs b/cli/src/tests/helpers/allocations.rs
index 9a514014..43537633 100644
--- a/cli/src/tests/helpers/allocations.rs
+++ b/cli/src/tests/helpers/allocations.rs
@@ -2,7 +2,7 @@ use std::{
     collections::HashMap,
     os::raw::c_void,
     sync::{
-        atomic::{AtomicBool, AtomicU64, Ordering::SeqCst},
+        atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst},
         Mutex,
     },
 };
@@ -25,8 +25,8 @@ unsafe impl Sync for Allocation {}
 #[derive(Default)]
 struct AllocationRecorder {
     enabled: AtomicBool,
-    allocation_count: AtomicU64,
-    outstanding_allocations: Mutex<HashMap<Allocation, u64>>,
+    allocation_count: AtomicUsize,
+    outstanding_allocations: Mutex<HashMap<Allocation, usize>>,
 }
 
 thread_local! {
@@ -83,6 +83,9 @@ fn record_alloc(ptr: *mut c_void) {
 }
 
 fn record_dealloc(ptr: *mut c_void) {
+    if ptr.is_null() {
+        panic!("Zero pointer deallocation!");
+    }
     RECORDER.with(|recorder| {
         if recorder.enabled.load(SeqCst) {
             recorder
@@ -107,9 +110,13 @@ unsafe extern "C" fn ts_record_calloc(count: usize, size: usize) -> *mut c_void
 }
 
 unsafe extern "C" fn ts_record_realloc(ptr: *mut c_void, size: usize) -> *mut c_void {
-    record_dealloc(ptr);
     let result = realloc(ptr, size);
-    record_alloc(result);
+    if ptr.is_null() {
+        record_alloc(result);
+    } else if ptr != result {
+        record_dealloc(ptr);
+        record_alloc(result);
+    }
     result
 }
 
diff --git a/cli/src/tests/helpers/dirs.rs b/cli/src/tests/helpers/dirs.rs
index 4bf345d8..7ff48ab7 100644
--- a/cli/src/tests/helpers/dirs.rs
+++ b/cli/src/tests/helpers/dirs.rs
@@ -1,11 +1,46 @@
 lazy_static! {
-    static ref ROOT_DIR: PathBuf = PathBuf::from(env!("CARGO_MANIFEST_DIR")).parent().unwrap().to_owned();
-    static ref FIXTURES_DIR: PathBuf = ROOT_DIR.join("test").join("fixtures");
-    static ref HEADER_DIR: PathBuf = ROOT_DIR.join("lib").join("include");
-    static ref GRAMMARS_DIR: PathBuf = ROOT_DIR.join("test").join("fixtures").join("grammars");
-    static ref SCRATCH_DIR: PathBuf = {
+    pub static ref ROOT_DIR: PathBuf = PathBuf::from(env!("CARGO_MANIFEST_DIR")).parent().unwrap().to_owned();
+    pub static ref FIXTURES_DIR: PathBuf = ROOT_DIR.join("test").join("fixtures");
+    pub static ref HEADER_DIR: PathBuf = ROOT_DIR.join("lib").join("include");
+    pub static ref GRAMMARS_DIR: PathBuf = ROOT_DIR.join("test").join("fixtures").join("grammars");
+    pub static ref SCRATCH_BASE_DIR: PathBuf = {
         let result = ROOT_DIR.join("target").join("scratch");
         fs::create_dir_all(&result).unwrap();
         result
     };
+    pub static ref SCRATCH_DIR: PathBuf = {
+        // https://doc.rust-lang.org/reference/conditional-compilation.html
+        let vendor = if cfg!(target_vendor = "apple") {
+            "apple"
+        } else if cfg!(target_vendor = "fortanix") {
+            "fortanix"
+        } else if cfg!(target_vendor = "pc") {
+            "pc"
+        } else {
+            "unknown"
+        };
+        let env = if cfg!(target_env = "gnu") {
+            "gnu"
+        } else if cfg!(target_env = "msvc") {
+            "msvc"
+        } else if cfg!(target_env = "musl") {
+            "musl"
+        } else if cfg!(target_env = "sgx") {
+            "sgx"
+        } else {
+            "unknown"
+        };
+        let endian = if cfg!(target_endian = "little") {
+            "little"
+        } else if cfg!(target_endian = "big") {
+            "big"
+        } else {
+            "unknown"
+        };
+
+        let machine = format!("{}-{}-{}-{}-{}", std::env::consts::ARCH, std::env::consts::OS, vendor, env, endian);
+        let result = SCRATCH_BASE_DIR.join(machine);
+        fs::create_dir_all(&result).unwrap();
+        result
+    };
 }
diff --git a/cli/src/tests/helpers/fixtures.rs b/cli/src/tests/helpers/fixtures.rs
index 672695ac..7cb981ae 100644
--- a/cli/src/tests/helpers/fixtures.rs
+++ b/cli/src/tests/helpers/fixtures.rs
@@ -1,6 +1,6 @@
 use lazy_static::lazy_static;
-use std::fs;
 use std::path::{Path, PathBuf};
+use std::{env, fs};
 use tree_sitter::Language;
 use tree_sitter_highlight::HighlightConfiguration;
 use tree_sitter_loader::Loader;
@@ -9,7 +9,13 @@ use tree_sitter_tags::TagsConfiguration;
 include!("./dirs.rs");
 
 lazy_static! {
-    static ref TEST_LOADER: Loader = Loader::with_parser_lib_path(SCRATCH_DIR.join("lib"));
+    static ref TEST_LOADER: Loader = {
+        let mut loader = Loader::with_parser_lib_path(SCRATCH_DIR.clone());
+        if env::var("TREE_SITTER_GRAMMAR_DEBUG").is_ok() {
+            loader.use_debug_build(true);
+        }
+        loader
+    };
 }
 
 pub fn test_loader<'a>() -> &'a Loader {
@@ -46,9 +52,11 @@ pub fn get_highlight_config(
     let locals_query = fs::read_to_string(queries_path.join("locals.scm")).unwrap_or(String::new());
     let mut result = HighlightConfiguration::new(
         language,
+        language_name,
         &highlights_query,
         &injections_query,
         &locals_query,
+        false,
     )
     .unwrap();
     result.configure(&highlight_names);
@@ -63,11 +71,7 @@ pub fn get_tags_config(language_name: &str) -> TagsConfiguration {
     TagsConfiguration::new(language, &tags_query, &locals_query).unwrap()
 }
 
-pub fn get_test_language(
-    name: &str,
-    parser_code: &str,
-    scanner_src_path: Option<&Path>,
-) -> Language {
+pub fn get_test_language(name: &str, parser_code: &str, path: Option<&Path>) -> Language {
     let src_dir = SCRATCH_DIR.join("src").join(name);
     fs::create_dir_all(&src_dir).unwrap();
 
@@ -76,11 +80,16 @@ pub fn get_test_language(
         fs::write(&parser_path, parser_code).unwrap();
     }
 
-    if let Some(scanner_src_path) = scanner_src_path {
-        let scanner_code = fs::read_to_string(&scanner_src_path).unwrap();
-        let scanner_path = src_dir.join("scanner.c");
-        if !fs::read_to_string(&scanner_path).map_or(false, |content| content == scanner_code) {
-            fs::write(&scanner_path, scanner_code).unwrap();
+    if let Some(path) = path {
+        let scanner_path = path.join("scanner.c");
+        if scanner_path.exists() {
+            let scanner_code = fs::read_to_string(&scanner_path).unwrap();
+            let scanner_copy_path = src_dir.join("scanner.c");
+            if !fs::read_to_string(&scanner_copy_path)
+                .map_or(false, |content| content == scanner_code)
+            {
+                fs::write(&scanner_copy_path, scanner_code).unwrap();
+            }
         }
     }
 
diff --git a/cli/src/tests/helpers/mod.rs b/cli/src/tests/helpers/mod.rs
index def0ea3e..54df8809 100644
--- a/cli/src/tests/helpers/mod.rs
+++ b/cli/src/tests/helpers/mod.rs
@@ -6,7 +6,8 @@ pub(super) mod random;
 pub(super) mod scope_sequence;
 
 use lazy_static::lazy_static;
-use std::{env, time, usize};
+use rand::Rng;
+use std::env;
 
 lazy_static! {
     pub static ref LOG_ENABLED: bool = env::var("TREE_SITTER_LOG").is_ok();
@@ -16,11 +17,7 @@ lazy_static! {
 }
 
 lazy_static! {
-    pub static ref START_SEED: usize =
-        int_env_var("TREE_SITTER_SEED").unwrap_or_else(|| time::SystemTime::now()
-            .duration_since(time::UNIX_EPOCH)
-            .unwrap()
-            .as_secs() as usize,);
+    pub static ref START_SEED: usize = new_seed();
     pub static ref EDIT_COUNT: usize = int_env_var("TREE_SITTER_EDITS").unwrap_or(3);
     pub static ref ITERATION_COUNT: usize = int_env_var("TREE_SITTER_ITERATIONS").unwrap_or(10);
 }
@@ -28,3 +25,10 @@ lazy_static! {
 fn int_env_var(name: &'static str) -> Option<usize> {
     env::var(name).ok().and_then(|e| e.parse().ok())
 }
+
+pub(crate) fn new_seed() -> usize {
+    int_env_var("TREE_SITTER_SEED").unwrap_or_else(|| {
+        let mut rng = rand::thread_rng();
+        rng.gen::<usize>()
+    })
+}
diff --git a/cli/src/tests/helpers/query_helpers.rs b/cli/src/tests/helpers/query_helpers.rs
index 78ae559c..4d71dfd0 100644
--- a/cli/src/tests/helpers/query_helpers.rs
+++ b/cli/src/tests/helpers/query_helpers.rs
@@ -1,6 +1,8 @@
 use rand::prelude::Rng;
 use std::{cmp::Ordering, fmt::Write, ops::Range};
-use tree_sitter::{Node, Point, Tree, TreeCursor};
+use tree_sitter::{
+    Language, Node, Parser, Point, Query, QueryCapture, QueryCursor, QueryMatch, Tree, TreeCursor,
+};
 
 #[derive(Debug)]
 pub struct Pattern {
@@ -304,3 +306,56 @@ fn compare_depth_first(a: Node, b: Node) -> Ordering {
     let b = b.byte_range();
     a.start.cmp(&b.start).then_with(|| b.end.cmp(&a.end))
 }
+
+pub fn assert_query_matches(
+    language: Language,
+    query: &Query,
+    source: &str,
+    expected: &[(usize, Vec<(&str, &str)>)],
+) {
+    let mut parser = Parser::new();
+    parser.set_language(language).unwrap();
+    let tree = parser.parse(source, None).unwrap();
+    let mut cursor = QueryCursor::new();
+    let matches = cursor.matches(&query, tree.root_node(), source.as_bytes());
+    pretty_assertions::assert_eq!(collect_matches(matches, &query, source), expected);
+    pretty_assertions::assert_eq!(cursor.did_exceed_match_limit(), false);
+}
+
+pub fn collect_matches<'a>(
+    matches: impl Iterator<Item = QueryMatch<'a, 'a>>,
+    query: &'a Query,
+    source: &'a str,
+) -> Vec<(usize, Vec<(&'a str, &'a str)>)> {
+    matches
+        .map(|m| {
+            (
+                m.pattern_index,
+                format_captures(m.captures.iter().cloned(), query, source),
+            )
+        })
+        .collect()
+}
+
+pub fn collect_captures<'a>(
+    captures: impl Iterator<Item = (QueryMatch<'a, 'a>, usize)>,
+    query: &'a Query,
+    source: &'a str,
+) -> Vec<(&'a str, &'a str)> {
+    format_captures(captures.map(|(m, i)| m.captures[i]), query, source)
+}
+
+fn format_captures<'a>(
+    captures: impl Iterator<Item = QueryCapture<'a>>,
+    query: &'a Query,
+    source: &'a str,
+) -> Vec<(&'a str, &'a str)> {
+    captures
+        .map(|capture| {
+            (
+                query.capture_names()[capture.index as usize],
+                capture.node.utf8_text(source.as_bytes()).unwrap(),
+            )
+        })
+        .collect()
+}
diff --git a/cli/src/tests/highlight_test.rs b/cli/src/tests/highlight_test.rs
index e0b356d2..12c120ab 100644
--- a/cli/src/tests/highlight_test.rs
+++ b/cli/src/tests/highlight_test.rs
@@ -24,6 +24,7 @@ lazy_static! {
         get_highlight_config("rust", Some("injections.scm"), &HIGHLIGHT_NAMES);
     static ref HIGHLIGHT_NAMES: Vec<String> = [
         "attribute",
+        "boolean",
         "carriage-return",
         "comment",
         "constant",
@@ -61,7 +62,7 @@ lazy_static! {
 fn test_highlighting_javascript() {
     let source = "const a = function(b) { return b + c; }";
     assert_eq!(
-        &to_token_vector(&source, &JS_HIGHLIGHT).unwrap(),
+        &to_token_vector(source, &JS_HIGHLIGHT).unwrap(),
         &[vec![
             ("const", vec!["keyword"]),
             (" ", vec![]),
@@ -71,14 +72,14 @@ fn test_highlighting_javascript() {
             (" ", vec![]),
             ("function", vec!["keyword"]),
             ("(", vec!["punctuation.bracket"]),
-            ("b", vec!["variable.parameter"]),
+            ("b", vec!["variable"]),
             (")", vec!["punctuation.bracket"]),
             (" ", vec![]),
             ("{", vec!["punctuation.bracket"]),
             (" ", vec![]),
             ("return", vec!["keyword"]),
             (" ", vec![]),
-            ("b", vec!["variable.parameter"]),
+            ("b", vec!["variable"]),
             (" ", vec![]),
             ("+", vec!["operator"]),
             (" ", vec![]),
@@ -92,7 +93,7 @@ fn test_highlighting_javascript() {
 
 #[test]
 fn test_highlighting_injected_html_in_javascript() {
-    let source = vec!["const s = html `<div>${a < b}</div>`;"].join("\n");
+    let source = ["const s = html `<div>${a < b}</div>`;"].join("\n");
 
     assert_eq!(
         &to_token_vector(&source, &JS_HIGHLIGHT).unwrap(),
@@ -156,7 +157,7 @@ fn test_highlighting_injected_javascript_in_html_mini() {
 
 #[test]
 fn test_highlighting_injected_javascript_in_html() {
-    let source = vec![
+    let source = [
         "<body>",
         "  <script>",
         "    const x = new Thing();",
@@ -211,7 +212,7 @@ fn test_highlighting_injected_javascript_in_html() {
 
 #[test]
 fn test_highlighting_multiline_nodes_to_html() {
-    let source = vec![
+    let source = [
         "const SOMETHING = `",
         "  one ${",
         "    two()",
@@ -235,7 +236,7 @@ fn test_highlighting_multiline_nodes_to_html() {
 
 #[test]
 fn test_highlighting_with_local_variable_tracking() {
-    let source = vec![
+    let source = [
         "module.exports = function a(b) {",
         "  const module = c;",
         "  console.log(module, b);",
@@ -257,7 +258,7 @@ fn test_highlighting_with_local_variable_tracking() {
                 (" ", vec![]),
                 ("a", vec!["function"]),
                 ("(", vec!["punctuation.bracket"]),
-                ("b", vec!["variable.parameter"]),
+                ("b", vec!["variable"]),
                 (")", vec!["punctuation.bracket"]),
                 (" ", vec![]),
                 ("{", vec!["punctuation.bracket"])
@@ -284,7 +285,7 @@ fn test_highlighting_with_local_variable_tracking() {
                 (",", vec!["punctuation.delimiter"]),
                 (" ", vec![]),
                 // A parameter, because `b` was defined as a parameter above.
-                ("b", vec!["variable.parameter"]),
+                ("b", vec!["variable"]),
                 (")", vec!["punctuation.bracket"]),
                 (";", vec!["punctuation.delimiter"]),
             ],
@@ -295,7 +296,7 @@ fn test_highlighting_with_local_variable_tracking() {
 
 #[test]
 fn test_highlighting_empty_lines() {
-    let source = vec![
+    let source = [
         "class A {",
         "",
         "  b(c) {",
@@ -313,7 +314,7 @@ fn test_highlighting_empty_lines() {
         &[
             "<span class=keyword>class</span> <span class=constructor>A</span> <span class=punctuation.bracket>{</span>\n".to_string(),
             "\n".to_string(),
-            "  <span class=function>b</span><span class=punctuation.bracket>(</span><span class=variable.parameter>c</span><span class=punctuation.bracket>)</span> <span class=punctuation.bracket>{</span>\n".to_string(),
+            "  <span class=function>b</span><span class=punctuation.bracket>(</span><span class=variable>c</span><span class=punctuation.bracket>)</span> <span class=punctuation.bracket>{</span>\n".to_string(),
             "\n".to_string(),
             "    <span class=function>d</span><span class=punctuation.bracket>(</span><span class=variable>e</span><span class=punctuation.bracket>)</span>\n".to_string(),
             "\n".to_string(),
@@ -329,7 +330,7 @@ fn test_highlighting_carriage_returns() {
     let source = "a = \"a\rb\"\r\nb\r";
 
     assert_eq!(
-        &to_html(&source, &JS_HIGHLIGHT).unwrap(),
+        &to_html(source, &JS_HIGHLIGHT).unwrap(),
         &[
             "<span class=variable>a</span> <span class=operator>=</span> <span class=string>&quot;a<span class=carriage-return></span>b&quot;</span>\n",
             "<span class=variable>b</span>\n",
@@ -339,7 +340,7 @@ fn test_highlighting_carriage_returns() {
 
 #[test]
 fn test_highlighting_ejs_with_html_and_javascript() {
-    let source = vec!["<div><% foo() %></div><script> bar() </script>"].join("\n");
+    let source = ["<div><% foo() %></div><script> bar() </script>"].join("\n");
 
     assert_eq!(
         &to_token_vector(&source, &EJS_HIGHLIGHT).unwrap(),
@@ -376,7 +377,7 @@ fn test_highlighting_ejs_with_html_and_javascript() {
 fn test_highlighting_javascript_with_jsdoc() {
     // Regression test: the middle comment has no highlights. This should not prevent
     // later injections from highlighting properly.
-    let source = vec!["a /* @see a */ b; /* nothing */ c; /* @see b */"].join("\n");
+    let source = ["a /* @see a */ b; /* nothing */ c; /* @see b */"].join("\n");
 
     assert_eq!(
         &to_token_vector(&source, &JS_HIGHLIGHT).unwrap(),
@@ -404,7 +405,7 @@ fn test_highlighting_javascript_with_jsdoc() {
 
 #[test]
 fn test_highlighting_with_content_children_included() {
-    let source = vec!["assert!(", "    a.b.c() < D::e::<F>()", ");"].join("\n");
+    let source = ["assert!(", "    a.b.c() < D::e::<F>()", ");"].join("\n");
 
     assert_eq!(
         &to_token_vector(&source, &RUST_HIGHLIGHT).unwrap(),
@@ -482,7 +483,7 @@ fn test_highlighting_cancellation() {
 
 #[test]
 fn test_highlighting_via_c_api() {
-    let highlights = vec![
+    let highlights = [
         "class=tag\0",
         "class=function\0",
         "class=string\0",
@@ -496,68 +497,82 @@ fn test_highlighting_via_c_api() {
         .iter()
         .map(|h| h.as_bytes().as_ptr() as *const c_char)
         .collect::<Vec<_>>();
-    let highlighter = c::ts_highlighter_new(
-        &highlight_names[0] as *const *const c_char,
-        &highlight_attrs[0] as *const *const c_char,
-        highlights.len() as u32,
-    );
+    let highlighter = unsafe {
+        c::ts_highlighter_new(
+            &highlight_names[0] as *const *const c_char,
+            &highlight_attrs[0] as *const *const c_char,
+            highlights.len() as u32,
+        )
+    };
 
     let source_code = c_string("<script>\nconst a = b('c');\nc.d();\n</script>");
 
     let js_scope = c_string("source.js");
     let js_injection_regex = c_string("^javascript");
     let language = get_language("javascript");
+    let lang_name = c_string("javascript");
     let queries = get_language_queries_path("javascript");
     let highlights_query = fs::read_to_string(queries.join("highlights.scm")).unwrap();
     let injections_query = fs::read_to_string(queries.join("injections.scm")).unwrap();
     let locals_query = fs::read_to_string(queries.join("locals.scm")).unwrap();
-    c::ts_highlighter_add_language(
-        highlighter,
-        js_scope.as_ptr(),
-        js_injection_regex.as_ptr(),
-        language,
-        highlights_query.as_ptr() as *const c_char,
-        injections_query.as_ptr() as *const c_char,
-        locals_query.as_ptr() as *const c_char,
-        highlights_query.len() as u32,
-        injections_query.len() as u32,
-        locals_query.len() as u32,
-    );
+    unsafe {
+        c::ts_highlighter_add_language(
+            highlighter,
+            lang_name.as_ptr(),
+            js_scope.as_ptr(),
+            js_injection_regex.as_ptr(),
+            language,
+            highlights_query.as_ptr() as *const c_char,
+            injections_query.as_ptr() as *const c_char,
+            locals_query.as_ptr() as *const c_char,
+            highlights_query.len() as u32,
+            injections_query.len() as u32,
+            locals_query.len() as u32,
+            false,
+        );
+    }
 
     let html_scope = c_string("text.html.basic");
     let html_injection_regex = c_string("^html");
     let language = get_language("html");
+    let lang_name = c_string("html");
     let queries = get_language_queries_path("html");
     let highlights_query = fs::read_to_string(queries.join("highlights.scm")).unwrap();
     let injections_query = fs::read_to_string(queries.join("injections.scm")).unwrap();
-    c::ts_highlighter_add_language(
-        highlighter,
-        html_scope.as_ptr(),
-        html_injection_regex.as_ptr(),
-        language,
-        highlights_query.as_ptr() as *const c_char,
-        injections_query.as_ptr() as *const c_char,
-        ptr::null(),
-        highlights_query.len() as u32,
-        injections_query.len() as u32,
-        0,
-    );
+    unsafe {
+        c::ts_highlighter_add_language(
+            highlighter,
+            lang_name.as_ptr(),
+            html_scope.as_ptr(),
+            html_injection_regex.as_ptr(),
+            language,
+            highlights_query.as_ptr() as *const c_char,
+            injections_query.as_ptr() as *const c_char,
+            ptr::null(),
+            highlights_query.len() as u32,
+            injections_query.len() as u32,
+            0,
+            false,
+        );
+    }
 
     let buffer = c::ts_highlight_buffer_new();
 
-    c::ts_highlighter_highlight(
-        highlighter,
-        html_scope.as_ptr(),
-        source_code.as_ptr(),
-        source_code.as_bytes().len() as u32,
-        buffer,
-        ptr::null_mut(),
-    );
+    unsafe {
+        c::ts_highlighter_highlight(
+            highlighter,
+            html_scope.as_ptr(),
+            source_code.as_ptr(),
+            source_code.as_bytes().len() as u32,
+            buffer,
+            ptr::null_mut(),
+        );
+    }
 
-    let output_bytes = c::ts_highlight_buffer_content(buffer);
-    let output_line_offsets = c::ts_highlight_buffer_line_offsets(buffer);
-    let output_len = c::ts_highlight_buffer_len(buffer);
-    let output_line_count = c::ts_highlight_buffer_line_count(buffer);
+    let output_bytes = unsafe { c::ts_highlight_buffer_content(buffer) };
+    let output_line_offsets = unsafe { c::ts_highlight_buffer_line_offsets(buffer) };
+    let output_len = unsafe { c::ts_highlight_buffer_len(buffer) };
+    let output_line_count = unsafe { c::ts_highlight_buffer_line_count(buffer) };
 
     let output_bytes = unsafe { slice::from_raw_parts(output_bytes, output_len as usize) };
     let output_line_offsets =
@@ -583,8 +598,69 @@ fn test_highlighting_via_c_api() {
         ]
     );
 
-    c::ts_highlighter_delete(highlighter);
-    c::ts_highlight_buffer_delete(buffer);
+    unsafe {
+        c::ts_highlighter_delete(highlighter);
+        c::ts_highlight_buffer_delete(buffer);
+    }
+}
+
+#[test]
+fn test_highlighting_with_all_captures_applied() {
+    let source = "fn main(a: u32, b: u32) -> { let c = a + b; }";
+    let language = get_language("rust");
+    let highlights_query = indoc::indoc! {"
+        [
+          \"fn\"
+          \"let\"
+        ] @keyword
+        (identifier) @variable
+        (function_item name: (identifier) @function)
+        (parameter pattern: (identifier) @variable.parameter)
+        (primitive_type) @type.builtin
+        \"=\" @operator
+        [ \"->\" \":\" \";\" ] @punctuation.delimiter
+        [ \"{\" \"}\" \"(\" \")\" ] @punctuation.bracket
+    "};
+    let mut rust_highlight_reverse =
+        HighlightConfiguration::new(language, "rust", highlights_query, "", "", true).unwrap();
+    rust_highlight_reverse.configure(&HIGHLIGHT_NAMES);
+
+    assert_eq!(
+        &to_token_vector(source, &rust_highlight_reverse).unwrap(),
+        &[[
+            ("fn", vec!["keyword"]),
+            (" ", vec![]),
+            ("main", vec!["function"]),
+            ("(", vec!["punctuation.bracket"]),
+            ("a", vec!["variable.parameter"]),
+            (":", vec!["punctuation.delimiter"]),
+            (" ", vec![]),
+            ("u32", vec!["type.builtin"]),
+            (", ", vec![]),
+            ("b", vec!["variable.parameter"]),
+            (":", vec!["punctuation.delimiter"]),
+            (" ", vec![]),
+            ("u32", vec!["type.builtin"]),
+            (")", vec!["punctuation.bracket"]),
+            (" ", vec![]),
+            ("->", vec!["punctuation.delimiter"]),
+            (" ", vec![]),
+            ("{", vec!["punctuation.bracket"]),
+            (" ", vec![]),
+            ("let", vec!["keyword"]),
+            (" ", vec![]),
+            ("c", vec!["variable"]),
+            (" ", vec![]),
+            ("=", vec!["operator"]),
+            (" ", vec![]),
+            ("a", vec!["variable"]),
+            (" + ", vec![]),
+            ("b", vec!["variable"]),
+            (";", vec!["punctuation.delimiter"]),
+            (" ", vec![]),
+            ("}", vec!["punctuation.bracket"])
+        ]],
+    );
 }
 
 #[test]
@@ -667,20 +743,20 @@ fn to_token_vector<'a>(
             }
             HighlightEvent::Source { start, end } => {
                 let s = str::from_utf8(&src[start..end]).unwrap();
-                for (i, l) in s.split("\n").enumerate() {
+                for (i, l) in s.split('\n').enumerate() {
                     let l = l.trim_end_matches('\r');
                     if i > 0 {
                         lines.push(line);
                         line = Vec::new();
                     }
-                    if l.len() > 0 {
+                    if !l.is_empty() {
                         line.push((l, highlights.clone()));
                     }
                 }
             }
         }
     }
-    if line.len() > 0 {
+    if !line.is_empty() {
         lines.push(line);
     }
     Ok(lines)
diff --git a/cli/src/tests/language_test.rs b/cli/src/tests/language_test.rs
new file mode 100644
index 00000000..5dd04c46
--- /dev/null
+++ b/cli/src/tests/language_test.rs
@@ -0,0 +1,95 @@
+use super::helpers::fixtures::get_language;
+use tree_sitter::Parser;
+
+#[test]
+fn test_lookahead_iterator() {
+    let mut parser = Parser::new();
+    let language = get_language("rust");
+    parser.set_language(language).unwrap();
+
+    let tree = parser.parse("struct Stuff {}", None).unwrap();
+
+    let mut cursor = tree.walk();
+
+    assert!(cursor.goto_first_child()); // struct
+    assert!(cursor.goto_first_child()); // struct keyword
+
+    let next_state = cursor.node().next_parse_state();
+    assert_ne!(next_state, 0);
+    assert_eq!(
+        next_state,
+        language.next_state(cursor.node().parse_state(), cursor.node().grammar_id())
+    );
+    assert!((next_state as usize) < language.parse_state_count());
+    assert!(cursor.goto_next_sibling()); // type_identifier
+    assert_eq!(next_state, cursor.node().parse_state());
+    assert_eq!(cursor.node().grammar_name(), "identifier");
+    assert_ne!(cursor.node().grammar_id(), cursor.node().kind_id());
+
+    let expected_symbols = ["identifier", "block_comment", "line_comment"];
+    let mut lookahead = language.lookahead_iterator(next_state).unwrap();
+    assert_eq!(lookahead.language(), language);
+    assert!(lookahead.iter_names().eq(expected_symbols));
+
+    lookahead.reset_state(next_state);
+    assert!(lookahead.iter_names().eq(expected_symbols));
+
+    lookahead.reset(language, next_state);
+    assert!(lookahead
+        .map(|s| language.node_kind_for_id(s).unwrap())
+        .eq(expected_symbols));
+}
+
+#[test]
+fn test_lookahead_iterator_modifiable_only_by_mut() {
+    let mut parser = Parser::new();
+    let language = get_language("rust");
+    parser.set_language(language).unwrap();
+
+    let tree = parser.parse("struct Stuff {}", None).unwrap();
+
+    let mut cursor = tree.walk();
+
+    assert!(cursor.goto_first_child()); // struct
+    assert!(cursor.goto_first_child()); // struct keyword
+
+    let next_state = cursor.node().next_parse_state();
+    assert_ne!(next_state, 0);
+
+    let mut lookahead = language.lookahead_iterator(next_state).unwrap();
+    let _ = lookahead.next();
+
+    let mut names = lookahead.iter_names();
+    let _ = names.next();
+}
+
+/// It doesn't allowed to use lookahead iterator by shared ref:
+///     error[E0596]: cannot borrow `lookahead` as mutable, as it is not declared as mutable
+/// ```compile_fail
+/// use tree_sitter::{Parser, Language};
+/// let mut parser = Parser::new();
+/// let language = unsafe { Language::from_raw(std::ptr::null()) };
+/// let tree = parser.parse("", None).unwrap();
+/// let mut cursor = tree.walk();
+/// let next_state = cursor.node().next_parse_state();
+/// let lookahead = language.lookahead_iterator(next_state).unwrap();
+/// let _ = lookahead.next();
+/// ```
+
+/// It doesn't allowed to use lookahead names iterator by shared ref:
+///     error[E0596]: cannot borrow `names` as mutable, as it is not declared as mutable
+/// ```compile_fail
+/// use tree_sitter::{Parser, Language};
+/// let mut parser = Parser::new();
+/// let language = unsafe { Language::from_raw(std::ptr::null()) };
+/// let tree = parser.parse("", None).unwrap();
+/// let mut cursor = tree.walk();
+/// let next_state = cursor.node().next_parse_state();
+/// if let Some(mut lookahead) = language.lookahead_iterator(next_state) {
+///     let _ = lookahead.next();
+///     let names = lookahead.iter_names();
+///     let _ = names.next();
+/// }
+/// ```
+
+fn _dummy() {}
diff --git a/cli/src/tests/mod.rs b/cli/src/tests/mod.rs
index 1b804450..308fc2c5 100644
--- a/cli/src/tests/mod.rs
+++ b/cli/src/tests/mod.rs
@@ -1,11 +1,16 @@
+mod async_context_test;
 mod corpus_test;
+mod github_issue_test;
 mod helpers;
 mod highlight_test;
+mod language_test;
 mod node_test;
+mod parser_hang_test;
 mod parser_test;
 mod pathological_test;
 mod query_test;
 mod tags_test;
 mod test_highlight_test;
 mod test_tags_test;
+mod text_provider_test;
 mod tree_test;
diff --git a/cli/src/tests/node_test.rs b/cli/src/tests/node_test.rs
index 6d5ed61d..c4548d3e 100644
--- a/cli/src/tests/node_test.rs
+++ b/cli/src/tests/node_test.rs
@@ -252,12 +252,14 @@ fn test_node_parent_of_child_by_field_name() {
 fn test_node_field_name_for_child() {
     let mut parser = Parser::new();
     parser.set_language(get_language("c")).unwrap();
-    let tree = parser.parse("x + y;", None).unwrap();
+    let tree = parser.parse("int w = x + y;", None).unwrap();
     let translation_unit_node = tree.root_node();
-    let binary_expression_node = translation_unit_node
-        .named_child(0)
+    let declaration_node = translation_unit_node.named_child(0).unwrap();
+
+    let binary_expression_node = declaration_node
+        .child_by_field_name("declarator")
         .unwrap()
-        .named_child(0)
+        .child_by_field_name("value")
         .unwrap();
 
     assert_eq!(binary_expression_node.field_name_for_child(0), Some("left"));
@@ -385,10 +387,52 @@ fn test_node_named_child_with_aliases_and_extras() {
     assert_eq!(root.named_child(4).unwrap().kind(), "C");
 }
 
+#[test]
+fn test_node_descendant_count() {
+    let tree = parse_json_example();
+    let value_node = tree.root_node();
+    let all_nodes = get_all_nodes(&tree);
+
+    assert_eq!(value_node.descendant_count(), all_nodes.len());
+
+    let mut cursor = value_node.walk();
+    for (i, node) in all_nodes.iter().enumerate() {
+        cursor.goto_descendant(i);
+        assert_eq!(cursor.node(), *node, "index {i}");
+    }
+
+    for (i, node) in all_nodes.iter().enumerate().rev() {
+        cursor.goto_descendant(i);
+        assert_eq!(cursor.node(), *node, "rev index {i}");
+    }
+}
+
+#[test]
+fn test_descendant_count_single_node_tree() {
+    let mut parser = Parser::new();
+    parser
+        .set_language(get_language("embedded-template"))
+        .unwrap();
+    let tree = parser.parse("hello", None).unwrap();
+
+    let nodes = get_all_nodes(&tree);
+    assert_eq!(nodes.len(), 2);
+    assert_eq!(tree.root_node().descendant_count(), 2);
+
+    let mut cursor = tree.root_node().walk();
+
+    cursor.goto_descendant(0);
+    assert_eq!(cursor.depth(), 0);
+    assert_eq!(cursor.node(), nodes[0]);
+    cursor.goto_descendant(1);
+    assert_eq!(cursor.depth(), 1);
+    assert_eq!(cursor.node(), nodes[1]);
+}
+
 #[test]
 fn test_node_descendant_for_range() {
     let tree = parse_json_example();
-    let array_node = tree.root_node().child(0).unwrap();
+    let array_node = tree.root_node();
 
     // Leaf node exactly matches the given bounds - byte query
     let colon_index = JSON_EXAMPLE.find(":").unwrap();
@@ -508,7 +552,7 @@ fn test_node_edit() {
 
         let edit = get_random_edit(&mut rand, &mut code);
         let mut tree2 = tree.clone();
-        let edit = perform_edit(&mut tree2, &mut code, &edit);
+        let edit = perform_edit(&mut tree2, &mut code, &edit).unwrap();
         for node in nodes_before.iter_mut() {
             node.edit(&edit);
         }
@@ -841,15 +885,17 @@ fn get_all_nodes(tree: &Tree) -> Vec<Node> {
     let mut visited_children = false;
     let mut cursor = tree.walk();
     loop {
-        result.push(cursor.node());
-        if !visited_children && cursor.goto_first_child() {
-            continue;
-        } else if cursor.goto_next_sibling() {
-            visited_children = false;
-        } else if cursor.goto_parent() {
-            visited_children = true;
+        if !visited_children {
+            result.push(cursor.node());
+            if !cursor.goto_first_child() {
+                visited_children = true;
+            }
         } else {
-            break;
+            if cursor.goto_next_sibling() {
+                visited_children = false;
+            } else if !cursor.goto_parent() {
+                break;
+            }
         }
     }
     return result;
diff --git a/cli/src/tests/parser_hang_test.rs b/cli/src/tests/parser_hang_test.rs
new file mode 100644
index 00000000..02a2689c
--- /dev/null
+++ b/cli/src/tests/parser_hang_test.rs
@@ -0,0 +1,104 @@
+// For some reasons `Command::spawn` doesn't work in CI env for many exotic arches.
+#![cfg(all(any(target_arch = "x86_64", target_arch = "x86"), not(sanitizing)))]
+
+use crate::{
+    generate::{generate_parser_for_grammar, load_grammar_file},
+    tests::helpers::fixtures::{fixtures_dir, get_test_language},
+};
+use std::{
+    env::VarError,
+    process::{Command, Stdio},
+};
+use tree_sitter::Parser;
+
+// The `sanitizing` cfg is required to don't run tests under specific sunitizer
+// because they don't work well with subprocesses _(it's an assumption)_.
+//
+// Bellow are two alternative examples of how to disable tests for some arches
+// if a way with excluding the whole mod from compilation wouldn't work well.
+//
+// XXX: Also may be it makes sense to keep such tests as ignored by default
+//      to omit surprises and enable them on CI by passing an extra option explicitly:
+//
+//        > cargo test -- --include-ignored
+//
+// #[cfg(all(any(target_arch = "x86_64", target_arch = "x86"), not(sanitizing)))]
+// #[cfg_attr(not(all(any(target_arch = "x86_64", target_arch = "x86"), not(sanitizing))), ignore)]
+//
+#[test]
+fn test_grammar_that_should_hang_and_not_segfault() {
+    let parent_sleep_millis = 1000;
+    let test_name = "test_grammar_that_should_hang_and_not_segfault";
+    let test_var = "CARGO_HANG_TEST";
+
+    eprintln!("  {test_name}");
+
+    let tests_exec_path = std::env::args()
+        .nth(0)
+        .expect("Failed get get tests executable path");
+
+    match std::env::var(test_var) {
+        Ok(v) if v == test_name => {
+            eprintln!("    child process id {}", std::process::id());
+            hang_test();
+        }
+
+        Err(VarError::NotPresent) => {
+            eprintln!("    parent process id {}", std::process::id());
+            if true {
+                let mut command = Command::new(tests_exec_path);
+                command.arg(test_name).env(test_var, test_name);
+                if std::env::args().any(|x| x == "--nocapture") {
+                    command.arg("--nocapture");
+                } else {
+                    command.stdout(Stdio::null()).stderr(Stdio::null());
+                }
+                match command.spawn() {
+                    Ok(mut child) => {
+                        std::thread::sleep(std::time::Duration::from_millis(parent_sleep_millis));
+                        match child.try_wait() {
+                            Ok(Some(status)) if status.success() => {
+                                panic!("Child wasn't hang and exited successfully")
+                            }
+                            Ok(Some(status)) => panic!(
+                                "Child wasn't hang and exited with status code: {:?}",
+                                status.code()
+                            ),
+                            _ => (),
+                        }
+                        if let Err(e) = child.kill() {
+                            eprintln!(
+                                "Failed to kill hang test sub process id: {}, error: {e}",
+                                child.id()
+                            );
+                        }
+                    }
+                    Err(e) => panic!("{e}"),
+                }
+            }
+        }
+
+        Err(e) => panic!("Env var error: {e}"),
+        _ => unreachable!(),
+    }
+
+    fn hang_test() {
+        let test_grammar_dir = fixtures_dir()
+            .join("test_grammars")
+            .join("get_col_should_hang_not_crash");
+
+        let grammar_json = load_grammar_file(&test_grammar_dir.join("grammar.js"), None).unwrap();
+        let (parser_name, parser_code) =
+            generate_parser_for_grammar(grammar_json.as_str()).unwrap();
+
+        let language =
+            get_test_language(&parser_name, &parser_code, Some(test_grammar_dir.as_path()));
+
+        let mut parser = Parser::new();
+        parser.set_language(language).unwrap();
+
+        let code_that_should_hang = "\nHello";
+
+        parser.parse(code_that_should_hang, None).unwrap();
+    }
+}
diff --git a/cli/src/tests/parser_test.rs b/cli/src/tests/parser_test.rs
index 9e914a2f..5f6febee 100644
--- a/cli/src/tests/parser_test.rs
+++ b/cli/src/tests/parser_test.rs
@@ -15,6 +15,7 @@ use std::{
     thread, time,
 };
 use tree_sitter::{IncludedRangesError, InputEdit, LogType, Parser, Point, Range};
+use tree_sitter_proc_macro::retry;
 
 #[test]
 fn test_parsing_simple_string() {
@@ -149,7 +150,7 @@ fn test_parsing_with_custom_utf8_input() {
         )
     );
     assert_eq!(root.kind(), "source_file");
-    assert_eq!(root.has_error(), false);
+    assert!(!root.has_error());
     assert_eq!(root.child(0).unwrap().kind(), "function_item");
 }
 
@@ -188,7 +189,7 @@ fn test_parsing_with_custom_utf16_input() {
         "(source_file (function_item (visibility_modifier) name: (identifier) parameters: (parameters) body: (block (integer_literal))))"
     );
     assert_eq!(root.kind(), "source_file");
-    assert_eq!(root.has_error(), false);
+    assert!(!root.has_error());
     assert_eq!(root.child(0).unwrap().kind(), "function_item");
 }
 
@@ -277,7 +278,10 @@ fn test_parsing_invalid_chars_at_eof() {
     let mut parser = Parser::new();
     parser.set_language(get_language("json")).unwrap();
     let tree = parser.parse(b"\xdf", None).unwrap();
-    assert_eq!(tree.root_node().to_sexp(), "(ERROR (UNEXPECTED INVALID))");
+    assert_eq!(
+        tree.root_node().to_sexp(),
+        "(document (ERROR (UNEXPECTED INVALID)))"
+    );
 }
 
 #[test]
@@ -340,7 +344,8 @@ fn test_parsing_after_editing_beginning_of_code() {
             deleted_length: 0,
             inserted_text: b" || 5".to_vec(),
         },
-    );
+    )
+    .unwrap();
 
     let mut recorder = ReadRecorder::new(&code);
     let tree = parser
@@ -387,7 +392,8 @@ fn test_parsing_after_editing_end_of_code() {
             deleted_length: 0,
             inserted_text: b".d".to_vec(),
         },
-    );
+    )
+    .unwrap();
 
     let mut recorder = ReadRecorder::new(&code);
     let tree = parser
@@ -466,7 +472,8 @@ h + i
             deleted_length: 0,
             inserted_text: b"1234".to_vec(),
         },
-    );
+    )
+    .unwrap();
 
     assert_eq!(
         code,
@@ -511,7 +518,7 @@ fn test_parsing_after_detecting_error_in_the_middle_of_a_string_token() {
     let tree = parser.parse(&source, None).unwrap();
     assert_eq!(
         tree.root_node().to_sexp(),
-        "(module (expression_statement (assignment left: (identifier) right: (expression_list (identifier) (string)))))"
+        "(module (expression_statement (assignment left: (identifier) right: (expression_list (identifier) (string (string_start) (string_content) (string_end))))))"
     );
 
     // Delete a suffix of the source code, starting in the middle of the string
@@ -530,12 +537,12 @@ fn test_parsing_after_detecting_error_in_the_middle_of_a_string_token() {
     let undo = invert_edit(&source, &edit);
 
     let mut tree2 = tree.clone();
-    perform_edit(&mut tree2, &mut source, &edit);
+    perform_edit(&mut tree2, &mut source, &edit).unwrap();
     tree2 = parser.parse(&source, Some(&tree2)).unwrap();
     assert!(tree2.root_node().has_error());
 
     let mut tree3 = tree2.clone();
-    perform_edit(&mut tree3, &mut source, &undo);
+    perform_edit(&mut tree3, &mut source, &undo).unwrap();
     tree3 = parser.parse(&source, Some(&tree3)).unwrap();
     assert_eq!(tree3.root_node().to_sexp(), tree.root_node().to_sexp(),);
 }
@@ -644,6 +651,7 @@ fn test_parsing_cancelled_by_another_thread() {
 // Timeouts
 
 #[test]
+#[retry(10)]
 fn test_parsing_with_a_timeout() {
     let mut parser = Parser::new();
     parser.set_language(get_language("json")).unwrap();
@@ -662,8 +670,12 @@ fn test_parsing_with_a_timeout() {
         None,
     );
     assert!(tree.is_none());
+    #[cfg(not(target_arch = "sparc64"))]
     assert!(start_time.elapsed().as_micros() < 2000);
 
+    #[cfg(target_arch = "sparc64")]
+    assert!(start_time.elapsed().as_micros() < 8000);
+
     // Continue parsing, but pause after 1 ms of processing.
     parser.set_timeout_micros(5000);
     let start_time = time::Instant::now();
@@ -701,6 +713,7 @@ fn test_parsing_with_a_timeout() {
 }
 
 #[test]
+#[retry(10)]
 fn test_parsing_with_a_timeout_and_a_reset() {
     let mut parser = Parser::new();
     parser.set_language(get_language("json")).unwrap();
@@ -756,6 +769,7 @@ fn test_parsing_with_a_timeout_and_a_reset() {
 }
 
 #[test]
+#[retry(10)]
 fn test_parsing_with_a_timeout_and_implicit_reset() {
     allocations::record(|| {
         let mut parser = Parser::new();
@@ -789,6 +803,7 @@ fn test_parsing_with_a_timeout_and_implicit_reset() {
 }
 
 #[test]
+#[retry(10)]
 fn test_parsing_with_timeout_and_no_completion() {
     allocations::record(|| {
         let mut parser = Parser::new();
@@ -828,7 +843,7 @@ fn test_parsing_with_one_included_range() {
         concat!(
             "(program (expression_statement (call_expression ",
             "function: (member_expression object: (identifier) property: (property_identifier)) ",
-            "arguments: (arguments (string)))))",
+            "arguments: (arguments (string (string_fragment))))))",
         )
     );
     assert_eq!(
@@ -1177,7 +1192,7 @@ fn test_parsing_with_a_newly_included_range() {
         .set_included_ranges(&[simple_range(range1_start, range1_end)])
         .unwrap();
     let tree = parser
-        .parse_with(&mut chunked_input(&source_code, 3), None)
+        .parse_with(&mut chunked_input(source_code, 3), None)
         .unwrap();
     assert_eq!(
         tree.root_node().to_sexp(),
@@ -1196,7 +1211,7 @@ fn test_parsing_with_a_newly_included_range() {
         ])
         .unwrap();
     let tree2 = parser
-        .parse_with(&mut chunked_input(&source_code, 3), Some(&tree))
+        .parse_with(&mut chunked_input(source_code, 3), Some(&tree))
         .unwrap();
     assert_eq!(
         tree2.root_node().to_sexp(),
@@ -1220,7 +1235,7 @@ fn test_parsing_with_a_newly_included_range() {
             simple_range(range3_start, range3_end),
         ])
         .unwrap();
-    let tree3 = parser.parse(&source_code, Some(&tree)).unwrap();
+    let tree3 = parser.parse(source_code, Some(&tree)).unwrap();
     assert_eq!(
         tree3.root_node().to_sexp(),
         concat!(
@@ -1297,6 +1312,85 @@ fn test_parsing_with_included_ranges_and_missing_tokens() {
     assert_eq!(root.child(3).unwrap().start_byte(), 4);
 }
 
+#[test]
+fn test_grammars_that_can_hang_on_eof() {
+    let (parser_name, parser_code) = generate_parser_for_grammar(
+        r#"
+        {
+            "name": "test_single_null_char_regex",
+            "rules": {
+                "source_file": {
+                    "type": "SEQ",
+                    "members": [
+                        { "type": "STRING", "value": "\"" },
+                        { "type": "PATTERN", "value": "[\\x00]*" },
+                        { "type": "STRING", "value": "\"" }
+                    ]
+                }
+            },
+            "extras": [ { "type": "PATTERN", "value": "\\s" } ]
+        }
+        "#,
+    )
+    .unwrap();
+
+    let mut parser = Parser::new();
+    parser
+        .set_language(get_test_language(&parser_name, &parser_code, None))
+        .unwrap();
+    parser.parse("\"", None).unwrap();
+
+    let (parser_name, parser_code) = generate_parser_for_grammar(
+        r#"
+        {
+            "name": "test_null_char_with_next_char_regex",
+            "rules": {
+                "source_file": {
+                    "type": "SEQ",
+                    "members": [
+                        { "type": "STRING", "value": "\"" },
+                        { "type": "PATTERN", "value": "[\\x00-\\x01]*" },
+                        { "type": "STRING", "value": "\"" }
+                    ]
+                }
+            },
+            "extras": [ { "type": "PATTERN", "value": "\\s" } ]
+        }
+        "#,
+    )
+    .unwrap();
+
+    parser
+        .set_language(get_test_language(&parser_name, &parser_code, None))
+        .unwrap();
+    parser.parse("\"", None).unwrap();
+
+    let (parser_name, parser_code) = generate_parser_for_grammar(
+        r#"
+        {
+            "name": "test_null_char_with_range_regex",
+            "rules": {
+                "source_file": {
+                    "type": "SEQ",
+                    "members": [
+                        { "type": "STRING", "value": "\"" },
+                        { "type": "PATTERN", "value": "[\\x00-\\x7F]*" },
+                        { "type": "STRING", "value": "\"" }
+                    ]
+                }
+            },
+            "extras": [ { "type": "PATTERN", "value": "\\s" } ]
+        }
+        "#,
+    )
+    .unwrap();
+
+    parser
+        .set_language(get_test_language(&parser_name, &parser_code, None))
+        .unwrap();
+    parser.parse("\"", None).unwrap();
+}
+
 fn simple_range(start: usize, end: usize) -> Range {
     Range {
         start_byte: start,
diff --git a/cli/src/tests/proc_macro/Cargo.toml b/cli/src/tests/proc_macro/Cargo.toml
new file mode 100644
index 00000000..1ca1be39
--- /dev/null
+++ b/cli/src/tests/proc_macro/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "tree-sitter-tests-proc-macro"
+version = "0.0.0"
+edition = "2021"
+publish = false
+rust-version.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0.63"
+quote = "1"
+rand = "0.8.5"
+syn = { version = "1", features = ["full"] }
diff --git a/cli/src/tests/proc_macro/src/lib.rs b/cli/src/tests/proc_macro/src/lib.rs
new file mode 100644
index 00000000..4d92479f
--- /dev/null
+++ b/cli/src/tests/proc_macro/src/lib.rs
@@ -0,0 +1,137 @@
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use quote::quote;
+use syn::{
+    parse::{Parse, ParseStream},
+    parse_macro_input, Error, Expr, Ident, ItemFn, LitInt, Token,
+};
+
+#[proc_macro_attribute]
+pub fn retry(args: TokenStream, input: TokenStream) -> TokenStream {
+    let count = parse_macro_input!(args as LitInt);
+    let input = parse_macro_input!(input as ItemFn);
+    let attrs = input.attrs.clone();
+    let name = input.sig.ident.clone();
+
+    TokenStream::from(quote! {
+        #(#attrs),*
+        fn #name() {
+            #input
+
+            for i in 0..=#count {
+                let result = std::panic::catch_unwind(|| {
+                    #name();
+                });
+
+                if result.is_ok() {
+                    return;
+                }
+
+                if i == #count {
+                    std::panic::resume_unwind(result.unwrap_err());
+                }
+            }
+        }
+    })
+}
+
+#[proc_macro_attribute]
+pub fn test_with_seed(args: TokenStream, input: TokenStream) -> TokenStream {
+    struct Args {
+        retry: LitInt,
+        seed: Expr,
+        seed_fn: Option<Ident>,
+    }
+
+    impl Parse for Args {
+        fn parse(input: ParseStream) -> syn::Result<Self> {
+            let mut retry = None;
+            let mut seed = None;
+            let mut seed_fn = None;
+
+            while !input.is_empty() {
+                let name = input.parse::<Ident>()?;
+                match name.to_string().as_str() {
+                    "retry" => {
+                        input.parse::<Token![=]>()?;
+                        retry.replace(input.parse()?);
+                    }
+                    "seed" => {
+                        input.parse::<Token![=]>()?;
+                        seed.replace(input.parse()?);
+                    }
+                    "seed_fn" => {
+                        input.parse::<Token![=]>()?;
+                        seed_fn.replace(input.parse()?);
+                    }
+                    x => {
+                        return Err(Error::new(
+                            name.span(),
+                            format!("Unsupported parameter `{x}`"),
+                        ))
+                    }
+                }
+
+                if !input.is_empty() {
+                    input.parse::<Token![,]>()?;
+                }
+            }
+
+            if retry.is_none() {
+                retry.replace(LitInt::new("0", Span::mixed_site()));
+            }
+
+            Ok(Args {
+                retry: retry.expect("`retry` parameter is required"),
+                seed: seed.expect("`seed` parameter is required"),
+                seed_fn,
+            })
+        }
+    }
+
+    let Args {
+        retry,
+        seed,
+        seed_fn,
+    } = parse_macro_input!(args as Args);
+
+    let seed_fn = seed_fn.iter();
+
+    let func = parse_macro_input!(input as ItemFn);
+    let attrs = func.attrs.clone();
+    let name = func.sig.ident.clone();
+
+    // dbg!(quote::ToTokens::into_token_stream(&func));
+
+    TokenStream::from(quote! {
+        #[test]
+        #(#attrs),*
+        fn #name() {
+            #func
+
+            let mut seed = #seed;
+
+            for i in 0..=#retry {
+                let result = std::panic::catch_unwind(|| {
+                    #name(seed);
+                });
+
+                if result.is_ok() {
+                    return;
+                }
+
+                if i == #retry {
+                    std::panic::resume_unwind(result.unwrap_err());
+                }
+
+                #(
+                    seed = #seed_fn();
+                )*
+
+                if i < #retry {
+                    println!("\nRetry {}/{} with a new seed {}", i + 1, #retry, seed);
+                }
+            }
+        }
+    })
+}
diff --git a/cli/src/tests/query_test.rs b/cli/src/tests/query_test.rs
index 31cb8035..13e4f8d0 100644
--- a/cli/src/tests/query_test.rs
+++ b/cli/src/tests/query_test.rs
@@ -1,15 +1,22 @@
 use super::helpers::{
     allocations,
-    fixtures::get_language,
-    query_helpers::{Match, Pattern},
+    fixtures::{get_language, get_test_language},
+    query_helpers::{assert_query_matches, Match, Pattern},
+    ITERATION_COUNT,
 };
+use crate::{
+    generate::generate_parser_for_grammar,
+    tests::helpers::query_helpers::{collect_captures, collect_matches},
+};
+use indoc::indoc;
 use lazy_static::lazy_static;
 use rand::{prelude::StdRng, SeedableRng};
 use std::{env, fmt::Write};
 use tree_sitter::{
-    CaptureQuantifier, Language, Node, Parser, Point, Query, QueryCapture, QueryCursor, QueryError,
-    QueryErrorKind, QueryMatch, QueryPredicate, QueryPredicateArg, QueryProperty,
+    CaptureQuantifier, Language, Node, Parser, Point, Query, QueryCursor, QueryError,
+    QueryErrorKind, QueryPredicate, QueryPredicateArg, QueryProperty,
 };
+use unindent::Unindent;
 
 lazy_static! {
     static ref EXAMPLE_FILTER: Option<String> = env::var("TREE_SITTER_TEST_EXAMPLE_FILTER").ok();
@@ -316,16 +323,16 @@ fn test_query_errors_on_impossible_patterns() {
         assert_eq!(
             Query::new(
                 js_lang,
-                "(binary_expression left: (identifier) left: (identifier))"
+                "(binary_expression left: (expression (identifier)) left: (expression (identifier)))"
             ),
             Err(QueryError {
                 kind: QueryErrorKind::Structure,
                 row: 0,
-                offset: 38,
-                column: 38,
+                offset: 51,
+                column: 51,
                 message: [
-                    "(binary_expression left: (identifier) left: (identifier))",
-                    "                                      ^"
+                    "(binary_expression left: (expression (identifier)) left: (expression (identifier)))",
+                    "                                                   ^",
                 ]
                 .join("\n"),
             })
@@ -430,19 +437,19 @@ fn test_query_errors_on_impossible_patterns() {
         Query::new(
             js_lang,
             "(if_statement
-                condition: (parenthesized_expression (_expression) @cond))",
+                condition: (parenthesized_expression (expression) @cond))",
         )
         .unwrap();
 
         assert_eq!(
-            Query::new(js_lang, "(if_statement condition: (_expression))",),
+            Query::new(js_lang, "(if_statement condition: (expression))",),
             Err(QueryError {
                 kind: QueryErrorKind::Structure,
                 row: 0,
                 offset: 14,
                 column: 14,
                 message: [
-                    "(if_statement condition: (_expression))", //
+                    "(if_statement condition: (expression))", //
                     "              ^",
                 ]
                 .join("\n")
@@ -849,6 +856,33 @@ fn test_query_matches_with_wildcard_at_the_root() {
     });
 }
 
+#[test]
+fn test_query_matches_with_wildcard_within_wildcard() {
+    allocations::record(|| {
+        let language = get_language("javascript");
+        let query = Query::new(
+            language,
+            "
+            (_ (_) @child) @parent
+            ",
+        )
+        .unwrap();
+
+        assert_query_matches(
+            language,
+            &query,
+            "/* a */ b; c;",
+            &[
+                (0, vec![("parent", "/* a */ b; c;"), ("child", "/* a */")]),
+                (0, vec![("parent", "/* a */ b; c;"), ("child", "b;")]),
+                (0, vec![("parent", "b;"), ("child", "b")]),
+                (0, vec![("parent", "/* a */ b; c;"), ("child", "c;")]),
+                (0, vec![("parent", "c;"), ("child", "c")]),
+            ],
+        );
+    });
+}
+
 #[test]
 fn test_query_matches_with_immediate_siblings() {
     allocations::record(|| {
@@ -1162,11 +1196,20 @@ fn test_query_matches_with_non_terminal_repetitions_within_root() {
             language,
             &query,
             r#"
+            function f() {
+                d;
+                e;
+                f;
+                g;
+            }
             a;
             b;
             c;
             "#,
-            &[(0, vec![("id", "a"), ("id", "b"), ("id", "c")])],
+            &[
+                (0, vec![("id", "d"), ("id", "e"), ("id", "f"), ("id", "g")]),
+                (0, vec![("id", "a"), ("id", "b"), ("id", "c")]),
+            ],
         );
     });
 }
@@ -1683,7 +1726,7 @@ fn test_query_matches_with_too_many_permutations_to_track() {
             collect_matches(matches, &query, source.as_str())[0],
             (0, vec![("pre", "hello"), ("post", "hello")]),
         );
-        assert_eq!(cursor.did_exceed_match_limit(), true);
+        assert!(cursor.did_exceed_match_limit());
     });
 }
 
@@ -1732,7 +1775,7 @@ fn test_query_sibling_patterns_dont_match_children_of_an_error() {
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
         let mut cursor = QueryCursor::new();
         let matches = cursor.matches(&query, tree.root_node(), source.as_bytes());
         assert_eq!(
@@ -1782,7 +1825,54 @@ fn test_query_matches_with_alternatives_and_too_many_permutations_to_track() {
             collect_matches(matches, &query, source.as_str()),
             vec![(1, vec![("method", "b")]); 50],
         );
-        assert_eq!(cursor.did_exceed_match_limit(), true);
+        assert!(cursor.did_exceed_match_limit());
+    });
+}
+
+#[test]
+fn test_repetitions_before_with_alternatives() {
+    allocations::record(|| {
+        let language = get_language("rust");
+        let query = Query::new(
+            language,
+            r#"
+            (
+                (line_comment)* @comment
+                .
+                [
+                    (struct_item name: (_) @name)
+                    (function_item name: (_) @name)
+                    (enum_item name: (_) @name)
+                    (impl_item type: (_) @name)
+                ]
+            )
+            "#,
+        )
+        .unwrap();
+
+        assert_query_matches(
+            language,
+            &query,
+            r#"
+            // a
+            // b
+            fn c() {}
+
+            // d
+            // e
+            impl F {}
+            "#,
+            &[
+                (
+                    0,
+                    vec![("comment", "// a"), ("comment", "// b"), ("name", "c")],
+                ),
+                (
+                    0,
+                    vec![("comment", "// d"), ("comment", "// e"), ("name", "F")],
+                ),
+            ],
+        );
     });
 }
 
@@ -1866,7 +1956,7 @@ fn test_query_matches_within_byte_range() {
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
 
         let mut cursor = QueryCursor::new();
 
@@ -1874,7 +1964,6 @@ fn test_query_matches_within_byte_range() {
             cursor
                 .set_byte_range(0..8)
                 .matches(&query, tree.root_node(), source.as_bytes());
-
         assert_eq!(
             collect_matches(matches, &query, source),
             &[
@@ -1888,7 +1977,6 @@ fn test_query_matches_within_byte_range() {
             cursor
                 .set_byte_range(5..15)
                 .matches(&query, tree.root_node(), source.as_bytes());
-
         assert_eq!(
             collect_matches(matches, &query, source),
             &[
@@ -1902,7 +1990,6 @@ fn test_query_matches_within_byte_range() {
             cursor
                 .set_byte_range(12..0)
                 .matches(&query, tree.root_node(), source.as_bytes());
-
         assert_eq!(
             collect_matches(matches, &query, source),
             &[
@@ -1920,20 +2007,28 @@ fn test_query_matches_within_point_range() {
         let language = get_language("javascript");
         let query = Query::new(language, "(identifier) @element").unwrap();
 
-        let source = "[a, b,\n c, d,\n e, f,\n g]";
+        let source = "
+            [
+              a, b,
+              c, d,
+              e, f,
+              g, h,
+              i, j,
+              k, l,
+            ]
+        "
+        .unindent();
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
         let tree = parser.parse(&source, None).unwrap();
-
         let mut cursor = QueryCursor::new();
 
         let matches = cursor
-            .set_point_range(Point::new(0, 0)..Point::new(1, 3))
+            .set_point_range(Point::new(1, 0)..Point::new(2, 3))
             .matches(&query, tree.root_node(), source.as_bytes());
-
         assert_eq!(
-            collect_matches(matches, &query, source),
+            collect_matches(matches, &query, &source),
             &[
                 (0, vec![("element", "a")]),
                 (0, vec![("element", "b")]),
@@ -1942,11 +2037,10 @@ fn test_query_matches_within_point_range() {
         );
 
         let matches = cursor
-            .set_point_range(Point::new(1, 0)..Point::new(2, 3))
+            .set_point_range(Point::new(2, 0)..Point::new(3, 3))
             .matches(&query, tree.root_node(), source.as_bytes());
-
         assert_eq!(
-            collect_matches(matches, &query, source),
+            collect_matches(matches, &query, &source),
             &[
                 (0, vec![("element", "c")]),
                 (0, vec![("element", "d")]),
@@ -1954,16 +2048,19 @@ fn test_query_matches_within_point_range() {
             ]
         );
 
+        // Zero end point is treated like no end point.
         let matches = cursor
-            .set_point_range(Point::new(2, 1)..Point::new(0, 0))
+            .set_point_range(Point::new(4, 1)..Point::new(0, 0))
             .matches(&query, tree.root_node(), source.as_bytes());
-
         assert_eq!(
-            collect_matches(matches, &query, source),
+            collect_matches(matches, &query, &source),
             &[
-                (0, vec![("element", "e")]),
-                (0, vec![("element", "f")]),
                 (0, vec![("element", "g")]),
+                (0, vec![("element", "h")]),
+                (0, vec![("element", "i")]),
+                (0, vec![("element", "j")]),
+                (0, vec![("element", "k")]),
+                (0, vec![("element", "l")]),
             ]
         );
     });
@@ -1989,7 +2086,7 @@ fn test_query_captures_within_byte_range() {
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
 
         let mut cursor = QueryCursor::new();
         let captures =
@@ -2025,7 +2122,7 @@ fn test_query_matches_with_unrooted_patterns_intersecting_byte_range() {
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
         let mut cursor = QueryCursor::new();
 
         // within the type parameter list
@@ -2163,16 +2260,16 @@ fn test_query_captures_within_byte_range_assigned_after_iterating() {
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
         let mut cursor = QueryCursor::new();
         let mut captures = cursor.captures(&query, tree.root_node(), source.as_bytes());
 
         // Retrieve some captures
         let mut results = Vec::new();
         for (mat, capture_ix) in captures.by_ref().take(5) {
-            let capture = mat.captures[capture_ix as usize];
+            let capture = mat.captures[capture_ix];
             results.push((
-                query.capture_names()[capture.index as usize].as_str(),
+                query.capture_names()[capture.index as usize],
                 &source[capture.node.byte_range()],
             ));
         }
@@ -2193,9 +2290,9 @@ fn test_query_captures_within_byte_range_assigned_after_iterating() {
         results.clear();
         captures.set_byte_range(source.find("Ok").unwrap()..source.len());
         for (mat, capture_ix) in captures {
-            let capture = mat.captures[capture_ix as usize];
+            let capture = mat.captures[capture_ix];
             results.push((
-                query.capture_names()[capture.index as usize].as_str(),
+                query.capture_names()[capture.index as usize],
                 &source[capture.node.byte_range()],
             ));
         }
@@ -2210,6 +2307,57 @@ fn test_query_captures_within_byte_range_assigned_after_iterating() {
     });
 }
 
+#[test]
+fn test_query_matches_within_range_of_long_repetition() {
+    allocations::record(|| {
+        let language = get_language("rust");
+        let query = Query::new(
+            language,
+            "
+            (function_item name: (identifier) @fn-name)
+            ",
+        )
+        .unwrap();
+
+        let source = "
+            fn zero() {}
+            fn one() {}
+            fn two() {}
+            fn three() {}
+            fn four() {}
+            fn five() {}
+            fn six() {}
+            fn seven() {}
+            fn eight() {}
+            fn nine() {}
+            fn ten() {}
+            fn eleven() {}
+            fn twelve() {}
+        "
+        .unindent();
+
+        let mut parser = Parser::new();
+        let mut cursor = QueryCursor::new();
+
+        parser.set_language(language).unwrap();
+        let tree = parser.parse(&source, None).unwrap();
+
+        let matches = cursor
+            .set_point_range(Point::new(8, 0)..Point::new(20, 0))
+            .matches(&query, tree.root_node(), source.as_bytes());
+        assert_eq!(
+            collect_matches(matches, &query, &source),
+            &[
+                (0, vec![("fn-name", "eight")]),
+                (0, vec![("fn-name", "nine")]),
+                (0, vec![("fn-name", "ten")]),
+                (0, vec![("fn-name", "eleven")]),
+                (0, vec![("fn-name", "twelve")]),
+            ]
+        );
+    });
+}
+
 #[test]
 fn test_query_matches_different_queries_same_cursor() {
     allocations::record(|| {
@@ -2245,7 +2393,7 @@ fn test_query_matches_different_queries_same_cursor() {
         let mut cursor = QueryCursor::new();
 
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
 
         let matches = cursor.matches(&query1, tree.root_node(), source.as_bytes());
         assert_eq!(
@@ -2288,7 +2436,7 @@ fn test_query_matches_with_multiple_captures_on_a_node() {
         let mut cursor = QueryCursor::new();
 
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
 
         let matches = cursor.matches(&query, tree.root_node(), source.as_bytes());
         assert_eq!(
@@ -2376,7 +2524,7 @@ fn test_query_matches_with_captured_wildcard_at_root() {
         let mut parser = Parser::new();
         let mut cursor = QueryCursor::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
 
         let match_capture_names_and_rows = cursor
             .matches(&query, tree.root_node(), source.as_bytes())
@@ -2385,7 +2533,7 @@ fn test_query_matches_with_captured_wildcard_at_root() {
                     .iter()
                     .map(|c| {
                         (
-                            query.capture_names()[c.index as usize].as_str(),
+                            query.capture_names()[c.index as usize],
                             c.node.kind(),
                             c.node.start_position().row,
                         )
@@ -2642,7 +2790,7 @@ fn test_query_captures_basic() {
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
         let mut cursor = QueryCursor::new();
         let matches = cursor.matches(&query, tree.root_node(), source.as_bytes());
 
@@ -2697,6 +2845,14 @@ fn test_query_captures_with_text_conditions() {
             ((identifier) @function.builtin
              (#eq? @function.builtin "require"))
 
+            ((identifier) @variable.builtin
+              (#any-of? @variable.builtin
+                        "arguments"
+                        "module"
+                        "console"
+                        "window"
+                        "document"))
+
             ((identifier) @variable
              (#not-match? @variable "^(lambda|load)$"))
             "#,
@@ -2710,11 +2866,14 @@ fn test_query_captures_with_text_conditions() {
           lambda
           const ab = require('./ab');
           new Cd(EF);
+          document;
+          module;
+          console;
         ";
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
         let mut cursor = QueryCursor::new();
 
         let captures = cursor.captures(&query, tree.root_node(), source.as_bytes());
@@ -2731,6 +2890,12 @@ fn test_query_captures_with_text_conditions() {
                 ("constant", "EF"),
                 ("constructor", "EF"),
                 ("variable", "EF"),
+                ("variable.builtin", "document"),
+                ("variable", "document"),
+                ("variable.builtin", "module"),
+                ("variable", "module"),
+                ("variable.builtin", "console"),
+                ("variable", "console"),
             ],
         );
     });
@@ -2769,7 +2934,8 @@ fn test_query_captures_with_predicates() {
                 args: vec![
                     QueryPredicateArg::Capture(0),
                     QueryPredicateArg::String("omg".to_string().into_boxed_str()),
-                ],
+                ]
+                .into_boxed_slice(),
             },]
         );
         assert_eq!(query.property_settings(1), &[]);
@@ -2853,7 +3019,7 @@ fn test_query_captures_with_duplicates() {
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
         let mut cursor = QueryCursor::new();
 
         let captures = cursor.captures(&query, tree.root_node(), source.as_bytes());
@@ -3055,11 +3221,11 @@ fn test_query_captures_with_too_many_nested_results() {
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
         let mut cursor = QueryCursor::new();
         cursor.set_match_limit(32);
         let captures = cursor.captures(&query, tree.root_node(), source.as_bytes());
-        let captures = collect_captures(captures, &query, &source);
+        let captures = collect_captures(captures, &query, source);
 
         assert_eq!(
             &captures[0..4],
@@ -3118,7 +3284,7 @@ fn test_query_captures_with_definite_pattern_containing_many_nested_matches() {
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
         let mut cursor = QueryCursor::new();
 
         let captures = cursor.captures(&query, tree.root_node(), source.as_bytes());
@@ -3154,7 +3320,7 @@ fn test_query_captures_ordered_by_both_start_and_end_positions() {
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
         let mut cursor = QueryCursor::new();
 
         let captures = cursor.captures(&query, tree.root_node(), source.as_bytes());
@@ -3195,7 +3361,7 @@ fn test_query_captures_with_matches_removed() {
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
         let mut cursor = QueryCursor::new();
 
         let mut captured_strings = Vec::new();
@@ -3239,7 +3405,7 @@ fn test_query_captures_with_matches_removed_before_they_finish() {
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
         let mut cursor = QueryCursor::new();
 
         let mut captured_strings = Vec::new();
@@ -3281,7 +3447,7 @@ fn test_query_captures_and_matches_iterators_are_fused() {
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
         let mut cursor = QueryCursor::new();
         let mut captures = cursor.captures(&query, tree.root_node(), source.as_bytes());
 
@@ -3355,7 +3521,7 @@ fn test_query_text_callback_returns_chunks() {
 
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
         let mut cursor = QueryCursor::new();
         let captures = cursor.captures(&query, tree.root_node(), |node: Node| {
             chunks_in_range(node.byte_range())
@@ -3439,12 +3605,7 @@ fn test_query_capture_names() {
 
         assert_eq!(
             query.capture_names(),
-            &[
-                "left-operand".to_string(),
-                "right-operand".to_string(),
-                "body".to_string(),
-                "loop-condition".to_string(),
-            ]
+            ["left-operand", "right-operand", "body", "loop-condition"]
         );
     });
 }
@@ -3458,7 +3619,7 @@ fn test_query_lifetime_is_separate_from_nodes_lifetime() {
         let language = get_language("javascript");
         let mut parser = Parser::new();
         parser.set_language(language).unwrap();
-        let tree = parser.parse(&source, None).unwrap();
+        let tree = parser.parse(source, None).unwrap();
 
         fn take_first_node_from_captures<'tree>(
             source: &str,
@@ -3634,17 +3795,22 @@ fn test_query_random() {
             .parse(include_str!("helpers/query_helpers.rs"), None)
             .unwrap();
 
-        // let start_seed = *SEED;
         let start_seed = 0;
+        let end_seed = start_seed + *ITERATION_COUNT;
 
-        for i in 0..100 {
-            let seed = (start_seed + i) as u64;
+        for seed in start_seed..(start_seed + end_seed) {
+            let seed = seed as u64;
             let mut rand = StdRng::seed_from_u64(seed);
             let (pattern_ast, _) = Pattern::random_pattern_in_tree(&pattern_tree, &mut rand);
             let pattern = pattern_ast.to_string();
             let expected_matches = pattern_ast.matches_in_tree(&test_tree);
 
-            let query = Query::new(language, &pattern).unwrap();
+            let query = match Query::new(language, &pattern) {
+                Ok(query) => query,
+                Err(e) => {
+                    panic!("failed to build query for pattern {pattern} - {e}. seed: {seed}");
+                }
+            };
             let mut actual_matches = cursor
                 .matches(
                     &query,
@@ -3656,7 +3822,7 @@ fn test_query_random() {
                     captures: mat
                         .captures
                         .iter()
-                        .map(|c| (query.capture_names()[c.index as usize].as_str(), c.node))
+                        .map(|c| (query.capture_names()[c.index as usize], c.node))
                         .collect::<Vec<_>>(),
                 })
                 .collect::<Vec<_>>();
@@ -3766,10 +3932,10 @@ fn test_query_is_pattern_guaranteed_at_step() {
         Row {
             description: "a guaranteed step with a field",
             language: get_language("javascript"),
-            pattern: r#"(binary_expression left: (identifier) right: (_))"#,
+            pattern: r#"(binary_expression left: (expression) right: (_))"#,
             results_by_substring: &[
                 ("binary_expression", false),
-                ("(identifier)", false),
+                ("(expression)", false),
                 ("(_)", true),
             ],
         },
@@ -3836,7 +4002,7 @@ fn test_query_is_pattern_guaranteed_at_step() {
             "#,
             results_by_substring: &[
                 ("identifier", false),
-                ("property_identifier", true),
+                ("property_identifier", false),
                 ("[", true),
             ],
         },
@@ -4070,6 +4236,103 @@ fn test_query_is_pattern_rooted() {
     });
 }
 
+#[test]
+fn test_query_is_pattern_non_local() {
+    struct Row {
+        description: &'static str,
+        pattern: &'static str,
+        language: Language,
+        is_non_local: bool,
+    }
+
+    let rows = [
+        Row {
+            description: "simple token",
+            pattern: r#"(identifier)"#,
+            language: get_language("python"),
+            is_non_local: false,
+        },
+        Row {
+            description: "siblings that can occur in an argument list",
+            pattern: r#"((identifier) (identifier))"#,
+            language: get_language("python"),
+            is_non_local: true,
+        },
+        Row {
+            description: "siblings that can occur in a statement block",
+            pattern: r#"((return_statement) (return_statement))"#,
+            language: get_language("python"),
+            is_non_local: true,
+        },
+        Row {
+            description: "siblings that can occur in a source file",
+            pattern: r#"((function_definition) (class_definition))"#,
+            language: get_language("python"),
+            is_non_local: true,
+        },
+        Row {
+            description: "siblings that can't occur in any repetition",
+            pattern: r#"("{" "}")"#,
+            language: get_language("python"),
+            is_non_local: false,
+        },
+        Row {
+            description: "siblings that can't occur in any repetition, wildcard root",
+            pattern: r#"(_ "{" "}") @foo"#,
+            language: get_language("javascript"),
+            is_non_local: false,
+        },
+        Row {
+            description: "siblings that can occur in a class body, wildcard root",
+            pattern: r#"(_ (method_definition) (method_definition)) @foo"#,
+            language: get_language("javascript"),
+            is_non_local: true,
+        },
+        Row {
+            description: "top-level repetitions that can occur in a class body",
+            pattern: r#"(method_definition)+ @foo"#,
+            language: get_language("javascript"),
+            is_non_local: true,
+        },
+        Row {
+            description: "top-level repetitions that can occur in a statement block",
+            pattern: r#"(return_statement)+ @foo"#,
+            language: get_language("javascript"),
+            is_non_local: true,
+        },
+        Row {
+            description: "rooted pattern that can occur in a statement block",
+            pattern: r#"(return_statement) @foo"#,
+            language: get_language("javascript"),
+            is_non_local: false,
+        },
+    ];
+
+    allocations::record(|| {
+        eprintln!("");
+
+        for row in &rows {
+            if let Some(filter) = EXAMPLE_FILTER.as_ref() {
+                if !row.description.contains(filter.as_str()) {
+                    continue;
+                }
+            }
+            eprintln!("  query example: {:?}", row.description);
+            let query = Query::new(row.language, row.pattern).unwrap();
+            assert_eq!(
+                query.is_pattern_non_local(0),
+                row.is_non_local,
+                "Description: {}, Pattern: {:?}",
+                row.description,
+                row.pattern
+                    .split_ascii_whitespace()
+                    .collect::<Vec<_>>()
+                    .join(" "),
+            )
+        }
+    });
+}
+
 #[test]
 fn test_capture_quantifiers() {
     struct Row {
@@ -4307,55 +4570,410 @@ fn test_capture_quantifiers() {
     });
 }
 
-fn assert_query_matches(
-    language: Language,
-    query: &Query,
-    source: &str,
-    expected: &[(usize, Vec<(&str, &str)>)],
-) {
+#[test]
+fn test_query_quantified_captures() {
+    struct Row {
+        description: &'static str,
+        language: Language,
+        code: &'static str,
+        pattern: &'static str,
+        captures: &'static [(&'static str, &'static str)],
+    }
+
+    // #[rustfmt::skip]
+    let rows = &[
+        Row {
+            description: "doc comments where all must match the prefix",
+            language: get_language("c"),
+            code: indoc! {"
+            /// foo
+            /// bar
+            /// baz
+
+            void main() {}
+
+            /// qux
+            /// quux
+            // quuz
+        "},
+            pattern: r#"
+                ((comment)+ @comment.documentation
+                  (#match? @comment.documentation "^///"))
+            "#,
+            captures: &[
+                ("comment.documentation", "/// foo"),
+                ("comment.documentation", "/// bar"),
+                ("comment.documentation", "/// baz"),
+            ],
+        },
+        Row {
+            description: "doc comments where one must match the prefix",
+            language: get_language("c"),
+            code: indoc! {"
+            /// foo
+            /// bar
+            /// baz
+
+            void main() {}
+
+            /// qux
+            /// quux
+            // quuz
+        "},
+            pattern: r#"
+                ((comment)+ @comment.documentation
+                  (#any-match? @comment.documentation "^///"))
+            "#,
+            captures: &[
+                ("comment.documentation", "/// foo"),
+                ("comment.documentation", "/// bar"),
+                ("comment.documentation", "/// baz"),
+                ("comment.documentation", "/// qux"),
+                ("comment.documentation", "/// quux"),
+                ("comment.documentation", "// quuz"),
+            ],
+        },
+    ];
+
+    allocations::record(|| {
+        for row in rows {
+            eprintln!("  quantified query example: {:?}", row.description);
+
+            let mut parser = Parser::new();
+            parser.set_language(row.language).unwrap();
+            let tree = parser.parse(row.code, None).unwrap();
+
+            let query = Query::new(row.language, row.pattern).unwrap();
+
+            let mut cursor = QueryCursor::new();
+            let matches = cursor.captures(&query, tree.root_node(), row.code.as_bytes());
+
+            assert_eq!(collect_captures(matches, &query, row.code), row.captures);
+        }
+    });
+}
+
+#[test]
+fn test_query_max_start_depth() {
+    struct Row {
+        description: &'static str,
+        pattern: &'static str,
+        depth: u32,
+        matches: &'static [(usize, &'static [(&'static str, &'static str)])],
+    }
+
+    let source = indoc! {"
+        if (a1 && a2) {
+            if (b1 && b2) { }
+            if (c) { }
+        }
+        if (d) {
+            if (e1 && e2) { }
+            if (f) { }
+        }
+    "};
+
+    #[rustfmt::skip]
+    let rows = &[
+        Row {
+            description: "depth 0: match translation unit",
+            depth: 0,
+            pattern: r#"
+                (translation_unit) @capture
+            "#,
+            matches: &[
+                (0, &[("capture", "if (a1 && a2) {\n    if (b1 && b2) { }\n    if (c) { }\n}\nif (d) {\n    if (e1 && e2) { }\n    if (f) { }\n}\n")]),
+            ]
+        },
+        Row {
+            description: "depth 0: match none",
+            depth: 0,
+            pattern: r#"
+                (if_statement) @capture
+            "#,
+            matches: &[]
+        },
+        Row {
+            description: "depth 1: match 2 if statements at the top level",
+            depth: 1,
+            pattern: r#"
+                (if_statement) @capture
+            "#,
+            matches : &[
+                (0, &[("capture", "if (a1 && a2) {\n    if (b1 && b2) { }\n    if (c) { }\n}")]),
+                (0, &[("capture", "if (d) {\n    if (e1 && e2) { }\n    if (f) { }\n}")]),
+            ]
+        },
+        Row {
+            description: "depth 1 with deep pattern: match the only the first if statement",
+            depth: 1,
+            pattern: r#"
+                (if_statement
+                    condition: (parenthesized_expression
+                        (binary_expression)
+                    )
+                ) @capture
+            "#,
+            matches: &[
+                (0, &[("capture", "if (a1 && a2) {\n    if (b1 && b2) { }\n    if (c) { }\n}")]),
+            ]
+        },
+        Row {
+            description: "depth 3 with deep pattern: match all if statements with a binexpr condition",
+            depth: 3,
+            pattern: r#"
+                (if_statement
+                    condition: (parenthesized_expression
+                        (binary_expression)
+                    )
+                ) @capture
+            "#,
+            matches: &[
+                (0, &[("capture", "if (a1 && a2) {\n    if (b1 && b2) { }\n    if (c) { }\n}")]),
+                (0, &[("capture", "if (b1 && b2) { }")]),
+                (0, &[("capture", "if (e1 && e2) { }")]),
+            ]
+        },
+    ];
+
+    allocations::record(|| {
+        let language = get_language("c");
+        let mut parser = Parser::new();
+        parser.set_language(language).unwrap();
+        let tree = parser.parse(source, None).unwrap();
+        let mut cursor = QueryCursor::new();
+
+        for row in rows.iter() {
+            eprintln!("  query example: {:?}", row.description);
+
+            let query = Query::new(language, row.pattern).unwrap();
+            cursor.set_max_start_depth(Some(row.depth));
+
+            let matches = cursor.matches(&query, tree.root_node(), source.as_bytes());
+            let expected = row
+                .matches
+                .iter()
+                .map(|x| (x.0, x.1.to_vec()))
+                .collect::<Vec<_>>();
+
+            assert_eq!(collect_matches(matches, &query, source), expected);
+        }
+    });
+}
+
+#[test]
+fn test_query_error_does_not_oob() {
+    let language = get_language("javascript");
+
+    assert_eq!(
+        Query::new(language, "(clas").unwrap_err(),
+        QueryError {
+            row: 0,
+            offset: 1,
+            column: 1,
+            kind: QueryErrorKind::NodeType,
+            message: "clas".to_string()
+        }
+    );
+}
+
+#[test]
+fn test_consecutive_zero_or_modifiers() {
+    let language = get_language("javascript");
     let mut parser = Parser::new();
     parser.set_language(language).unwrap();
-    let tree = parser.parse(source, None).unwrap();
-    let mut cursor = QueryCursor::new();
-    let matches = cursor.matches(&query, tree.root_node(), source.as_bytes());
-    assert_eq!(collect_matches(matches, &query, source), expected);
-    assert_eq!(cursor.did_exceed_match_limit(), false);
+
+    let zero_source = "";
+    let three_source = "/**/ /**/ /**/";
+
+    let zero_tree = parser.parse(zero_source, None).unwrap();
+    let three_tree = parser.parse(three_source, None).unwrap();
+
+    let tests = [
+        "(comment)*** @capture",
+        "(comment)??? @capture",
+        "(comment)*?* @capture",
+        "(comment)?*? @capture",
+    ];
+
+    for test in tests {
+        let query = Query::new(language, test).unwrap();
+
+        let mut cursor = QueryCursor::new();
+        let mut matches = cursor.matches(&query, zero_tree.root_node(), zero_source.as_bytes());
+        assert!(matches.next().is_some());
+
+        let mut cursor = QueryCursor::new();
+        let matches = cursor.matches(&query, three_tree.root_node(), three_source.as_bytes());
+
+        let mut len_3 = false;
+        let mut len_1 = false;
+
+        for m in matches {
+            if m.captures.len() == 3 {
+                len_3 = true;
+            }
+            if m.captures.len() == 1 {
+                len_1 = true;
+            }
+        }
+
+        assert_eq!(len_3, test.contains('*'));
+        assert_eq!(len_1, test.contains("???"));
+    }
 }
 
-fn collect_matches<'a>(
-    matches: impl Iterator<Item = QueryMatch<'a, 'a>>,
-    query: &'a Query,
-    source: &'a str,
-) -> Vec<(usize, Vec<(&'a str, &'a str)>)> {
-    matches
-        .map(|m| {
-            (
-                m.pattern_index,
-                format_captures(m.captures.iter().cloned(), query, source),
-            )
-        })
-        .collect()
+#[test]
+fn test_query_max_start_depth_more() {
+    struct Row {
+        depth: u32,
+        matches: &'static [(usize, &'static [(&'static str, &'static str)])],
+    }
+
+    let source = indoc! {"
+        {
+            { }
+            {
+                { }
+            }
+        }
+    "};
+
+    #[rustfmt::skip]
+    let rows = &[
+        Row {
+            depth: 0,
+            matches: &[
+                (0, &[("capture", "{\n    { }\n    {\n        { }\n    }\n}")])
+            ]
+        },
+        Row {
+            depth: 1,
+            matches: &[
+                (0, &[("capture", "{\n    { }\n    {\n        { }\n    }\n}")]),
+                (0, &[("capture", "{ }")]),
+                (0, &[("capture", "{\n        { }\n    }")])
+            ]
+        },
+        Row {
+            depth: 2,
+            matches: &[
+                (0, &[("capture", "{\n    { }\n    {\n        { }\n    }\n}")]),
+                (0, &[("capture", "{ }")]),
+                (0, &[("capture", "{\n        { }\n    }")]),
+                (0, &[("capture", "{ }")]),
+            ]
+        },
+    ];
+
+    allocations::record(|| {
+        let language = get_language("c");
+        let mut parser = Parser::new();
+        parser.set_language(language).unwrap();
+        let tree = parser.parse(source, None).unwrap();
+        let mut cursor = QueryCursor::new();
+        let query = Query::new(language, "(compound_statement) @capture").unwrap();
+
+        let mut matches = cursor.matches(&query, tree.root_node(), source.as_bytes());
+        let node = matches.next().unwrap().captures[0].node;
+        assert_eq!(node.kind(), "compound_statement");
+
+        for row in rows.iter() {
+            eprintln!("  depth: {}", row.depth);
+
+            cursor.set_max_start_depth(Some(row.depth));
+
+            let matches = cursor.matches(&query, node, source.as_bytes());
+            let expected = row
+                .matches
+                .iter()
+                .map(|x| (x.0, x.1.to_vec()))
+                .collect::<Vec<_>>();
+
+            assert_eq!(collect_matches(matches, &query, source), expected);
+        }
+    });
 }
 
-fn collect_captures<'a>(
-    captures: impl Iterator<Item = (QueryMatch<'a, 'a>, usize)>,
-    query: &'a Query,
-    source: &'a str,
-) -> Vec<(&'a str, &'a str)> {
-    format_captures(captures.map(|(m, i)| m.captures[i]), query, source)
-}
+#[test]
+fn test_grammar_with_aliased_literal_query() {
+    // module.exports = grammar({
+    //   name: 'test',
+    //
+    //   rules: {
+    //     source: $ => repeat(choice($.compound_statement, $.expansion)),
+    //
+    //     compound_statement: $ => seq(alias(token(prec(-1, '}')), '}')),
+    //
+    //     expansion: $ => seq('}'),
+    //   },
+    // });
+    let (parser_name, parser_code) = generate_parser_for_grammar(
+        r#"
+        {
+            "name": "test",
+            "rules": {
+                "source": {
+                    "type": "REPEAT",
+                    "content": {
+                        "type": "CHOICE",
+                        "members": [
+                            {
+                                "type": "SYMBOL",
+                                "name": "compound_statement"
+                            },
+                            {
+                                "type": "SYMBOL",
+                                "name": "expansion"
+                            }
+                        ]
+                    }
+                },
+                "compound_statement": {
+                    "type": "SEQ",
+                    "members": [
+                        {
+                            "type": "ALIAS",
+                            "content": {
+                                "type": "TOKEN",
+                                "content": {
+                                    "type": "PREC",
+                                    "value": -1,
+                                    "content": {
+                                        "type": "STRING",
+                                        "value": "}"
+                                    }
+                                }
+                            },
+                            "named": false,
+                            "value": "}"
+                        }
+                    ]
+                },
+                "expansion": {
+                    "type": "SEQ",
+                    "members": [
+                        {
+                            "type": "STRING",
+                            "value": "}"
+                        }
+                    ]
+                }
+            }
+        }
+        "#,
+    )
+    .unwrap();
 
-fn format_captures<'a>(
-    captures: impl Iterator<Item = QueryCapture<'a>>,
-    query: &'a Query,
-    source: &'a str,
-) -> Vec<(&'a str, &'a str)> {
-    captures
-        .map(|capture| {
-            (
-                query.capture_names()[capture.index as usize].as_str(),
-                capture.node.utf8_text(source.as_bytes()).unwrap(),
-            )
-        })
-        .collect()
+    let language = get_test_language(&parser_name, &parser_code, None);
+
+    let query = Query::new(
+        language,
+        r#"
+        (compound_statement "}" @bracket1)
+        (expansion "}" @bracket2)
+        "#,
+    );
+
+    assert!(query.is_ok());
 }
diff --git a/cli/src/tests/tags_test.rs b/cli/src/tests/tags_test.rs
index 07e5d1de..20392749 100644
--- a/cli/src/tests/tags_test.rs
+++ b/cli/src/tests/tags_test.rs
@@ -9,7 +9,7 @@ use std::{
 use tree_sitter::Point;
 use tree_sitter_tags::{c_lib as c, Error, TagsConfiguration, TagsContext};
 
-const PYTHON_TAG_QUERY: &'static str = r#"
+const PYTHON_TAG_QUERY: &str = r#"
 (
   (function_definition
     name: (identifier) @name
@@ -39,7 +39,7 @@ const PYTHON_TAG_QUERY: &'static str = r#"
     attribute: (identifier) @name)) @reference.call
 "#;
 
-const JS_TAG_QUERY: &'static str = r#"
+const JS_TAG_QUERY: &str = r#"
 (
     (comment)* @doc .
     (class_declaration
@@ -68,7 +68,7 @@ const JS_TAG_QUERY: &'static str = r#"
     function: (identifier) @name) @reference.call
 "#;
 
-const RUBY_TAG_QUERY: &'static str = r#"
+const RUBY_TAG_QUERY: &str = r#"
 (method
     name: (_) @name) @definition.method
 
@@ -359,25 +359,29 @@ fn test_tags_via_c_api() {
         );
 
         let c_scope_name = CString::new(scope_name).unwrap();
-        let result = c::ts_tagger_add_language(
-            tagger,
-            c_scope_name.as_ptr(),
-            language,
-            JS_TAG_QUERY.as_ptr(),
-            ptr::null(),
-            JS_TAG_QUERY.len() as u32,
-            0,
-        );
+        let result = unsafe {
+            c::ts_tagger_add_language(
+                tagger,
+                c_scope_name.as_ptr(),
+                language,
+                JS_TAG_QUERY.as_ptr(),
+                ptr::null(),
+                JS_TAG_QUERY.len() as u32,
+                0,
+            )
+        };
         assert_eq!(result, c::TSTagsError::Ok);
 
-        let result = c::ts_tagger_tag(
-            tagger,
-            c_scope_name.as_ptr(),
-            source_code.as_ptr(),
-            source_code.len() as u32,
-            buffer,
-            ptr::null(),
-        );
+        let result = unsafe {
+            c::ts_tagger_tag(
+                tagger,
+                c_scope_name.as_ptr(),
+                source_code.as_ptr(),
+                source_code.len() as u32,
+                buffer,
+                ptr::null(),
+            )
+        };
         assert_eq!(result, c::TSTagsError::Ok);
         let tags = unsafe {
             slice::from_raw_parts(
@@ -419,8 +423,10 @@ fn test_tags_via_c_api() {
             ]
         );
 
-        c::ts_tags_buffer_delete(buffer);
-        c::ts_tagger_delete(tagger);
+        unsafe {
+            c::ts_tags_buffer_delete(buffer);
+            c::ts_tagger_delete(tagger);
+        }
     });
 }
 
diff --git a/cli/src/tests/test_highlight_test.rs b/cli/src/tests/test_highlight_test.rs
index af2c15c5..06ad7d59 100644
--- a/cli/src/tests/test_highlight_test.rs
+++ b/cli/src/tests/test_highlight_test.rs
@@ -12,7 +12,7 @@ fn test_highlight_test_with_basic_test() {
         Some("injections.scm"),
         &[
             "function".to_string(),
-            "variable.parameter".to_string(),
+            "variable".to_string(),
             "keyword".to_string(),
         ],
     );
@@ -22,7 +22,8 @@ fn test_highlight_test_with_basic_test() {
         "  // ^ function",
         "  //       ^ keyword",
         "  return d + e;",
-        "  //     ^ variable.parameter",
+        "  //     ^ variable",
+        "  //       ^ !variable",
         "};",
     ]
     .join("\n");
@@ -32,18 +33,10 @@ fn test_highlight_test_with_basic_test() {
     assert_eq!(
         assertions,
         &[
-            Assertion {
-                position: Point::new(1, 5),
-                expected_capture_name: "function".to_string()
-            },
-            Assertion {
-                position: Point::new(1, 11),
-                expected_capture_name: "keyword".to_string()
-            },
-            Assertion {
-                position: Point::new(4, 9),
-                expected_capture_name: "variable.parameter".to_string()
-            },
+            Assertion::new(1, 5, false, String::from("function")),
+            Assertion::new(1, 11, false, String::from("keyword")),
+            Assertion::new(4, 9, false, String::from("variable")),
+            Assertion::new(4, 11, true, String::from("variable")),
         ]
     );
 
@@ -60,6 +53,7 @@ fn test_highlight_test_with_basic_test() {
             (Point::new(1, 19), Point::new(1, 20), Highlight(1)), // "d"
             (Point::new(4, 2), Point::new(4, 8), Highlight(2)), // "return"
             (Point::new(4, 9), Point::new(4, 10), Highlight(1)), // "d"
+            (Point::new(4, 13), Point::new(4, 14), Highlight(1)), // "e"
         ]
     );
 }
diff --git a/cli/src/tests/test_tags_test.rs b/cli/src/tests/test_tags_test.rs
index 61f98abd..e682434e 100644
--- a/cli/src/tests/test_tags_test.rs
+++ b/cli/src/tests/test_tags_test.rs
@@ -16,6 +16,7 @@ fn test_tags_test_with_basic_test() {
         "    #    ^ reference.call",
         "    return d(e)",
         "    #      ^ reference.call",
+        "    #        ^ !variable.parameter",
         "",
     ]
     .join("\n");
@@ -26,18 +27,10 @@ fn test_tags_test_with_basic_test() {
     assert_eq!(
         assertions,
         &[
-            Assertion {
-                position: Point::new(1, 4),
-                expected_capture_name: "definition.function".to_string(),
-            },
-            Assertion {
-                position: Point::new(3, 9),
-                expected_capture_name: "reference.call".to_string(),
-            },
-            Assertion {
-                position: Point::new(5, 11),
-                expected_capture_name: "reference.call".to_string(),
-            },
+            Assertion::new(1, 4, false, String::from("definition.function")),
+            Assertion::new(3, 9, false, String::from("reference.call")),
+            Assertion::new(5, 11, false, String::from("reference.call")),
+            Assertion::new(5, 13, true, String::from("variable.parameter")),
         ]
     );
 
diff --git a/cli/src/tests/text_provider_test.rs b/cli/src/tests/text_provider_test.rs
new file mode 100644
index 00000000..cb0b38f6
--- /dev/null
+++ b/cli/src/tests/text_provider_test.rs
@@ -0,0 +1,173 @@
+use std::{iter, sync::Arc};
+
+use crate::tests::helpers::fixtures::get_language;
+use tree_sitter::{Language, Node, Parser, Point, Query, QueryCursor, TextProvider, Tree};
+
+fn parse_text(text: impl AsRef<[u8]>) -> (Tree, Language) {
+    let language = get_language("c");
+    let mut parser = Parser::new();
+    parser.set_language(language).unwrap();
+    (parser.parse(text, None).unwrap(), language)
+}
+
+fn parse_text_with<T, F>(callback: &mut F) -> (Tree, Language)
+where
+    T: AsRef<[u8]>,
+    F: FnMut(usize, Point) -> T,
+{
+    let language = get_language("c");
+    let mut parser = Parser::new();
+    parser.set_language(language).unwrap();
+    let tree = parser.parse_with(callback, None).unwrap();
+    // eprintln!("{}", tree.clone().root_node().to_sexp());
+    assert_eq!("comment", tree.clone().root_node().child(0).unwrap().kind());
+    (tree, language)
+}
+
+fn tree_query<I: AsRef<[u8]>>(tree: &Tree, text: impl TextProvider<I>, language: Language) {
+    let query = Query::new(language, "((comment) @c (#eq? @c \"// comment\"))").unwrap();
+    let mut cursor = QueryCursor::new();
+    let mut captures = cursor.captures(&query, tree.root_node(), text);
+    let (match_, idx) = captures.next().unwrap();
+    let capture = match_.captures[idx];
+    assert_eq!(capture.index as usize, idx);
+    assert_eq!("comment", capture.node.kind());
+}
+
+fn check_parsing<I: AsRef<[u8]>>(
+    parser_text: impl AsRef<[u8]>,
+    text_provider: impl TextProvider<I>,
+) {
+    let (tree, language) = parse_text(parser_text);
+    tree_query(&tree, text_provider, language);
+}
+
+fn check_parsing_callback<T, F, I: AsRef<[u8]>>(
+    parser_callback: &mut F,
+    text_provider: impl TextProvider<I>,
+) where
+    T: AsRef<[u8]>,
+    F: FnMut(usize, Point) -> T,
+{
+    let (tree, language) = parse_text_with(parser_callback);
+    tree_query(&tree, text_provider, language);
+}
+
+#[test]
+fn test_text_provider_for_str_slice() {
+    let text: &str = "// comment";
+
+    check_parsing(text, text.as_bytes());
+    check_parsing(text.as_bytes(), text.as_bytes());
+}
+
+#[test]
+fn test_text_provider_for_string() {
+    let text: String = "// comment".to_owned();
+
+    check_parsing(text.clone(), text.as_bytes());
+    check_parsing(text.as_bytes(), text.as_bytes());
+    check_parsing(<_ as AsRef<[u8]>>::as_ref(&text), text.as_bytes());
+}
+
+#[test]
+fn test_text_provider_for_box_of_str_slice() {
+    let text: Box<str> = "// comment".to_owned().into_boxed_str();
+
+    check_parsing(text.as_bytes(), text.as_bytes());
+    check_parsing(<_ as AsRef<str>>::as_ref(&text), text.as_bytes());
+    check_parsing(text.as_ref(), text.as_ref().as_bytes());
+    check_parsing(text.as_ref(), text.as_bytes());
+}
+
+#[test]
+fn test_text_provider_for_box_of_bytes_slice() {
+    let text: Box<[u8]> = "// comment".to_owned().into_boxed_str().into_boxed_bytes();
+
+    check_parsing(text.as_ref(), text.as_ref());
+    check_parsing(text.as_ref(), &*text);
+    check_parsing(&*text, &*text);
+}
+
+#[test]
+fn test_text_provider_for_vec_of_bytes() {
+    let text: Vec<u8> = "// comment".to_owned().into_bytes();
+
+    check_parsing(&*text, &*text);
+}
+
+#[test]
+fn test_text_provider_for_arc_of_bytes_slice() {
+    let text: Vec<u8> = "// comment".to_owned().into_bytes();
+    let text: Arc<[u8]> = Arc::from(text);
+
+    check_parsing(&*text, &*text);
+    check_parsing(text.as_ref(), text.as_ref());
+    check_parsing(text.clone(), text.as_ref());
+}
+
+#[test]
+fn test_text_provider_callback_with_str_slice() {
+    let text: &str = "// comment";
+
+    check_parsing(text, |_node: Node<'_>| iter::once(text));
+    check_parsing_callback(
+        &mut |offset, _point| {
+            (offset < text.len())
+                .then(|| text.as_bytes())
+                .unwrap_or_default()
+        },
+        |_node: Node<'_>| iter::once(text),
+    );
+}
+
+#[test]
+fn test_text_provider_callback_with_owned_string_slice() {
+    let text: &str = "// comment";
+
+    check_parsing_callback(
+        &mut |offset, _point| {
+            (offset < text.len())
+                .then(|| text.as_bytes())
+                .unwrap_or_default()
+        },
+        |_node: Node<'_>| {
+            let slice: String = text.to_owned();
+            iter::once(slice)
+        },
+    );
+}
+
+#[test]
+fn test_text_provider_callback_with_owned_bytes_vec_slice() {
+    let text: &str = "// comment";
+
+    check_parsing_callback(
+        &mut |offset, _point| {
+            (offset < text.len())
+                .then(|| text.as_bytes())
+                .unwrap_or_default()
+        },
+        |_node: Node<'_>| {
+            let slice: Vec<u8> = text.to_owned().into_bytes();
+            iter::once(slice)
+        },
+    );
+}
+
+#[test]
+fn test_text_provider_callback_with_owned_arc_of_bytes_slice() {
+    let text: &str = "// comment";
+
+    check_parsing_callback(
+        &mut |offset, _point| {
+            (offset < text.len())
+                .then(|| text.as_bytes())
+                .unwrap_or_default()
+        },
+        |_node: Node<'_>| {
+            let slice: Arc<[u8]> = text.to_owned().into_bytes().into();
+            iter::once(slice)
+        },
+    );
+}
diff --git a/cli/src/tests/tree_test.rs b/cli/src/tests/tree_test.rs
index be0c4ff1..f3792138 100644
--- a/cli/src/tests/tree_test.rs
+++ b/cli/src/tests/tree_test.rs
@@ -306,7 +306,7 @@ fn test_tree_cursor() {
         .parse(
             "
                 struct Stuff {
-                    a: A;
+                    a: A,
                     b: Option<B>,
                 }
             ",
@@ -331,6 +331,88 @@ fn test_tree_cursor() {
     assert!(cursor.goto_next_sibling());
     assert_eq!(cursor.node().kind(), "field_declaration_list");
     assert_eq!(cursor.node().is_named(), true);
+
+    assert!(cursor.goto_last_child());
+    assert_eq!(cursor.node().kind(), "}");
+    assert_eq!(cursor.node().is_named(), false);
+    assert_eq!(cursor.node().start_position(), Point { row: 4, column: 16 });
+
+    assert!(cursor.goto_previous_sibling());
+    assert_eq!(cursor.node().kind(), ",");
+    assert_eq!(cursor.node().is_named(), false);
+    assert_eq!(cursor.node().start_position(), Point { row: 3, column: 32 });
+
+    assert!(cursor.goto_previous_sibling());
+    assert_eq!(cursor.node().kind(), "field_declaration");
+    assert_eq!(cursor.node().is_named(), true);
+    assert_eq!(cursor.node().start_position(), Point { row: 3, column: 20 });
+
+    assert!(cursor.goto_previous_sibling());
+    assert_eq!(cursor.node().kind(), ",");
+    assert_eq!(cursor.node().is_named(), false);
+    assert_eq!(cursor.node().start_position(), Point { row: 2, column: 24 });
+
+    assert!(cursor.goto_previous_sibling());
+    assert_eq!(cursor.node().kind(), "field_declaration");
+    assert_eq!(cursor.node().is_named(), true);
+    assert_eq!(cursor.node().start_position(), Point { row: 2, column: 20 });
+
+    assert!(cursor.goto_previous_sibling());
+    assert_eq!(cursor.node().kind(), "{");
+    assert_eq!(cursor.node().is_named(), false);
+    assert_eq!(cursor.node().start_position(), Point { row: 1, column: 29 });
+
+    let mut copy = tree.walk();
+    copy.reset_to(cursor);
+
+    assert_eq!(copy.node().kind(), "{");
+    assert_eq!(copy.node().is_named(), false);
+
+    assert!(copy.goto_parent());
+    assert_eq!(copy.node().kind(), "field_declaration_list");
+    assert_eq!(copy.node().is_named(), true);
+
+    assert!(copy.goto_parent());
+    assert_eq!(copy.node().kind(), "struct_item");
+}
+
+#[test]
+fn test_tree_cursor_previous_sibling() {
+    let mut parser = Parser::new();
+    parser.set_language(get_language("rust")).unwrap();
+
+    let text = "
+    // Hi there
+    // This is fun!
+    // Another one!
+";
+    let tree = parser.parse(text, None).unwrap();
+
+    let mut cursor = tree.walk();
+    assert_eq!(cursor.node().kind(), "source_file");
+
+    assert!(cursor.goto_last_child());
+    assert_eq!(cursor.node().kind(), "line_comment");
+    assert_eq!(
+        cursor.node().utf8_text(text.as_bytes()).unwrap(),
+        "// Another one!"
+    );
+
+    assert!(cursor.goto_previous_sibling());
+    assert_eq!(cursor.node().kind(), "line_comment");
+    assert_eq!(
+        cursor.node().utf8_text(text.as_bytes()).unwrap(),
+        "// This is fun!"
+    );
+
+    assert!(cursor.goto_previous_sibling());
+    assert_eq!(cursor.node().kind(), "line_comment");
+    assert_eq!(
+        cursor.node().utf8_text(text.as_bytes()).unwrap(),
+        "// Hi there"
+    );
+
+    assert!(!cursor.goto_previous_sibling());
 }
 
 #[test]
@@ -620,7 +702,7 @@ fn get_changed_ranges(
     source_code: &mut Vec<u8>,
     edit: Edit,
 ) -> Vec<Range> {
-    perform_edit(tree, source_code, &edit);
+    perform_edit(tree, source_code, &edit).unwrap();
     let new_tree = parser.parse(&source_code, Some(tree)).unwrap();
     let result = tree.changed_ranges(&new_tree).collect();
     *tree = new_tree;
diff --git a/cli/src/util.rs b/cli/src/util.rs
index acd8acbf..0793e525 100644
--- a/cli/src/util.rs
+++ b/cli/src/util.rs
@@ -1,9 +1,7 @@
 use anyhow::Result;
-use std::io;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
-use std::thread;
-use tree_sitter::Parser;
+use tree_sitter::{Parser, Tree};
 
 #[cfg(unix)]
 use anyhow::{anyhow, Context};
@@ -13,55 +11,86 @@ use std::path::PathBuf;
 use std::process::{Child, ChildStdin, Command, Stdio};
 
 #[cfg(unix)]
-const HTML_HEADER: &[u8] = b"<!DOCTYPE html>\n<style>svg { width: 100%; }</style>\n\n";
+const HTML_HEADER: &[u8] = b"
+<!DOCTYPE html>
 
-pub fn cancel_on_stdin() -> Arc<AtomicUsize> {
+<style>
+svg { width: 100%; }
+</style>
+
+";
+
+pub fn cancel_on_signal() -> Arc<AtomicUsize> {
     let result = Arc::new(AtomicUsize::new(0));
-    if atty::is(atty::Stream::Stdin) {
-        thread::spawn({
-            let flag = result.clone();
-            move || {
-                let mut line = String::new();
-                io::stdin().read_line(&mut line).unwrap();
-                flag.store(1, Ordering::Relaxed);
-            }
-        });
-    }
+    ctrlc::set_handler({
+        let flag = result.clone();
+        move || {
+            flag.store(1, Ordering::Relaxed);
+        }
+    })
+    .expect("Error setting Ctrl-C handler");
     result
 }
+
 #[cfg(windows)]
-pub struct LogSession();
+pub struct LogSession;
 
 #[cfg(unix)]
-pub struct LogSession(PathBuf, Option<Child>, Option<ChildStdin>);
+pub struct LogSession {
+    path: PathBuf,
+    dot_process: Option<Child>,
+    dot_process_stdin: Option<ChildStdin>,
+}
+
+#[cfg(windows)]
+pub fn print_tree_graph(_tree: &Tree, _path: &str) -> Result<()> {
+    Ok(())
+}
 
 #[cfg(windows)]
 pub fn log_graphs(_parser: &mut Parser, _path: &str) -> Result<LogSession> {
-    Ok(LogSession())
+    Ok(LogSession)
+}
+
+#[cfg(unix)]
+pub fn print_tree_graph(tree: &Tree, path: &str) -> Result<()> {
+    let session = LogSession::new(path)?;
+    tree.print_dot_graph(session.dot_process_stdin.as_ref().unwrap());
+    Ok(())
 }
 
 #[cfg(unix)]
 pub fn log_graphs(parser: &mut Parser, path: &str) -> Result<LogSession> {
-    use std::io::Write;
+    let session = LogSession::new(path)?;
+    parser.print_dot_graphs(session.dot_process_stdin.as_ref().unwrap());
+    Ok(session)
+}
 
-    let mut dot_file = std::fs::File::create(path)?;
-    dot_file.write(HTML_HEADER)?;
-    let mut dot_process = Command::new("dot")
-        .arg("-Tsvg")
-        .stdin(Stdio::piped())
-        .stdout(dot_file)
-        .spawn()
-        .with_context(|| "Failed to run the `dot` command. Check that graphviz is installed.")?;
-    let dot_stdin = dot_process
-        .stdin
-        .take()
-        .ok_or_else(|| anyhow!("Failed to open stdin for `dot` process."))?;
-    parser.print_dot_graphs(&dot_stdin);
-    Ok(LogSession(
-        PathBuf::from(path),
-        Some(dot_process),
-        Some(dot_stdin),
-    ))
+#[cfg(unix)]
+impl LogSession {
+    fn new(path: &str) -> Result<Self> {
+        use std::io::Write;
+
+        let mut dot_file = std::fs::File::create(path)?;
+        dot_file.write(HTML_HEADER)?;
+        let mut dot_process = Command::new("dot")
+            .arg("-Tsvg")
+            .stdin(Stdio::piped())
+            .stdout(dot_file)
+            .spawn()
+            .with_context(|| {
+                "Failed to run the `dot` command. Check that graphviz is installed."
+            })?;
+        let dot_stdin = dot_process
+            .stdin
+            .take()
+            .ok_or_else(|| anyhow!("Failed to open stdin for `dot` process."))?;
+        Ok(Self {
+            path: PathBuf::from(path),
+            dot_process: Some(dot_process),
+            dot_process_stdin: Some(dot_stdin),
+        })
+    }
 }
 
 #[cfg(unix)]
@@ -69,13 +98,13 @@ impl Drop for LogSession {
     fn drop(&mut self) {
         use std::fs;
 
-        drop(self.2.take().unwrap());
-        let output = self.1.take().unwrap().wait_with_output().unwrap();
+        drop(self.dot_process_stdin.take().unwrap());
+        let output = self.dot_process.take().unwrap().wait_with_output().unwrap();
         if output.status.success() {
             if cfg!(target_os = "macos")
-                && fs::metadata(&self.0).unwrap().len() > HTML_HEADER.len() as u64
+                && fs::metadata(&self.path).unwrap().len() > HTML_HEADER.len() as u64
             {
-                Command::new("open").arg(&self.0).output().unwrap();
+                Command::new("open").arg(&self.path).output().unwrap();
             }
         } else {
             eprintln!(
diff --git a/cli/src/wasm.rs b/cli/src/wasm.rs
index d63ec922..794ba353 100644
--- a/cli/src/wasm.rs
+++ b/cli/src/wasm.rs
@@ -1,5 +1,6 @@
 use super::generate::parse_grammar::GrammarJSON;
 use anyhow::{anyhow, Context, Result};
+use path_slash::PathExt as _;
 use std::{
     ffi::{OsStr, OsString},
     fs,
@@ -60,7 +61,7 @@ pub fn compile_language_to_wasm(
             volume_string = OsString::from(parent);
             volume_string.push(":/src:Z");
             command.arg("--workdir");
-            command.arg(&Path::new("/src").join(filename));
+            command.arg(Path::new("/src").join(filename).to_slash_lossy().as_ref());
         } else {
             volume_string = OsString::from(language_dir);
             volume_string.push(":/src:Z");
@@ -84,6 +85,11 @@ pub fn compile_language_to_wasm(
         // Run `emcc` in a container using the `emscripten-slim` image
         command.args(&[EMSCRIPTEN_TAG, "emcc"]);
     } else {
+        if force_docker {
+            return Err(anyhow!(
+                "You must have docker on your PATH to run this command with --docker"
+            ));
+        }
         return Err(anyhow!(
             "You must have either emcc or docker on your PATH to run this command"
         ));
@@ -116,14 +122,18 @@ pub fn compile_language_to_wasm(
     let scanner_cpp_path = src.join("scanner.cpp");
 
     if language_dir.join(&scanner_cc_path).exists() {
-        command.arg("-xc++").arg(&scanner_cc_path);
+        command
+            .arg("-xc++")
+            .arg(scanner_cc_path.to_slash_lossy().as_ref());
     } else if language_dir.join(&scanner_cpp_path).exists() {
-        command.arg("-xc++").arg(&scanner_cpp_path);
+        command
+            .arg("-xc++")
+            .arg(scanner_cpp_path.to_slash_lossy().as_ref());
     } else if language_dir.join(&scanner_c_path).exists() {
-        command.arg(&scanner_c_path);
+        command.arg(scanner_c_path.to_slash_lossy().as_ref());
     }
 
-    command.arg(&parser_c_path);
+    command.arg(parser_c_path.to_slash_lossy().as_ref());
 
     let output = command
         .output()
diff --git a/docs/Gemfile b/docs/Gemfile
index 91ceacd3..ee114290 100644
--- a/docs/Gemfile
+++ b/docs/Gemfile
@@ -1,2 +1,3 @@
 source 'https://rubygems.org'
-gem 'github-pages', group: :jekyll_plugins
\ No newline at end of file
+gem 'github-pages', group: :jekyll_plugins
+gem "webrick"
diff --git a/docs/Gemfile.lock b/docs/Gemfile.lock
index 44aff756..ce19edac 100644
--- a/docs/Gemfile.lock
+++ b/docs/Gemfile.lock
@@ -1,258 +1,260 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (4.2.9)
-      i18n (~> 0.7)
-      minitest (~> 5.1)
-      thread_safe (~> 0.3, >= 0.3.4)
-      tzinfo (~> 1.1)
-    addressable (2.8.0)
-      public_suffix (>= 2.0.2, < 5.0)
+    activesupport (7.0.4.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    addressable (2.8.1)
+      public_suffix (>= 2.0.2, < 6.0)
     coffee-script (2.4.1)
       coffee-script-source
       execjs
     coffee-script-source (1.11.1)
     colorator (1.1.0)
-    commonmarker (0.17.8)
-      ruby-enum (~> 0.5)
-    concurrent-ruby (1.0.5)
-    ethon (0.14.0)
+    commonmarker (0.23.10)
+    concurrent-ruby (1.2.2)
+    dnsruby (1.61.9)
+      simpleidn (~> 0.1)
+    em-websocket (0.5.3)
+      eventmachine (>= 0.12.9)
+      http_parser.rb (~> 0)
+    ethon (0.16.0)
       ffi (>= 1.15.0)
-    execjs (2.7.0)
-    faraday (1.5.1)
-      faraday-em_http (~> 1.0)
-      faraday-em_synchrony (~> 1.0)
-      faraday-excon (~> 1.1)
-      faraday-httpclient (~> 1.0.1)
-      faraday-net_http (~> 1.0)
-      faraday-net_http_persistent (~> 1.1)
-      faraday-patron (~> 1.0)
-      multipart-post (>= 1.2, < 3)
+    eventmachine (1.2.7)
+    execjs (2.8.1)
+    faraday (2.7.4)
+      faraday-net_http (>= 2.0, < 3.1)
       ruby2_keywords (>= 0.0.4)
-    faraday-em_http (1.0.0)
-    faraday-em_synchrony (1.0.0)
-    faraday-excon (1.1.0)
-    faraday-httpclient (1.0.1)
-    faraday-net_http (1.0.1)
-    faraday-net_http_persistent (1.2.0)
-    faraday-patron (1.0.0)
-    ffi (1.15.3)
+    faraday-net_http (3.0.2)
+    ffi (1.15.5)
     forwardable-extended (2.6.0)
-    gemoji (3.0.0)
-    github-pages (177)
-      activesupport (= 4.2.9)
-      github-pages-health-check (= 1.3.5)
-      jekyll (= 3.6.2)
-      jekyll-avatar (= 0.5.0)
-      jekyll-coffeescript (= 1.0.2)
-      jekyll-commonmark-ghpages (= 0.1.5)
+    gemoji (3.0.1)
+    github-pages (228)
+      github-pages-health-check (= 1.17.9)
+      jekyll (= 3.9.3)
+      jekyll-avatar (= 0.7.0)
+      jekyll-coffeescript (= 1.1.1)
+      jekyll-commonmark-ghpages (= 0.4.0)
       jekyll-default-layout (= 0.1.4)
-      jekyll-feed (= 0.9.2)
-      jekyll-gist (= 1.4.1)
-      jekyll-github-metadata (= 2.9.3)
-      jekyll-mentions (= 1.2.0)
-      jekyll-optional-front-matter (= 0.3.0)
+      jekyll-feed (= 0.15.1)
+      jekyll-gist (= 1.5.0)
+      jekyll-github-metadata (= 2.13.0)
+      jekyll-include-cache (= 0.2.1)
+      jekyll-mentions (= 1.6.0)
+      jekyll-optional-front-matter (= 0.3.2)
       jekyll-paginate (= 1.1.0)
-      jekyll-readme-index (= 0.2.0)
-      jekyll-redirect-from (= 0.12.1)
-      jekyll-relative-links (= 0.5.2)
-      jekyll-remote-theme (= 0.2.3)
-      jekyll-sass-converter (= 1.5.0)
-      jekyll-seo-tag (= 2.3.0)
-      jekyll-sitemap (= 1.1.1)
-      jekyll-swiss (= 0.4.0)
-      jekyll-theme-architect (= 0.1.0)
-      jekyll-theme-cayman (= 0.1.0)
-      jekyll-theme-dinky (= 0.1.0)
-      jekyll-theme-hacker (= 0.1.0)
-      jekyll-theme-leap-day (= 0.1.0)
-      jekyll-theme-merlot (= 0.1.0)
-      jekyll-theme-midnight (= 0.1.0)
-      jekyll-theme-minimal (= 0.1.0)
-      jekyll-theme-modernist (= 0.1.0)
-      jekyll-theme-primer (= 0.5.2)
-      jekyll-theme-slate (= 0.1.0)
-      jekyll-theme-tactile (= 0.1.0)
-      jekyll-theme-time-machine (= 0.1.0)
-      jekyll-titles-from-headings (= 0.5.0)
-      jemoji (= 0.8.1)
-      kramdown (= 1.16.2)
-      liquid (= 4.0.0)
-      listen (= 3.0.6)
+      jekyll-readme-index (= 0.3.0)
+      jekyll-redirect-from (= 0.16.0)
+      jekyll-relative-links (= 0.6.1)
+      jekyll-remote-theme (= 0.4.3)
+      jekyll-sass-converter (= 1.5.2)
+      jekyll-seo-tag (= 2.8.0)
+      jekyll-sitemap (= 1.4.0)
+      jekyll-swiss (= 1.0.0)
+      jekyll-theme-architect (= 0.2.0)
+      jekyll-theme-cayman (= 0.2.0)
+      jekyll-theme-dinky (= 0.2.0)
+      jekyll-theme-hacker (= 0.2.0)
+      jekyll-theme-leap-day (= 0.2.0)
+      jekyll-theme-merlot (= 0.2.0)
+      jekyll-theme-midnight (= 0.2.0)
+      jekyll-theme-minimal (= 0.2.0)
+      jekyll-theme-modernist (= 0.2.0)
+      jekyll-theme-primer (= 0.6.0)
+      jekyll-theme-slate (= 0.2.0)
+      jekyll-theme-tactile (= 0.2.0)
+      jekyll-theme-time-machine (= 0.2.0)
+      jekyll-titles-from-headings (= 0.5.3)
+      jemoji (= 0.12.0)
+      kramdown (= 2.3.2)
+      kramdown-parser-gfm (= 1.1.0)
+      liquid (= 4.0.4)
       mercenary (~> 0.3)
-      minima (= 2.1.1)
-      nokogiri (>= 1.8.1, < 2.0)
-      rouge (= 2.2.1)
+      minima (= 2.5.1)
+      nokogiri (>= 1.13.6, < 2.0)
+      rouge (= 3.26.0)
       terminal-table (~> 1.4)
-    github-pages-health-check (1.3.5)
+    github-pages-health-check (1.17.9)
       addressable (~> 2.3)
-      net-dns (~> 0.8)
+      dnsruby (~> 1.60)
       octokit (~> 4.0)
-      public_suffix (~> 2.0)
-      typhoeus (~> 0.7)
-    html-pipeline (2.7.1)
+      public_suffix (>= 3.0, < 5.0)
+      typhoeus (~> 1.3)
+    html-pipeline (2.14.3)
       activesupport (>= 2)
       nokogiri (>= 1.4)
-    i18n (0.9.5)
+    http_parser.rb (0.8.0)
+    i18n (1.12.0)
       concurrent-ruby (~> 1.0)
-    jekyll (3.6.2)
+    jekyll (3.9.3)
       addressable (~> 2.4)
       colorator (~> 1.0)
+      em-websocket (~> 0.5)
+      i18n (>= 0.7, < 2)
       jekyll-sass-converter (~> 1.0)
-      jekyll-watch (~> 1.1)
-      kramdown (~> 1.14)
+      jekyll-watch (~> 2.0)
+      kramdown (>= 1.17, < 3)
       liquid (~> 4.0)
       mercenary (~> 0.3.3)
       pathutil (~> 0.9)
-      rouge (>= 1.7, < 3)
+      rouge (>= 1.7, < 4)
       safe_yaml (~> 1.0)
-    jekyll-avatar (0.5.0)
-      jekyll (~> 3.0)
-    jekyll-coffeescript (1.0.2)
+    jekyll-avatar (0.7.0)
+      jekyll (>= 3.0, < 5.0)
+    jekyll-coffeescript (1.1.1)
       coffee-script (~> 2.2)
       coffee-script-source (~> 1.11.1)
-    jekyll-commonmark (1.1.0)
-      commonmarker (~> 0.14)
-      jekyll (>= 3.0, < 4.0)
-    jekyll-commonmark-ghpages (0.1.5)
-      commonmarker (~> 0.17.6)
-      jekyll-commonmark (~> 1)
-      rouge (~> 2)
+    jekyll-commonmark (1.4.0)
+      commonmarker (~> 0.22)
+    jekyll-commonmark-ghpages (0.4.0)
+      commonmarker (~> 0.23.7)
+      jekyll (~> 3.9.0)
+      jekyll-commonmark (~> 1.4.0)
+      rouge (>= 2.0, < 5.0)
     jekyll-default-layout (0.1.4)
       jekyll (~> 3.0)
-    jekyll-feed (0.9.2)
-      jekyll (~> 3.3)
-    jekyll-gist (1.4.1)
+    jekyll-feed (0.15.1)
+      jekyll (>= 3.7, < 5.0)
+    jekyll-gist (1.5.0)
       octokit (~> 4.2)
-    jekyll-github-metadata (2.9.3)
-      jekyll (~> 3.1)
+    jekyll-github-metadata (2.13.0)
+      jekyll (>= 3.4, < 5.0)
       octokit (~> 4.0, != 4.4.0)
-    jekyll-mentions (1.2.0)
-      activesupport (~> 4.0)
+    jekyll-include-cache (0.2.1)
+      jekyll (>= 3.7, < 5.0)
+    jekyll-mentions (1.6.0)
       html-pipeline (~> 2.3)
-      jekyll (~> 3.0)
-    jekyll-optional-front-matter (0.3.0)
-      jekyll (~> 3.0)
+      jekyll (>= 3.7, < 5.0)
+    jekyll-optional-front-matter (0.3.2)
+      jekyll (>= 3.0, < 5.0)
     jekyll-paginate (1.1.0)
-    jekyll-readme-index (0.2.0)
-      jekyll (~> 3.0)
-    jekyll-redirect-from (0.12.1)
-      jekyll (~> 3.3)
-    jekyll-relative-links (0.5.2)
-      jekyll (~> 3.3)
-    jekyll-remote-theme (0.2.3)
-      jekyll (~> 3.5)
-      rubyzip (>= 1.2.1, < 3.0)
-      typhoeus (>= 0.7, < 2.0)
-    jekyll-sass-converter (1.5.0)
+    jekyll-readme-index (0.3.0)
+      jekyll (>= 3.0, < 5.0)
+    jekyll-redirect-from (0.16.0)
+      jekyll (>= 3.3, < 5.0)
+    jekyll-relative-links (0.6.1)
+      jekyll (>= 3.3, < 5.0)
+    jekyll-remote-theme (0.4.3)
+      addressable (~> 2.0)
+      jekyll (>= 3.5, < 5.0)
+      jekyll-sass-converter (>= 1.0, <= 3.0.0, != 2.0.0)
+      rubyzip (>= 1.3.0, < 3.0)
+    jekyll-sass-converter (1.5.2)
       sass (~> 3.4)
-    jekyll-seo-tag (2.3.0)
-      jekyll (~> 3.3)
-    jekyll-sitemap (1.1.1)
-      jekyll (~> 3.3)
-    jekyll-swiss (0.4.0)
-    jekyll-theme-architect (0.1.0)
-      jekyll (~> 3.5)
+    jekyll-seo-tag (2.8.0)
+      jekyll (>= 3.8, < 5.0)
+    jekyll-sitemap (1.4.0)
+      jekyll (>= 3.7, < 5.0)
+    jekyll-swiss (1.0.0)
+    jekyll-theme-architect (0.2.0)
+      jekyll (> 3.5, < 5.0)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-cayman (0.1.0)
-      jekyll (~> 3.5)
+    jekyll-theme-cayman (0.2.0)
+      jekyll (> 3.5, < 5.0)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-dinky (0.1.0)
-      jekyll (~> 3.5)
+    jekyll-theme-dinky (0.2.0)
+      jekyll (> 3.5, < 5.0)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-hacker (0.1.0)
-      jekyll (~> 3.5)
+    jekyll-theme-hacker (0.2.0)
+      jekyll (> 3.5, < 5.0)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-leap-day (0.1.0)
-      jekyll (~> 3.5)
+    jekyll-theme-leap-day (0.2.0)
+      jekyll (> 3.5, < 5.0)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-merlot (0.1.0)
-      jekyll (~> 3.5)
+    jekyll-theme-merlot (0.2.0)
+      jekyll (> 3.5, < 5.0)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-midnight (0.1.0)
-      jekyll (~> 3.5)
+    jekyll-theme-midnight (0.2.0)
+      jekyll (> 3.5, < 5.0)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-minimal (0.1.0)
-      jekyll (~> 3.5)
+    jekyll-theme-minimal (0.2.0)
+      jekyll (> 3.5, < 5.0)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-modernist (0.1.0)
-      jekyll (~> 3.5)
+    jekyll-theme-modernist (0.2.0)
+      jekyll (> 3.5, < 5.0)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-primer (0.5.2)
-      jekyll (~> 3.5)
+    jekyll-theme-primer (0.6.0)
+      jekyll (> 3.5, < 5.0)
       jekyll-github-metadata (~> 2.9)
-      jekyll-seo-tag (~> 2.2)
-    jekyll-theme-slate (0.1.0)
-      jekyll (~> 3.5)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-tactile (0.1.0)
-      jekyll (~> 3.5)
+    jekyll-theme-slate (0.2.0)
+      jekyll (> 3.5, < 5.0)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-time-machine (0.1.0)
-      jekyll (~> 3.5)
+    jekyll-theme-tactile (0.2.0)
+      jekyll (> 3.5, < 5.0)
       jekyll-seo-tag (~> 2.0)
-    jekyll-titles-from-headings (0.5.0)
-      jekyll (~> 3.3)
-    jekyll-watch (1.5.1)
+    jekyll-theme-time-machine (0.2.0)
+      jekyll (> 3.5, < 5.0)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-titles-from-headings (0.5.3)
+      jekyll (>= 3.3, < 5.0)
+    jekyll-watch (2.2.1)
       listen (~> 3.0)
-    jemoji (0.8.1)
-      activesupport (~> 4.0, >= 4.2.9)
+    jemoji (0.12.0)
       gemoji (~> 3.0)
       html-pipeline (~> 2.2)
-      jekyll (>= 3.0)
-    kramdown (1.16.2)
-    liquid (4.0.0)
-    listen (3.0.6)
-      rb-fsevent (>= 0.9.3)
-      rb-inotify (>= 0.9.7)
+      jekyll (>= 3.0, < 5.0)
+    kramdown (2.3.2)
+      rexml
+    kramdown-parser-gfm (1.1.0)
+      kramdown (~> 2.0)
+    liquid (4.0.4)
+    listen (3.8.0)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
     mercenary (0.3.6)
-    mini_portile2 (2.8.0)
-    minima (2.1.1)
-      jekyll (~> 3.3)
-    minitest (5.11.3)
-    multipart-post (2.1.1)
-    net-dns (0.9.0)
-    nokogiri (1.13.3)
-      mini_portile2 (~> 2.8.0)
+    minima (2.5.1)
+      jekyll (>= 3.5, < 5.0)
+      jekyll-feed (~> 0.9)
+      jekyll-seo-tag (~> 2.1)
+    minitest (5.18.0)
+    nokogiri (1.14.3-x86_64-linux)
       racc (~> 1.4)
-    octokit (4.21.0)
-      faraday (>= 0.9)
-      sawyer (~> 0.8.0, >= 0.5.3)
+    octokit (4.25.1)
+      faraday (>= 1, < 3)
+      sawyer (~> 0.9)
     pathutil (0.16.2)
       forwardable-extended (~> 2.6)
-    public_suffix (2.0.5)
-    racc (1.6.0)
-    rb-fsevent (0.11.0)
+    public_suffix (4.0.7)
+    racc (1.6.2)
+    rb-fsevent (0.11.2)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rouge (2.2.1)
-    ruby-enum (0.7.2)
-      i18n
-    ruby2_keywords (0.0.4)
-    rubyzip (2.0.0)
+    rexml (3.2.5)
+    rouge (3.26.0)
+    ruby2_keywords (0.0.5)
+    rubyzip (2.3.2)
     safe_yaml (1.0.5)
     sass (3.7.4)
       sass-listen (~> 4.0.0)
     sass-listen (4.0.0)
       rb-fsevent (~> 0.9, >= 0.9.4)
       rb-inotify (~> 0.9, >= 0.9.7)
-    sawyer (0.8.2)
+    sawyer (0.9.2)
       addressable (>= 2.3.5)
-      faraday (> 0.8, < 2.0)
+      faraday (>= 0.17.3, < 3)
+    simpleidn (0.2.1)
+      unf (~> 0.1.4)
     terminal-table (1.8.0)
       unicode-display_width (~> 1.1, >= 1.1.1)
-    thread_safe (0.3.6)
-    typhoeus (0.8.0)
-      ethon (>= 0.8.0)
-    tzinfo (1.2.5)
-      thread_safe (~> 0.1)
-    unicode-display_width (1.3.0)
+    typhoeus (1.4.0)
+      ethon (>= 0.9.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.8.2)
+    unicode-display_width (1.8.0)
+    webrick (1.8.1)
 
 PLATFORMS
-  ruby
+  x86_64-linux
 
 DEPENDENCIES
   github-pages
+  webrick
 
 BUNDLED WITH
-   1.16.1
+   2.4.8
diff --git a/docs/index.md b/docs/index.md
index 1c4f958a..86f83de7 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -9,95 +9,142 @@ Tree-sitter is a parser generator tool and an incremental parsing library. It ca
 * **General** enough to parse any programming language
 * **Fast** enough to parse on every keystroke in a text editor
 * **Robust** enough to provide useful results even in the presence of syntax errors
-* **Dependency-free** so that the runtime library (which is written in pure C) can be embedded in any application
+* **Dependency-free** so that the runtime library (which is written in pure [C](https://github.com/tree-sitter/tree-sitter/tree/master/lib)) can be embedded in any application
 
 ### Language Bindings
 
 There are currently bindings that allow Tree-sitter to be used from the following languages:
 
+* [Go](https://github.com/smacker/go-tree-sitter)
 * [Haskell](https://github.com/tree-sitter/haskell-tree-sitter)
+* [Java](https://github.com/serenadeai/java-tree-sitter)
 * [JavaScript (Node.js)](https://github.com/tree-sitter/node-tree-sitter)
 * [JavaScript (Wasm)](https://github.com/tree-sitter/tree-sitter/tree/master/lib/binding_web)
+* [Kotlin](https://github.com/oxisto/kotlintree)
 * [Lua](https://github.com/euclidianAce/ltreesitter)
 * [OCaml](https://github.com/returntocorp/ocaml-tree-sitter-core)
+* [Perl](https://metacpan.org/pod/Text::Treesitter)
 * [Python](https://github.com/tree-sitter/py-tree-sitter)
 * [Ruby](https://github.com/tree-sitter/ruby-tree-sitter)
+* [Ruby](https://github.com/calicoday/ruby-tree-sitter-ffi)
 * [Rust](https://github.com/tree-sitter/tree-sitter/tree/master/lib/binding_rust)
 * [Swift](https://github.com/ChimeHQ/SwiftTreeSitter)
-* [Kotlin](https://github.com/oxisto/kotlintree)
-* [Java](https://github.com/serenadeai/java-tree-sitter)
 
-### Available Parsers
-
-Parsers for these languages are fairly complete:
+### Parsers
 
+* [Ada](https://github.com/briot/tree-sitter-ada)
+* [Agda](https://github.com/tree-sitter/tree-sitter-agda)
+* [Apex](https://github.com/aheber/tree-sitter-sfapex)
 * [Bash](https://github.com/tree-sitter/tree-sitter-bash)
+* [Beancount](https://github.com/zwpaper/tree-sitter-beancount)
+* [Cap'n Proto](https://github.com/amaanq/tree-sitter-capnp)
 * [C](https://github.com/tree-sitter/tree-sitter-c)
-* [C#](https://github.com/tree-sitter/tree-sitter-c-sharp)
 * [C++](https://github.com/tree-sitter/tree-sitter-cpp)
+* [C#](https://github.com/tree-sitter/tree-sitter-c-sharp)
+* [Clojure](https://github.com/sogaiu/tree-sitter-clojure)
+* [CMake](https://github.com/uyha/tree-sitter-cmake)
+* [Comment](https://github.com/stsewd/tree-sitter-comment)
 * [Common Lisp](https://github.com/theHamsta/tree-sitter-commonlisp)
 * [CSS](https://github.com/tree-sitter/tree-sitter-css)
 * [CUDA](https://github.com/theHamsta/tree-sitter-cuda)
+* [Dart](https://github.com/UserNobody14/tree-sitter-dart)
 * [D](https://github.com/gdamore/tree-sitter-d)
+* [Dockerfile](https://github.com/camdencheek/tree-sitter-dockerfile)
 * [DOT](https://github.com/rydesun/tree-sitter-dot)
+* [Elixir](https://github.com/elixir-lang/tree-sitter-elixir)
 * [Elm](https://github.com/elm-tooling/tree-sitter-elm)
 * [Emacs Lisp](https://github.com/Wilfred/tree-sitter-elisp)
 * [Eno](https://github.com/eno-lang/tree-sitter-eno)
 * [ERB / EJS](https://github.com/tree-sitter/tree-sitter-embedded-template)
 * [Erlang](https://github.com/WhatsApp/tree-sitter-erlang/)
 * [Fennel](https://github.com/travonted/tree-sitter-fennel)
+* [Fish](https://github.com/ram02z/tree-sitter-fish)
+* [Formula](https://github.com/siraben/tree-sitter-formula)
+* [Fortran](https://github.com/stadelmanma/tree-sitter-fortran)
+* [gitattributes](https://github.com/ObserverOfTime/tree-sitter-gitattributes)
+* [gitignore](https://github.com/shunsambongi/tree-sitter-gitignore)
+* [Gleam](https://github.com/gleam-lang/tree-sitter-gleam)
 * [GLSL (OpenGL Shading Language)](https://github.com/theHamsta/tree-sitter-glsl)
 * [Go](https://github.com/tree-sitter/tree-sitter-go)
+* [Go mod](https://github.com/camdencheek/tree-sitter-go-mod)
+* [Go work](https://github.com/omertuc/tree-sitter-go-work)
+* [Graphql](https://github.com/bkegley/tree-sitter-graphql)
+* [Hack](https://github.com/slackhq/tree-sitter-hack)
+* [Haskell](https://github.com/tree-sitter/tree-sitter-haskell)
 * [HCL](https://github.com/MichaHoffmann/tree-sitter-hcl)
 * [HTML](https://github.com/tree-sitter/tree-sitter-html)
 * [Java](https://github.com/tree-sitter/tree-sitter-java)
 * [JavaScript](https://github.com/tree-sitter/tree-sitter-javascript)
+* [jq](https://github.com/flurie/tree-sitter-jq)
+* [JSON5](https://github.com/Joakker/tree-sitter-json5)
 * [JSON](https://github.com/tree-sitter/tree-sitter-json)
+* [Julia](https://github.com/tree-sitter/tree-sitter-julia)
+* [Kotlin](https://github.com/fwcd/tree-sitter-kotlin)
+* [LALRPOP](https://github.com/traxys/tree-sitter-lalrpop)
+* [Latex](https://github.com/latex-lsp/tree-sitter-latex)
+* [Lean](https://github.com/Julian/tree-sitter-lean)
+* [LLVM](https://github.com/benwilliamgraham/tree-sitter-llvm)
+* [LLVM MachineIR](https://github.com/Flakebi/tree-sitter-llvm-mir)
+* [LLVM TableGen](https://github.com/Flakebi/tree-sitter-tablegen)
 * [Lua](https://github.com/Azganoth/tree-sitter-lua)
 * [Make](https://github.com/alemuller/tree-sitter-make)
 * [Markdown](https://github.com/ikatyang/tree-sitter-markdown)
+* [Markdown](https://github.com/MDeiml/tree-sitter-markdown)
+* [Meson](https://github.com/Decodetalkers/tree-sitter-meson)
+* [Meson](https://github.com/staysail/tree-sitter-meson)
+* [Motorola 68000 Assembly](https://github.com/grahambates/tree-sitter-m68k)
+* [Nix](https://github.com/cstrahan/tree-sitter-nix)
+* [Objective-C](https://github.com/jiyee/tree-sitter-objc)
 * [OCaml](https://github.com/tree-sitter/tree-sitter-ocaml)
+* [Org](https://github.com/milisims/tree-sitter-org)
+* [Pascal](https://github.com/Isopod/tree-sitter-pascal)
+* [Perl](https://github.com/ganezdragon/tree-sitter-perl)
+* [Perl](https://github.com/tree-sitter-perl/tree-sitter-perl)
+* [Perl POD](https://github.com/tree-sitter-perl/tree-sitter-pod)
 * [PHP](https://github.com/tree-sitter/tree-sitter-php)
+* [Portable Game Notation](https://github.com/rolandwalker/tree-sitter-pgn)
+* [PowerShell](https://github.com/PowerShell/tree-sitter-PowerShell)
+* [Protocol Buffers](https://github.com/mitchellh/tree-sitter-proto)
 * [Python](https://github.com/tree-sitter/tree-sitter-python)
+* [QML](https://github.com/yuja/tree-sitter-qmljs)
+* [Racket](https://github.com/6cdh/tree-sitter-racket)
+* [Rasi](https://github.com/Fymyte/tree-sitter-rasi)
+* [re2c](https://github.com/alemuller/tree-sitter-re2c)
+* [Regex](https://github.com/tree-sitter/tree-sitter-regex)
+* [Rego](https://github.com/FallenAngel97/tree-sitter-rego)
+* [reStructuredText](https://github.com/stsewd/tree-sitter-rst)
+* [R](https://github.com/r-lib/tree-sitter-r)
 * [Ruby](https://github.com/tree-sitter/tree-sitter-ruby)
 * [Rust](https://github.com/tree-sitter/tree-sitter-rust)
-* [R](https://github.com/r-lib/tree-sitter-r)
+* [Scala](https://github.com/tree-sitter/tree-sitter-scala)
+* [Scheme](https://github.com/6cdh/tree-sitter-scheme)
+* [Scss](https://github.com/serenadeai/tree-sitter-scss)
 * [S-expressions](https://github.com/AbstractMachinesLab/tree-sitter-sexp)
+* [Smali](https://github.com/amaanq/tree-sitter-smali)
+* [Smali](https://git.sr.ht/~yotam/tree-sitter-smali)
+* [Sourcepawn](https://github.com/nilshelmig/tree-sitter-sourcepawn)
 * [SPARQL](https://github.com/BonaBeavis/tree-sitter-sparql)
+* [SQL - BigQuery](https://github.com/takegue/tree-sitter-sql-bigquery)
+* [SQL - PostgreSQL](https://github.com/m-novikov/tree-sitter-sql)
+* [SQL - SQLite](https://github.com/dhcmrlchtdj/tree-sitter-sqlite)
+* [SSH](https://github.com/metio/tree-sitter-ssh-client-config)
 * [Svelte](https://github.com/Himujjal/tree-sitter-svelte)
 * [Swift](https://github.com/alex-pinkus/tree-sitter-swift)
 * [SystemRDL](https://github.com/SystemRDL/tree-sitter-systemrdl)
+* [Thrift](https://github.com/duskmoon314/tree-sitter-thrift)
 * [TOML](https://github.com/ikatyang/tree-sitter-toml)
+* [Tree-sitter Query](https://github.com/nvim-treesitter/tree-sitter-query)
 * [Turtle](https://github.com/BonaBeavis/tree-sitter-turtle)
 * [Twig](https://github.com/gbprod/tree-sitter-twig)
 * [TypeScript](https://github.com/tree-sitter/tree-sitter-typescript)
 * [Verilog](https://github.com/tree-sitter/tree-sitter-verilog)
 * [VHDL](https://github.com/alemuller/tree-sitter-vhdl)
 * [Vue](https://github.com/ikatyang/tree-sitter-vue)
-* [YAML](https://github.com/ikatyang/tree-sitter-yaml)
 * [WASM](https://github.com/wasm-lsp/tree-sitter-wasm)
 * [WGSL WebGPU Shading Language](https://github.com/mehmetoguzderin/tree-sitter-wgsl)
-
-Parsers for these languages are in development:
-
-* [Agda](https://github.com/tree-sitter/tree-sitter-agda)
-* [Elixir](https://github.com/elixir-lang/tree-sitter-elixir)
-* [Dockerfile](https://github.com/camdencheek/tree-sitter-dockerfile)
-* [Go mod](https://github.com/camdencheek/tree-sitter-go-mod)
-* [Hack](https://github.com/slackhq/tree-sitter-hack)
-* [Haskell](https://github.com/tree-sitter/tree-sitter-haskell)
-* [Julia](https://github.com/tree-sitter/tree-sitter-julia)
-* [Kotlin](https://github.com/fwcd/tree-sitter-kotlin)
-* [Nix](https://github.com/cstrahan/tree-sitter-nix)
-* [Objective-C](https://github.com/jiyee/tree-sitter-objc)
-* [Org](https://github.com/milisims/tree-sitter-org)
-* [Perl](https://github.com/ganezdragon/tree-sitter-perl)
-* [Protocol Buffers](https://github.com/mitchellh/tree-sitter-proto)
-* [Racket](https://github.com/6cdh/tree-sitter-racket)
-* [Scala](https://github.com/tree-sitter/tree-sitter-scala)
-* [Sourcepawn](https://github.com/nilshelmig/tree-sitter-sourcepawn)
-* [SQL](https://github.com/m-novikov/tree-sitter-sql)
-
+* [YAML](https://github.com/ikatyang/tree-sitter-yaml)
+* [YANG](https://github.com/Hubro/tree-sitter-yang)
+* [Zig](https://github.com/maxxnino/tree-sitter-zig)
 
 ### Talks on Tree-sitter
 
@@ -109,9 +156,9 @@ Parsers for these languages are in development:
 
 The design of Tree-sitter was greatly influenced by the following research papers:
 
-- [Practical Algorithms for Incremental Software Development Environments](https://www2.eecs.berkeley.edu/Pubs/TechRpts/1997/CSD-97-946.pdf)
-- [Context Aware Scanning for Parsing Extensible Languages](https://www-users.cse.umn.edu/~evw/pubs/vanwyk07gpce/vanwyk07gpce.pdf)
-- [Efficient and Flexible Incremental Parsing](http://harmonia.cs.berkeley.edu/papers/twagner-parsing.pdf)
-- [Incremental Analysis of Real Programming Languages](http://harmonia.cs.berkeley.edu/papers/twagner-glr.pdf)
-- [Error Detection and Recovery in LR Parsers](http://what-when-how.com/compiler-writing/bottom-up-parsing-compiler-writing-part-13)
-- [Error Recovery for LR Parsers](https://apps.dtic.mil/sti/pdfs/ADA043470.pdf)
+* [Practical Algorithms for Incremental Software Development Environments](https://www2.eecs.berkeley.edu/Pubs/TechRpts/1997/CSD-97-946.pdf)
+* [Context Aware Scanning for Parsing Extensible Languages](https://www-users.cse.umn.edu/~evw/pubs/vanwyk07gpce/vanwyk07gpce.pdf)
+* [Efficient and Flexible Incremental Parsing](https://harmonia.cs.berkeley.edu/papers/twagner-parsing.pdf)
+* [Incremental Analysis of Real Programming Languages](https://harmonia.cs.berkeley.edu/papers/twagner-glr.pdf)
+* [Error Detection and Recovery in LR Parsers](https://what-when-how.com/compiler-writing/bottom-up-parsing-compiler-writing-part-13)
+* [Error Recovery for LR Parsers](https://apps.dtic.mil/sti/pdfs/ADA043470.pdf)
diff --git a/docs/section-2-using-parsers.md b/docs/section-2-using-parsers.md
index ac3f968f..5106a49c 100644
--- a/docs/section-2-using-parsers.md
+++ b/docs/section-2-using-parsers.md
@@ -290,7 +290,7 @@ This `ts_node_edit` function is _only_ needed in the case where you have retriev
 
 ### Multi-language Documents
 
-Sometimes, different parts of a file may be written in different languages. For example, templating languages like [EJS](http://ejs.co) and [ERB](https://ruby-doc.org/stdlib-2.5.1/libdoc/erb/rdoc/ERB.html) allow you to generate HTML by writing a mixture of HTML and another language like JavaScript or Ruby.
+Sometimes, different parts of a file may be written in different languages. For example, templating languages like [EJS](https://ejs.co) and [ERB](https://ruby-doc.org/stdlib-2.5.1/libdoc/erb/rdoc/ERB.html) allow you to generate HTML by writing a mixture of HTML and another language like JavaScript or Ruby.
 
 Tree-sitter handles these types of documents by allowing you to create a syntax tree based on the text in certain _ranges_ of a file.
 
@@ -442,13 +442,13 @@ Many code analysis tasks involve searching for patterns in syntax trees. Tree-si
 
 A _query_ consists of one or more _patterns_, where each pattern is an [S-expression](https://en.wikipedia.org/wiki/S-expression) that matches a certain set of nodes in a syntax tree. The expression to match a given node consists of a pair of parentheses containing two things: the node's type, and optionally, a series of other S-expressions that match the node's children. For example, this pattern would match any `binary_expression` node whose children are both `number_literal` nodes:
 
-```
+```scheme
 (binary_expression (number_literal) (number_literal))
 ```
 
 Children can also be omitted. For example, this would match any `binary_expression` where at least _one_ of child is a `string_literal` node:
 
-```
+```scheme
 (binary_expression (string_literal))
 ```
 
@@ -456,7 +456,7 @@ Children can also be omitted. For example, this would match any `binary_expressi
 
 In general, it's a good idea to make patterns more specific by specifying [field names](#node-field-names) associated with child nodes. You do this by prefixing a child pattern with a field name followed by a colon. For example, this pattern would match an `assignment_expression` node where the `left` child is a `member_expression` whose `object` is a `call_expression`.
 
-```
+```scheme
 (assignment_expression
   left: (member_expression
     object: (call_expression)))
@@ -464,9 +464,9 @@ In general, it's a good idea to make patterns more specific by specifying [field
 
 #### Negated Fields
 
-You can also constrain a pattern so that it only matches nodes that *lack* a certain field. To do this, add a field name prefixed by a `!` within the parent pattern. For example, this pattern would match a class declaration with no type parameters:
+You can also constrain a pattern so that it only matches nodes that _lack_ a certain field. To do this, add a field name prefixed by a `!` within the parent pattern. For example, this pattern would match a class declaration with no type parameters:
 
-```
+```scheme
 (class_declaration
   name: (identifier) @class_name
   !type_parameters)
@@ -476,7 +476,7 @@ You can also constrain a pattern so that it only matches nodes that *lack* a cer
 
 The parenthesized syntax for writing nodes only applies to [named nodes](#named-vs-anonymous-nodes). To match specific anonymous nodes, you write their name between double quotes. For example, this pattern would match any `binary_expression` where the operator is `!=` and the right side is `null`:
 
-```
+```scheme
 (binary_expression
   operator: "!="
   right: (null))
@@ -488,7 +488,7 @@ When matching patterns, you may want to process specific nodes within the patter
 
 For example, this pattern would match any assignment of a `function` to an `identifier`, and it would associate the name `the-function-name` with the identifier:
 
-```
+```scheme
 (assignment_expression
   left: (identifier) @the-function-name
   right: (function))
@@ -496,7 +496,7 @@ For example, this pattern would match any assignment of a `function` to an `iden
 
 And this pattern would match all method definitions, associating the name `the-method-name` with the method name, `the-class-name` with the containing class name:
 
-```
+```scheme
 (class_declaration
   name: (identifier) @the-class-name
   body: (class_body
@@ -510,13 +510,13 @@ You can match a repeating sequence of sibling nodes using the postfix `+` and `*
 
 For example, this pattern would match a sequence of one or more comments:
 
-```
+```scheme
 (comment)+
 ```
 
 This pattern would match a class declaration, capturing all of the decorators if any were present:
 
-```
+```scheme
 (class_declaration
   (decorator)* @the-decorator
   name: (identifier) @the-name)
@@ -524,7 +524,7 @@ This pattern would match a class declaration, capturing all of the decorators if
 
 You can also mark a node as optional using the `?` operator. For example, this pattern would match all function calls, capturing a string argument if one was present:
 
-```
+```scheme
 (call_expression
   function: (identifier) @the-function
   arguments: (arguments (string)? @the-string-arg))
@@ -534,7 +534,7 @@ You can also mark a node as optional using the `?` operator. For example, this p
 
 You can also use parentheses for grouping a sequence of _sibling_ nodes. For example, this pattern would match a comment followed by a function declaration:
 
-```
+```scheme
 (
   (comment)
   (function_declaration)
@@ -543,7 +543,7 @@ You can also use parentheses for grouping a sequence of _sibling_ nodes. For exa
 
 Any of the quantification operators mentioned above (`+`, `*`, and `?`) can also be applied to groups. For example, this pattern would match a comma-separated series of numbers:
 
-```
+```scheme
 (
   (number)
   ("," (number))*
@@ -558,7 +558,7 @@ This is similar to _character classes_ from regular expressions (`[abc]` matches
 For example, this pattern would match a call to either a variable or an object property.
 In the case of a variable, capture it as `@function`, and in the case of a property, capture it as `@method`:
 
-```
+```scheme
 (call_expression
   function: [
     (identifier) @function
@@ -569,7 +569,7 @@ In the case of a variable, capture it as `@function`, and in the case of a prope
 
 This pattern would match a set of possible keyword tokens, capturing them as `@keyword`:
 
-```
+```scheme
 [
   "break"
   "delete"
@@ -592,7 +592,7 @@ and `_` will match any named or anonymous node.
 
 For example, this pattern would match any node inside a call:
 
-```
+```scheme
 (call (_) @call.inner)
 ```
 
@@ -602,7 +602,7 @@ The anchor operator, `.`, is used to constrain the ways in which child patterns
 
 When `.` is placed before the _first_ child within a parent pattern, the child will only match when it is the first named node in the parent. For example, the below pattern matches a given `array` node at most once, assigning the `@the-element` capture to the first `identifier` node in the parent `array`:
 
-```
+```scheme
 (array . (identifier) @the-element)
 ```
 
@@ -610,13 +610,13 @@ Without this anchor, the pattern would match once for every identifier in the ar
 
 Similarly, an anchor placed after a pattern's _last_ child will cause that child pattern to only match nodes that are the last named child of their parent. The below pattern matches only nodes that are the last named child within a `block`.
 
-```
+```scheme
 (block (_) @last-expression .)
 ```
 
 Finally, an anchor _between_ two child patterns will cause the patterns to only match nodes that are immediate siblings. The pattern below, given a long dotted name like `a.b.c.d`, will only match pairs of consecutive identifiers: `a, b`, `b, c`, and `c, d`.
 
-```
+```scheme
 (dotted_name
   (identifier) @prev-id
   .
@@ -629,20 +629,38 @@ The restrictions placed on a pattern by an anchor operator ignore anonymous node
 
 #### Predicates
 
-You can also specify arbitrary metadata and conditions associated with a pattern by adding _predicate_ S-expressions anywhere within your pattern. Predicate S-expressions start with a _predicate name_ beginning with a `#` character. After that, they can contain an arbitrary number of `@`-prefixed capture names or strings.
+You can also specify arbitrary metadata and conditions associated with a pattern
+by adding _predicate_ S-expressions anywhere within your pattern. Predicate S-expressions
+start with a _predicate name_ beginning with a `#` character. After that, they can
+contain an arbitrary number of `@`-prefixed capture names or strings.
 
-For example, this pattern would match identifier whose names is written in `SCREAMING_SNAKE_CASE`:
+Tree-Sitter's CLI supports the following predicates by default:
 
-```
-(
-  (identifier) @constant
-  (#match? @constant "^[A-Z][A-Z_]+")
-)
+##### eq?, not-eq?, any-eq?, any-not-eq?
+
+This family of predicates allows you to match against a single capture or string
+value.
+
+The first argument must be a capture, but the second can be either a capture to
+compare the two captures' text, or a string to compare first capture's text
+against.
+
+The base predicate is "#eq?", but its complement "#not-eq?" can be used to _not_
+match a value.
+
+Consider the following example targeting C:
+
+```scheme
+((identifier) @variable.builtin
+  (#eq? @variable.builtin "self"))
 ```
 
-And this pattern would match key-value pairs where the `value` is an identifier with the same name as the key:
+This pattern would match any identifier that is `self` or `this`.
 
-```
+And this pattern would match key-value pairs where the `value` is an identifier
+with the same name as the key:
+
+```scheme
 (
   (pair
     key: (property_identifier) @key-name
@@ -651,7 +669,87 @@ And this pattern would match key-value pairs where the `value` is an identifier
 )
 ```
 
-_Note_ - Predicates are not handled directly by the Tree-sitter C library. They are just exposed in a structured form so that higher-level code can perform the filtering. However, higher-level bindings to Tree-sitter like [the Rust crate](https://github.com/tree-sitter/tree-sitter/tree/master/lib/binding_rust) or the [WebAssembly binding](https://github.com/tree-sitter/tree-sitter/tree/master/lib/binding_web) implement a few common predicates like `#eq?` and `#match?`.
+The prefix "any-" is meant for use with quantified captures. Here's
+an example finding a segment of empty comments
+
+```scheme
+((comment)+ @comment.empty
+  (#any-eq? @comment.empty "//"))
+```
+
+Note that "#any-eq?" will match a quantified capture if
+_any_ of the nodes match the predicate, while by default a quantified capture
+will only match if _all_ the nodes match the predicate.
+
+##### match?, not-match?, any-match?, any-not-match?
+
+These predicates are similar to the eq? predicates, but they use regular expressions
+to match against the capture's text.
+
+The first argument must be a capture, and the second must be a string containing
+a regular expression.
+
+For example, this pattern would match identifier whose name is written in `SCREAMING_SNAKE_CASE`:
+
+```scheme
+((identifier) @constant
+  (#match? @constant "^[A-Z][A-Z_]+"))
+```
+
+Here's an example finding potential documentation comments in C
+
+```scheme
+((comment)+ @comment.documentation
+  (#match? @comment.documentation "^///\s+.*"))
+```
+
+Here's another example finding Cgo comments to potentially inject with C
+
+```scheme
+((comment)+ @injection.content
+  .
+  (import_declaration
+    (import_spec path: (interpreted_string_literal) @_import_c))
+  (#eq? @_import_c "\"C\"")
+  (#match? @injection.content "^//"))
+```
+
+##### any-of?, not-any-of?
+
+The "any-of?" predicate allows you to match a capture against multiple strings,
+and will match if the capture's text is equal to any of the strings.
+
+Consider this example that targets JavaScript:
+
+```scheme
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin
+        "arguments"
+        "module"
+        "console"
+        "window"
+        "document"))
+```
+
+This will match any of the builtin variables in JavaScript.
+
+_Note_ — Predicates are not handled directly by the Tree-sitter C library.
+They are just exposed in a structured form so that higher-level code can perform
+the filtering. However, higher-level bindings to Tree-sitter like
+[the Rust Crate](https://github.com/tree-sitter/tree-sitter/tree/master/lib/binding_rust)
+or the [WebAssembly binding](https://github.com/tree-sitter/tree-sitter/tree/master/lib/binding_web)
+do implement a few common predicates like the `#eq?`, `#match?`, and `#any-of?`
+predicates explained above.
+
+To recap about the predicates Tree-Sitter's bindings support:
+
+- `#eq?` checks for a direct match against a capture or string
+- `#match?` checks for a match against a regular expression
+- `#any-of?` checks for a match against a list of strings
+- Adding `not-` to the beginning of any of these predicates will negate the match
+- By default, a quantified capture will only match if _all_ of the nodes match the predicate
+- Adding `any-` before the `eq` or `match` predicates will instead match if any of the nodes match the predicate
+
 
 ### The Query API
 
diff --git a/docs/section-3-creating-parsers.md b/docs/section-3-creating-parsers.md
index 07f9d865..0ecef257 100644
--- a/docs/section-3-creating-parsers.md
+++ b/docs/section-3-creating-parsers.md
@@ -46,7 +46,7 @@ npm install --save nan
 npm install --save-dev tree-sitter-cli
 ```
 
-The last command will install the CLI into the `node_modules` folder in your working directory. An executable program called `tree-sitter` will be created inside of `node_modules/.bin/`. You may want to follow the Node.js convention of adding that folder to your your `PATH` so that you can easily run this program when working in this directory.
+The last command will install the CLI into the `node_modules` folder in your working directory. An executable program called `tree-sitter` will be created inside of `node_modules/.bin/`. You may want to follow the Node.js convention of adding that folder to your `PATH` so that you can easily run this program when working in this directory.
 
 ```sh
 # In your shell profile script
@@ -81,9 +81,16 @@ echo 'hello' > example-file
 tree-sitter parse example-file
 ```
 
+Alternatively, in Windows PowerShell:
+
+```pwsh
+"hello" | Out-File example-file -Encoding utf8
+tree-sitter parse example-file
+```
+
 This should print the following:
 
-```
+```text
 (source_file [0, 0] - [1, 0])
 ```
 
@@ -116,7 +123,7 @@ For each rule that you add to the grammar, you should first create a *test* that
 
 For example, you might have a file called `test/corpus/statements.txt` that contains a series of entries like this:
 
-```
+```text
 ==================
 Return statements
 ==================
@@ -142,7 +149,7 @@ func x() int {
 
   The expected output section can also *optionally* show the [*field names*][field-names-section] associated with each child node. To include field names in your tests, you write a node's field name followed by a colon, before the node itself in the S-expression:
 
-```
+```text
 (source_file
   (function_definition
     name: (identifier)
@@ -152,6 +159,26 @@ func x() int {
       (return_statement (number)))))
 ```
 
+* If your language's syntax conflicts with the `===` and `---` test separators, you can optionally add an arbitrary identical suffix (in the below example, `|||`) to disambiguate them:
+
+```text
+==================|||
+Basic module
+==================|||
+
+---- MODULE Test ----
+increment(n) == n + 1
+====
+
+---|||
+
+(source_file
+  (module (identifier)
+    (operator (identifier)
+      (parameter_list (identifier))
+      (plus (identifier_ref) (number)))))
+```
+
 These tests are important. They serve as the parser's API documentation, and they can be run every time you change the grammar to verify that everything still parses correctly.
 
 By default, the `tree-sitter test` command runs all of the tests in your `corpus` or `test/corpus/` folder. To run a particular test, you can use the `-f` flag:
@@ -174,7 +201,7 @@ The `tree-sitter test` command will *also* run any syntax highlighting tests in
 
 You can run your parser on an arbitrary file using `tree-sitter parse`. This will print the resulting the syntax tree, including nodes' ranges and field names, like this:
 
-```
+```text
 (source_file [0, 0] - [3, 0]
   (function_declaration [0, 0] - [2, 1]
     name: (identifier [0, 5] - [0, 9])
@@ -222,10 +249,10 @@ In addition to the `name` and `rules` fields, grammars have a few other optional
 * **`inline`** - an array of rule names that should be automatically *removed* from the grammar by replacing all of their usages with a copy of their definition. This is useful for rules that are used in multiple places but for which you *don't* want to create syntax tree nodes at runtime.
 * **`conflicts`** - an array of arrays of rule names. Each inner array represents a set of rules that's involved in an *LR(1) conflict* that is *intended to exist* in the grammar. When these conflicts occur at runtime, Tree-sitter will use the GLR algorithm to explore all of the possible interpretations. If *multiple* parses end up succeeding, Tree-sitter will pick the subtree whose corresponding rule has the highest total *dynamic precedence*.
 * **`externals`** - an array of token names which can be returned by an [*external scanner*](#external-scanners). External scanners allow you to write custom C code which runs during the lexing process in order to handle lexical rules (e.g. Python's indentation tokens) that cannot be described by regular expressions.
+* **`precedences`** - an array of array of strings, where each array of strings defines named precedence levels in descending order. These names can be used in the `prec` functions to define precedence relative only to other names in the array, rather than globally. Can only be used with parse precedence, not lexical precedence.
 * **`word`** - the name of a token that will match keywords for the purpose of the [keyword extraction](#keyword-extraction) optimization.
 * **`supertypes`** an array of hidden rule names which should be considered to be 'supertypes' in the generated [*node types* file][static-node-types].
 
-
 ## Writing the Grammar
 
 Writing a grammar requires creativity. There are an infinite number of CFGs (context-free grammars) that can be used to describe any given language. In order to produce a good Tree-sitter parser, you need to create a grammar with two important properties:
@@ -349,7 +376,7 @@ return x + y;
 
 According to the specification, this line is a `ReturnStatement`, the fragment `x + y` is an `AdditiveExpression`, and `x` and `y` are both `IdentifierReferences`. The relationship between these constructs is captured by a complex series of production rules:
 
-```
+```text
 ReturnStatement          ->  'return' Expression
 Expression               ->  AssignmentExpression
 AssignmentExpression     ->  ConditionalExpression
@@ -406,7 +433,7 @@ To produce a readable syntax tree, we'd like to model JavaScript expressions usi
 
 Of course, this flat structure is highly ambiguous. If we try to generate a parser, Tree-sitter gives us an error message:
 
-```
+```text
 Error: Unresolved conflict for symbol sequence:
 
   '-'  _expression  •  '*'  …
@@ -442,7 +469,7 @@ For an expression like `-a * b`, it's not clear whether the `-` operator applies
 
 Applying a higher precedence in `unary_expression` fixes that conflict, but there is still another conflict:
 
-```
+```text
 Error: Unresolved conflict for symbol sequence:
 
   _expression  '*'  _expression  •  '*'  …
@@ -498,11 +525,11 @@ Tree-sitter's parsing process is divided into two phases: parsing (which is desc
 
 ### Conflicting Tokens
 
-Grammars often contain multiple tokens that can match the same characters. For example, a grammar might contain the tokens (`"if"` and `/[a-z]+/`). Tree-sitter differentiates between these conflicting tokens in a few ways:
+Grammars often contain multiple tokens that can match the same characters. For example, a grammar might contain the tokens (`"if"` and `/[a-z]+/`). Tree-sitter differentiates between these conflicting tokens in a few ways.
 
 1. **Context-aware Lexing** - Tree-sitter performs lexing on-demand, during the parsing process. At any given position in a source document, the lexer only tries to recognize tokens that are *valid* at that position in the document.
 
-2. **Lexical Precedence** - When the precedence functions described [above](#the-grammar-dsl) are used within the `token` function, the given precedence values serve as instructions to the lexer. If there are two valid tokens that match the characters at a given position in the document, Tree-sitter will select the one with the higher precedence.
+2. **Lexical Precedence** - When the precedence functions described [above](#the-grammar-dsl) are used *within* the `token` function, the given explicit precedence values serve as instructions to the lexer. If there are two valid tokens that match the characters at a given position in the document, Tree-sitter will select the one with the higher precedence.
 
 3. **Match Length** - If multiple valid tokens with the same precedence match the characters at a given position in a document, Tree-sitter will select the token that matches the [longest sequence of characters][longest-match].
 
@@ -510,6 +537,12 @@ Grammars often contain multiple tokens that can match the same characters. For e
 
 5. **Rule Order** - If none of the above criteria can be used to select one token over another, Tree-sitter will prefer the token that appears earlier in the grammar.
 
+If there is an external scanner it may have [an additional impact](#other-external-scanner-details) over regular tokens defined in the grammar.
+
+### Lexical Precedence vs. Parse Precedence
+
+One common mistake involves not distinguishing *lexical precedence* from *parse precedence*. Parse precedence determines which rule is chosen to interpret a given sequence of tokens. *Lexical precedence* determines which token is chosen to interpret at a given position of text and it is a lower-level operation that is done first. The above list fully captures Tree-sitter's lexical precedence rules, and you will probably refer back to this section of the documentation more often than any other. Most of the time when you really get stuck, you're dealing with a lexical precedence problem. Pay particular attention to the difference in meaning between using `prec` inside of the `token` function versus outside of it. The *lexical precedence* syntax is `token(prec(N, ...))`.
+
 ### Keywords
 
 Many languages have a set of *keyword* tokens (e.g. `if`, `for`, `return`), as well as a more general token (e.g. `identifier`) that matches any word, including many of the keyword strings. For example, JavaScript has a keyword `instanceof`, which is used as a binary operator, like this:
@@ -568,6 +601,7 @@ Aside from improving error detection, keyword extraction also has performance be
 ### External Scanners
 
 Many languages have some tokens whose structure is impossible or inconvenient to describe with a regular expression. Some examples:
+
 * [Indent and dedent][indent-tokens] tokens in Python
 * [Heredocs][heredoc] in Bash and Ruby
 * [Percent strings][percent-string] in Ruby
@@ -592,7 +626,7 @@ grammar({
 
 Then, add another C or C++ source file to your project. Currently, its path must be `src/scanner.c` or `src/scanner.cc` for the CLI to recognize it. Be sure to add this file to the `sources` section of your `binding.gyp` file so that it will be included when your project is compiled by Node.js and uncomment the appropriate block in your `bindings/rust/build.rs` file so that it will be included in your Rust crate.
 
-In this new source file, define an [`enum`][enum] type containing the names of all of your external tokens. The ordering of this enum must match the order in your grammar's `externals` array.
+In this new source file, define an [`enum`][enum] type containing the names of all of your external tokens. The ordering of this enum must match the order in your grammar's `externals` array; the actual names do not matter.
 
 ```c
 #include <tree_sitter/parser.h>
@@ -616,7 +650,6 @@ void * tree_sitter_my_language_external_scanner_create() {
 
 This function should create your scanner object. It will only be called once anytime your language is set on a parser. Often, you will want to allocate memory on the heap and return a pointer to it. If your external scanner doesn't need to maintain any state, it's ok to return `NULL`.
 
-
 #### Destroy
 
 ```c
@@ -655,6 +688,7 @@ void tree_sitter_my_language_external_scanner_deserialize(
 ```
 
 This function should *restore* the state of your scanner based the bytes that were previously written by the `serialize` function. It is called with a pointer to your scanner, a pointer to the buffer of bytes, and the number of bytes that should be read.
+It is good practice to explicitly erase your scanner state variables at the start of this function, before restoring their values from the byte buffer.
 
 #### Scan
 
@@ -672,15 +706,16 @@ This function is responsible for recognizing external tokens. It should return `
 
 * **`int32_t lookahead`** - The current next character in the input stream, represented as a 32-bit unicode code point.
 * **`TSSymbol result_symbol`** - The symbol that was recognized. Your scan function should *assign* to this field one of the values from the `TokenType` enum, described above.
-* **`void (*advance)(TSLexer *, bool skip)`** - A function for advancing to the next character. If you pass `true` for the second argument, the current character will be treated as whitespace.
+* **`void (*advance)(TSLexer *, bool skip)`** - A function for advancing to the next character. If you pass `true` for the second argument, the current character will be treated as whitespace; whitespace won't be included in the text range associated with tokens emitted by the external scanner.
 * **`void (*mark_end)(TSLexer *)`** - A function for marking the end of the recognized token. This allows matching tokens that require multiple characters of lookahead. By default (if you don't call `mark_end`), any character that you moved past using the `advance` function will be included in the size of the token. But once you call `mark_end`, then any later calls to `advance` will *not* increase the size of the returned token. You can call `mark_end` multiple times to increase the size of the token.
 * **`uint32_t (*get_column)(TSLexer *)`** - A function for querying the current column position of the lexer. It returns the number of codepoints since the start of the current line. The codepoint position is recalculated on every call to this function by reading from the start of the line.
-* **`bool (*is_at_included_range_start)(TSLexer *)`** - A function for checking if the parser has just skipped some characters in the document. When parsing an embedded document using the `ts_parser_set_included_ranges` function (described in the [multi-language document section][multi-language-section]), your scanner may want to apply some special behavior when moving to a disjoint part of the document. For example, in [EJS documents][ejs], the JavaScript parser uses this function to enable inserting automatic semicolon tokens in between the code directives, delimited by `<%` and `%>`.
+* **`bool (*is_at_included_range_start)(const TSLexer *)`** - A function for checking whether the parser has just skipped some characters in the document. When parsing an embedded document using the `ts_parser_set_included_ranges` function (described in the [multi-language document section][multi-language-section]), the scanner may want to apply some special behavior when moving to a disjoint part of the document. For example, in [EJS documents][ejs], the JavaScript parser uses this function to enable inserting automatic semicolon tokens in between the code directives, delimited by `<%` and `%>`.
+* **`bool (*eof)(const TSLexer *)`** - A function for determining whether the lexer is at the end of the file. The value of `lookahead` will be `0` at the end of a file, but this function should be used instead of checking for that value because the `0` or "NUL" value is also a valid character that could be present in the file being parsed.
 
-The third argument to the `scan` function is an array of booleans that indicates which of your external tokens are currently expected by the parser. You should only look for a given token if it is valid according to this array. At the same time, you cannot backtrack, so you may need to combine certain pieces of logic.
+The third argument to the `scan` function is an array of booleans that indicates which of external tokens are currently expected by the parser. You should only look for a given token if it is valid according to this array. At the same time, you cannot backtrack, so you may need to combine certain pieces of logic.
 
 ```c
-if (valid_symbols[INDENT] || valid_symbol[DEDENT]) {
+if (valid_symbols[INDENT] || valid_symbols[DEDENT]) {
 
   // ... logic that is common to both `INDENT` and `DEDENT`
 
@@ -694,8 +729,23 @@ if (valid_symbols[INDENT] || valid_symbol[DEDENT]) {
 }
 ```
 
+#### Other External Scanner Details
+
+If a token in the `externals` array is valid at a given position in the parse, the external scanner will be called first before anything else is done. This means the external scanner functions as a powerful override of Tree-sitter's lexing behavior, and can be used to solve problems that can't be cracked with ordinary lexical, parse, or dynamic precedence.
+
+If a syntax error is encountered during regular parsing, Tree-sitter's first action during error recovery will be to call the external scanner's `scan` function with all tokens marked valid. The scanner should detect this case and handle it appropriately. One simple method of detection is to add an unused token to the end of the `externals` array, for example `externals: $ => [$.token1, $.token2, $.error_sentinel]`, then check whether that token is marked valid to determine whether Tree-sitter is in error correction mode.
+
+If you put terminal keywords in the `externals` array, for example `externals: $ => ['if', 'then', 'else']`, then any time those terminals are present in the grammar they will be tokenized by the external scanner. It is similar to writing `externals: [$.if_keyword, $.then_keyword, $.else_keyword]` then using `alias($.if_keyword, 'if')` in the grammar.
+
+If in the `externals` array use literal keywords then lexing works in two steps, the external scanner will be called first and if it sets a resulting token and returns `true` then the token considered as recognized and Tree-sitter moves to a next token. But the external scanner may return `false` and in this case Tree-sitter fallbacks to the internal lexing mechanism.
+
+In case of some keywords defined in the `externals` array in a rule referencing form like `$.if_keyword` and there is no additional definition of that rule in the grammar rules, e.g., `if_keyword: $ => 'if'` then fallback to the internal lexer isn't possible because Tree-sitter doesn't know the actual keyword and it's fully the external scanner resposibilty to recognize such tokens.
+
+External scanners are a common cause of infinite loops.
+Be very careful when emitting zero-width tokens from your external scanner, and if you consume characters in a loop be sure use the `eof` function to check whether you are at the end of the file.
+
 [ambiguous-grammar]: https://en.wikipedia.org/wiki/Ambiguous_grammar
-[antlr]: http://www.antlr.org/
+[antlr]: https://www.antlr.org
 [bison-dprec]: https://www.gnu.org/software/bison/manual/html_node/Generalized-LR-Parsing.html
 [bison]: https://en.wikipedia.org/wiki/GNU_bison
 [c-linkage]: https://en.cppreference.com/w/cpp/language/language_linkage
diff --git a/docs/section-4-syntax-highlighting.md b/docs/section-4-syntax-highlighting.md
index a6e5d74c..8fd73cf6 100644
--- a/docs/section-4-syntax-highlighting.md
+++ b/docs/section-4-syntax-highlighting.md
@@ -9,8 +9,6 @@ Syntax highlighting is a very common feature in applications that deal with code
 
 This document explains how the Tree-sitter syntax highlighting system works, using the command line interface. If you are using `tree-sitter-highlight` library (either from C or from Rust), all of these concepts are still applicable, but the configuration data is provided using in-memory objects, rather than files.
 
-**Note - If you are working on syntax highlighting in the [Atom](https://atom.io/) text editor, you should consult [the grammar-creation page](https://flight-manual.atom.io/hacking-atom/sections/creating-a-grammar/) of the Atom Flight Manual, *not* this document. Atom currently uses a different syntax highlighting system that is also based on Tree-sitter, but is older than the one described here.**
-
 ## Overview
 
 All of the files needed to highlight a given language are normally included in the same git repository as the Tree-sitter grammar for that language (for example, [`tree-sitter-javascript`](https://github.com/tree-sitter/tree-sitter-javascript), [`tree-sitter-ruby`](https://github.com/tree-sitter/tree-sitter-ruby)). In order to run syntax highlighting from the command-line, three types of files are needed:
@@ -27,9 +25,9 @@ The Tree-sitter CLI automatically creates two directories in your home folder.
 
 These directories are created in the "normal" place for your platform:
 
-- On Linux, `~/.config/tree-sitter` and `~/.cache/tree-sitter`
-- On Mac, `~/Library/Application Support/tree-sitter` and `~/Library/Caches/tree-sitter`
-- On Windows, `C:\Users\[username]\AppData\Roaming\tree-sitter` and `C:\Users\[username]\AppData\Local\tree-sitter`
+* On Linux, `~/.config/tree-sitter` and `~/.cache/tree-sitter`
+* On Mac, `~/Library/Application Support/tree-sitter` and `~/Library/Caches/tree-sitter`
+* On Windows, `C:\Users\[username]\AppData\Roaming\tree-sitter` and `C:\Users\[username]\AppData\Local\tree-sitter`
 
 The CLI will work if there's no config file present, falling back on default values for each configuration option.  To create a config file that you can edit, run this command:
 
@@ -63,6 +61,7 @@ In your config file, the `"theme"` value is an object whose keys are dot-separat
 #### Highlight Names
 
 A theme can contain multiple keys that share a common subsequence. Examples:
+
 * `variable` and `variable.parameter`
 * `function`, `function.builtin`, and `function.method`
 
@@ -160,7 +159,7 @@ func increment(a int) int {
 
 With this syntax tree:
 
-```
+```scheme
 (source_file
   (function_declaration
     name: (identifier)
@@ -180,6 +179,7 @@ With this syntax tree:
 #### Example Query
 
 Suppose we wanted to render this code with the following colors:
+
 * keywords `func` and `return` in purple
 * function `increment` in blue
 * type `int` in green
@@ -187,7 +187,7 @@ Suppose we wanted to render this code with the following colors:
 
 We can assign each of these categories a *highlight name* using a query like this:
 
-```
+```scheme
 ; highlights.scm
 
 "func" @keyword
@@ -254,7 +254,7 @@ list = [item]
 
 With this syntax tree:
 
-```
+```scheme
 (program
   (method
     name: (identifier)
@@ -297,7 +297,7 @@ There are several different types of names within this method:
 
 Let's write some queries that let us clearly distinguish between these types of names. First, set up the highlighting query, as described in the previous section. We'll assign distinct colors to method calls, method definitions, and formal parameters:
 
-```
+```scheme
 ; highlights.scm
 
 (call method: (identifier) @function.method)
@@ -314,7 +314,7 @@ Let's write some queries that let us clearly distinguish between these types of
 
 Then, we'll set up a local variable query to keep track of the variables and scopes. Here, we're indicating that methods and blocks create local *scopes*, parameters and assignments create *definitions*, and other identifiers should be considered *references*:
 
-```
+```scheme
 ; locals.scm
 
 (method) @local.scope
@@ -347,6 +347,7 @@ Running `tree-sitter highlight` on this ruby file would produce output like this
 ### Language Injection
 
 Some source files contain code written in multiple different languages. Examples include:
+
 * HTML files, which can contain JavaScript inside of `<script>` tags and CSS inside of `<style>` tags
 * [ERB](https://en.wikipedia.org/wiki/ERuby) files, which contain Ruby inside of `<% %>` tags, and HTML outside of those tags
 * PHP files, which can contain  HTML between the `<php` tags
@@ -361,8 +362,18 @@ All of these examples can be modeled in terms of a *parent* syntax tree and one
 The language injection behavior can also be configured by some properties associated with patterns:
 
 * `injection.language` - can be used to hard-code the name of a specific language.
-* `injection.combined` - indicates that *all* of the matching nodes in the tree should have their content parsed as *one* nested document.
-* `injection.include-children` - indicates that the `@injection.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.combined` - indicates that *all* of the matching nodes in the tree
+  should have their content parsed as *one* nested document.
+* `injection.include-children` - indicates that the `@injection.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.self` - indicates that the `@injection.content` node should be parsed
+  using the same language as the node itself. This is useful for cases where the
+  node's language is not known until runtime (e.g. via inheriting another language)
+* `injection.parent` indicates that the `@injection.content` node should be parsed
+  using the same language as the node's parent language. This is only meant for injections
+  that need to refer back to the parent language to parse the node's text inside
+  the injected language.
 
 #### Examples
 
@@ -376,7 +387,7 @@ BASH
 
 With this syntax tree:
 
-```
+```scheme
 (program
   (method_call
     method: (identifier)
@@ -390,7 +401,7 @@ With this syntax tree:
 
 The following query would specify that the contents of the heredoc should be parsed using a language named "BASH" (because that is the text of the `heredoc_end` node):
 
-```
+```scheme
 (heredoc_body
   (heredoc_end) @injection.language) @injection.content
 ```
@@ -398,7 +409,7 @@ The following query would specify that the contents of the heredoc should be par
 You can also force the language using the `#set!` predicate.
 For example, this will force the language to be always `ruby`.
 
-```
+```scheme
 ((heredoc_body) @injection.content
  (#set! injection.language "ruby"))
 ```
@@ -427,6 +438,9 @@ var abc = function(d) {
     //    ^ string
     //          ^ variable
   }
+
+  baz();
+  ^ !variable
 };
 ```
 
@@ -437,3 +451,5 @@ From the Sublime text docs:
 > **Caret**: ^ this will test the following selector against the scope on the most recent non-test line. It will test it at the same column the ^ is in. Consecutive ^s will test each column against the selector.
 >
 > **Arrow**: <- this will test the following selector against the scope on the most recent non-test line. It will test it at the same column as the comment character is in.
+
+Note that an exclamation mark (`!`) can be used to negate a selector. For example, `!keyword` will match any scope that is not the `keyword` class.
diff --git a/docs/section-5-implementation.md b/docs/section-5-implementation.md
index 532f1046..07a34307 100644
--- a/docs/section-5-implementation.md
+++ b/docs/section-5-implementation.md
@@ -13,7 +13,7 @@ syntax trees up-to-date as the source code changes. `libtree-sitter` is designed
 
 The CLI is
 used to generate a parser for a language by supplying a [context-free grammar](https://en.wikipedia.org/wiki/Context-free_grammar) describing the
-language. The CLI is a build tool; it is no longer needed once a parser has been generated. It is written in Rust, and is available on [crates.io](https://crates.io), [npm](http://npmjs.com), and as a pre-built binary [on GitHub](https://github.com/tree-sitter/tree-sitter/releases/latest).
+language. The CLI is a build tool; it is no longer needed once a parser has been generated. It is written in Rust, and is available on [crates.io](https://crates.io), [npm](https://npmjs.com), and as a pre-built binary [on GitHub](https://github.com/tree-sitter/tree-sitter/releases/latest).
 
 ## The CLI
 
@@ -21,7 +21,7 @@ The `tree-sitter` CLI's most important feature is the `generate` subcommand. Thi
 
 ### Parsing a Grammar
 
-First, Tree-sitter must must evaluate the JavaScript code in `grammar.js` and convert the grammar to a JSON format. It does this by shelling out to `node`. The format of the grammars is formally specified by the JSON schema in [grammar-schema.json](https://github.com/tree-sitter/tree-sitter/blob/master/cli/src/generate/grammar-schema.json). The parsing is implemented in [parse_grammar.rs](https://github.com/tree-sitter/tree-sitter/blob/master/cli/src/generate/parse_grammar.rs).
+First, Tree-sitter must evaluate the JavaScript code in `grammar.js` and convert the grammar to a JSON format. It does this by shelling out to `node`. The format of the grammars is formally specified by the JSON schema in [grammar-schema.json](https://github.com/tree-sitter/tree-sitter/blob/master/cli/src/generate/grammar-schema.json). The parsing is implemented in [parse_grammar.rs](https://github.com/tree-sitter/tree-sitter/blob/master/cli/src/generate/parse_grammar.rs).
 
 ### Grammar Rules
 
@@ -35,8 +35,6 @@ At the end of these transformations, the initial grammar is split into two gramm
 
 ### Building Parse Tables
 
-
-
 ## The Runtime
 
 WIP
diff --git a/docs/section-6-contributing.md b/docs/section-6-contributing.md
index 36f5f499..1fb8c003 100644
--- a/docs/section-6-contributing.md
+++ b/docs/section-6-contributing.md
@@ -96,18 +96,18 @@ script/test -l javascript -e Arrays
 
 The main [`tree-sitter/tree-sitter`](https://github.com/tree-sitter/tree-sitter) repository contains the source code for several packages that are published to package registries for different languages:
 
-- Rust crates on [crates.io](https://crates.io):
-  - [`tree-sitter`](https://crates.io/crates/tree-sitter) - A Rust binding to the core library
-  - [`tree-sitter-highlight`](https://crates.io/crates/tree-sitter-highlight) - The syntax-highlighting library
-  - [`tree-sitter-cli`](https://crates.io/crates/tree-sitter-cli) - The command-line tool
-- JavaScript modules on [npmjs.com](https://npmjs.com):
-  - [`web-tree-sitter`](https://www.npmjs.com/package/web-tree-sitter) - A WASM-based JavaScript binding to the core library
-  - [`tree-sitter-cli`](https://www.npmjs.com/package/tree-sitter-cli) - The command-line tool
+* Rust crates on [crates.io](https://crates.io):
+  * [`tree-sitter`](https://crates.io/crates/tree-sitter) - A Rust binding to the core library
+  * [`tree-sitter-highlight`](https://crates.io/crates/tree-sitter-highlight) - The syntax-highlighting library
+  * [`tree-sitter-cli`](https://crates.io/crates/tree-sitter-cli) - The command-line tool
+* JavaScript modules on [npmjs.com](https://npmjs.com):
+  * [`web-tree-sitter`](https://www.npmjs.com/package/web-tree-sitter) - A WASM-based JavaScript binding to the core library
+  * [`tree-sitter-cli`](https://www.npmjs.com/package/tree-sitter-cli) - The command-line tool
 
 There are also several other dependent repositories that contain other published packages:
 
-- [`tree-sitter/node-tree-sitter`](https://github.com/tree-sitter/node-tree-sitter) - Node.js bindings to the core library, published as [`tree-sitter`](https://www.npmjs.com/package/tree-sitter) on npmjs.com
-- [`tree-sitter/py-tree-sitter`](https://github.com/tree-sitter/py-tree-sitter) - Python bindings to the core library, published as [`tree-sitter`](https://pypi.org/project/tree-sitter) on [PyPI.org](https://pypi.org).
+* [`tree-sitter/node-tree-sitter`](https://github.com/tree-sitter/node-tree-sitter) - Node.js bindings to the core library, published as [`tree-sitter`](https://www.npmjs.com/package/tree-sitter) on npmjs.com
+* [`tree-sitter/py-tree-sitter`](https://github.com/tree-sitter/py-tree-sitter) - Python bindings to the core library, published as [`tree-sitter`](https://pypi.org/project/tree-sitter) on [PyPI.org](https://pypi.org).
 
 ## Publishing New Releases
 
diff --git a/docs/section-8-code-navigation-systems.md b/docs/section-8-code-navigation-systems.md
index a1b6a280..04346e46 100644
--- a/docs/section-8-code-navigation-systems.md
+++ b/docs/section-8-code-navigation-systems.md
@@ -9,7 +9,7 @@ Tree-sitter can be used in conjunction with its [tree query language](https://tr
 
 ## Tagging and captures
 
-*Tagging* is the act of identifying the entities that can be named in a program. We use Tree-sitter queries to find those entities. Having found them, you use a syntax capture to label the entity and its name.
+_Tagging_ is the act of identifying the entities that can be named in a program. We use Tree-sitter queries to find those entities. Having found them, you use a syntax capture to label the entity and its name.
 
 The essence of a given tag lies in two pieces of data: the _role_ of the entity that is matched (i.e. whether it is a definition or a reference) and the _kind_ of that entity, which describes how the entity is used (i.e. whether it's a class definition, function call, variable reference, and so on). Our convention is to use a syntax capture following the `@role.kind` capture name format, and another inner capture, always called `@name`, that pulls out the name of a given identifier.
 
@@ -19,14 +19,14 @@ You may optionally include a capture named `@doc` to bind a docstring. For conve
 
 This [query](https://github.com/tree-sitter/tree-sitter-python/blob/78c4e9b6b2f08e1be23b541ffced47b15e2972ad/queries/tags.scm#L4-L5) recognizes Python function definitions and captures their declared name. The `function_definition` syntax node is defined in the [Python Tree-sitter grammar](https://github.com/tree-sitter/tree-sitter-python/blob/78c4e9b6b2f08e1be23b541ffced47b15e2972ad/grammar.js#L354).
 
-``` scheme
+```scheme
 (function_definition
   name: (identifier) @name) @definition.function
 ```
 
 A more sophisticated query can be found in the [JavaScript Tree-sitter repository](https://github.com/tree-sitter/tree-sitter-javascript/blob/fdeb68ac8d2bd5a78b943528bb68ceda3aade2eb/queries/tags.scm#L63-L70):
 
-``` scheme
+```scheme
 (assignment_expression
   left: [
     (identifier) @name
@@ -39,7 +39,7 @@ A more sophisticated query can be found in the [JavaScript Tree-sitter repositor
 
 An even more sophisticated query is in the [Ruby Tree-sitter repository](https://github.com/tree-sitter/tree-sitter-ruby/blob/1ebfdb288842dae5a9233e2509a135949023dd82/queries/tags.scm#L24-L43), which uses built-in functions to strip the Ruby comment character (`#`) from the docstrings associated with a class or singleton-class declaration, then selects only the docstrings adjacent to the node matched as `@definition.class`.
 
-``` scheme
+```scheme
 (
   (comment)* @doc
   .
@@ -79,7 +79,7 @@ The below table describes a standard vocabulary for kinds and roles during the t
 
 You can use the `tree-sitter tags` command to test out a tags query file, passing as arguments one or more files to tag. We can run this tool from within the Tree-sitter Ruby repository, over code in a file called `test.rb`:
 
-``` ruby
+```ruby
 module Foo
   class Bar
     # won't be included
@@ -93,7 +93,7 @@ end
 
 Invoking `tree-sitter tags test.rb` produces the following console output, representing matched entities' name, role, location, first line, and docstring:
 
-```
+```text
     test.rb
         Foo              | module       def (0, 7) - (0, 10) `module Foo`
         Bar              | class        def (1, 8) - (1, 11) `class Bar`
diff --git a/highlight/Cargo.toml b/highlight/Cargo.toml
index 0b0de18e..c74e66c9 100644
--- a/highlight/Cargo.toml
+++ b/highlight/Cargo.toml
@@ -1,10 +1,10 @@
 [package]
 name = "tree-sitter-highlight"
 description = "Library for performing syntax highlighting with Tree-sitter"
-version = "0.20.1"
+version = "0.20.2"
 authors = [
-  "Max Brunsfeld <maxbrunsfeld@gmail.com>",
-  "Tim Clem <timothy.clem@gmail.com>",
+	"Max Brunsfeld <maxbrunsfeld@gmail.com>",
+	"Tim Clem <timothy.clem@gmail.com>",
 ]
 license = "MIT"
 readme = "README.md"
@@ -12,13 +12,15 @@ edition = "2018"
 keywords = ["incremental", "parsing", "syntax", "highlighting"]
 categories = ["parsing", "text-editors"]
 repository = "https://github.com/tree-sitter/tree-sitter"
+rust-version.workspace = true
 
 [lib]
 crate-type = ["lib", "staticlib"]
 
 [dependencies]
-regex = "1"
-thiserror = "1.0"
+lazy_static = "1.4.0"
+regex = "1.9.1"
+thiserror = "1.0.43"
 
 [dependencies.tree-sitter]
 version = "0.20"
diff --git a/highlight/README.md b/highlight/README.md
index c04c7c08..459790ef 100644
--- a/highlight/README.md
+++ b/highlight/README.md
@@ -1,8 +1,9 @@
-# `tree-sitter-highlight`
+# Tree-sitter Highlight
 
-[![Build Status](https://travis-ci.org/tree-sitter/tree-sitter.svg?branch=master)](https://travis-ci.org/tree-sitter/tree-sitter)
-[![Build status](https://ci.appveyor.com/api/projects/status/vtmbd6i92e97l55w/branch/master?svg=true)](https://ci.appveyor.com/project/maxbrunsfeld/tree-sitter/branch/master)
-[![Crates.io](https://img.shields.io/crates/v/tree-sitter-highlight.svg)](https://crates.io/crates/tree-sitter-highlight)
+[![crates.io badge]][crates.io]
+
+[crates.io]: https://crates.io/crates/tree-sitter-highlight
+[crates.io badge]: https://img.shields.io/crates/v/tree-sitter-highlight.svg?color=%23B48723
 
 ### Usage
 
@@ -10,15 +11,14 @@ Add this crate, and the language-specific crates for whichever languages you wan
 
 ```toml
 [dependencies]
-tree-sitter-highlight = "0.19"
-tree-sitter-html = "0.19"
+tree-sitter-highlight = "^0.20"
 tree-sitter-javascript = "0.19"
 ```
 
 Define the list of highlight names that you will recognize:
 
 ```rust
-let highlight_names = &[
+let highlight_names = [
     "attribute",
     "constant",
     "function.builtin",
@@ -45,29 +45,21 @@ Create a highlighter. You need one of these for each thread that you're using fo
 ```rust
 use tree_sitter_highlight::Highlighter;
 
-let highlighter = Highlighter::new();
+let mut highlighter = Highlighter::new();
 ```
 
-Load some highlighting queries from the `queries` directory of some language repositories:
+Load some highlighting queries from the `queries` directory of the language repository:
 
 ```rust
 use tree_sitter_highlight::HighlightConfiguration;
 
-let html_language = unsafe { tree_sitter_html() };
-let javascript_language = unsafe { tree_sitter_javascript() };
+let javascript_language = tree_sitter_javascript::language();
 
-let html_config = HighlightConfiguration::new(
-    tree_sitter_html::language(),
-    tree_sitter_html::HIGHLIGHTS_QUERY,
-    tree_sitter_html::INJECTIONS_QUERY,
-    "",
-).unwrap();
-
-let javascript_config = HighlightConfiguration::new(
-    tree_sitter_javascript::language(),
-    tree_sitter_javascript::HIGHLIGHTS_QUERY,
-    tree_sitter_javascript::INJECTIONS_QUERY,
-    tree_sitter_javascript::LCOALS_QUERY,
+let mut javascript_config = HighlightConfiguration::new(
+    javascript_language,
+    tree_sitter_javascript::HIGHLIGHT_QUERY,
+    tree_sitter_javascript::INJECTION_QUERY,
+    tree_sitter_javascript::LOCALS_QUERY,
 ).unwrap();
 ```
 
diff --git a/highlight/include/tree_sitter/highlight.h b/highlight/include/tree_sitter/highlight.h
index 496faea4..325cf413 100644
--- a/highlight/include/tree_sitter/highlight.h
+++ b/highlight/include/tree_sitter/highlight.h
@@ -48,7 +48,8 @@ TSHighlightError ts_highlighter_add_language(
   const char *locals_query,
   uint32_t highlight_query_len,
   uint32_t injection_query_len,
-  uint32_t locals_query_len
+  uint32_t locals_query_len,
+  bool apply_all_captures
 );
 
 // Compute syntax highlighting for a given document. You must first
diff --git a/highlight/src/c_lib.rs b/highlight/src/c_lib.rs
index d48a180c..1ab4903a 100644
--- a/highlight/src/c_lib.rs
+++ b/highlight/src/c_lib.rs
@@ -29,25 +29,30 @@ pub enum ErrorCode {
     InvalidUtf8,
     InvalidRegex,
     InvalidQuery,
+    InvalidLanguageName,
 }
 
+/// Create a new [`TSHighlighter`] instance.
+///
+/// # Safety
+///
+/// The caller must ensure that the `highlight_names` and `attribute_strings` arrays are valid for
+/// the lifetime of the returned [`TSHighlighter`] instance, and are non-null.
 #[no_mangle]
-pub extern "C" fn ts_highlighter_new(
+pub unsafe extern "C" fn ts_highlighter_new(
     highlight_names: *const *const c_char,
     attribute_strings: *const *const c_char,
     highlight_count: u32,
 ) -> *mut TSHighlighter {
-    let highlight_names =
-        unsafe { slice::from_raw_parts(highlight_names, highlight_count as usize) };
-    let attribute_strings =
-        unsafe { slice::from_raw_parts(attribute_strings, highlight_count as usize) };
+    let highlight_names = slice::from_raw_parts(highlight_names, highlight_count as usize);
+    let attribute_strings = slice::from_raw_parts(attribute_strings, highlight_count as usize);
     let highlight_names = highlight_names
-        .into_iter()
-        .map(|s| unsafe { CStr::from_ptr(*s).to_string_lossy().to_string() })
+        .iter()
+        .map(|s| CStr::from_ptr(*s).to_string_lossy().to_string())
         .collect::<Vec<_>>();
     let attribute_strings = attribute_strings
-        .into_iter()
-        .map(|s| unsafe { CStr::from_ptr(*s).to_bytes() })
+        .iter()
+        .map(|s| CStr::from_ptr(*s).to_bytes())
         .collect();
     let carriage_return_index = highlight_names.iter().position(|s| s == "carriage-return");
     Box::into_raw(Box::new(TSHighlighter {
@@ -58,9 +63,21 @@ pub extern "C" fn ts_highlighter_new(
     }))
 }
 
+/// Add a language to a [`TSHighlighter`] instance.
+///
+/// Returns an [`ErrorCode`] indicating whether the language was added successfully or not.
+///
+/// # Safety
+///
+/// `this` must be non-null and must be a valid pointer to a [`TSHighlighter`] instance
+/// created by [`ts_highlighter_new`].
+///
+/// The caller must ensure that any `*const c_char` (C-style string) parameters are valid for the lifetime of
+/// the [`TSHighlighter`] instance, and are non-null.
 #[no_mangle]
-pub extern "C" fn ts_highlighter_add_language(
+pub unsafe extern "C" fn ts_highlighter_add_language(
     this: *mut TSHighlighter,
+    language_name: *const c_char,
     scope_name: *const c_char,
     injection_regex: *const c_char,
     language: Language,
@@ -70,10 +87,11 @@ pub extern "C" fn ts_highlighter_add_language(
     highlight_query_len: u32,
     injection_query_len: u32,
     locals_query_len: u32,
+    apply_all_captures: bool,
 ) -> ErrorCode {
     let f = move || {
         let this = unwrap_mut_ptr(this);
-        let scope_name = unsafe { CStr::from_ptr(scope_name) };
+        let scope_name = CStr::from_ptr(scope_name);
         let scope_name = scope_name
             .to_str()
             .or(Err(ErrorCode::InvalidUtf8))?
@@ -81,38 +99,45 @@ pub extern "C" fn ts_highlighter_add_language(
         let injection_regex = if injection_regex.is_null() {
             None
         } else {
-            let pattern = unsafe { CStr::from_ptr(injection_regex) };
+            let pattern = CStr::from_ptr(injection_regex);
             let pattern = pattern.to_str().or(Err(ErrorCode::InvalidUtf8))?;
             Some(Regex::new(pattern).or(Err(ErrorCode::InvalidRegex))?)
         };
 
-        let highlight_query = unsafe {
-            slice::from_raw_parts(highlight_query as *const u8, highlight_query_len as usize)
-        };
+        let highlight_query =
+            slice::from_raw_parts(highlight_query as *const u8, highlight_query_len as usize);
+
         let highlight_query = str::from_utf8(highlight_query).or(Err(ErrorCode::InvalidUtf8))?;
 
         let injection_query = if injection_query_len > 0 {
-            let query = unsafe {
-                slice::from_raw_parts(injection_query as *const u8, injection_query_len as usize)
-            };
+            let query =
+                slice::from_raw_parts(injection_query as *const u8, injection_query_len as usize);
             str::from_utf8(query).or(Err(ErrorCode::InvalidUtf8))?
         } else {
             ""
         };
 
         let locals_query = if locals_query_len > 0 {
-            let query = unsafe {
-                slice::from_raw_parts(locals_query as *const u8, locals_query_len as usize)
-            };
+            let query = slice::from_raw_parts(locals_query as *const u8, locals_query_len as usize);
             str::from_utf8(query).or(Err(ErrorCode::InvalidUtf8))?
         } else {
             ""
         };
 
-        let mut config =
-            HighlightConfiguration::new(language, highlight_query, injection_query, locals_query)
-                .or(Err(ErrorCode::InvalidQuery))?;
-        config.configure(&this.highlight_names.as_slice());
+        let lang = CStr::from_ptr(language_name)
+            .to_str()
+            .or(Err(ErrorCode::InvalidLanguageName))?;
+
+        let mut config = HighlightConfiguration::new(
+            language,
+            lang,
+            highlight_query,
+            injection_query,
+            locals_query,
+            apply_all_captures,
+        )
+        .or(Err(ErrorCode::InvalidQuery))?;
+        config.configure(this.highlight_names.as_slice());
         this.languages.insert(scope_name, (injection_regex, config));
 
         Ok(())
@@ -132,42 +157,102 @@ pub extern "C" fn ts_highlight_buffer_new() -> *mut TSHighlightBuffer {
     }))
 }
 
+/// Deletes a [`TSHighlighter`] instance.
+///
+/// # Safety
+///
+/// `this` must be non-null and must be a valid pointer to a [`TSHighlighter`] instance
+/// created by [`ts_highlighter_new`].
+///
+/// It cannot be used after this function is called.
 #[no_mangle]
-pub extern "C" fn ts_highlighter_delete(this: *mut TSHighlighter) {
-    drop(unsafe { Box::from_raw(this) })
+pub unsafe extern "C" fn ts_highlighter_delete(this: *mut TSHighlighter) {
+    drop(Box::from_raw(this))
 }
 
+/// Deletes a [`TSHighlightBuffer`] instance.
+///
+/// # Safety
+///
+/// `this` must be non-null and must be a valid pointer to a [`TSHighlightBuffer`] instance
+/// created by [`ts_highlight_buffer_new`]
+///
+/// It cannot be used after this function is called.
 #[no_mangle]
-pub extern "C" fn ts_highlight_buffer_delete(this: *mut TSHighlightBuffer) {
-    drop(unsafe { Box::from_raw(this) })
+pub unsafe extern "C" fn ts_highlight_buffer_delete(this: *mut TSHighlightBuffer) {
+    drop(Box::from_raw(this))
 }
 
+/// Get the HTML content of a [`TSHighlightBuffer`] instance as a raw pointer.
+///
+/// # Safety
+///
+/// `this` must be non-null and must be a valid pointer to a [`TSHighlightBuffer`] instance
+/// created by [`ts_highlight_buffer_new`].
+///
+/// The returned pointer, a C-style string, must not outlive the [`TSHighlightBuffer`] instance, else the
+/// data will point to garbage.
+///
+/// To get the length of the HTML content, use [`ts_highlight_buffer_len`].
 #[no_mangle]
-pub extern "C" fn ts_highlight_buffer_content(this: *const TSHighlightBuffer) -> *const u8 {
+pub unsafe extern "C" fn ts_highlight_buffer_content(this: *const TSHighlightBuffer) -> *const u8 {
     let this = unwrap_ptr(this);
     this.renderer.html.as_slice().as_ptr()
 }
 
+/// Get the line offsets of a [`TSHighlightBuffer`] instance as a C-style array.
+///
+/// # Safety
+///
+/// `this` must be non-null and must be a valid pointer to a [`TSHighlightBuffer`] instance
+/// created by [`ts_highlight_buffer_new`].
+///
+/// The returned pointer, a C-style array of [`u32`]s, must not outlive the [`TSHighlightBuffer`] instance, else the
+/// data will point to garbage.
+///
+/// To get the length of the array, use [`ts_highlight_buffer_line_count`].
 #[no_mangle]
-pub extern "C" fn ts_highlight_buffer_line_offsets(this: *const TSHighlightBuffer) -> *const u32 {
+pub unsafe extern "C" fn ts_highlight_buffer_line_offsets(
+    this: *const TSHighlightBuffer,
+) -> *const u32 {
     let this = unwrap_ptr(this);
     this.renderer.line_offsets.as_slice().as_ptr()
 }
 
+/// Get the length of the HTML content of a [`TSHighlightBuffer`] instance.
+///
+/// # Safety
+///
+/// `this` must be non-null and must be a valid pointer to a [`TSHighlightBuffer`] instance
+/// created by [`ts_highlight_buffer_new`].
 #[no_mangle]
-pub extern "C" fn ts_highlight_buffer_len(this: *const TSHighlightBuffer) -> u32 {
+pub unsafe extern "C" fn ts_highlight_buffer_len(this: *const TSHighlightBuffer) -> u32 {
     let this = unwrap_ptr(this);
     this.renderer.html.len() as u32
 }
 
+/// Get the number of lines in a [`TSHighlightBuffer`] instance.
+///
+/// # Safety
+///
+/// `this` must be non-null and must be a valid pointer to a [`TSHighlightBuffer`] instance
+/// created by [`ts_highlight_buffer_new`].
 #[no_mangle]
-pub extern "C" fn ts_highlight_buffer_line_count(this: *const TSHighlightBuffer) -> u32 {
+pub unsafe extern "C" fn ts_highlight_buffer_line_count(this: *const TSHighlightBuffer) -> u32 {
     let this = unwrap_ptr(this);
     this.renderer.line_offsets.len() as u32
 }
 
+/// Highlight a string of source code.
+///
+/// # Safety
+///
+/// The caller must ensure that `scope_name`, `source_code`, `output`, and `cancellation_flag` are valid for
+/// the lifetime of the [`TSHighlighter`] instance, and are non-null.
+///
+/// `this` must be a non-null pointer to a [`TSHighlighter`] instance created by [`ts_highlighter_new`]
 #[no_mangle]
-pub extern "C" fn ts_highlighter_highlight(
+pub unsafe extern "C" fn ts_highlighter_highlight(
     this: *const TSHighlighter,
     scope_name: *const c_char,
     source_code: *const c_char,
@@ -177,10 +262,9 @@ pub extern "C" fn ts_highlighter_highlight(
 ) -> ErrorCode {
     let this = unwrap_ptr(this);
     let output = unwrap_mut_ptr(output);
-    let scope_name = unwrap(unsafe { CStr::from_ptr(scope_name).to_str() });
-    let source_code =
-        unsafe { slice::from_raw_parts(source_code as *const u8, source_code_len as usize) };
-    let cancellation_flag = unsafe { cancellation_flag.as_ref() };
+    let scope_name = unwrap(CStr::from_ptr(scope_name).to_str());
+    let source_code = slice::from_raw_parts(source_code as *const u8, source_code_len as usize);
+    let cancellation_flag = cancellation_flag.as_ref();
     this.highlight(source_code, scope_name, output, cancellation_flag)
 }
 
@@ -225,15 +309,8 @@ impl TSHighlighter {
                 .renderer
                 .render(highlights, source_code, &|s| self.attribute_strings[s.0]);
             match result {
-                Err(Error::Cancelled) => {
-                    return ErrorCode::Timeout;
-                }
-                Err(Error::InvalidLanguage) => {
-                    return ErrorCode::InvalidLanguage;
-                }
-                Err(Error::Unknown) => {
-                    return ErrorCode::Timeout;
-                }
+                Err(Error::Cancelled) | Err(Error::Unknown) => ErrorCode::Timeout,
+                Err(Error::InvalidLanguage) => ErrorCode::InvalidLanguage,
                 Ok(()) => ErrorCode::Ok,
             }
         } else {
@@ -242,15 +319,15 @@ impl TSHighlighter {
     }
 }
 
-fn unwrap_ptr<'a, T>(result: *const T) -> &'a T {
-    unsafe { result.as_ref() }.unwrap_or_else(|| {
+unsafe fn unwrap_ptr<'a, T>(result: *const T) -> &'a T {
+    result.as_ref().unwrap_or_else(|| {
         eprintln!("{}:{} - pointer must not be null", file!(), line!());
         abort();
     })
 }
 
-fn unwrap_mut_ptr<'a, T>(result: *mut T) -> &'a mut T {
-    unsafe { result.as_mut() }.unwrap_or_else(|| {
+unsafe fn unwrap_mut_ptr<'a, T>(result: *mut T) -> &'a mut T {
+    result.as_mut().unwrap_or_else(|| {
         eprintln!("{}:{} - pointer must not be null", file!(), line!());
         abort();
     })
diff --git a/highlight/src/lib.rs b/highlight/src/lib.rs
index 8a79c624..2170b07f 100644
--- a/highlight/src/lib.rs
+++ b/highlight/src/lib.rs
@@ -1,7 +1,11 @@
+#![doc = include_str!("../README.md")]
+
 pub mod c_lib;
 pub mod util;
 pub use c_lib as c;
 
+use lazy_static::lazy_static;
+use std::collections::HashSet;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::{iter, mem, ops, str, usize};
 use thiserror::Error;
@@ -14,6 +18,65 @@ const CANCELLATION_CHECK_INTERVAL: usize = 100;
 const BUFFER_HTML_RESERVE_CAPACITY: usize = 10 * 1024;
 const BUFFER_LINES_RESERVE_CAPACITY: usize = 1000;
 
+lazy_static! {
+    static ref STANDARD_CAPTURE_NAMES: HashSet<&'static str> = vec![
+        "attribute",
+        "boolean",
+        "carriage-return",
+        "comment",
+        "comment.documentation",
+        "constant",
+        "constant.builtin",
+        "constructor",
+        "constructor.builtin",
+        "embedded",
+        "error",
+        "escape",
+        "function",
+        "function.builtin",
+        "keyword",
+        "markup",
+        "markup.bold",
+        "markup.heading",
+        "markup.italic",
+        "markup.link",
+        "markup.link.url",
+        "markup.list",
+        "markup.list.checked",
+        "markup.list.numbered",
+        "markup.list.unchecked",
+        "markup.list.unnumbered",
+        "markup.quote",
+        "markup.raw",
+        "markup.raw.block",
+        "markup.raw.inline",
+        "markup.strikethrough",
+        "module",
+        "number",
+        "operator",
+        "property",
+        "property.builtin",
+        "punctuation",
+        "punctuation.bracket",
+        "punctuation.delimiter",
+        "punctuation.special",
+        "string",
+        "string.escape",
+        "string.regexp",
+        "string.special",
+        "string.special.symbol",
+        "tag",
+        "type",
+        "type.builtin",
+        "variable",
+        "variable.builtin",
+        "variable.member",
+        "variable.parameter",
+    ]
+    .into_iter()
+    .collect();
+}
+
 /// Indicates which highlight should be applied to a region of source code.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub struct Highlight(pub usize);
@@ -42,7 +105,9 @@ pub enum HighlightEvent {
 /// This struct is immutable and can be shared between threads.
 pub struct HighlightConfiguration {
     pub language: Language,
+    pub language_name: String,
     pub query: Query,
+    pub apply_all_captures: bool,
     combined_injections_query: Option<Query>,
     locals_pattern_index: usize,
     highlights_pattern_index: usize,
@@ -92,6 +157,7 @@ where
     F: FnMut(&str) -> Option<&'a HighlightConfiguration> + 'a,
 {
     source: &'a [u8],
+    language_name: &'a str,
     byte_offset: usize,
     highlighter: &'a mut Highlighter,
     injection_callback: F,
@@ -100,12 +166,13 @@ where
     iter_count: usize,
     next_event: Option<HighlightEvent>,
     last_highlight_range: Option<(usize, usize, usize)>,
+    apply_all_captures: bool,
 }
 
 struct HighlightIterLayer<'a> {
     _tree: Tree,
     cursor: QueryCursor,
-    captures: iter::Peekable<QueryCaptures<'a, 'a, &'a [u8]>>,
+    captures: iter::Peekable<QueryCaptures<'a, 'a, &'a [u8], &'a [u8]>>,
     config: &'a HighlightConfiguration,
     highlight_end_stack: Vec<usize>,
     scope_stack: Vec<LocalScope<'a>>,
@@ -135,6 +202,7 @@ impl Highlighter {
     ) -> Result<impl Iterator<Item = Result<HighlightEvent, Error>> + 'a, Error> {
         let layers = HighlightIterLayer::new(
             source,
+            None,
             self,
             cancellation_flag,
             &mut injection_callback,
@@ -150,14 +218,16 @@ impl Highlighter {
         assert_ne!(layers.len(), 0);
         let mut result = HighlightIter {
             source,
+            language_name: &config.language_name,
             byte_offset: 0,
             injection_callback,
             cancellation_flag,
             highlighter: self,
             iter_count: 0,
-            layers: layers,
+            layers,
             next_event: None,
             last_highlight_range: None,
+            apply_all_captures: config.apply_all_captures,
         };
         result.sort_layers();
         Ok(result)
@@ -181,9 +251,11 @@ impl HighlightConfiguration {
     /// Returns a `HighlightConfiguration` that can then be used with the `highlight` method.
     pub fn new(
         language: Language,
+        name: impl Into<String>,
         highlights_query: &str,
         injection_query: &str,
         locals_query: &str,
+        apply_all_captures: bool,
     ) -> Result<Self, QueryError> {
         // Concatenate the query strings, keeping track of the start offset of each section.
         let mut query_source = String::new();
@@ -249,7 +321,7 @@ impl HighlightConfiguration {
         let mut local_scope_capture_index = None;
         for (i, name) in query.capture_names().iter().enumerate() {
             let i = Some(i as u32);
-            match name.as_str() {
+            match *name {
                 "injection.content" => injection_content_capture_index = i,
                 "injection.language" => injection_language_capture_index = i,
                 "local.definition" => local_def_capture_index = i,
@@ -263,7 +335,9 @@ impl HighlightConfiguration {
         let highlight_indices = vec![None; query.capture_names().len()];
         Ok(HighlightConfiguration {
             language,
+            language_name: name.into(),
             query,
+            apply_all_captures,
             combined_injections_query,
             locals_pattern_index,
             highlights_pattern_index,
@@ -279,7 +353,7 @@ impl HighlightConfiguration {
     }
 
     /// Get a slice containing all of the highlight names used in the configuration.
-    pub fn names(&self) -> &[String] {
+    pub fn names(&self) -> &[&str] {
         self.query.capture_names()
     }
 
@@ -321,6 +395,22 @@ impl HighlightConfiguration {
                 best_index.map(Highlight)
             }));
     }
+
+    // Return the list of this configuration's capture names that are neither present in the
+    // list of predefined 'canonical' names nor start with an underscore (denoting 'private' captures
+    // used as part of capture internals).
+    pub fn nonconformant_capture_names(&self, capture_names: &HashSet<&str>) -> Vec<&str> {
+        let capture_names = if capture_names.is_empty() {
+            &*STANDARD_CAPTURE_NAMES
+        } else {
+            &capture_names
+        };
+        self.names()
+            .iter()
+            .filter(|&n| !(n.starts_with('_') || capture_names.contains(n)))
+            .map(|n| *n)
+            .collect()
+    }
 }
 
 impl<'a> HighlightIterLayer<'a> {
@@ -331,6 +421,7 @@ impl<'a> HighlightIterLayer<'a> {
     /// added to the returned vector.
     fn new<F: FnMut(&str) -> Option<&'a HighlightConfiguration> + 'a>(
         source: &'a [u8],
+        parent_name: Option<&str>,
         highlighter: &mut Highlighter,
         cancellation_flag: Option<&'a AtomicUsize>,
         injection_callback: &mut F,
@@ -363,8 +454,13 @@ impl<'a> HighlightIterLayer<'a> {
                         cursor.matches(combined_injections_query, tree.root_node(), source);
                     for mat in matches {
                         let entry = &mut injections_by_pattern_index[mat.pattern_index];
-                        let (language_name, content_node, include_children) =
-                            injection_for_match(config, combined_injections_query, &mat, source);
+                        let (language_name, content_node, include_children) = injection_for_match(
+                            config,
+                            parent_name,
+                            combined_injections_query,
+                            &mat,
+                            source,
+                        );
                         if language_name.is_some() {
                             entry.0 = language_name;
                         }
@@ -685,8 +781,13 @@ where
 
             // If this capture represents an injection, then process the injection.
             if match_.pattern_index < layer.config.locals_pattern_index {
-                let (language_name, content_node, include_children) =
-                    injection_for_match(&layer.config, &layer.config.query, &match_, &self.source);
+                let (language_name, content_node, include_children) = injection_for_match(
+                    layer.config,
+                    Some(self.language_name),
+                    &layer.config.query,
+                    &match_,
+                    self.source,
+                );
 
                 // Explicitly remove this match so that none of its other captures will remain
                 // in the stream of captures.
@@ -704,6 +805,7 @@ where
                         if !ranges.is_empty() {
                             match HighlightIterLayer::new(
                                 self.source,
+                                Some(self.language_name),
                                 self.highlighter,
                                 self.cancellation_flag,
                                 &mut self.injection_callback,
@@ -858,7 +960,13 @@ where
             while let Some((next_match, next_capture_index)) = layer.captures.peek() {
                 let next_capture = next_match.captures[*next_capture_index];
                 if next_capture.node == capture.node {
-                    layer.captures.next();
+                    if self.apply_all_captures {
+                        match_.remove();
+                        capture = next_capture;
+                        match_ = layer.captures.next().unwrap().0;
+                    } else {
+                        layer.captures.next();
+                    }
                 } else {
                     break;
                 }
@@ -1024,7 +1132,8 @@ impl HtmlRenderer {
 }
 
 fn injection_for_match<'a>(
-    config: &HighlightConfiguration,
+    config: &'a HighlightConfiguration,
+    parent_name: Option<&'a str>,
     query: &'a Query,
     query_match: &QueryMatch<'a, 'a>,
     source: &'a [u8],
@@ -1034,6 +1143,7 @@ fn injection_for_match<'a>(
 
     let mut language_name = None;
     let mut content_node = None;
+
     for capture in query_match.captures {
         let index = Some(capture.index);
         if index == language_capture_index {
@@ -1051,7 +1161,25 @@ fn injection_for_match<'a>(
             // that sets the injection.language key.
             "injection.language" => {
                 if language_name.is_none() {
-                    language_name = prop.value.as_ref().map(|s| s.as_ref())
+                    language_name = prop.value.as_ref().map(|s| s.as_ref());
+                }
+            }
+
+            // Setting the `injection.self` key can be used to specify that the
+            // language name should be the same as the language of the current
+            // layer.
+            "injection.self" => {
+                if language_name.is_none() {
+                    language_name = Some(config.language_name.as_str());
+                }
+            }
+
+            // Setting the `injection.parent` key can be used to specify that
+            // the language name should be the same as the language of the
+            // parent layer
+            "injection.parent" => {
+                if language_name.is_none() {
+                    language_name = parent_name;
                 }
             }
 
diff --git a/lib/Cargo.toml b/lib/Cargo.toml
index 7f3ff1b2..d100c4d5 100644
--- a/lib/Cargo.toml
+++ b/lib/Cargo.toml
@@ -1,14 +1,15 @@
 [package]
 name = "tree-sitter"
 description = "Rust bindings to the Tree-sitter parsing library"
-version = "0.20.9"
+version = "0.20.10"
 authors = ["Max Brunsfeld <maxbrunsfeld@gmail.com>"]
-edition = "2018"
+edition = "2021"
 license = "MIT"
 readme = "binding_rust/README.md"
 keywords = ["incremental", "parsing"]
 categories = ["api-bindings", "parsing", "text-editors"]
 repository = "https://github.com/tree-sitter/tree-sitter"
+rust-version.workspace = true
 
 build = "binding_rust/build.rs"
 
@@ -25,7 +26,7 @@ include = [
 wasm = ["wasmtime", "wasmtime-c-api"]
 
 [dependencies]
-regex = "1"
+regex = "1.9.1"
 
 [dependencies.wasmtime]
 git = "https://github.com/maxbrunsfeld/wasmtime"
@@ -41,7 +42,8 @@ optional = true
 default-features = false
 
 [build-dependencies]
-cc = "^1.0.58"
+bindgen = { version = "^0.66.1", optional = true }
+cc = "^1.0.79"
 
 [lib]
 path = "binding_rust/lib.rs"
diff --git a/lib/README.md b/lib/README.md
index 82ebc5a5..231fe2ab 100644
--- a/lib/README.md
+++ b/lib/README.md
@@ -1,5 +1,4 @@
-Subdirectories
---------------
+## Subdirectories
 
 * [`src`](./src) - C source code for the Tree-sitter library
 * [`include`](./include) - C headers for the Tree-sitter library
diff --git a/lib/binding_rust/README.md b/lib/binding_rust/README.md
index 6b48630a..7a052b2b 100644
--- a/lib/binding_rust/README.md
+++ b/lib/binding_rust/README.md
@@ -1,12 +1,13 @@
 # Rust Tree-sitter
 
-[![Build Status](https://travis-ci.org/tree-sitter/tree-sitter.svg?branch=master)](https://travis-ci.org/tree-sitter/tree-sitter)
-[![Build status](https://ci.appveyor.com/api/projects/status/vtmbd6i92e97l55w/branch/master?svg=true)](https://ci.appveyor.com/project/maxbrunsfeld/tree-sitter/branch/master)
-[![Crates.io](https://img.shields.io/crates/v/tree-sitter.svg)](https://crates.io/crates/tree-sitter)
+[![crates.io badge]][crates.io]
+
+[crates.io]: https://crates.io/crates/tree-sitter
+[crates.io badge]: https://img.shields.io/crates/v/tree-sitter.svg?color=%23B48723
 
 Rust bindings to the [Tree-sitter][] parsing library.
 
-### Basic Usage
+## Basic Usage
 
 First, create a parser:
 
@@ -16,22 +17,6 @@ use tree_sitter::{Parser, Language};
 let mut parser = Parser::new();
 ```
 
-Tree-sitter languages consist of generated C code. To make sure they're properly compiled and linked, you can create a [build script](https://doc.rust-lang.org/cargo/reference/build-scripts.html) like the following (assuming `tree-sitter-javascript` is in your root directory):
-
-```rust
-use std::path::PathBuf;
-
-fn main() {
-    let dir: PathBuf = ["tree-sitter-javascript", "src"].iter().collect();
-
-    cc::Build::new()
-        .include(&dir)
-        .file(dir.join("parser.c"))
-        .file(dir.join("scanner.c"))
-        .compile("tree-sitter-javascript");
-}
-```
-
 Add the `cc` crate to your `Cargo.toml` under `[build-dependencies]`:
 
 ```toml
@@ -39,15 +24,18 @@ Add the `cc` crate to your `Cargo.toml` under `[build-dependencies]`:
 cc="*"
 ```
 
-To then use languages from rust, you must declare them as `extern "C"` functions and invoke them with `unsafe`. Then you can assign them to the parser.
+Then, add a language as a dependency:
+
+```toml
+[dependencies]
+tree-sitter = "0.20.10"
+tree-sitter-rust = "0.20.3"
+```
+
+To then use a language, you assign them to the parser.
 
 ```rust
-extern "C" { fn tree_sitter_c() -> Language; }
-extern "C" { fn tree_sitter_rust() -> Language; }
-extern "C" { fn tree_sitter_javascript() -> Language; }
-
-let language = unsafe { tree_sitter_rust() };
-parser.set_language(language).unwrap();
+parser.set_language(tree_sitter_rust::language()).expect("Error loading Rust grammar");
 ```
 
 Now you can parse source code:
@@ -64,7 +52,8 @@ assert_eq!(root_node.end_position().column, 12);
 
 ### Editing
 
-Once you have a syntax tree, you can update it when your source code changes. Passing in the previous edited tree makes `parse` run much more quickly:
+Once you have a syntax tree, you can update it when your source code changes.
+Passing in the previous edited tree makes `parse` run much more quickly:
 
 ```rust
 let new_source_code = "fn test(a: u32) {}"
@@ -83,7 +72,8 @@ let new_tree = parser.parse(new_source_code, Some(&tree));
 
 ### Text Input
 
-The source code to parse can be provided either as a string, a slice, a vector, or as a function that returns a slice. The text can be encoded as either UTF8 or UTF16:
+The source code to parse can be provided either as a string, a slice, a vector,
+or as a function that returns a slice. The text can be encoded as either UTF8 or UTF16:
 
 ```rust
 // Store some source code in an array of lines.
diff --git a/lib/binding_rust/bindings.rs b/lib/binding_rust/bindings.rs
index be155be1..112161ee 100644
--- a/lib/binding_rust/bindings.rs
+++ b/lib/binding_rust/bindings.rs
@@ -1,38 +1,46 @@
-/* automatically generated by rust-bindgen 0.59.2 */
+/* automatically generated by rust-bindgen 0.66.1 */
 
+pub const TREE_SITTER_LANGUAGE_VERSION: u32 = 14;
+pub const TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION: u32 = 13;
+pub type TSStateId = u16;
 pub type TSSymbol = u16;
 pub type TSFieldId = u16;
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 pub struct TSLanguage {
     _unused: [u8; 0],
 }
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 pub struct TSParser {
     _unused: [u8; 0],
 }
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 pub struct TSTree {
     _unused: [u8; 0],
 }
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 pub struct TSQuery {
     _unused: [u8; 0],
 }
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 pub struct TSQueryCursor {
     _unused: [u8; 0],
 }
-pub const TSInputEncoding_TSInputEncodingUTF8: TSInputEncoding = 0;
-pub const TSInputEncoding_TSInputEncodingUTF16: TSInputEncoding = 1;
+#[repr(C)]
+#[derive(Debug)]
+pub struct TSLookaheadIterator {
+    _unused: [u8; 0],
+}
+pub const TSInputEncodingUTF8: TSInputEncoding = 0;
+pub const TSInputEncodingUTF16: TSInputEncoding = 1;
 pub type TSInputEncoding = ::std::os::raw::c_uint;
-pub const TSSymbolType_TSSymbolTypeRegular: TSSymbolType = 0;
-pub const TSSymbolType_TSSymbolTypeAnonymous: TSSymbolType = 1;
-pub const TSSymbolType_TSSymbolTypeAuxiliary: TSSymbolType = 2;
+pub const TSSymbolTypeRegular: TSSymbolType = 0;
+pub const TSSymbolTypeAnonymous: TSSymbolType = 1;
+pub const TSSymbolTypeAuxiliary: TSSymbolType = 2;
 pub type TSSymbolType = ::std::os::raw::c_uint;
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
@@ -49,7 +57,7 @@ pub struct TSRange {
     pub end_byte: u32,
 }
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 pub struct TSInput {
     pub payload: *mut ::std::os::raw::c_void,
     pub read: ::std::option::Option<
@@ -62,18 +70,18 @@ pub struct TSInput {
     >,
     pub encoding: TSInputEncoding,
 }
-pub const TSLogType_TSLogTypeParse: TSLogType = 0;
-pub const TSLogType_TSLogTypeLex: TSLogType = 1;
+pub const TSLogTypeParse: TSLogType = 0;
+pub const TSLogTypeLex: TSLogType = 1;
 pub type TSLogType = ::std::os::raw::c_uint;
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 pub struct TSLogger {
     pub payload: *mut ::std::os::raw::c_void,
     pub log: ::std::option::Option<
         unsafe extern "C" fn(
             payload: *mut ::std::os::raw::c_void,
-            arg1: TSLogType,
-            arg2: *const ::std::os::raw::c_char,
+            log_type: TSLogType,
+            buffer: *const ::std::os::raw::c_char,
         ),
     >,
 }
@@ -102,42 +110,42 @@ pub struct TSTreeCursor {
     pub context: [u32; 2usize],
 }
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 pub struct TSQueryCapture {
     pub node: TSNode,
     pub index: u32,
 }
-pub const TSQuantifier_TSQuantifierZero: TSQuantifier = 0;
-pub const TSQuantifier_TSQuantifierZeroOrOne: TSQuantifier = 1;
-pub const TSQuantifier_TSQuantifierZeroOrMore: TSQuantifier = 2;
-pub const TSQuantifier_TSQuantifierOne: TSQuantifier = 3;
-pub const TSQuantifier_TSQuantifierOneOrMore: TSQuantifier = 4;
+pub const TSQuantifierZero: TSQuantifier = 0;
+pub const TSQuantifierZeroOrOne: TSQuantifier = 1;
+pub const TSQuantifierZeroOrMore: TSQuantifier = 2;
+pub const TSQuantifierOne: TSQuantifier = 3;
+pub const TSQuantifierOneOrMore: TSQuantifier = 4;
 pub type TSQuantifier = ::std::os::raw::c_uint;
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 pub struct TSQueryMatch {
     pub id: u32,
     pub pattern_index: u16,
     pub capture_count: u16,
     pub captures: *const TSQueryCapture,
 }
-pub const TSQueryPredicateStepType_TSQueryPredicateStepTypeDone: TSQueryPredicateStepType = 0;
-pub const TSQueryPredicateStepType_TSQueryPredicateStepTypeCapture: TSQueryPredicateStepType = 1;
-pub const TSQueryPredicateStepType_TSQueryPredicateStepTypeString: TSQueryPredicateStepType = 2;
+pub const TSQueryPredicateStepTypeDone: TSQueryPredicateStepType = 0;
+pub const TSQueryPredicateStepTypeCapture: TSQueryPredicateStepType = 1;
+pub const TSQueryPredicateStepTypeString: TSQueryPredicateStepType = 2;
 pub type TSQueryPredicateStepType = ::std::os::raw::c_uint;
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 pub struct TSQueryPredicateStep {
     pub type_: TSQueryPredicateStepType,
     pub value_id: u32,
 }
-pub const TSQueryError_TSQueryErrorNone: TSQueryError = 0;
-pub const TSQueryError_TSQueryErrorSyntax: TSQueryError = 1;
-pub const TSQueryError_TSQueryErrorNodeType: TSQueryError = 2;
-pub const TSQueryError_TSQueryErrorField: TSQueryError = 3;
-pub const TSQueryError_TSQueryErrorCapture: TSQueryError = 4;
-pub const TSQueryError_TSQueryErrorStructure: TSQueryError = 5;
-pub const TSQueryError_TSQueryErrorLanguage: TSQueryError = 6;
+pub const TSQueryErrorNone: TSQueryError = 0;
+pub const TSQueryErrorSyntax: TSQueryError = 1;
+pub const TSQueryErrorNodeType: TSQueryError = 2;
+pub const TSQueryErrorField: TSQueryError = 3;
+pub const TSQueryErrorCapture: TSQueryError = 4;
+pub const TSQueryErrorStructure: TSQueryError = 5;
+pub const TSQueryErrorLanguage: TSQueryError = 6;
 pub type TSQueryError = ::std::os::raw::c_uint;
 extern "C" {
     #[doc = " Create a new parser."]
@@ -145,94 +153,30 @@ extern "C" {
 }
 extern "C" {
     #[doc = " Delete the parser, freeing all of the memory that it used."]
-    pub fn ts_parser_delete(parser: *mut TSParser);
-}
-extern "C" {
-    #[doc = " Set the language that the parser should use for parsing."]
-    #[doc = ""]
-    #[doc = " Returns a boolean indicating whether or not the language was successfully"]
-    #[doc = " assigned. True means assignment succeeded. False means there was a version"]
-    #[doc = " mismatch: the language was generated with an incompatible version of the"]
-    #[doc = " Tree-sitter CLI. Check the language's version using `ts_language_version`"]
-    #[doc = " and compare it to this library's `TREE_SITTER_LANGUAGE_VERSION` and"]
-    #[doc = " `TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION` constants."]
-    pub fn ts_parser_set_language(self_: *mut TSParser, language: *const TSLanguage) -> bool;
+    pub fn ts_parser_delete(self_: *mut TSParser);
 }
 extern "C" {
     #[doc = " Get the parser's current language."]
     pub fn ts_parser_language(self_: *const TSParser) -> *const TSLanguage;
 }
 extern "C" {
-    #[doc = " Set the ranges of text that the parser should include when parsing."]
-    #[doc = ""]
-    #[doc = " By default, the parser will always include entire documents. This function"]
-    #[doc = " allows you to parse only a *portion* of a document but still return a syntax"]
-    #[doc = " tree whose ranges match up with the document as a whole. You can also pass"]
-    #[doc = " multiple disjoint ranges."]
-    #[doc = ""]
-    #[doc = " The second and third parameters specify the location and length of an array"]
-    #[doc = " of ranges. The parser does *not* take ownership of these ranges; it copies"]
-    #[doc = " the data, so it doesn't matter how these ranges are allocated."]
-    #[doc = ""]
-    #[doc = " If `length` is zero, then the entire document will be parsed. Otherwise,"]
-    #[doc = " the given ranges must be ordered from earliest to latest in the document,"]
-    #[doc = " and they must not overlap. That is, the following must hold for all"]
-    #[doc = " `i` < `length - 1`: ranges[i].end_byte <= ranges[i + 1].start_byte"]
-    #[doc = ""]
-    #[doc = " If this requirement is not satisfied, the operation will fail, the ranges"]
-    #[doc = " will not be assigned, and this function will return `false`. On success,"]
-    #[doc = " this function returns `true`"]
+    #[doc = " Set the language that the parser should use for parsing.\n\n Returns a boolean indicating whether or not the language was successfully\n assigned. True means assignment succeeded. False means there was a version\n mismatch: the language was generated with an incompatible version of the\n Tree-sitter CLI. Check the language's version using [`ts_language_version`]\n and compare it to this library's [`TREE_SITTER_LANGUAGE_VERSION`] and\n [`TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION`] constants."]
+    pub fn ts_parser_set_language(self_: *mut TSParser, language: *const TSLanguage) -> bool;
+}
+extern "C" {
+    #[doc = " Set the ranges of text that the parser should include when parsing.\n\n By default, the parser will always include entire documents. This function\n allows you to parse only a *portion* of a document but still return a syntax\n tree whose ranges match up with the document as a whole. You can also pass\n multiple disjoint ranges.\n\n The second and third parameters specify the location and length of an array\n of ranges. The parser does *not* take ownership of these ranges; it copies\n the data, so it doesn't matter how these ranges are allocated.\n\n If `count` is zero, then the entire document will be parsed. Otherwise,\n the given ranges must be ordered from earliest to latest in the document,\n and they must not overlap. That is, the following must hold for all:\n\n `i < count - 1`: `ranges[i].end_byte <= ranges[i + 1].start_byte`\n\n If this requirement is not satisfied, the operation will fail, the ranges\n will not be assigned, and this function will return `false`. On success,\n this function returns `true`"]
     pub fn ts_parser_set_included_ranges(
         self_: *mut TSParser,
         ranges: *const TSRange,
-        length: u32,
+        count: u32,
     ) -> bool;
 }
 extern "C" {
-    #[doc = " Get the ranges of text that the parser will include when parsing."]
-    #[doc = ""]
-    #[doc = " The returned pointer is owned by the parser. The caller should not free it"]
-    #[doc = " or write to it. The length of the array will be written to the given"]
-    #[doc = " `length` pointer."]
-    pub fn ts_parser_included_ranges(self_: *const TSParser, length: *mut u32) -> *const TSRange;
+    #[doc = " Get the ranges of text that the parser will include when parsing.\n\n The returned pointer is owned by the parser. The caller should not free it\n or write to it. The length of the array will be written to the given\n `count` pointer."]
+    pub fn ts_parser_included_ranges(self_: *const TSParser, count: *mut u32) -> *const TSRange;
 }
 extern "C" {
-    #[doc = " Use the parser to parse some source code and create a syntax tree."]
-    #[doc = ""]
-    #[doc = " If you are parsing this document for the first time, pass `NULL` for the"]
-    #[doc = " `old_tree` parameter. Otherwise, if you have already parsed an earlier"]
-    #[doc = " version of this document and the document has since been edited, pass the"]
-    #[doc = " previous syntax tree so that the unchanged parts of it can be reused."]
-    #[doc = " This will save time and memory. For this to work correctly, you must have"]
-    #[doc = " already edited the old syntax tree using the `ts_tree_edit` function in a"]
-    #[doc = " way that exactly matches the source code changes."]
-    #[doc = ""]
-    #[doc = " The `TSInput` parameter lets you specify how to read the text. It has the"]
-    #[doc = " following three fields:"]
-    #[doc = " 1. `read`: A function to retrieve a chunk of text at a given byte offset"]
-    #[doc = "    and (row, column) position. The function should return a pointer to the"]
-    #[doc = "    text and write its length to the `bytes_read` pointer. The parser does"]
-    #[doc = "    not take ownership of this buffer; it just borrows it until it has"]
-    #[doc = "    finished reading it. The function should write a zero value to the"]
-    #[doc = "    `bytes_read` pointer to indicate the end of the document."]
-    #[doc = " 2. `payload`: An arbitrary pointer that will be passed to each invocation"]
-    #[doc = "    of the `read` function."]
-    #[doc = " 3. `encoding`: An indication of how the text is encoded. Either"]
-    #[doc = "    `TSInputEncodingUTF8` or `TSInputEncodingUTF16`."]
-    #[doc = ""]
-    #[doc = " This function returns a syntax tree on success, and `NULL` on failure. There"]
-    #[doc = " are three possible reasons for failure:"]
-    #[doc = " 1. The parser does not have a language assigned. Check for this using the"]
-    #[doc = "`ts_parser_language` function."]
-    #[doc = " 2. Parsing was cancelled due to a timeout that was set by an earlier call to"]
-    #[doc = "    the `ts_parser_set_timeout_micros` function. You can resume parsing from"]
-    #[doc = "    where the parser left out by calling `ts_parser_parse` again with the"]
-    #[doc = "    same arguments. Or you can start parsing from scratch by first calling"]
-    #[doc = "    `ts_parser_reset`."]
-    #[doc = " 3. Parsing was cancelled using a cancellation flag that was set by an"]
-    #[doc = "    earlier call to `ts_parser_set_cancellation_flag`. You can resume parsing"]
-    #[doc = "    from where the parser left out by calling `ts_parser_parse` again with"]
-    #[doc = "    the same arguments."]
+    #[doc = " Use the parser to parse some source code and create a syntax tree.\n\n If you are parsing this document for the first time, pass `NULL` for the\n `old_tree` parameter. Otherwise, if you have already parsed an earlier\n version of this document and the document has since been edited, pass the\n previous syntax tree so that the unchanged parts of it can be reused.\n This will save time and memory. For this to work correctly, you must have\n already edited the old syntax tree using the [`ts_tree_edit`] function in a\n way that exactly matches the source code changes.\n\n The [`TSInput`] parameter lets you specify how to read the text. It has the\n following three fields:\n 1. [`read`]: A function to retrieve a chunk of text at a given byte offset\n    and (row, column) position. The function should return a pointer to the\n    text and write its length to the [`bytes_read`] pointer. The parser does\n    not take ownership of this buffer; it just borrows it until it has\n    finished reading it. The function should write a zero value to the\n    [`bytes_read`] pointer to indicate the end of the document.\n 2. [`payload`]: An arbitrary pointer that will be passed to each invocation\n    of the [`read`] function.\n 3. [`encoding`]: An indication of how the text is encoded. Either\n    `TSInputEncodingUTF8` or `TSInputEncodingUTF16`.\n\n This function returns a syntax tree on success, and `NULL` on failure. There\n are three possible reasons for failure:\n 1. The parser does not have a language assigned. Check for this using the\n[`ts_parser_language`] function.\n 2. Parsing was cancelled due to a timeout that was set by an earlier call to\n    the [`ts_parser_set_timeout_micros`] function. You can resume parsing from\n    where the parser left out by calling [`ts_parser_parse`] again with the\n    same arguments. Or you can start parsing from scratch by first calling\n    [`ts_parser_reset`].\n 3. Parsing was cancelled using a cancellation flag that was set by an\n    earlier call to [`ts_parser_set_cancellation_flag`]. You can resume parsing\n    from where the parser left out by calling [`ts_parser_parse`] again with\n    the same arguments.\n\n [`read`]: TSInput::read\n [`payload`]: TSInput::payload\n [`encoding`]: TSInput::encoding\n [`bytes_read`]: TSInput::read"]
     pub fn ts_parser_parse(
         self_: *mut TSParser,
         old_tree: *const TSTree,
@@ -240,10 +184,7 @@ extern "C" {
     ) -> *mut TSTree;
 }
 extern "C" {
-    #[doc = " Use the parser to parse some source code stored in one contiguous buffer."]
-    #[doc = " The first two parameters are the same as in the `ts_parser_parse` function"]
-    #[doc = " above. The second two parameters indicate the location of the buffer and its"]
-    #[doc = " length in bytes."]
+    #[doc = " Use the parser to parse some source code stored in one contiguous buffer.\n The first two parameters are the same as in the [`ts_parser_parse`] function\n above. The second two parameters indicate the location of the buffer and its\n length in bytes."]
     pub fn ts_parser_parse_string(
         self_: *mut TSParser,
         old_tree: *const TSTree,
@@ -252,10 +193,7 @@ extern "C" {
     ) -> *mut TSTree;
 }
 extern "C" {
-    #[doc = " Use the parser to parse some source code stored in one contiguous buffer with"]
-    #[doc = " a given encoding. The first four parameters work the same as in the"]
-    #[doc = " `ts_parser_parse_string` method above. The final parameter indicates whether"]
-    #[doc = " the text is encoded as UTF8 or UTF16."]
+    #[doc = " Use the parser to parse some source code stored in one contiguous buffer with\n a given encoding. The first four parameters work the same as in the\n [`ts_parser_parse_string`] method above. The final parameter indicates whether\n the text is encoded as UTF8 or UTF16."]
     pub fn ts_parser_parse_string_encoding(
         self_: *mut TSParser,
         old_tree: *const TSTree,
@@ -265,33 +203,19 @@ extern "C" {
     ) -> *mut TSTree;
 }
 extern "C" {
-    #[doc = " Instruct the parser to start the next parse from the beginning."]
-    #[doc = ""]
-    #[doc = " If the parser previously failed because of a timeout or a cancellation, then"]
-    #[doc = " by default, it will resume where it left off on the next call to"]
-    #[doc = " `ts_parser_parse` or other parsing functions. If you don't want to resume,"]
-    #[doc = " and instead intend to use this parser to parse some other document, you must"]
-    #[doc = " call `ts_parser_reset` first."]
+    #[doc = " Instruct the parser to start the next parse from the beginning.\n\n If the parser previously failed because of a timeout or a cancellation, then\n by default, it will resume where it left off on the next call to\n [`ts_parser_parse`] or other parsing functions. If you don't want to resume,\n and instead intend to use this parser to parse some other document, you must\n call [`ts_parser_reset`] first."]
     pub fn ts_parser_reset(self_: *mut TSParser);
 }
 extern "C" {
-    #[doc = " Set the maximum duration in microseconds that parsing should be allowed to"]
-    #[doc = " take before halting."]
-    #[doc = ""]
-    #[doc = " If parsing takes longer than this, it will halt early, returning NULL."]
-    #[doc = " See `ts_parser_parse` for more information."]
-    pub fn ts_parser_set_timeout_micros(self_: *mut TSParser, timeout: u64);
+    #[doc = " Set the maximum duration in microseconds that parsing should be allowed to\n take before halting.\n\n If parsing takes longer than this, it will halt early, returning NULL.\n See [`ts_parser_parse`] for more information."]
+    pub fn ts_parser_set_timeout_micros(self_: *mut TSParser, timeout_micros: u64);
 }
 extern "C" {
     #[doc = " Get the duration in microseconds that parsing is allowed to take."]
     pub fn ts_parser_timeout_micros(self_: *const TSParser) -> u64;
 }
 extern "C" {
-    #[doc = " Set the parser's current cancellation flag pointer."]
-    #[doc = ""]
-    #[doc = " If a non-null pointer is assigned, then the parser will periodically read"]
-    #[doc = " from this pointer during parsing. If it reads a non-zero value, it will"]
-    #[doc = " halt early, returning NULL. See `ts_parser_parse` for more information."]
+    #[doc = " Set the parser's current cancellation flag pointer.\n\n If a non-null pointer is assigned, then the parser will periodically read\n from this pointer during parsing. If it reads a non-zero value, it will\n halt early, returning NULL. See [`ts_parser_parse`] for more information."]
     pub fn ts_parser_set_cancellation_flag(self_: *mut TSParser, flag: *const usize);
 }
 extern "C" {
@@ -299,11 +223,7 @@ extern "C" {
     pub fn ts_parser_cancellation_flag(self_: *const TSParser) -> *const usize;
 }
 extern "C" {
-    #[doc = " Set the logger that a parser should use during parsing."]
-    #[doc = ""]
-    #[doc = " The parser does not take ownership over the logger payload. If a logger was"]
-    #[doc = " previously assigned, the caller is responsible for releasing any memory"]
-    #[doc = " owned by the previous logger."]
+    #[doc = " Set the logger that a parser should use during parsing.\n\n The parser does not take ownership over the logger payload. If a logger was\n previously assigned, the caller is responsible for releasing any memory\n owned by the previous logger."]
     pub fn ts_parser_set_logger(self_: *mut TSParser, logger: TSLogger);
 }
 extern "C" {
@@ -311,17 +231,11 @@ extern "C" {
     pub fn ts_parser_logger(self_: *const TSParser) -> TSLogger;
 }
 extern "C" {
-    #[doc = " Set the file descriptor to which the parser should write debugging graphs"]
-    #[doc = " during parsing. The graphs are formatted in the DOT language. You may want"]
-    #[doc = " to pipe these graphs directly to a `dot(1)` process in order to generate"]
-    #[doc = " SVG output. You can turn off this logging by passing a negative number."]
-    pub fn ts_parser_print_dot_graphs(self_: *mut TSParser, file: ::std::os::raw::c_int);
+    #[doc = " Set the file descriptor to which the parser should write debugging graphs\n during parsing. The graphs are formatted in the DOT language. You may want\n to pipe these graphs directly to a `dot(1)` process in order to generate\n SVG output. You can turn off this logging by passing a negative number."]
+    pub fn ts_parser_print_dot_graphs(self_: *mut TSParser, fd: ::std::os::raw::c_int);
 }
 extern "C" {
-    #[doc = " Create a shallow copy of the syntax tree. This is very fast."]
-    #[doc = ""]
-    #[doc = " You need to copy a syntax tree in order to use it on more than one thread at"]
-    #[doc = " a time, as syntax trees are not thread safe."]
+    #[doc = " Create a shallow copy of the syntax tree. This is very fast.\n\n You need to copy a syntax tree in order to use it on more than one thread at\n a time, as syntax trees are not thread safe."]
     pub fn ts_tree_copy(self_: *const TSTree) -> *mut TSTree;
 }
 extern "C" {
@@ -333,296 +247,288 @@ extern "C" {
     pub fn ts_tree_root_node(self_: *const TSTree) -> TSNode;
 }
 extern "C" {
-    #[doc = " Get the root node of the syntax tree, but with its position"]
-    #[doc = " shifted forward by the given offset."]
+    #[doc = " Get the root node of the syntax tree, but with its position\n shifted forward by the given offset."]
     pub fn ts_tree_root_node_with_offset(
         self_: *const TSTree,
         offset_bytes: u32,
-        offset_point: TSPoint,
+        offset_extent: TSPoint,
     ) -> TSNode;
 }
 extern "C" {
     #[doc = " Get the language that was used to parse the syntax tree."]
-    pub fn ts_tree_language(arg1: *const TSTree) -> *const TSLanguage;
+    pub fn ts_tree_language(self_: *const TSTree) -> *const TSLanguage;
 }
 extern "C" {
-    #[doc = " Get the array of included ranges that was used to parse the syntax tree."]
-    #[doc = ""]
-    #[doc = " The returned pointer must be freed by the caller."]
-    pub fn ts_tree_included_ranges(arg1: *const TSTree, length: *mut u32) -> *mut TSRange;
+    #[doc = " Get the array of included ranges that was used to parse the syntax tree.\n\n The returned pointer must be freed by the caller."]
+    pub fn ts_tree_included_ranges(self_: *const TSTree, length: *mut u32) -> *mut TSRange;
 }
 extern "C" {
-    #[doc = " Edit the syntax tree to keep it in sync with source code that has been"]
-    #[doc = " edited."]
-    #[doc = ""]
-    #[doc = " You must describe the edit both in terms of byte offsets and in terms of"]
-    #[doc = " (row, column) coordinates."]
+    #[doc = " Edit the syntax tree to keep it in sync with source code that has been\n edited.\n\n You must describe the edit both in terms of byte offsets and in terms of\n (row, column) coordinates."]
     pub fn ts_tree_edit(self_: *mut TSTree, edit: *const TSInputEdit);
 }
 extern "C" {
-    #[doc = " Compare an old edited syntax tree to a new syntax tree representing the same"]
-    #[doc = " document, returning an array of ranges whose syntactic structure has changed."]
-    #[doc = ""]
-    #[doc = " For this to work correctly, the old syntax tree must have been edited such"]
-    #[doc = " that its ranges match up to the new tree. Generally, you'll want to call"]
-    #[doc = " this function right after calling one of the `ts_parser_parse` functions."]
-    #[doc = " You need to pass the old tree that was passed to parse, as well as the new"]
-    #[doc = " tree that was returned from that function."]
-    #[doc = ""]
-    #[doc = " The returned array is allocated using `malloc` and the caller is responsible"]
-    #[doc = " for freeing it using `free`. The length of the array will be written to the"]
-    #[doc = " given `length` pointer."]
+    #[doc = " Compare an old edited syntax tree to a new syntax tree representing the same\n document, returning an array of ranges whose syntactic structure has changed.\n\n For this to work correctly, the old syntax tree must have been edited such\n that its ranges match up to the new tree. Generally, you'll want to call\n this function right after calling one of the [`ts_parser_parse`] functions.\n You need to pass the old tree that was passed to parse, as well as the new\n tree that was returned from that function.\n\n The returned array is allocated using `malloc` and the caller is responsible\n for freeing it using `free`. The length of the array will be written to the\n given `length` pointer."]
     pub fn ts_tree_get_changed_ranges(
         old_tree: *const TSTree,
         new_tree: *const TSTree,
         length: *mut u32,
     ) -> *mut TSRange;
 }
+extern "C" {
+    #[doc = " Write a DOT graph describing the syntax tree to the given file."]
+    pub fn ts_tree_print_dot_graph(self_: *const TSTree, file_descriptor: ::std::os::raw::c_int);
+}
 extern "C" {
     #[doc = " Get the node's type as a null-terminated string."]
-    pub fn ts_node_type(arg1: TSNode) -> *const ::std::os::raw::c_char;
+    pub fn ts_node_type(self_: TSNode) -> *const ::std::os::raw::c_char;
 }
 extern "C" {
     #[doc = " Get the node's type as a numerical id."]
-    pub fn ts_node_symbol(arg1: TSNode) -> TSSymbol;
+    pub fn ts_node_symbol(self_: TSNode) -> TSSymbol;
+}
+extern "C" {
+    #[doc = " Get the node's language."]
+    pub fn ts_node_language(self_: TSNode) -> *const TSLanguage;
+}
+extern "C" {
+    #[doc = " Get the node's type as it appears in the grammar ignoring aliases as a\n null-terminated string."]
+    pub fn ts_node_grammar_type(self_: TSNode) -> *const ::std::os::raw::c_char;
+}
+extern "C" {
+    #[doc = " Get the node's type as a numerical id as it appears in the grammar ignoring\n aliases. This should be used in [`ts_language_next_state`] instead of\n [`ts_node_symbol`]."]
+    pub fn ts_node_grammar_symbol(self_: TSNode) -> TSSymbol;
 }
 extern "C" {
     #[doc = " Get the node's start byte."]
-    pub fn ts_node_start_byte(arg1: TSNode) -> u32;
+    pub fn ts_node_start_byte(self_: TSNode) -> u32;
 }
 extern "C" {
     #[doc = " Get the node's start position in terms of rows and columns."]
-    pub fn ts_node_start_point(arg1: TSNode) -> TSPoint;
+    pub fn ts_node_start_point(self_: TSNode) -> TSPoint;
 }
 extern "C" {
     #[doc = " Get the node's end byte."]
-    pub fn ts_node_end_byte(arg1: TSNode) -> u32;
+    pub fn ts_node_end_byte(self_: TSNode) -> u32;
 }
 extern "C" {
     #[doc = " Get the node's end position in terms of rows and columns."]
-    pub fn ts_node_end_point(arg1: TSNode) -> TSPoint;
+    pub fn ts_node_end_point(self_: TSNode) -> TSPoint;
 }
 extern "C" {
-    #[doc = " Get an S-expression representing the node as a string."]
-    #[doc = ""]
-    #[doc = " This string is allocated with `malloc` and the caller is responsible for"]
-    #[doc = " freeing it using `free`."]
-    pub fn ts_node_string(arg1: TSNode) -> *mut ::std::os::raw::c_char;
+    #[doc = " Get an S-expression representing the node as a string.\n\n This string is allocated with `malloc` and the caller is responsible for\n freeing it using `free`."]
+    pub fn ts_node_string(self_: TSNode) -> *mut ::std::os::raw::c_char;
 }
 extern "C" {
-    #[doc = " Check if the node is null. Functions like `ts_node_child` and"]
-    #[doc = " `ts_node_next_sibling` will return a null node to indicate that no such node"]
-    #[doc = " was found."]
-    pub fn ts_node_is_null(arg1: TSNode) -> bool;
+    #[doc = " Check if the node is null. Functions like [`ts_node_child`] and\n [`ts_node_next_sibling`] will return a null node to indicate that no such node\n was found."]
+    pub fn ts_node_is_null(self_: TSNode) -> bool;
 }
 extern "C" {
-    #[doc = " Check if the node is *named*. Named nodes correspond to named rules in the"]
-    #[doc = " grammar, whereas *anonymous* nodes correspond to string literals in the"]
-    #[doc = " grammar."]
-    pub fn ts_node_is_named(arg1: TSNode) -> bool;
+    #[doc = " Check if the node is *named*. Named nodes correspond to named rules in the\n grammar, whereas *anonymous* nodes correspond to string literals in the\n grammar."]
+    pub fn ts_node_is_named(self_: TSNode) -> bool;
 }
 extern "C" {
-    #[doc = " Check if the node is *missing*. Missing nodes are inserted by the parser in"]
-    #[doc = " order to recover from certain kinds of syntax errors."]
-    pub fn ts_node_is_missing(arg1: TSNode) -> bool;
+    #[doc = " Check if the node is *missing*. Missing nodes are inserted by the parser in\n order to recover from certain kinds of syntax errors."]
+    pub fn ts_node_is_missing(self_: TSNode) -> bool;
 }
 extern "C" {
-    #[doc = " Check if the node is *extra*. Extra nodes represent things like comments,"]
-    #[doc = " which are not required the grammar, but can appear anywhere."]
-    pub fn ts_node_is_extra(arg1: TSNode) -> bool;
+    #[doc = " Check if the node is *extra*. Extra nodes represent things like comments,\n which are not required the grammar, but can appear anywhere."]
+    pub fn ts_node_is_extra(self_: TSNode) -> bool;
 }
 extern "C" {
     #[doc = " Check if a syntax node has been edited."]
-    pub fn ts_node_has_changes(arg1: TSNode) -> bool;
+    pub fn ts_node_has_changes(self_: TSNode) -> bool;
 }
 extern "C" {
     #[doc = " Check if the node is a syntax error or contains any syntax errors."]
-    pub fn ts_node_has_error(arg1: TSNode) -> bool;
+    pub fn ts_node_has_error(self_: TSNode) -> bool;
+}
+extern "C" {
+    #[doc = " Check if the node is a syntax error."]
+    pub fn ts_node_is_error(self_: TSNode) -> bool;
+}
+extern "C" {
+    #[doc = " Get this node's parse state."]
+    pub fn ts_node_parse_state(self_: TSNode) -> TSStateId;
+}
+extern "C" {
+    #[doc = " Get the parse state after this node."]
+    pub fn ts_node_next_parse_state(self_: TSNode) -> TSStateId;
 }
 extern "C" {
     #[doc = " Get the node's immediate parent."]
-    pub fn ts_node_parent(arg1: TSNode) -> TSNode;
+    pub fn ts_node_parent(self_: TSNode) -> TSNode;
 }
 extern "C" {
-    #[doc = " Get the node's child at the given index, where zero represents the first"]
-    #[doc = " child."]
-    pub fn ts_node_child(arg1: TSNode, arg2: u32) -> TSNode;
+    #[doc = " Get the node's child at the given index, where zero represents the first\n child."]
+    pub fn ts_node_child(self_: TSNode, child_index: u32) -> TSNode;
 }
 extern "C" {
-    #[doc = " Get the field name for node's child at the given index, where zero represents"]
-    #[doc = " the first child. Returns NULL, if no field is found."]
-    pub fn ts_node_field_name_for_child(arg1: TSNode, arg2: u32) -> *const ::std::os::raw::c_char;
+    #[doc = " Get the field name for node's child at the given index, where zero represents\n the first child. Returns NULL, if no field is found."]
+    pub fn ts_node_field_name_for_child(
+        self_: TSNode,
+        child_index: u32,
+    ) -> *const ::std::os::raw::c_char;
 }
 extern "C" {
     #[doc = " Get the node's number of children."]
-    pub fn ts_node_child_count(arg1: TSNode) -> u32;
+    pub fn ts_node_child_count(self_: TSNode) -> u32;
 }
 extern "C" {
-    #[doc = " Get the node's *named* child at the given index."]
-    #[doc = ""]
-    #[doc = " See also `ts_node_is_named`."]
-    pub fn ts_node_named_child(arg1: TSNode, arg2: u32) -> TSNode;
+    #[doc = " Get the node's *named* child at the given index.\n\n See also [`ts_node_is_named`]."]
+    pub fn ts_node_named_child(self_: TSNode, child_index: u32) -> TSNode;
 }
 extern "C" {
-    #[doc = " Get the node's number of *named* children."]
-    #[doc = ""]
-    #[doc = " See also `ts_node_is_named`."]
-    pub fn ts_node_named_child_count(arg1: TSNode) -> u32;
+    #[doc = " Get the node's number of *named* children.\n\n See also [`ts_node_is_named`]."]
+    pub fn ts_node_named_child_count(self_: TSNode) -> u32;
 }
 extern "C" {
     #[doc = " Get the node's child with the given field name."]
     pub fn ts_node_child_by_field_name(
         self_: TSNode,
-        field_name: *const ::std::os::raw::c_char,
-        field_name_length: u32,
+        name: *const ::std::os::raw::c_char,
+        name_length: u32,
     ) -> TSNode;
 }
 extern "C" {
-    #[doc = " Get the node's child with the given numerical field id."]
-    #[doc = ""]
-    #[doc = " You can convert a field name to an id using the"]
-    #[doc = " `ts_language_field_id_for_name` function."]
-    pub fn ts_node_child_by_field_id(arg1: TSNode, arg2: TSFieldId) -> TSNode;
+    #[doc = " Get the node's child with the given numerical field id.\n\n You can convert a field name to an id using the\n [`ts_language_field_id_for_name`] function."]
+    pub fn ts_node_child_by_field_id(self_: TSNode, field_id: TSFieldId) -> TSNode;
 }
 extern "C" {
     #[doc = " Get the node's next / previous sibling."]
-    pub fn ts_node_next_sibling(arg1: TSNode) -> TSNode;
+    pub fn ts_node_next_sibling(self_: TSNode) -> TSNode;
 }
 extern "C" {
-    pub fn ts_node_prev_sibling(arg1: TSNode) -> TSNode;
+    pub fn ts_node_prev_sibling(self_: TSNode) -> TSNode;
 }
 extern "C" {
     #[doc = " Get the node's next / previous *named* sibling."]
-    pub fn ts_node_next_named_sibling(arg1: TSNode) -> TSNode;
+    pub fn ts_node_next_named_sibling(self_: TSNode) -> TSNode;
 }
 extern "C" {
-    pub fn ts_node_prev_named_sibling(arg1: TSNode) -> TSNode;
+    pub fn ts_node_prev_named_sibling(self_: TSNode) -> TSNode;
 }
 extern "C" {
     #[doc = " Get the node's first child that extends beyond the given byte offset."]
-    pub fn ts_node_first_child_for_byte(arg1: TSNode, arg2: u32) -> TSNode;
+    pub fn ts_node_first_child_for_byte(self_: TSNode, byte: u32) -> TSNode;
 }
 extern "C" {
     #[doc = " Get the node's first named child that extends beyond the given byte offset."]
-    pub fn ts_node_first_named_child_for_byte(arg1: TSNode, arg2: u32) -> TSNode;
+    pub fn ts_node_first_named_child_for_byte(self_: TSNode, byte: u32) -> TSNode;
 }
 extern "C" {
-    #[doc = " Get the smallest node within this node that spans the given range of bytes"]
-    #[doc = " or (row, column) positions."]
-    pub fn ts_node_descendant_for_byte_range(arg1: TSNode, arg2: u32, arg3: u32) -> TSNode;
+    #[doc = " Get the node's number of descendants, including one for the node itself."]
+    pub fn ts_node_descendant_count(self_: TSNode) -> u32;
 }
 extern "C" {
-    pub fn ts_node_descendant_for_point_range(arg1: TSNode, arg2: TSPoint, arg3: TSPoint)
-        -> TSNode;
+    #[doc = " Get the smallest node within this node that spans the given range of bytes\n or (row, column) positions."]
+    pub fn ts_node_descendant_for_byte_range(self_: TSNode, start: u32, end: u32) -> TSNode;
 }
 extern "C" {
-    #[doc = " Get the smallest named node within this node that spans the given range of"]
-    #[doc = " bytes or (row, column) positions."]
-    pub fn ts_node_named_descendant_for_byte_range(arg1: TSNode, arg2: u32, arg3: u32) -> TSNode;
-}
-extern "C" {
-    pub fn ts_node_named_descendant_for_point_range(
-        arg1: TSNode,
-        arg2: TSPoint,
-        arg3: TSPoint,
+    pub fn ts_node_descendant_for_point_range(
+        self_: TSNode,
+        start: TSPoint,
+        end: TSPoint,
     ) -> TSNode;
 }
 extern "C" {
-    #[doc = " Edit the node to keep it in-sync with source code that has been edited."]
-    #[doc = ""]
-    #[doc = " This function is only rarely needed. When you edit a syntax tree with the"]
-    #[doc = " `ts_tree_edit` function, all of the nodes that you retrieve from the tree"]
-    #[doc = " afterward will already reflect the edit. You only need to use `ts_node_edit`"]
-    #[doc = " when you have a `TSNode` instance that you want to keep and continue to use"]
-    #[doc = " after an edit."]
-    pub fn ts_node_edit(arg1: *mut TSNode, arg2: *const TSInputEdit);
+    #[doc = " Get the smallest named node within this node that spans the given range of\n bytes or (row, column) positions."]
+    pub fn ts_node_named_descendant_for_byte_range(self_: TSNode, start: u32, end: u32) -> TSNode;
+}
+extern "C" {
+    pub fn ts_node_named_descendant_for_point_range(
+        self_: TSNode,
+        start: TSPoint,
+        end: TSPoint,
+    ) -> TSNode;
+}
+extern "C" {
+    #[doc = " Edit the node to keep it in-sync with source code that has been edited.\n\n This function is only rarely needed. When you edit a syntax tree with the\n [`ts_tree_edit`] function, all of the nodes that you retrieve from the tree\n afterward will already reflect the edit. You only need to use [`ts_node_edit`]\n when you have a [`TSNode`] instance that you want to keep and continue to use\n after an edit."]
+    pub fn ts_node_edit(self_: *mut TSNode, edit: *const TSInputEdit);
 }
 extern "C" {
     #[doc = " Check if two nodes are identical."]
-    pub fn ts_node_eq(arg1: TSNode, arg2: TSNode) -> bool;
+    pub fn ts_node_eq(self_: TSNode, other: TSNode) -> bool;
 }
 extern "C" {
-    #[doc = " Create a new tree cursor starting from the given node."]
-    #[doc = ""]
-    #[doc = " A tree cursor allows you to walk a syntax tree more efficiently than is"]
-    #[doc = " possible using the `TSNode` functions. It is a mutable object that is always"]
-    #[doc = " on a certain syntax node, and can be moved imperatively to different nodes."]
-    pub fn ts_tree_cursor_new(arg1: TSNode) -> TSTreeCursor;
+    #[doc = " Create a new tree cursor starting from the given node.\n\n A tree cursor allows you to walk a syntax tree more efficiently than is\n possible using the [`TSNode`] functions. It is a mutable object that is always\n on a certain syntax node, and can be moved imperatively to different nodes."]
+    pub fn ts_tree_cursor_new(node: TSNode) -> TSTreeCursor;
 }
 extern "C" {
     #[doc = " Delete a tree cursor, freeing all of the memory that it used."]
-    pub fn ts_tree_cursor_delete(arg1: *mut TSTreeCursor);
+    pub fn ts_tree_cursor_delete(self_: *mut TSTreeCursor);
 }
 extern "C" {
     #[doc = " Re-initialize a tree cursor to start at a different node."]
-    pub fn ts_tree_cursor_reset(arg1: *mut TSTreeCursor, arg2: TSNode);
+    pub fn ts_tree_cursor_reset(self_: *mut TSTreeCursor, node: TSNode);
+}
+extern "C" {
+    #[doc = " Re-initialize a tree cursor to the same position as another cursor.\n\n Unlike [`ts_tree_cursor_reset`], this will not lose parent information and\n allows reusing already created cursors."]
+    pub fn ts_tree_cursor_reset_to(dst: *mut TSTreeCursor, src: *const TSTreeCursor);
 }
 extern "C" {
     #[doc = " Get the tree cursor's current node."]
-    pub fn ts_tree_cursor_current_node(arg1: *const TSTreeCursor) -> TSNode;
+    pub fn ts_tree_cursor_current_node(self_: *const TSTreeCursor) -> TSNode;
 }
 extern "C" {
-    #[doc = " Get the field name of the tree cursor's current node."]
-    #[doc = ""]
-    #[doc = " This returns `NULL` if the current node doesn't have a field."]
-    #[doc = " See also `ts_node_child_by_field_name`."]
+    #[doc = " Get the field name of the tree cursor's current node.\n\n This returns `NULL` if the current node doesn't have a field.\n See also [`ts_node_child_by_field_name`]."]
     pub fn ts_tree_cursor_current_field_name(
-        arg1: *const TSTreeCursor,
+        self_: *const TSTreeCursor,
     ) -> *const ::std::os::raw::c_char;
 }
 extern "C" {
-    #[doc = " Get the field id of the tree cursor's current node."]
-    #[doc = ""]
-    #[doc = " This returns zero if the current node doesn't have a field."]
-    #[doc = " See also `ts_node_child_by_field_id`, `ts_language_field_id_for_name`."]
-    pub fn ts_tree_cursor_current_field_id(arg1: *const TSTreeCursor) -> TSFieldId;
+    #[doc = " Get the field id of the tree cursor's current node.\n\n This returns zero if the current node doesn't have a field.\n See also [`ts_node_child_by_field_id`], [`ts_language_field_id_for_name`]."]
+    pub fn ts_tree_cursor_current_field_id(self_: *const TSTreeCursor) -> TSFieldId;
 }
 extern "C" {
-    #[doc = " Move the cursor to the parent of its current node."]
-    #[doc = ""]
-    #[doc = " This returns `true` if the cursor successfully moved, and returns `false`"]
-    #[doc = " if there was no parent node (the cursor was already on the root node)."]
-    pub fn ts_tree_cursor_goto_parent(arg1: *mut TSTreeCursor) -> bool;
+    #[doc = " Move the cursor to the parent of its current node.\n\n This returns `true` if the cursor successfully moved, and returns `false`\n if there was no parent node (the cursor was already on the root node)."]
+    pub fn ts_tree_cursor_goto_parent(self_: *mut TSTreeCursor) -> bool;
 }
 extern "C" {
-    #[doc = " Move the cursor to the next sibling of its current node."]
-    #[doc = ""]
-    #[doc = " This returns `true` if the cursor successfully moved, and returns `false`"]
-    #[doc = " if there was no next sibling node."]
-    pub fn ts_tree_cursor_goto_next_sibling(arg1: *mut TSTreeCursor) -> bool;
+    #[doc = " Move the cursor to the next sibling of its current node.\n\n This returns `true` if the cursor successfully moved, and returns `false`\n if there was no next sibling node."]
+    pub fn ts_tree_cursor_goto_next_sibling(self_: *mut TSTreeCursor) -> bool;
 }
 extern "C" {
-    #[doc = " Move the cursor to the first child of its current node."]
-    #[doc = ""]
-    #[doc = " This returns `true` if the cursor successfully moved, and returns `false`"]
-    #[doc = " if there were no children."]
-    pub fn ts_tree_cursor_goto_first_child(arg1: *mut TSTreeCursor) -> bool;
+    #[doc = " Move the cursor to the previous sibling of its current node.\n\n This returns `true` if the cursor successfully moved, and returns `false` if\n there was no previous sibling node.\n\n Note, that this function may be slower than\n [`ts_tree_cursor_goto_next_sibling`] due to how node positions are stored. In\n the worst case, this will need to iterate through all the children upto the\n previous sibling node to recalculate its position."]
+    pub fn ts_tree_cursor_goto_previous_sibling(self_: *mut TSTreeCursor) -> bool;
 }
 extern "C" {
-    #[doc = " Move the cursor to the first child of its current node that extends beyond"]
-    #[doc = " the given byte offset or point."]
-    #[doc = ""]
-    #[doc = " This returns the index of the child node if one was found, and returns -1"]
-    #[doc = " if no such child was found."]
-    pub fn ts_tree_cursor_goto_first_child_for_byte(arg1: *mut TSTreeCursor, arg2: u32) -> i64;
+    #[doc = " Move the cursor to the first child of its current node.\n\n This returns `true` if the cursor successfully moved, and returns `false`\n if there were no children."]
+    pub fn ts_tree_cursor_goto_first_child(self_: *mut TSTreeCursor) -> bool;
 }
 extern "C" {
-    pub fn ts_tree_cursor_goto_first_child_for_point(arg1: *mut TSTreeCursor, arg2: TSPoint)
-        -> i64;
+    #[doc = " Move the cursor to the last child of its current node.\n\n This returns `true` if the cursor successfully moved, and returns `false` if\n there were no children.\n\n Note that this function may be slower than [`ts_tree_cursor_goto_first_child`]\n because it needs to iterate through all the children to compute the child's\n position."]
+    pub fn ts_tree_cursor_goto_last_child(self_: *mut TSTreeCursor) -> bool;
 }
 extern "C" {
-    pub fn ts_tree_cursor_copy(arg1: *const TSTreeCursor) -> TSTreeCursor;
+    #[doc = " Move the cursor to the node that is the nth descendant of\n the original node that the cursor was constructed with, where\n zero represents the original node itself."]
+    pub fn ts_tree_cursor_goto_descendant(self_: *mut TSTreeCursor, goal_descendant_index: u32);
 }
 extern "C" {
-    #[doc = " Create a new query from a string containing one or more S-expression"]
-    #[doc = " patterns. The query is associated with a particular language, and can"]
-    #[doc = " only be run on syntax nodes parsed with that language."]
-    #[doc = ""]
-    #[doc = " If all of the given patterns are valid, this returns a `TSQuery`."]
-    #[doc = " If a pattern is invalid, this returns `NULL`, and provides two pieces"]
-    #[doc = " of information about the problem:"]
-    #[doc = " 1. The byte offset of the error is written to the `error_offset` parameter."]
-    #[doc = " 2. The type of error is written to the `error_type` parameter."]
+    #[doc = " Get the index of the cursor's current node out of all of the\n descendants of the original node that the cursor was constructed with."]
+    pub fn ts_tree_cursor_current_descendant_index(self_: *const TSTreeCursor) -> u32;
+}
+extern "C" {
+    #[doc = " Get the depth of the cursor's current node relative to the original\n node that the cursor was constructed with."]
+    pub fn ts_tree_cursor_current_depth(self_: *const TSTreeCursor) -> u32;
+}
+extern "C" {
+    #[doc = " Move the cursor to the first child of its current node that extends beyond\n the given byte offset or point.\n\n This returns the index of the child node if one was found, and returns -1\n if no such child was found."]
+    pub fn ts_tree_cursor_goto_first_child_for_byte(
+        self_: *mut TSTreeCursor,
+        goal_byte: u32,
+    ) -> i64;
+}
+extern "C" {
+    pub fn ts_tree_cursor_goto_first_child_for_point(
+        self_: *mut TSTreeCursor,
+        goal_point: TSPoint,
+    ) -> i64;
+}
+extern "C" {
+    pub fn ts_tree_cursor_copy(cursor: *const TSTreeCursor) -> TSTreeCursor;
+}
+extern "C" {
+    #[doc = " Create a new query from a string containing one or more S-expression\n patterns. The query is associated with a particular language, and can\n only be run on syntax nodes parsed with that language.\n\n If all of the given patterns are valid, this returns a [`TSQuery`].\n If a pattern is invalid, this returns `NULL`, and provides two pieces\n of information about the problem:\n 1. The byte offset of the error is written to the `error_offset` parameter.\n 2. The type of error is written to the `error_type` parameter."]
     pub fn ts_query_new(
         language: *const TSLanguage,
         source: *const ::std::os::raw::c_char,
@@ -633,184 +539,144 @@ extern "C" {
 }
 extern "C" {
     #[doc = " Delete a query, freeing all of the memory that it used."]
-    pub fn ts_query_delete(arg1: *mut TSQuery);
+    pub fn ts_query_delete(self_: *mut TSQuery);
 }
 extern "C" {
     #[doc = " Get the number of patterns, captures, or string literals in the query."]
-    pub fn ts_query_pattern_count(arg1: *const TSQuery) -> u32;
+    pub fn ts_query_pattern_count(self_: *const TSQuery) -> u32;
 }
 extern "C" {
-    pub fn ts_query_capture_count(arg1: *const TSQuery) -> u32;
+    pub fn ts_query_capture_count(self_: *const TSQuery) -> u32;
 }
 extern "C" {
-    pub fn ts_query_string_count(arg1: *const TSQuery) -> u32;
+    pub fn ts_query_string_count(self_: *const TSQuery) -> u32;
 }
 extern "C" {
-    #[doc = " Get the byte offset where the given pattern starts in the query's source."]
-    #[doc = ""]
-    #[doc = " This can be useful when combining queries by concatenating their source"]
-    #[doc = " code strings."]
-    pub fn ts_query_start_byte_for_pattern(arg1: *const TSQuery, arg2: u32) -> u32;
+    #[doc = " Get the byte offset where the given pattern starts in the query's source.\n\n This can be useful when combining queries by concatenating their source\n code strings."]
+    pub fn ts_query_start_byte_for_pattern(self_: *const TSQuery, pattern_index: u32) -> u32;
 }
 extern "C" {
-    #[doc = " Get all of the predicates for the given pattern in the query."]
-    #[doc = ""]
-    #[doc = " The predicates are represented as a single array of steps. There are three"]
-    #[doc = " types of steps in this array, which correspond to the three legal values for"]
-    #[doc = " the `type` field:"]
-    #[doc = " - `TSQueryPredicateStepTypeCapture` - Steps with this type represent names"]
-    #[doc = "    of captures. Their `value_id` can be used with the"]
-    #[doc = "   `ts_query_capture_name_for_id` function to obtain the name of the capture."]
-    #[doc = " - `TSQueryPredicateStepTypeString` - Steps with this type represent literal"]
-    #[doc = "    strings. Their `value_id` can be used with the"]
-    #[doc = "    `ts_query_string_value_for_id` function to obtain their string value."]
-    #[doc = " - `TSQueryPredicateStepTypeDone` - Steps with this type are *sentinels*"]
-    #[doc = "    that represent the end of an individual predicate. If a pattern has two"]
-    #[doc = "    predicates, then there will be two steps with this `type` in the array."]
+    #[doc = " Get all of the predicates for the given pattern in the query.\n\n The predicates are represented as a single array of steps. There are three\n types of steps in this array, which correspond to the three legal values for\n the `type` field:\n - `TSQueryPredicateStepTypeCapture` - Steps with this type represent names\n    of captures. Their `value_id` can be used with the\n   [`ts_query_capture_name_for_id`] function to obtain the name of the capture.\n - `TSQueryPredicateStepTypeString` - Steps with this type represent literal\n    strings. Their `value_id` can be used with the\n    [`ts_query_string_value_for_id`] function to obtain their string value.\n - `TSQueryPredicateStepTypeDone` - Steps with this type are *sentinels*\n    that represent the end of an individual predicate. If a pattern has two\n    predicates, then there will be two steps with this `type` in the array."]
     pub fn ts_query_predicates_for_pattern(
         self_: *const TSQuery,
         pattern_index: u32,
-        length: *mut u32,
+        step_count: *mut u32,
     ) -> *const TSQueryPredicateStep;
 }
 extern "C" {
     pub fn ts_query_is_pattern_rooted(self_: *const TSQuery, pattern_index: u32) -> bool;
 }
+extern "C" {
+    pub fn ts_query_is_pattern_non_local(self_: *const TSQuery, pattern_index: u32) -> bool;
+}
 extern "C" {
     pub fn ts_query_is_pattern_guaranteed_at_step(self_: *const TSQuery, byte_offset: u32) -> bool;
 }
 extern "C" {
-    #[doc = " Get the name and length of one of the query's captures, or one of the"]
-    #[doc = " query's string literals. Each capture and string is associated with a"]
-    #[doc = " numeric id based on the order that it appeared in the query's source."]
+    #[doc = " Get the name and length of one of the query's captures, or one of the\n query's string literals. Each capture and string is associated with a\n numeric id based on the order that it appeared in the query's source."]
     pub fn ts_query_capture_name_for_id(
-        arg1: *const TSQuery,
-        id: u32,
+        self_: *const TSQuery,
+        index: u32,
         length: *mut u32,
     ) -> *const ::std::os::raw::c_char;
 }
 extern "C" {
-    #[doc = " Get the quantifier of the query's captures. Each capture is * associated"]
-    #[doc = " with a numeric id based on the order that it appeared in the query's source."]
+    #[doc = " Get the quantifier of the query's captures. Each capture is * associated\n with a numeric id based on the order that it appeared in the query's source."]
     pub fn ts_query_capture_quantifier_for_id(
-        arg1: *const TSQuery,
-        pattern_id: u32,
-        capture_id: u32,
+        self_: *const TSQuery,
+        pattern_index: u32,
+        capture_index: u32,
     ) -> TSQuantifier;
 }
 extern "C" {
     pub fn ts_query_string_value_for_id(
-        arg1: *const TSQuery,
-        id: u32,
+        self_: *const TSQuery,
+        index: u32,
         length: *mut u32,
     ) -> *const ::std::os::raw::c_char;
 }
 extern "C" {
-    #[doc = " Disable a certain capture within a query."]
-    #[doc = ""]
-    #[doc = " This prevents the capture from being returned in matches, and also avoids"]
-    #[doc = " any resource usage associated with recording the capture. Currently, there"]
-    #[doc = " is no way to undo this."]
+    #[doc = " Disable a certain capture within a query.\n\n This prevents the capture from being returned in matches, and also avoids\n any resource usage associated with recording the capture. Currently, there\n is no way to undo this."]
     pub fn ts_query_disable_capture(
-        arg1: *mut TSQuery,
-        arg2: *const ::std::os::raw::c_char,
-        arg3: u32,
+        self_: *mut TSQuery,
+        name: *const ::std::os::raw::c_char,
+        length: u32,
     );
 }
 extern "C" {
-    #[doc = " Disable a certain pattern within a query."]
-    #[doc = ""]
-    #[doc = " This prevents the pattern from matching and removes most of the overhead"]
-    #[doc = " associated with the pattern. Currently, there is no way to undo this."]
-    pub fn ts_query_disable_pattern(arg1: *mut TSQuery, arg2: u32);
+    #[doc = " Disable a certain pattern within a query.\n\n This prevents the pattern from matching and removes most of the overhead\n associated with the pattern. Currently, there is no way to undo this."]
+    pub fn ts_query_disable_pattern(self_: *mut TSQuery, pattern_index: u32);
 }
 extern "C" {
-    #[doc = " Create a new cursor for executing a given query."]
-    #[doc = ""]
-    #[doc = " The cursor stores the state that is needed to iteratively search"]
-    #[doc = " for matches. To use the query cursor, first call `ts_query_cursor_exec`"]
-    #[doc = " to start running a given query on a given syntax node. Then, there are"]
-    #[doc = " two options for consuming the results of the query:"]
-    #[doc = " 1. Repeatedly call `ts_query_cursor_next_match` to iterate over all of the"]
-    #[doc = "    *matches* in the order that they were found. Each match contains the"]
-    #[doc = "    index of the pattern that matched, and an array of captures. Because"]
-    #[doc = "    multiple patterns can match the same set of nodes, one match may contain"]
-    #[doc = "    captures that appear *before* some of the captures from a previous match."]
-    #[doc = " 2. Repeatedly call `ts_query_cursor_next_capture` to iterate over all of the"]
-    #[doc = "    individual *captures* in the order that they appear. This is useful if"]
-    #[doc = "    don't care about which pattern matched, and just want a single ordered"]
-    #[doc = "    sequence of captures."]
-    #[doc = ""]
-    #[doc = " If you don't care about consuming all of the results, you can stop calling"]
-    #[doc = " `ts_query_cursor_next_match` or `ts_query_cursor_next_capture` at any point."]
-    #[doc = "  You can then start executing another query on another node by calling"]
-    #[doc = "  `ts_query_cursor_exec` again."]
+    #[doc = " Create a new cursor for executing a given query.\n\n The cursor stores the state that is needed to iteratively search\n for matches. To use the query cursor, first call [`ts_query_cursor_exec`]\n to start running a given query on a given syntax node. Then, there are\n two options for consuming the results of the query:\n 1. Repeatedly call [`ts_query_cursor_next_match`] to iterate over all of the\n    *matches* in the order that they were found. Each match contains the\n    index of the pattern that matched, and an array of captures. Because\n    multiple patterns can match the same set of nodes, one match may contain\n    captures that appear *before* some of the captures from a previous match.\n 2. Repeatedly call [`ts_query_cursor_next_capture`] to iterate over all of the\n    individual *captures* in the order that they appear. This is useful if\n    don't care about which pattern matched, and just want a single ordered\n    sequence of captures.\n\n If you don't care about consuming all of the results, you can stop calling\n [`ts_query_cursor_next_match`] or [`ts_query_cursor_next_capture`] at any point.\n  You can then start executing another query on another node by calling\n  [`ts_query_cursor_exec`] again."]
     pub fn ts_query_cursor_new() -> *mut TSQueryCursor;
 }
 extern "C" {
     #[doc = " Delete a query cursor, freeing all of the memory that it used."]
-    pub fn ts_query_cursor_delete(arg1: *mut TSQueryCursor);
+    pub fn ts_query_cursor_delete(self_: *mut TSQueryCursor);
 }
 extern "C" {
     #[doc = " Start running a given query on a given node."]
-    pub fn ts_query_cursor_exec(arg1: *mut TSQueryCursor, arg2: *const TSQuery, arg3: TSNode);
+    pub fn ts_query_cursor_exec(self_: *mut TSQueryCursor, query: *const TSQuery, node: TSNode);
 }
 extern "C" {
-    #[doc = " Manage the maximum number of in-progress matches allowed by this query"]
-    #[doc = " cursor."]
-    #[doc = ""]
-    #[doc = " Query cursors have an optional maximum capacity for storing lists of"]
-    #[doc = " in-progress captures. If this capacity is exceeded, then the"]
-    #[doc = " earliest-starting match will silently be dropped to make room for further"]
-    #[doc = " matches. This maximum capacity is optional — by default, query cursors allow"]
-    #[doc = " any number of pending matches, dynamically allocating new space for them as"]
-    #[doc = " needed as the query is executed."]
-    pub fn ts_query_cursor_did_exceed_match_limit(arg1: *const TSQueryCursor) -> bool;
+    #[doc = " Manage the maximum number of in-progress matches allowed by this query\n cursor.\n\n Query cursors have an optional maximum capacity for storing lists of\n in-progress captures. If this capacity is exceeded, then the\n earliest-starting match will silently be dropped to make room for further\n matches. This maximum capacity is optional — by default, query cursors allow\n any number of pending matches, dynamically allocating new space for them as\n needed as the query is executed."]
+    pub fn ts_query_cursor_did_exceed_match_limit(self_: *const TSQueryCursor) -> bool;
 }
 extern "C" {
-    pub fn ts_query_cursor_match_limit(arg1: *const TSQueryCursor) -> u32;
+    pub fn ts_query_cursor_match_limit(self_: *const TSQueryCursor) -> u32;
 }
 extern "C" {
-    pub fn ts_query_cursor_set_match_limit(arg1: *mut TSQueryCursor, arg2: u32);
+    pub fn ts_query_cursor_set_match_limit(self_: *mut TSQueryCursor, limit: u32);
 }
 extern "C" {
-    #[doc = " Set the range of bytes or (row, column) positions in which the query"]
-    #[doc = " will be executed."]
-    pub fn ts_query_cursor_set_byte_range(arg1: *mut TSQueryCursor, arg2: u32, arg3: u32);
+    #[doc = " Set the range of bytes or (row, column) positions in which the query\n will be executed."]
+    pub fn ts_query_cursor_set_byte_range(
+        self_: *mut TSQueryCursor,
+        start_byte: u32,
+        end_byte: u32,
+    );
 }
 extern "C" {
-    pub fn ts_query_cursor_set_point_range(arg1: *mut TSQueryCursor, arg2: TSPoint, arg3: TSPoint);
+    pub fn ts_query_cursor_set_point_range(
+        self_: *mut TSQueryCursor,
+        start_point: TSPoint,
+        end_point: TSPoint,
+    );
 }
 extern "C" {
-    #[doc = " Advance to the next match of the currently running query."]
-    #[doc = ""]
-    #[doc = " If there is a match, write it to `*match` and return `true`."]
-    #[doc = " Otherwise, return `false`."]
-    pub fn ts_query_cursor_next_match(arg1: *mut TSQueryCursor, match_: *mut TSQueryMatch) -> bool;
+    #[doc = " Advance to the next match of the currently running query.\n\n If there is a match, write it to `*match` and return `true`.\n Otherwise, return `false`."]
+    pub fn ts_query_cursor_next_match(self_: *mut TSQueryCursor, match_: *mut TSQueryMatch)
+        -> bool;
 }
 extern "C" {
-    pub fn ts_query_cursor_remove_match(arg1: *mut TSQueryCursor, id: u32);
+    pub fn ts_query_cursor_remove_match(self_: *mut TSQueryCursor, match_id: u32);
 }
 extern "C" {
-    #[doc = " Advance to the next capture of the currently running query."]
-    #[doc = ""]
-    #[doc = " If there is a capture, write its match to `*match` and its index within"]
-    #[doc = " the matche's capture list to `*capture_index`. Otherwise, return `false`."]
+    #[doc = " Advance to the next capture of the currently running query.\n\n If there is a capture, write its match to `*match` and its index within\n the matche's capture list to `*capture_index`. Otherwise, return `false`."]
     pub fn ts_query_cursor_next_capture(
-        arg1: *mut TSQueryCursor,
+        self_: *mut TSQueryCursor,
         match_: *mut TSQueryMatch,
         capture_index: *mut u32,
     ) -> bool;
 }
+extern "C" {
+    #[doc = " Set the maximum start depth for a query cursor.\n\n This prevents cursors from exploring children nodes at a certain depth.\n Note if a pattern includes many children, then they will still be checked.\n\n The zero max start depth value can be used as a special behavior and\n it helps to destructure a subtree by staying on a node and using captures\n for interested parts. Note that the zero max start depth only limit a search\n depth for a pattern's root node but other nodes that are parts of the pattern\n may be searched at any depth what defined by the pattern structure.\n\n Set to `UINT32_MAX` to remove the maximum start depth."]
+    pub fn ts_query_cursor_set_max_start_depth(self_: *mut TSQueryCursor, max_start_depth: u32);
+}
 extern "C" {
     #[doc = " Get the number of distinct node types in the language."]
-    pub fn ts_language_symbol_count(arg1: *const TSLanguage) -> u32;
+    pub fn ts_language_symbol_count(self_: *const TSLanguage) -> u32;
+}
+extern "C" {
+    #[doc = " Get the number of valid states in this language."]
+    pub fn ts_language_state_count(self_: *const TSLanguage) -> u32;
 }
 extern "C" {
     #[doc = " Get a node type string for the given numerical id."]
     pub fn ts_language_symbol_name(
-        arg1: *const TSLanguage,
-        arg2: TSSymbol,
+        self_: *const TSLanguage,
+        symbol: TSSymbol,
     ) -> *const ::std::os::raw::c_char;
 }
 extern "C" {
@@ -824,37 +690,30 @@ extern "C" {
 }
 extern "C" {
     #[doc = " Get the number of distinct field names in the language."]
-    pub fn ts_language_field_count(arg1: *const TSLanguage) -> u32;
+    pub fn ts_language_field_count(self_: *const TSLanguage) -> u32;
 }
 extern "C" {
     #[doc = " Get the field name string for the given numerical id."]
     pub fn ts_language_field_name_for_id(
-        arg1: *const TSLanguage,
-        arg2: TSFieldId,
+        self_: *const TSLanguage,
+        id: TSFieldId,
     ) -> *const ::std::os::raw::c_char;
 }
 extern "C" {
     #[doc = " Get the numerical id for the given field name string."]
     pub fn ts_language_field_id_for_name(
-        arg1: *const TSLanguage,
-        arg2: *const ::std::os::raw::c_char,
-        arg3: u32,
+        self_: *const TSLanguage,
+        name: *const ::std::os::raw::c_char,
+        name_length: u32,
     ) -> TSFieldId;
 }
 extern "C" {
-    #[doc = " Check whether the given node type id belongs to named nodes, anonymous nodes,"]
-    #[doc = " or a hidden nodes."]
-    #[doc = ""]
-    #[doc = " See also `ts_node_is_named`. Hidden nodes are never returned from the API."]
-    pub fn ts_language_symbol_type(arg1: *const TSLanguage, arg2: TSSymbol) -> TSSymbolType;
+    #[doc = " Check whether the given node type id belongs to named nodes, anonymous nodes,\n or a hidden nodes.\n\n See also [`ts_node_is_named`]. Hidden nodes are never returned from the API."]
+    pub fn ts_language_symbol_type(self_: *const TSLanguage, symbol: TSSymbol) -> TSSymbolType;
 }
 extern "C" {
-    #[doc = " Get the ABI version number for this language. This version number is used"]
-    #[doc = " to ensure that languages were generated by a compatible version of"]
-    #[doc = " Tree-sitter."]
-    #[doc = ""]
-    #[doc = " See also `ts_parser_set_language`."]
-    pub fn ts_language_version(arg1: *const TSLanguage) -> u32;
+    #[doc = " Get the ABI version number for this language. This version number is used\n to ensure that languages were generated by a compatible version of\n Tree-sitter.\n\n See also [`ts_parser_set_language`]."]
+    pub fn ts_language_version(self_: *const TSLanguage) -> u32;
 }
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
@@ -904,20 +763,59 @@ extern "C" {
     pub fn ts_parser_take_wasm_store(arg1: *mut TSParser) -> *mut TSWasmStore;
 }
 extern "C" {
-    #[doc = " Set the allocation functions used by the library."]
-    #[doc = ""]
-    #[doc = " By default, Tree-sitter uses the standard libc allocation functions,"]
-    #[doc = " but aborts the process when an allocation fails. This function lets"]
-    #[doc = " you supply alternative allocation functions at runtime."]
-    #[doc = ""]
-    #[doc = " If you pass `NULL` for any parameter, Tree-sitter will switch back to"]
-    #[doc = " its default implementation of that function."]
-    #[doc = ""]
-    #[doc = " If you call this function after the library has already been used, then"]
-    #[doc = " you must ensure that either:"]
-    #[doc = "  1. All the existing objects have been freed."]
-    #[doc = "  2. The new allocator shares its state with the old one, so it is capable"]
-    #[doc = "     of freeing memory that was allocated by the old allocator."]
+    #[doc = " Get the next parse state. Combine this with lookahead iterators to generate\n completion suggestions or valid symbols in error nodes. Use\n [`ts_node_grammar_symbol`] for valid symbols."]
+    pub fn ts_language_next_state(
+        self_: *const TSLanguage,
+        state: TSStateId,
+        symbol: TSSymbol,
+    ) -> TSStateId;
+}
+extern "C" {
+    #[doc = " Create a new lookahead iterator for the given language and parse state.\n\n This returns `NULL` if state is invalid for the language.\n\n Repeatedly using [`ts_lookahead_iterator_next`] and\n [`ts_lookahead_iterator_current_symbol`] will generate valid symbols in the\n given parse state. Newly created lookahead iterators will contain the `ERROR`\n symbol.\n\n Lookahead iterators can be useful to generate suggestions and improve syntax\n error diagnostics. To get symbols valid in an ERROR node, use the lookahead\n iterator on its first leaf node state. For `MISSING` nodes, a lookahead\n iterator created on the previous non-extra leaf node may be appropriate."]
+    pub fn ts_lookahead_iterator_new(
+        self_: *const TSLanguage,
+        state: TSStateId,
+    ) -> *mut TSLookaheadIterator;
+}
+extern "C" {
+    #[doc = " Delete a lookahead iterator freeing all the memory used."]
+    pub fn ts_lookahead_iterator_delete(self_: *mut TSLookaheadIterator);
+}
+extern "C" {
+    #[doc = " Reset the lookahead iterator to another state.\n\n This returns `true` if the iterator was reset to the given state and `false`\n otherwise."]
+    pub fn ts_lookahead_iterator_reset_state(
+        self_: *mut TSLookaheadIterator,
+        state: TSStateId,
+    ) -> bool;
+}
+extern "C" {
+    #[doc = " Reset the lookahead iterator.\n\n This returns `true` if the language was set successfully and `false`\n otherwise."]
+    pub fn ts_lookahead_iterator_reset(
+        self_: *mut TSLookaheadIterator,
+        language: *const TSLanguage,
+        state: TSStateId,
+    ) -> bool;
+}
+extern "C" {
+    #[doc = " Get the current language of the lookahead iterator."]
+    pub fn ts_lookahead_iterator_language(self_: *const TSLookaheadIterator) -> *const TSLanguage;
+}
+extern "C" {
+    #[doc = " Advance the lookahead iterator to the next symbol.\n\n This returns `true` if there is a new symbol and `false` otherwise."]
+    pub fn ts_lookahead_iterator_next(self_: *mut TSLookaheadIterator) -> bool;
+}
+extern "C" {
+    #[doc = " Get the current symbol of the lookahead iterator;"]
+    pub fn ts_lookahead_iterator_current_symbol(self_: *const TSLookaheadIterator) -> TSSymbol;
+}
+extern "C" {
+    #[doc = " Get the current symbol type of the lookahead iterator as a null terminated\n string."]
+    pub fn ts_lookahead_iterator_current_symbol_name(
+        self_: *const TSLookaheadIterator,
+    ) -> *const ::std::os::raw::c_char;
+}
+extern "C" {
+    #[doc = " Set the allocation functions used by the library.\n\n By default, Tree-sitter uses the standard libc allocation functions,\n but aborts the process when an allocation fails. This function lets\n you supply alternative allocation functions at runtime.\n\n If you pass `NULL` for any parameter, Tree-sitter will switch back to\n its default implementation of that function.\n\n If you call this function after the library has already been used, then\n you must ensure that either:\n  1. All the existing objects have been freed.\n  2. The new allocator shares its state with the old one, so it is capable\n     of freeing memory that was allocated by the old allocator."]
     pub fn ts_set_allocator(
         new_malloc: ::std::option::Option<
             unsafe extern "C" fn(arg1: usize) -> *mut ::std::os::raw::c_void,
@@ -934,6 +832,3 @@ extern "C" {
         new_free: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
     );
 }
-
-pub const TREE_SITTER_LANGUAGE_VERSION: usize = 14;
-pub const TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION: usize = 13;
diff --git a/lib/binding_rust/build.rs b/lib/binding_rust/build.rs
index eb16a29d..11501300 100644
--- a/lib/binding_rust/build.rs
+++ b/lib/binding_rust/build.rs
@@ -17,6 +17,9 @@ fn main() {
         }
     }
 
+    #[cfg(feature = "bindgen")]
+    generate_bindings();
+
     let mut config = cc::Build::new();
 
     println!("cargo:rerun-if-env-changed=CARGO_FEATURE_WASM");
@@ -33,7 +36,8 @@ fn main() {
 
     config
         .flag_if_supported("-std=c99")
-        .flag_if_supported("-Wno-unused-parameter")
+        .flag_if_supported("-fvisibility=hidden")
+        .flag_if_supported("-Wshadow")
         .include(src_path)
         .include(src_path.join("wasm"))
         .include("include")
@@ -41,6 +45,45 @@ fn main() {
         .compile("tree-sitter");
 }
 
+#[cfg(feature = "bindgen")]
+fn generate_bindings() {
+    const HEADER_PATH: &str = "include/tree_sitter/api.h";
+
+    println!("cargo:rerun-if-changed={}", HEADER_PATH);
+
+    let no_copy = [
+        "TSInput",
+        "TSLanguage",
+        "TSLogger",
+        "TSLookaheadIterator",
+        "TSParser",
+        "TSTree",
+        "TSQuery",
+        "TSQueryCursor",
+        "TSQueryCapture",
+        "TSQueryMatch",
+        "TSQueryPredicateStep",
+    ];
+
+    let bindings = bindgen::Builder::default()
+        .header(HEADER_PATH)
+        .layout_tests(false)
+        .allowlist_type("^TS.*")
+        .allowlist_function("^ts_.*")
+        .allowlist_var("^TREE_SITTER.*")
+        .no_copy(no_copy.join("|"))
+        .prepend_enum_name(false)
+        .generate()
+        .expect("Failed to generate bindings");
+
+    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
+    let bindings_rs = out_dir.join("bindings.rs");
+
+    bindings.write_to_file(&bindings_rs).expect(&*format!(
+        "Failed to write bindings into path: {bindings_rs:?}"
+    ));
+}
+
 fn which(exe_name: impl AsRef<Path>) -> Option<PathBuf> {
     env::var_os("PATH").and_then(|paths| {
         env::split_paths(&paths).find_map(|dir| {
diff --git a/lib/binding_rust/ffi.rs b/lib/binding_rust/ffi.rs
index 685ed765..a962e6c1 100644
--- a/lib/binding_rust/ffi.rs
+++ b/lib/binding_rust/ffi.rs
@@ -2,8 +2,153 @@
 #![allow(non_upper_case_globals)]
 #![allow(non_camel_case_types)]
 
+#[cfg(feature = "bindgen")]
+include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
+
+#[cfg(not(feature = "bindgen"))]
 include!("./bindings.rs");
 
 extern "C" {
     pub(crate) fn dup(fd: std::os::raw::c_int) -> std::os::raw::c_int;
 }
+
+use crate::{
+    Language, LookaheadIterator, Node, Parser, Query, QueryCursor, QueryError, Tree, TreeCursor,
+};
+use std::{marker::PhantomData, mem::ManuallyDrop, ptr::NonNull, str};
+
+impl Language {
+    /// Reconstructs a [`Language`] from a raw pointer.
+    ///
+    /// # Safety
+    ///
+    /// `ptr` must be non-null.
+    pub unsafe fn from_raw(ptr: *const TSLanguage) -> Language {
+        Language(ptr)
+    }
+
+    /// Consumes the [`Language`], returning a raw pointer to the underlying C structure.
+    pub fn into_raw(self) -> *const TSLanguage {
+        ManuallyDrop::new(self).0
+    }
+}
+
+impl Parser {
+    /// Reconstructs a [`Parser`] from a raw pointer.
+    ///
+    /// # Safety
+    ///
+    /// `ptr` must be non-null.
+    pub unsafe fn from_raw(ptr: *mut TSParser) -> Parser {
+        Parser(NonNull::new_unchecked(ptr))
+    }
+
+    /// Consumes the [`Parser`], returning a raw pointer to the underlying C structure.
+    ///
+    /// # Safety
+    ///
+    /// It's a caller responsibility to adjust parser's state
+    /// like disable logging or dot graphs printing if this
+    /// may cause issues like use after free.
+    pub fn into_raw(self) -> *mut TSParser {
+        ManuallyDrop::new(self).0.as_ptr()
+    }
+}
+
+impl Tree {
+    /// Reconstructs a [`Tree`] from a raw pointer.
+    ///
+    /// # Safety
+    ///
+    /// `ptr` must be non-null.
+    pub unsafe fn from_raw(ptr: *mut TSTree) -> Tree {
+        Tree(NonNull::new_unchecked(ptr))
+    }
+
+    /// Consumes the [`Tree`], returning a raw pointer to the underlying C structure.
+    pub fn into_raw(self) -> *mut TSTree {
+        ManuallyDrop::new(self).0.as_ptr()
+    }
+}
+
+impl<'tree> Node<'tree> {
+    /// Reconstructs a [`Node`] from a raw pointer.
+    ///
+    /// # Safety
+    ///
+    /// `ptr` must be non-null.
+    pub unsafe fn from_raw(raw: TSNode) -> Node<'tree> {
+        Node(raw, PhantomData)
+    }
+
+    /// Consumes the [`Node`], returning a raw pointer to the underlying C structure.
+    pub fn into_raw(self) -> TSNode {
+        ManuallyDrop::new(self).0
+    }
+}
+
+impl<'a> TreeCursor<'a> {
+    /// Reconstructs a [`TreeCursor`] from a raw pointer.
+    ///
+    /// # Safety
+    ///
+    /// `ptr` must be non-null.
+    pub unsafe fn from_raw(raw: TSTreeCursor) -> TreeCursor<'a> {
+        TreeCursor(raw, PhantomData)
+    }
+
+    /// Consumes the [`TreeCursor`], returning a raw pointer to the underlying C structure.
+    pub fn into_raw(self) -> TSTreeCursor {
+        ManuallyDrop::new(self).0
+    }
+}
+
+impl Query {
+    /// Reconstructs a [`Query`] from a raw pointer.
+    ///
+    /// # Safety
+    ///
+    /// `ptr` must be non-null.
+    pub unsafe fn from_raw(ptr: *mut TSQuery, source: &str) -> Result<Query, QueryError> {
+        Query::from_raw_parts(ptr, source)
+    }
+
+    /// Consumes the [`Query`], returning a raw pointer to the underlying C structure.
+    pub fn into_raw(self) -> *mut TSQuery {
+        ManuallyDrop::new(self).ptr.as_ptr()
+    }
+}
+
+impl QueryCursor {
+    /// Reconstructs a [`QueryCursor`] from a raw pointer.
+    ///
+    /// # Safety
+    ///
+    /// `ptr` must be non-null.
+    pub unsafe fn from_raw(ptr: *mut TSQueryCursor) -> QueryCursor {
+        QueryCursor {
+            ptr: NonNull::new_unchecked(ptr),
+        }
+    }
+
+    /// Consumes the [`QueryCursor`], returning a raw pointer to the underlying C structure.
+    pub fn into_raw(self) -> *mut TSQueryCursor {
+        ManuallyDrop::new(self).ptr.as_ptr()
+    }
+}
+
+impl LookaheadIterator {
+    /// Reconstructs a [`LookaheadIterator`] from a raw pointer.
+    ///
+    /// # Safety
+    ///
+    /// `ptr` must be non-null.
+    pub unsafe fn from_raw(ptr: *mut TSLookaheadIterator) -> LookaheadIterator {
+        LookaheadIterator(NonNull::new_unchecked(ptr))
+    }
+
+    /// Consumes the [`LookaheadIterator`], returning a raw pointer to the underlying C structure.
+    pub fn into_raw(self) -> *mut TSLookaheadIterator {
+        ManuallyDrop::new(self).0.as_ptr()
+    }
+}
diff --git a/lib/binding_rust/lib.rs b/lib/binding_rust/lib.rs
index 15c1cc6e..29561926 100644
--- a/lib/binding_rust/lib.rs
+++ b/lib/binding_rust/lib.rs
@@ -1,4 +1,6 @@
-mod ffi;
+#![doc = include_str!("./README.md")]
+
+pub mod ffi;
 mod util;
 
 #[cfg(unix)]
@@ -10,6 +12,7 @@ use std::{
     fmt, hash, iter,
     marker::PhantomData,
     mem::MaybeUninit,
+    num::NonZeroU16,
     ops,
     os::raw::{c_char, c_void},
     ptr::{self, NonNull},
@@ -31,19 +34,20 @@ pub use wasm_language::*;
 /// The Tree-sitter library is generally backwards-compatible with languages
 /// generated using older CLI versions, but is not forwards-compatible.
 #[doc(alias = "TREE_SITTER_LANGUAGE_VERSION")]
-pub const LANGUAGE_VERSION: usize = ffi::TREE_SITTER_LANGUAGE_VERSION;
+pub const LANGUAGE_VERSION: usize = ffi::TREE_SITTER_LANGUAGE_VERSION as usize;
 
 /// The earliest ABI version that is supported by the current version of the
 /// library.
 #[doc(alias = "TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION")]
-pub const MIN_COMPATIBLE_LANGUAGE_VERSION: usize = ffi::TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION;
+pub const MIN_COMPATIBLE_LANGUAGE_VERSION: usize =
+    ffi::TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION as usize;
 
 pub const PARSER_HEADER: &'static str = include_str!("../include/tree_sitter/parser.h");
 
 /// An opaque object that defines how to parse a particular language. The code for each
 /// `Language` is generated by the Tree-sitter CLI.
 #[doc(alias = "TSLanguage")]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
 pub struct Language(*const ffi::TSLanguage);
 
@@ -62,7 +66,7 @@ pub struct Point {
 
 /// A range of positions in a multi-line text document, both in terms of bytes and of
 /// rows and columns.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct Range {
     pub start_byte: usize,
     pub end_byte: usize,
@@ -81,16 +85,21 @@ pub struct InputEdit {
     pub new_end_position: Point,
 }
 
-/// A single node within a syntax `Tree`.
+/// A single node within a syntax [`Tree`].
 #[doc(alias = "TSNode")]
 #[derive(Clone, Copy)]
 #[repr(transparent)]
-pub struct Node<'a>(ffi::TSNode, PhantomData<&'a ()>);
+pub struct Node<'tree>(ffi::TSNode, PhantomData<&'tree ()>);
 
-/// A stateful object that this is used to produce a `Tree` based on some source code.
+/// A stateful object that this is used to produce a [`Tree`] based on some source code.
 #[doc(alias = "TSParser")]
 pub struct Parser(NonNull<ffi::TSParser>);
 
+/// A stateful object that is used to look up symbols valid in a specific parse state
+#[doc(alias = "TSLookaheadIterator")]
+pub struct LookaheadIterator(NonNull<ffi::TSLookaheadIterator>);
+struct LookaheadNamesIterator<'a>(&'a mut LookaheadIterator);
+
 /// A type of log message.
 #[derive(Debug, PartialEq, Eq)]
 pub enum LogType {
@@ -98,24 +107,26 @@ pub enum LogType {
     Lex,
 }
 
+type FieldId = NonZeroU16;
+
 /// A callback that receives log messages during parser.
 type Logger<'a> = Box<dyn FnMut(LogType, &str) + 'a>;
 
-/// A stateful object for walking a syntax `Tree` efficiently.
+/// A stateful object for walking a syntax [`Tree`] efficiently.
 #[doc(alias = "TSTreeCursor")]
-pub struct TreeCursor<'a>(ffi::TSTreeCursor, PhantomData<&'a ()>);
+pub struct TreeCursor<'cursor>(ffi::TSTreeCursor, PhantomData<&'cursor ()>);
 
 /// A set of patterns that match nodes in a syntax tree.
 #[doc(alias = "TSQuery")]
 #[derive(Debug)]
 pub struct Query {
     ptr: NonNull<ffi::TSQuery>,
-    capture_names: Vec<String>,
-    capture_quantifiers: Vec<Vec<CaptureQuantifier>>,
-    text_predicates: Vec<Box<[TextPredicate]>>,
-    property_settings: Vec<Box<[QueryProperty]>>,
-    property_predicates: Vec<Box<[(QueryProperty, bool)]>>,
-    general_predicates: Vec<Box<[QueryPredicate]>>,
+    capture_names: Box<[&'static str]>,
+    capture_quantifiers: Box<[Box<[CaptureQuantifier]>]>,
+    text_predicates: Box<[Box<[TextPredicateCapture]>]>,
+    property_settings: Box<[Box<[QueryProperty]>]>,
+    property_predicates: Box<[Box<[(QueryProperty, bool)]>]>,
+    general_predicates: Box<[Box<[QueryPredicate]>]>,
 }
 
 /// A quantifier for captures
@@ -131,23 +142,23 @@ pub enum CaptureQuantifier {
 impl From<ffi::TSQuantifier> for CaptureQuantifier {
     fn from(value: ffi::TSQuantifier) -> Self {
         match value {
-            ffi::TSQuantifier_TSQuantifierZero => CaptureQuantifier::Zero,
-            ffi::TSQuantifier_TSQuantifierZeroOrOne => CaptureQuantifier::ZeroOrOne,
-            ffi::TSQuantifier_TSQuantifierZeroOrMore => CaptureQuantifier::ZeroOrMore,
-            ffi::TSQuantifier_TSQuantifierOne => CaptureQuantifier::One,
-            ffi::TSQuantifier_TSQuantifierOneOrMore => CaptureQuantifier::OneOrMore,
+            ffi::TSQuantifierZero => CaptureQuantifier::Zero,
+            ffi::TSQuantifierZeroOrOne => CaptureQuantifier::ZeroOrOne,
+            ffi::TSQuantifierZeroOrMore => CaptureQuantifier::ZeroOrMore,
+            ffi::TSQuantifierOne => CaptureQuantifier::One,
+            ffi::TSQuantifierOneOrMore => CaptureQuantifier::OneOrMore,
             _ => panic!("Unrecognized quantifier: {}", value),
         }
     }
 }
 
-/// A stateful object for executing a `Query` on a syntax `Tree`.
+/// A stateful object for executing a [`Query`] on a syntax [`Tree`].
 #[doc(alias = "TSQueryCursor")]
 pub struct QueryCursor {
     ptr: NonNull<ffi::TSQueryCursor>,
 }
 
-/// A key-value pair associated with a particular pattern in a `Query`.
+/// A key-value pair associated with a particular pattern in a [`Query`].
 #[derive(Debug, PartialEq, Eq)]
 pub struct QueryProperty {
     pub key: Box<str>,
@@ -161,14 +172,14 @@ pub enum QueryPredicateArg {
     String(Box<str>),
 }
 
-/// A key-value pair associated with a particular pattern in a `Query`.
+/// A key-value pair associated with a particular pattern in a [`Query`].
 #[derive(Debug, PartialEq, Eq)]
 pub struct QueryPredicate {
     pub operator: Box<str>,
-    pub args: Vec<QueryPredicateArg>,
+    pub args: Box<[QueryPredicateArg]>,
 }
 
-/// A match of a `Query` to a particular set of `Node`s.
+/// A match of a [`Query`] to a particular set of [`Node`]s.
 pub struct QueryMatch<'cursor, 'tree> {
     pub pattern_index: usize,
     pub captures: &'cursor [QueryCapture<'tree>],
@@ -176,50 +187,53 @@ pub struct QueryMatch<'cursor, 'tree> {
     cursor: *mut ffi::TSQueryCursor,
 }
 
-/// A sequence of `QueryMatch`es associated with a given `QueryCursor`.
-pub struct QueryMatches<'a, 'tree: 'a, T: TextProvider<'a>> {
+/// A sequence of [`QueryMatch`]es associated with a given [`QueryCursor`].
+pub struct QueryMatches<'query, 'cursor, T: TextProvider<I>, I: AsRef<[u8]>> {
     ptr: *mut ffi::TSQueryCursor,
-    query: &'a Query,
+    query: &'query Query,
     text_provider: T,
     buffer1: Vec<u8>,
     buffer2: Vec<u8>,
-    _tree: PhantomData<&'tree ()>,
+    _phantom: PhantomData<(&'cursor (), I)>,
 }
 
-/// A sequence of `QueryCapture`s associated with a given `QueryCursor`.
-pub struct QueryCaptures<'a, 'tree: 'a, T: TextProvider<'a>> {
+/// A sequence of [`QueryCapture`]s associated with a given [`QueryCursor`].
+pub struct QueryCaptures<'query, 'cursor, T: TextProvider<I>, I: AsRef<[u8]>> {
     ptr: *mut ffi::TSQueryCursor,
-    query: &'a Query,
+    query: &'query Query,
     text_provider: T,
     buffer1: Vec<u8>,
     buffer2: Vec<u8>,
-    _tree: PhantomData<&'tree ()>,
+    _phantom: PhantomData<(&'cursor (), I)>,
 }
 
-pub trait TextProvider<'a> {
-    type I: Iterator<Item = &'a [u8]> + 'a;
+pub trait TextProvider<I>
+where
+    I: AsRef<[u8]>,
+{
+    type I: Iterator<Item = I>;
     fn text(&mut self, node: Node) -> Self::I;
 }
 
-/// A particular `Node` that has been captured with a particular name within a `Query`.
+/// A particular [`Node`] that has been captured with a particular name within a [`Query`].
 #[derive(Clone, Copy, Debug)]
 #[repr(C)]
-pub struct QueryCapture<'a> {
-    pub node: Node<'a>,
+pub struct QueryCapture<'tree> {
+    pub node: Node<'tree>,
     pub index: u32,
 }
 
-/// An error that occurred when trying to assign an incompatible `Language` to a `Parser`.
+/// An error that occurred when trying to assign an incompatible [`Language`] to a [`Parser`].
 #[derive(Debug, PartialEq, Eq)]
 pub struct LanguageError {
     version: usize,
 }
 
-/// An error that occurred in `Parser::set_included_ranges`.
+/// An error that occurred in [`Parser::set_included_ranges`].
 #[derive(Debug, PartialEq, Eq)]
 pub struct IncludedRangesError(pub usize);
 
-/// An error that occurred when trying to create a `Query`.
+/// An error that occurred when trying to create a [`Query`].
 #[derive(Debug, PartialEq, Eq)]
 pub struct QueryError {
     pub row: usize,
@@ -241,10 +255,16 @@ pub enum QueryErrorKind {
 }
 
 #[derive(Debug)]
-enum TextPredicate {
-    CaptureEqString(u32, String, bool),
-    CaptureEqCapture(u32, u32, bool),
-    CaptureMatchString(u32, regex::bytes::Regex, bool),
+/// The first item is the capture index
+/// The next is capture specific, depending on what item is expected
+/// The first bool is if the capture is positive
+/// The last item is a bool signifying whether or not it's meant to match
+/// any or all captures
+enum TextPredicateCapture {
+    EqString(u32, Box<str>, bool, bool),
+    EqCapture(u32, u32, bool, bool),
+    MatchString(u32, regex::bytes::Regex, bool, bool),
+    AnyString(u32, Box<[Box<str>]>, bool),
 }
 
 // TODO: Remove this struct at at some point. If `core::str::lossy::Utf8Lossy`
@@ -256,7 +276,7 @@ pub struct LossyUtf8<'a> {
 
 impl Language {
     /// Get the ABI version number that indicates which version of the Tree-sitter CLI
-    /// that was used to generate this `Language`.
+    /// that was used to generate this [`Language`].
     #[doc(alias = "ts_language_version")]
     pub fn version(&self) -> usize {
         unsafe { ffi::ts_language_version(self.0) as usize }
@@ -268,15 +288,17 @@ impl Language {
         unsafe { ffi::ts_language_symbol_count(self.0) as usize }
     }
 
+    /// Get the number of valid states in this language.
+    #[doc(alias = "ts_language_state_count")]
+    pub fn parse_state_count(&self) -> usize {
+        unsafe { ffi::ts_language_state_count(self.0) as usize }
+    }
+
     /// Get the name of the node kind for the given numerical id.
     #[doc(alias = "ts_language_symbol_name")]
     pub fn node_kind_for_id(&self, id: u16) -> Option<&'static str> {
         let ptr = unsafe { ffi::ts_language_symbol_name(self.0, id) };
-        if ptr.is_null() {
-            None
-        } else {
-            Some(unsafe { CStr::from_ptr(ptr) }.to_str().unwrap())
-        }
+        (!ptr.is_null()).then(|| unsafe { CStr::from_ptr(ptr) }.to_str().unwrap())
     }
 
     /// Get the numeric id for the given node kind.
@@ -295,14 +317,12 @@ impl Language {
     /// Check if the node type for the given numerical id is named (as opposed
     /// to an anonymous node type).
     pub fn node_kind_is_named(&self, id: u16) -> bool {
-        unsafe { ffi::ts_language_symbol_type(self.0, id) == ffi::TSSymbolType_TSSymbolTypeRegular }
+        unsafe { ffi::ts_language_symbol_type(self.0, id) == ffi::TSSymbolTypeRegular }
     }
 
     #[doc(alias = "ts_language_symbol_type")]
     pub fn node_kind_is_visible(&self, id: u16) -> bool {
-        unsafe {
-            ffi::ts_language_symbol_type(self.0, id) <= ffi::TSSymbolType_TSSymbolTypeAnonymous
-        }
+        unsafe { ffi::ts_language_symbol_type(self.0, id) <= ffi::TSSymbolTypeAnonymous }
     }
 
     /// Get the number of distinct field names in this language.
@@ -315,16 +335,12 @@ impl Language {
     #[doc(alias = "ts_language_field_name_for_id")]
     pub fn field_name_for_id(&self, field_id: u16) -> Option<&'static str> {
         let ptr = unsafe { ffi::ts_language_field_name_for_id(self.0, field_id) };
-        if ptr.is_null() {
-            None
-        } else {
-            Some(unsafe { CStr::from_ptr(ptr) }.to_str().unwrap())
-        }
+        (!ptr.is_null()).then(|| unsafe { CStr::from_ptr(ptr) }.to_str().unwrap())
     }
 
     /// Get the numerical id for the given field name.
     #[doc(alias = "ts_language_field_id_for_name")]
-    pub fn field_id_for_name(&self, field_name: impl AsRef<[u8]>) -> Option<u16> {
+    pub fn field_id_for_name(&self, field_name: impl AsRef<[u8]>) -> Option<FieldId> {
         let field_name = field_name.as_ref();
         let id = unsafe {
             ffi::ts_language_field_id_for_name(
@@ -333,11 +349,39 @@ impl Language {
                 field_name.len() as u32,
             )
         };
-        if id == 0 {
-            None
-        } else {
-            Some(id)
-        }
+        FieldId::new(id)
+    }
+
+    /// Get the next parse state. Combine this with
+    /// [`lookahead_iterator`](Language::lookahead_iterator) to
+    /// generate completion suggestions or valid symbols in error nodes.
+    ///
+    /// Example:
+    /// ```
+    /// let state = language.next_state(node.parse_state(), node.grammar_id());
+    /// ```
+    #[doc(alias = "ts_language_next_state")]
+    pub fn next_state(&self, state: u16, id: u16) -> u16 {
+        unsafe { ffi::ts_language_next_state(self.0, state, id) }
+    }
+
+    /// Create a new lookahead iterator for this language and parse state.
+    ///
+    /// This returns `None` if state is invalid for this language.
+    ///
+    /// Iterating [`LookaheadIterator`] will yield valid symbols in the given
+    /// parse state. Newly created lookahead iterators will return the `ERROR`
+    /// symbol from [`LookaheadIterator::current_symbol`].
+    ///
+    /// Lookahead iterators can be useful to generate suggestions and improve
+    /// syntax error diagnostics. To get symbols valid in an ERROR node, use the
+    /// lookahead iterator on its first leaf node state. For `MISSING` nodes, a
+    /// lookahead iterator created on the previous non-extra leaf node may be
+    /// appropriate.
+    #[doc(alias = "ts_lookahead_iterator_new")]
+    pub fn lookahead_iterator(&self, state: u16) -> Option<LookaheadIterator> {
+        let ptr = unsafe { ffi::ts_lookahead_iterator_new(self.0, state) };
+        (!ptr.is_null()).then(|| unsafe { LookaheadIterator::from_raw(ptr) })
     }
 }
 
@@ -355,9 +399,9 @@ impl Parser {
     /// Returns a Result indicating whether or not the language was successfully
     /// assigned. True means assignment succeeded. False means there was a version
     /// mismatch: the language was generated with an incompatible version of the
-    /// Tree-sitter CLI. Check the language's version using [Language::version]
-    /// and compare it to this library's [LANGUAGE_VERSION](LANGUAGE_VERSION) and
-    /// [MIN_COMPATIBLE_LANGUAGE_VERSION](MIN_COMPATIBLE_LANGUAGE_VERSION) constants.
+    /// Tree-sitter CLI. Check the language's version using [`Language::version`]
+    /// and compare it to this library's [`LANGUAGE_VERSION`](LANGUAGE_VERSION) and
+    /// [`MIN_COMPATIBLE_LANGUAGE_VERSION`](MIN_COMPATIBLE_LANGUAGE_VERSION) constants.
     #[doc(alias = "ts_parser_set_language")]
     pub fn set_language(&mut self, language: Language) -> Result<(), LanguageError> {
         let version = language.version();
@@ -375,11 +419,7 @@ impl Parser {
     #[doc(alias = "ts_parser_language")]
     pub fn language(&self) -> Option<Language> {
         let ptr = unsafe { ffi::ts_parser_language(self.0.as_ptr()) };
-        if ptr.is_null() {
-            None
-        } else {
-            Some(Language(ptr))
-        }
+        (!ptr.is_null()).then(|| Language(ptr))
     }
 
     /// Get the parser's current logger.
@@ -408,7 +448,7 @@ impl Parser {
             ) {
                 let callback = (payload as *mut Logger).as_mut().unwrap();
                 if let Ok(message) = CStr::from_ptr(c_message).to_str() {
-                    let log_type = if c_log_type == ffi::TSLogType_TSLogTypeParse {
+                    let log_type = if c_log_type == ffi::TSLogTypeParse {
                         LogType::Parse
                     } else {
                         LogType::Lex
@@ -457,18 +497,18 @@ impl Parser {
     /// * `old_tree` A previous syntax tree parsed from the same document.
     ///   If the text of the document has changed since `old_tree` was
     ///   created, then you must edit `old_tree` to match the new text using
-    ///   [Tree::edit].
+    ///   [`Tree::edit`].
     ///
-    /// Returns a [Tree] if parsing succeeded, or `None` if:
-    ///  * The parser has not yet had a language assigned with [Parser::set_language]
-    ///  * The timeout set with [Parser::set_timeout_micros] expired
-    ///  * The cancellation flag set with [Parser::set_cancellation_flag] was flipped
+    /// Returns a [`Tree`] if parsing succeeded, or `None` if:
+    ///  * The parser has not yet had a language assigned with [`Parser::set_language`]
+    ///  * The timeout set with [`Parser::set_timeout_micros`] expired
+    ///  * The cancellation flag set with [`Parser::set_cancellation_flag`] was flipped
     #[doc(alias = "ts_parser_parse")]
     pub fn parse(&mut self, text: impl AsRef<[u8]>, old_tree: Option<&Tree>) -> Option<Tree> {
         let bytes = text.as_ref();
         let len = bytes.len();
         self.parse_with(
-            &mut |i, _| if i < len { &bytes[i..] } else { &[] },
+            &mut |i, _| (i < len).then(|| &bytes[i..]).unwrap_or_default(),
             old_tree,
         )
     }
@@ -480,7 +520,7 @@ impl Parser {
     /// * `old_tree` A previous syntax tree parsed from the same document.
     ///   If the text of the document has changed since `old_tree` was
     ///   created, then you must edit `old_tree` to match the new text using
-    ///   [Tree::edit].
+    ///   [`Tree::edit`].
     pub fn parse_utf16(
         &mut self,
         input: impl AsRef<[u16]>,
@@ -489,7 +529,7 @@ impl Parser {
         let code_points = input.as_ref();
         let len = code_points.len();
         self.parse_utf16_with(
-            &mut |i, _| if i < len { &code_points[i..] } else { &[] },
+            &mut |i, _| (i < len).then(|| &code_points[i..]).unwrap_or_default(),
             old_tree,
         )
     }
@@ -504,8 +544,8 @@ impl Parser {
     /// * `old_tree` A previous syntax tree parsed from the same document.
     ///   If the text of the document has changed since `old_tree` was
     ///   created, then you must edit `old_tree` to match the new text using
-    ///   [Tree::edit].
-    pub fn parse_with<'a, T: AsRef<[u8]>, F: FnMut(usize, Point) -> T>(
+    ///   [`Tree::edit`].
+    pub fn parse_with<T: AsRef<[u8]>, F: FnMut(usize, Point) -> T>(
         &mut self,
         callback: &mut F,
         old_tree: Option<&Tree>,
@@ -518,7 +558,7 @@ impl Parser {
         let mut payload: (&mut F, Option<T>) = (callback, None);
 
         // This C function is passed to Tree-sitter as the input callback.
-        unsafe extern "C" fn read<'a, T: AsRef<[u8]>, F: FnMut(usize, Point) -> T>(
+        unsafe extern "C" fn read<T: AsRef<[u8]>, F: FnMut(usize, Point) -> T>(
             payload: *mut c_void,
             byte_offset: u32,
             position: ffi::TSPoint,
@@ -534,7 +574,7 @@ impl Parser {
         let c_input = ffi::TSInput {
             payload: &mut payload as *mut (&mut F, Option<T>) as *mut c_void,
             read: Some(read::<T, F>),
-            encoding: ffi::TSInputEncoding_TSInputEncodingUTF8,
+            encoding: ffi::TSInputEncodingUTF8,
         };
 
         let c_old_tree = old_tree.map_or(ptr::null_mut(), |t| t.0.as_ptr());
@@ -554,8 +594,8 @@ impl Parser {
     /// * `old_tree` A previous syntax tree parsed from the same document.
     ///   If the text of the document has changed since `old_tree` was
     ///   created, then you must edit `old_tree` to match the new text using
-    ///   [Tree::edit].
-    pub fn parse_utf16_with<'a, T: AsRef<[u16]>, F: FnMut(usize, Point) -> T>(
+    ///   [`Tree::edit`].
+    pub fn parse_utf16_with<T: AsRef<[u16]>, F: FnMut(usize, Point) -> T>(
         &mut self,
         callback: &mut F,
         old_tree: Option<&Tree>,
@@ -568,7 +608,7 @@ impl Parser {
         let mut payload: (&mut F, Option<T>) = (callback, None);
 
         // This C function is passed to Tree-sitter as the input callback.
-        unsafe extern "C" fn read<'a, T: AsRef<[u16]>, F: FnMut(usize, Point) -> T>(
+        unsafe extern "C" fn read<T: AsRef<[u16]>, F: FnMut(usize, Point) -> T>(
             payload: *mut c_void,
             byte_offset: u32,
             position: ffi::TSPoint,
@@ -590,7 +630,7 @@ impl Parser {
         let c_input = ffi::TSInput {
             payload: &mut payload as *mut (&mut F, Option<T>) as *mut c_void,
             read: Some(read::<T, F>),
-            encoding: ffi::TSInputEncoding_TSInputEncodingUTF16,
+            encoding: ffi::TSInputEncodingUTF16,
         };
 
         let c_old_tree = old_tree.map_or(ptr::null_mut(), |t| t.0.as_ptr());
@@ -602,10 +642,10 @@ impl Parser {
 
     /// Instruct the parser to start the next parse from the beginning.
     ///
-    /// If the parser previously failed because of a timeout or a cancellation, then
-    /// by default, it will resume where it left off on the next call to `parse` or
-    /// other parsing functions. If you don't want to resume, and instead intend to
-    /// use this parser to parse some other document, you must call `reset` first.
+    /// If the parser previously failed because of a timeout or a cancellation, then by default, it
+    /// will resume where it left off on the next call to [`parse`](Parser::parse) or other parsing
+    /// functions. If you don't want to resume, and instead intend to use this parser to parse some
+    /// other document, you must call `reset` first.
     #[doc(alias = "ts_parser_reset")]
     pub fn reset(&mut self) {
         unsafe { ffi::ts_parser_reset(self.0.as_ptr()) }
@@ -613,7 +653,7 @@ impl Parser {
 
     /// Get the duration in microseconds that parsing is allowed to take.
     ///
-    /// This is set via [set_timeout_micros](Parser::set_timeout_micros).
+    /// This is set via [`set_timeout_micros`](Parser::set_timeout_micros).
     #[doc(alias = "ts_parser_timeout_micros")]
     pub fn timeout_micros(&self) -> u64 {
         unsafe { ffi::ts_parser_timeout_micros(self.0.as_ptr()) }
@@ -623,7 +663,7 @@ impl Parser {
     /// take before halting.
     ///
     /// If parsing takes longer than this, it will halt early, returning `None`.
-    /// See `parse` for more information.
+    /// See [`parse`](Parser::parse) for more information.
     #[doc(alias = "ts_parser_set_timeout_micros")]
     pub fn set_timeout_micros(&mut self, timeout_micros: u64) {
         unsafe { ffi::ts_parser_set_timeout_micros(self.0.as_ptr(), timeout_micros) }
@@ -646,10 +686,7 @@ impl Parser {
     /// If this requirement is not satisfied, method will return IncludedRangesError
     /// error with an offset in the passed ranges slice pointing to a first incorrect range.
     #[doc(alias = "ts_parser_set_included_ranges")]
-    pub fn set_included_ranges<'a>(
-        &mut self,
-        ranges: &'a [Range],
-    ) -> Result<(), IncludedRangesError> {
+    pub fn set_included_ranges(&mut self, ranges: &[Range]) -> Result<(), IncludedRangesError> {
         let ts_ranges: Vec<ffi::TSRange> =
             ranges.iter().cloned().map(|range| range.into()).collect();
         let result = unsafe {
@@ -684,7 +721,7 @@ impl Parser {
     ///
     /// If a pointer is assigned, then the parser will periodically read from
     /// this pointer during parsing. If it reads a non-zero value, it will halt early,
-    /// returning `None`. See [parse](Parser::parse) for more information.
+    /// returning `None`. See [`parse`](Parser::parse) for more information.
     #[doc(alias = "ts_parser_set_cancellation_flag")]
     pub unsafe fn set_cancellation_flag(&mut self, flag: Option<&AtomicUsize>) {
         if let Some(flag) = flag {
@@ -744,7 +781,7 @@ impl Tree {
         unsafe { ffi::ts_tree_edit(self.0.as_ptr(), &edit) };
     }
 
-    /// Create a new [TreeCursor] starting from the root of the tree.
+    /// Create a new [`TreeCursor`] starting from the root of the tree.
     pub fn walk(&self) -> TreeCursor {
         self.root_node().walk()
     }
@@ -754,7 +791,7 @@ impl Tree {
     ///
     /// For this to work correctly, this syntax tree must have been edited such that its
     /// ranges match up to the new tree. Generally, you'll want to call this method right
-    /// after calling one of the [Parser::parse] functions. Call it on the old tree that
+    /// after calling one of the [`Parser::parse`] functions. Call it on the old tree that
     /// was passed to parse, and pass the new tree that was returned from `parse`.
     #[doc(alias = "ts_tree_get_changed_ranges")]
     pub fn changed_ranges(&self, other: &Tree) -> impl ExactSizeIterator<Item = Range> {
@@ -780,6 +817,16 @@ impl Tree {
             result
         }
     }
+
+    /// Print a graph of the tree to the given file descriptor.
+    /// The graph is formatted in the DOT language. You may want to pipe this graph
+    /// directly to a `dot(1)` process in order to generate SVG output.
+    #[cfg(unix)]
+    #[doc(alias = "ts_tree_print_dot_graph")]
+    pub fn print_dot_graph(&self, file: &impl AsRawFd) {
+        let fd = file.as_raw_fd();
+        unsafe { ffi::ts_tree_print_dot_graph(self.0.as_ptr(), fd) }
+    }
 }
 
 impl fmt::Debug for Tree {
@@ -802,11 +849,7 @@ impl Clone for Tree {
 
 impl<'tree> Node<'tree> {
     fn new(node: ffi::TSNode) -> Option<Self> {
-        if node.id.is_null() {
-            None
-        } else {
-            Some(Node(node, PhantomData))
-        }
+        (!node.id.is_null()).then(|| Node(node, PhantomData))
     }
 
     /// Get a numeric id for this node that is unique.
@@ -825,6 +868,13 @@ impl<'tree> Node<'tree> {
         unsafe { ffi::ts_node_symbol(self.0) }
     }
 
+    /// Get the node's type as a numerical id as it appears in the grammar
+    /// ignoring aliases.
+    #[doc(alias = "ts_node_grammar_symbol")]
+    pub fn grammar_id(&self) -> u16 {
+        unsafe { ffi::ts_node_grammar_symbol(self.0) }
+    }
+
     /// Get this node's type as a string.
     #[doc(alias = "ts_node_type")]
     pub fn kind(&self) -> &'static str {
@@ -833,10 +883,19 @@ impl<'tree> Node<'tree> {
             .unwrap()
     }
 
-    /// Get the [Language] that was used to parse this node's syntax tree.
-    #[doc(alias = "ts_tree_language")]
+    /// Get this node's symbol name as it appears in the grammar ignoring
+    /// aliases as a string.
+    #[doc(alias = "ts_node_grammar_type")]
+    pub fn grammar_name(&self) -> &'static str {
+        unsafe { CStr::from_ptr(ffi::ts_node_grammar_type(self.0)) }
+            .to_str()
+            .unwrap()
+    }
+
+    /// Get the [`Language`] that was used to parse this node's syntax tree.
+    #[doc(alias = "ts_node_language")]
     pub fn language(&self) -> Language {
-        Language(unsafe { ffi::ts_tree_language(self.0.tree) })
+        Language(unsafe { ffi::ts_node_language(self.0) })
     }
 
     /// Check if this node is *named*.
@@ -874,8 +933,21 @@ impl<'tree> Node<'tree> {
     ///
     /// Syntax errors represent parts of the code that could not be incorporated into a
     /// valid syntax tree.
+    #[doc(alias = "ts_node_is_error")]
     pub fn is_error(&self) -> bool {
-        self.kind_id() == u16::MAX
+        unsafe { ffi::ts_node_is_error(self.0) }
+    }
+
+    /// Get this node's parse state.
+    #[doc(alias = "ts_node_parse_state")]
+    pub fn parse_state(&self) -> u16 {
+        unsafe { ffi::ts_node_parse_state(self.0) }
+    }
+
+    /// Get the parse state after this node.
+    #[doc(alias = "ts_node_next_parse_state")]
+    pub fn next_parse_state(&self) -> u16 {
+        unsafe { ffi::ts_node_next_parse_state(self.0) }
     }
 
     /// Check if this node is *missing*.
@@ -934,7 +1006,7 @@ impl<'tree> Node<'tree> {
     ///
     /// This method is fairly fast, but its cost is technically log(i), so you
     /// if you might be iterating over a long list of children, you should use
-    /// [Node::children] instead.
+    /// [`Node::children`] instead.
     #[doc(alias = "ts_node_child")]
     pub fn child(&self, i: usize) -> Option<Self> {
         Self::new(unsafe { ffi::ts_node_child(self.0, i as u32) })
@@ -948,18 +1020,18 @@ impl<'tree> Node<'tree> {
 
     /// Get this node's *named* child at the given index.
     ///
-    /// See also [Node::is_named].
+    /// See also [`Node::is_named`].
     /// This method is fairly fast, but its cost is technically log(i), so you
     /// if you might be iterating over a long list of children, you should use
-    /// [Node::named_children] instead.
+    /// [`Node::named_children`] instead.
     #[doc(alias = "ts_node_named_child")]
-    pub fn named_child<'a>(&'a self, i: usize) -> Option<Self> {
+    pub fn named_child(&self, i: usize) -> Option<Self> {
         Self::new(unsafe { ffi::ts_node_named_child(self.0, i as u32) })
     }
 
     /// Get this node's number of *named* children.
     ///
-    /// See also [Node::is_named].
+    /// See also [`Node::is_named`].
     #[doc(alias = "ts_node_named_child_count")]
     pub fn named_child_count(&self) -> usize {
         unsafe { ffi::ts_node_named_child_count(self.0) as usize }
@@ -968,7 +1040,7 @@ impl<'tree> Node<'tree> {
     /// Get the first child with the given field name.
     ///
     /// If multiple children may have the same field name, access them using
-    /// [children_by_field_name](Node::children_by_field_name)
+    /// [`children_by_field_name`](Node::children_by_field_name)
     #[doc(alias = "ts_node_child_by_field_name")]
     pub fn child_by_field_name(&self, field_name: impl AsRef<[u8]>) -> Option<Self> {
         let field_name = field_name.as_ref();
@@ -983,8 +1055,8 @@ impl<'tree> Node<'tree> {
 
     /// Get this node's child with the given numerical field id.
     ///
-    /// See also [child_by_field_name](Node::child_by_field_name). You can convert a field name to
-    /// an id using [Language::field_id_for_name].
+    /// See also [`child_by_field_name`](Node::child_by_field_name). You can convert a field name to
+    /// an id using [`Language::field_id_for_name`].
     #[doc(alias = "ts_node_child_by_field_id")]
     pub fn child_by_field_id(&self, field_id: u16) -> Option<Self> {
         Self::new(unsafe { ffi::ts_node_child_by_field_id(self.0, field_id) })
@@ -995,27 +1067,23 @@ impl<'tree> Node<'tree> {
     pub fn field_name_for_child(&self, child_index: u32) -> Option<&'static str> {
         unsafe {
             let ptr = ffi::ts_node_field_name_for_child(self.0, child_index);
-            if ptr.is_null() {
-                None
-            } else {
-                Some(CStr::from_ptr(ptr).to_str().unwrap())
-            }
+            (!ptr.is_null()).then(|| CStr::from_ptr(ptr).to_str().unwrap())
         }
     }
 
     /// Iterate over this node's children.
     ///
-    /// A [TreeCursor] is used to retrieve the children efficiently. Obtain
-    /// a [TreeCursor] by calling [Tree::walk] or [Node::walk]. To avoid unnecessary
+    /// A [`TreeCursor`] is used to retrieve the children efficiently. Obtain
+    /// a [`TreeCursor`] by calling [`Tree::walk`] or [`Node::walk`]. To avoid unnecessary
     /// allocations, you should reuse the same cursor for subsequent calls to
     /// this method.
     ///
-    /// If you're walking the tree recursively, you may want to use the `TreeCursor`
+    /// If you're walking the tree recursively, you may want to use the [`TreeCursor`]
     /// APIs directly instead.
-    pub fn children<'a>(
+    pub fn children<'cursor>(
         &self,
-        cursor: &'a mut TreeCursor<'tree>,
-    ) -> impl ExactSizeIterator<Item = Node<'tree>> + 'a {
+        cursor: &'cursor mut TreeCursor<'tree>,
+    ) -> impl ExactSizeIterator<Item = Node<'tree>> + 'cursor {
         cursor.reset(*self);
         cursor.goto_first_child();
         (0..self.child_count()).into_iter().map(move |_| {
@@ -1027,11 +1095,11 @@ impl<'tree> Node<'tree> {
 
     /// Iterate over this node's named children.
     ///
-    /// See also [Node::children].
-    pub fn named_children<'a>(
+    /// See also [`Node::children`].
+    pub fn named_children<'cursor>(
         &self,
-        cursor: &'a mut TreeCursor<'tree>,
-    ) -> impl ExactSizeIterator<Item = Node<'tree>> + 'a {
+        cursor: &'cursor mut TreeCursor<'tree>,
+    ) -> impl ExactSizeIterator<Item = Node<'tree>> + 'cursor {
         cursor.reset(*self);
         cursor.goto_first_child();
         (0..self.named_child_count()).into_iter().map(move |_| {
@@ -1048,29 +1116,48 @@ impl<'tree> Node<'tree> {
 
     /// Iterate over this node's children with a given field name.
     ///
-    /// See also [Node::children].
-    pub fn children_by_field_name<'a>(
+    /// See also [`Node::children`].
+    pub fn children_by_field_name<'cursor>(
         &self,
         field_name: &str,
-        cursor: &'a mut TreeCursor<'tree>,
-    ) -> impl Iterator<Item = Node<'tree>> + 'a {
+        cursor: &'cursor mut TreeCursor<'tree>,
+    ) -> impl Iterator<Item = Node<'tree>> + 'cursor {
         let field_id = self.language().field_id_for_name(field_name);
-        self.children_by_field_id(field_id.unwrap_or(0), cursor)
+        let mut done = field_id.is_none();
+        if !done {
+            cursor.reset(*self);
+            cursor.goto_first_child();
+        }
+        iter::from_fn(move || {
+            if !done {
+                while cursor.field_id() != field_id {
+                    if !cursor.goto_next_sibling() {
+                        return None;
+                    }
+                }
+                let result = cursor.node();
+                if !cursor.goto_next_sibling() {
+                    done = true;
+                }
+                return Some(result);
+            }
+            None
+        })
     }
 
     /// Iterate over this node's children with a given field id.
     ///
-    /// See also [Node::children_by_field_name].
-    pub fn children_by_field_id<'a>(
+    /// See also [`Node::children_by_field_name`].
+    pub fn children_by_field_id<'cursor>(
         &self,
-        field_id: u16,
-        cursor: &'a mut TreeCursor<'tree>,
-    ) -> impl Iterator<Item = Node<'tree>> + 'a {
+        field_id: FieldId,
+        cursor: &'cursor mut TreeCursor<'tree>,
+    ) -> impl Iterator<Item = Node<'tree>> + 'cursor {
         cursor.reset(*self);
         cursor.goto_first_child();
         let mut done = false;
         iter::from_fn(move || {
-            while !done {
+            if !done {
                 while cursor.field_id() != Some(field_id) {
                     if !cursor.goto_next_sibling() {
                         return None;
@@ -1116,6 +1203,12 @@ impl<'tree> Node<'tree> {
         Self::new(unsafe { ffi::ts_node_prev_named_sibling(self.0) })
     }
 
+    /// Get the node's number of descendants, including one for the node itself.
+    #[doc(alias = "ts_node_descendant_count")]
+    pub fn descendant_count(&self) -> usize {
+        unsafe { ffi::ts_node_descendant_count(self.0) as usize }
+    }
+
     /// Get the smallest node within this node that spans the given range.
     #[doc(alias = "ts_node_descendant_for_byte_range")]
     pub fn descendant_for_byte_range(&self, start: usize, end: usize) -> Option<Self> {
@@ -1167,7 +1260,7 @@ impl<'tree> Node<'tree> {
         &source.as_ref()[self.start_byte()..self.end_byte()]
     }
 
-    /// Create a new [TreeCursor] starting from this node.
+    /// Create a new [`TreeCursor`] starting from this node.
     #[doc(alias = "ts_tree_cursor_new")]
     pub fn walk(&self) -> TreeCursor<'tree> {
         TreeCursor(unsafe { ffi::ts_tree_cursor_new(self.0) }, PhantomData)
@@ -1176,9 +1269,9 @@ impl<'tree> Node<'tree> {
     /// Edit this node to keep it in-sync with source code that has been edited.
     ///
     /// This function is only rarely needed. When you edit a syntax tree with the
-    /// [Tree::edit] method, all of the nodes that you retrieve from the tree
-    /// afterward will already reflect the edit. You only need to use [Node::edit]
-    /// when you have a specific [Node] instance that you want to keep and continue
+    /// [`Tree::edit`] method, all of the nodes that you retrieve from the tree
+    /// afterward will already reflect the edit. You only need to use [`Node::edit`]
+    /// when you have a specific [`Node`] instance that you want to keep and continue
     /// to use after an edit.
     #[doc(alias = "ts_node_edit")]
     pub fn edit(&mut self, edit: &InputEdit) {
@@ -1187,15 +1280,15 @@ impl<'tree> Node<'tree> {
     }
 }
 
-impl<'a> PartialEq for Node<'a> {
+impl PartialEq for Node<'_> {
     fn eq(&self, other: &Self) -> bool {
         self.0.id == other.0.id
     }
 }
 
-impl<'a> Eq for Node<'a> {}
+impl Eq for Node<'_> {}
 
-impl<'a> hash::Hash for Node<'a> {
+impl hash::Hash for Node<'_> {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
         self.0.id.hash(state);
         self.0.context[0].hash(state);
@@ -1205,7 +1298,7 @@ impl<'a> hash::Hash for Node<'a> {
     }
 }
 
-impl<'a> fmt::Debug for Node<'a> {
+impl fmt::Debug for Node<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         write!(
             f,
@@ -1217,10 +1310,10 @@ impl<'a> fmt::Debug for Node<'a> {
     }
 }
 
-impl<'a> TreeCursor<'a> {
-    /// Get the tree cursor's current [Node].
+impl<'cursor> TreeCursor<'cursor> {
+    /// Get the tree cursor's current [`Node`].
     #[doc(alias = "ts_tree_cursor_current_node")]
-    pub fn node(&self) -> Node<'a> {
+    pub fn node(&self) -> Node<'cursor> {
         Node(
             unsafe { ffi::ts_tree_cursor_current_node(&self.0) },
             PhantomData,
@@ -1229,17 +1322,11 @@ impl<'a> TreeCursor<'a> {
 
     /// Get the numerical field id of this tree cursor's current node.
     ///
-    /// See also [field_name](TreeCursor::field_name).
+    /// See also [`field_name`](TreeCursor::field_name).
     #[doc(alias = "ts_tree_cursor_current_field_id")]
-    pub fn field_id(&self) -> Option<u16> {
-        unsafe {
-            let id = ffi::ts_tree_cursor_current_field_id(&self.0);
-            if id == 0 {
-                None
-            } else {
-                Some(id)
-            }
-        }
+    pub fn field_id(&self) -> Option<FieldId> {
+        let id = unsafe { ffi::ts_tree_cursor_current_field_id(&self.0) };
+        FieldId::new(id)
     }
 
     /// Get the field name of this tree cursor's current node.
@@ -1247,14 +1334,25 @@ impl<'a> TreeCursor<'a> {
     pub fn field_name(&self) -> Option<&'static str> {
         unsafe {
             let ptr = ffi::ts_tree_cursor_current_field_name(&self.0);
-            if ptr.is_null() {
-                None
-            } else {
-                Some(CStr::from_ptr(ptr).to_str().unwrap())
-            }
+            (!ptr.is_null()).then(|| CStr::from_ptr(ptr).to_str().unwrap())
         }
     }
 
+    /// Get the numerical field id of this tree cursor's current node.
+    ///
+    /// See also [`field_name`](TreeCursor::field_name).
+    #[doc(alias = "ts_tree_cursor_current_depth")]
+    pub fn depth(&self) -> u32 {
+        unsafe { ffi::ts_tree_cursor_current_depth(&self.0) }
+    }
+
+    /// Get the index of the cursor's current node out of all of the
+    /// descendants of the original node that the cursor was constructed with
+    #[doc(alias = "ts_tree_cursor_current_descendant_index")]
+    pub fn descendant_index(&self) -> usize {
+        unsafe { ffi::ts_tree_cursor_current_descendant_index(&self.0) as usize }
+    }
+
     /// Move this cursor to the first child of its current node.
     ///
     /// This returns `true` if the cursor successfully moved, and returns `false`
@@ -1264,6 +1362,19 @@ impl<'a> TreeCursor<'a> {
         return unsafe { ffi::ts_tree_cursor_goto_first_child(&mut self.0) };
     }
 
+    /// Move this cursor to the last child of its current node.
+    ///
+    /// This returns `true` if the cursor successfully moved, and returns
+    /// `false` if there were no children.
+    ///
+    /// Note that this function may be slower than
+    /// [`goto_first_child`](TreeCursor::goto_first_child) because it needs to
+    /// iterate through all the children to compute the child's position.
+    #[doc(alias = "ts_tree_cursor_goto_last_child")]
+    pub fn goto_last_child(&mut self) -> bool {
+        return unsafe { ffi::ts_tree_cursor_goto_last_child(&mut self.0) };
+    }
+
     /// Move this cursor to the parent of its current node.
     ///
     /// This returns `true` if the cursor successfully moved, and returns `false`
@@ -1282,6 +1393,31 @@ impl<'a> TreeCursor<'a> {
         return unsafe { ffi::ts_tree_cursor_goto_next_sibling(&mut self.0) };
     }
 
+    /// Move the cursor to the node that is the nth descendant of
+    /// the original node that the cursor was constructed with, where
+    /// zero represents the original node itself.
+    #[doc(alias = "ts_tree_cursor_goto_descendant")]
+    pub fn goto_descendant(&mut self, descendant_index: usize) {
+        return unsafe {
+            ffi::ts_tree_cursor_goto_descendant(&mut self.0, descendant_index as u32)
+        };
+    }
+
+    /// Move this cursor to the previous sibling of its current node.
+    ///
+    /// This returns `true` if the cursor successfully moved, and returns
+    /// `false` if there was no previous sibling node.
+    ///
+    /// Note, that this function may be slower than
+    /// [`goto_next_sibling`](TreeCursor::goto_next_sibling) due to how node
+    /// positions are stored. In the worst case, this will need to iterate
+    /// through all the children upto the previous sibling node to recalculate
+    /// its position.
+    #[doc(alias = "ts_tree_cursor_goto_previous_sibling")]
+    pub fn goto_previous_sibling(&mut self) -> bool {
+        return unsafe { ffi::ts_tree_cursor_goto_previous_sibling(&mut self.0) };
+    }
+
     /// Move this cursor to the first child of its current node that extends beyond
     /// the given byte offset.
     ///
@@ -1291,11 +1427,7 @@ impl<'a> TreeCursor<'a> {
     pub fn goto_first_child_for_byte(&mut self, index: usize) -> Option<usize> {
         let result =
             unsafe { ffi::ts_tree_cursor_goto_first_child_for_byte(&mut self.0, index as u32) };
-        if result < 0 {
-            None
-        } else {
-            Some(result as usize)
-        }
+        (result >= 0).then_some(result as usize)
     }
 
     /// Move this cursor to the first child of its current node that extends beyond
@@ -1307,32 +1439,113 @@ impl<'a> TreeCursor<'a> {
     pub fn goto_first_child_for_point(&mut self, point: Point) -> Option<usize> {
         let result =
             unsafe { ffi::ts_tree_cursor_goto_first_child_for_point(&mut self.0, point.into()) };
-        if result < 0 {
-            None
-        } else {
-            Some(result as usize)
-        }
+        (result >= 0).then_some(result as usize)
     }
 
     /// Re-initialize this tree cursor to start at a different node.
     #[doc(alias = "ts_tree_cursor_reset")]
-    pub fn reset(&mut self, node: Node<'a>) {
+    pub fn reset(&mut self, node: Node<'cursor>) {
         unsafe { ffi::ts_tree_cursor_reset(&mut self.0, node.0) };
     }
+
+    /// Re-initialize a tree cursor to the same position as another cursor.
+    ///
+    /// Unlike [`reset`](TreeCursor::reset), this will not lose parent information and
+    /// allows reusing already created cursors.
+    #[doc(alias = "ts_tree_cursor_reset_to")]
+    pub fn reset_to(&mut self, cursor: TreeCursor<'cursor>) {
+        unsafe { ffi::ts_tree_cursor_reset_to(&mut self.0, &cursor.0) };
+    }
 }
 
-impl<'a> Clone for TreeCursor<'a> {
+impl Clone for TreeCursor<'_> {
     fn clone(&self) -> Self {
         TreeCursor(unsafe { ffi::ts_tree_cursor_copy(&self.0) }, PhantomData)
     }
 }
 
-impl<'a> Drop for TreeCursor<'a> {
+impl Drop for TreeCursor<'_> {
     fn drop(&mut self) {
         unsafe { ffi::ts_tree_cursor_delete(&mut self.0) }
     }
 }
 
+impl LookaheadIterator {
+    /// Get the current language of the lookahead iterator.
+    #[doc(alias = "ts_lookahead_iterator_language")]
+    pub fn language(&self) -> Language {
+        Language(unsafe { ffi::ts_lookahead_iterator_language(self.0.as_ptr()) })
+    }
+
+    /// Get the current symbol of the lookahead iterator.
+    #[doc(alias = "ts_lookahead_iterator_current_symbol")]
+    pub fn current_symbol(&self) -> u16 {
+        unsafe { ffi::ts_lookahead_iterator_current_symbol(self.0.as_ptr()) }
+    }
+
+    /// Get the current symbol name of the lookahead iterator.
+    #[doc(alias = "ts_lookahead_iterator_current_symbol_name")]
+    pub fn current_symbol_name(&self) -> &'static str {
+        unsafe {
+            CStr::from_ptr(ffi::ts_lookahead_iterator_current_symbol_name(
+                self.0.as_ptr(),
+            ))
+            .to_str()
+            .unwrap()
+        }
+    }
+
+    /// Reset the lookahead iterator.
+    ///
+    /// This returns `true` if the language was set successfully and `false`
+    /// otherwise.
+    #[doc(alias = "ts_lookahead_iterator_reset")]
+    pub fn reset(&mut self, language: Language, state: u16) -> bool {
+        unsafe { ffi::ts_lookahead_iterator_reset(self.0.as_ptr(), language.0, state) }
+    }
+
+    /// Reset the lookahead iterator to another state.
+    ///
+    /// This returns `true` if the iterator was reset to the given state and `false`
+    /// otherwise.
+    #[doc(alias = "ts_lookahead_iterator_reset_state")]
+    pub fn reset_state(&mut self, state: u16) -> bool {
+        unsafe { ffi::ts_lookahead_iterator_reset_state(self.0.as_ptr(), state) }
+    }
+
+    /// Iterate symbol names.
+    pub fn iter_names(&mut self) -> impl Iterator<Item = &'static str> + '_ {
+        LookaheadNamesIterator(self)
+    }
+}
+
+impl Iterator for LookaheadNamesIterator<'_> {
+    type Item = &'static str;
+
+    #[doc(alias = "ts_lookahead_iterator_next")]
+    fn next(&mut self) -> Option<Self::Item> {
+        unsafe { ffi::ts_lookahead_iterator_next(self.0 .0.as_ptr()) }
+            .then(|| self.0.current_symbol_name())
+    }
+}
+
+impl Iterator for LookaheadIterator {
+    type Item = u16;
+
+    #[doc(alias = "ts_lookahead_iterator_next")]
+    fn next(&mut self) -> Option<Self::Item> {
+        // the first symbol is always `0` so we can safely skip it
+        unsafe { ffi::ts_lookahead_iterator_next(self.0.as_ptr()) }.then(|| self.current_symbol())
+    }
+}
+
+impl Drop for LookaheadIterator {
+    #[doc(alias = "ts_lookahead_iterator_delete")]
+    fn drop(&mut self) {
+        unsafe { ffi::ts_lookahead_iterator_delete(self.0.as_ptr()) }
+    }
+}
+
 impl Query {
     /// Create a new query from a string containing one or more S-expression
     /// patterns.
@@ -1358,7 +1571,7 @@ impl Query {
 
         // On failure, build an error based on the error code and offset.
         if ptr.is_null() {
-            if error_type == ffi::TSQueryError_TSQueryErrorLanguage {
+            if error_type == ffi::TSQueryErrorLanguage {
                 return Err(QueryError {
                     row: 0,
                     column: 0,
@@ -1390,18 +1603,16 @@ impl Query {
             let message;
             match error_type {
                 // Error types that report names
-                ffi::TSQueryError_TSQueryErrorNodeType
-                | ffi::TSQueryError_TSQueryErrorField
-                | ffi::TSQueryError_TSQueryErrorCapture => {
+                ffi::TSQueryErrorNodeType | ffi::TSQueryErrorField | ffi::TSQueryErrorCapture => {
                     let suffix = source.split_at(offset).1;
                     let end_offset = suffix
                         .find(|c| !char::is_alphanumeric(c) && c != '_' && c != '-')
-                        .unwrap_or(source.len());
+                        .unwrap_or(suffix.len());
                     message = suffix.split_at(end_offset).0.to_string();
                     kind = match error_type {
-                        ffi::TSQueryError_TSQueryErrorNodeType => QueryErrorKind::NodeType,
-                        ffi::TSQueryError_TSQueryErrorField => QueryErrorKind::Field,
-                        ffi::TSQueryError_TSQueryErrorCapture => QueryErrorKind::Capture,
+                        ffi::TSQueryErrorNodeType => QueryErrorKind::NodeType,
+                        ffi::TSQueryErrorField => QueryErrorKind::Field,
+                        ffi::TSQueryErrorCapture => QueryErrorKind::Capture,
                         _ => unreachable!(),
                     };
                 }
@@ -1414,7 +1625,7 @@ impl Query {
                         "Unexpected EOF".to_string()
                     };
                     kind = match error_type {
-                        ffi::TSQueryError_TSQueryErrorStructure => QueryErrorKind::Structure,
+                        ffi::TSQueryErrorStructure => QueryErrorKind::Structure,
                         _ => QueryErrorKind::Syntax,
                     };
                 }
@@ -1429,28 +1640,41 @@ impl Query {
             });
         }
 
-        let string_count = unsafe { ffi::ts_query_string_count(ptr) };
-        let capture_count = unsafe { ffi::ts_query_capture_count(ptr) };
-        let pattern_count = unsafe { ffi::ts_query_pattern_count(ptr) as usize };
-        let mut result = Query {
-            ptr: unsafe { NonNull::new_unchecked(ptr) },
-            capture_names: Vec::with_capacity(capture_count as usize),
-            capture_quantifiers: Vec::with_capacity(pattern_count as usize),
-            text_predicates: Vec::with_capacity(pattern_count),
-            property_predicates: Vec::with_capacity(pattern_count),
-            property_settings: Vec::with_capacity(pattern_count),
-            general_predicates: Vec::with_capacity(pattern_count),
+        unsafe { Query::from_raw_parts(ptr, source) }
+    }
+
+    #[doc(hidden)]
+    unsafe fn from_raw_parts(ptr: *mut ffi::TSQuery, source: &str) -> Result<Self, QueryError> {
+        let ptr = {
+            struct TSQueryDrop(*mut ffi::TSQuery);
+            impl Drop for TSQueryDrop {
+                fn drop(&mut self) {
+                    unsafe { ffi::ts_query_delete(self.0) }
+                }
+            }
+            TSQueryDrop(ptr)
         };
 
+        let string_count = unsafe { ffi::ts_query_string_count(ptr.0) };
+        let capture_count = unsafe { ffi::ts_query_capture_count(ptr.0) };
+        let pattern_count = unsafe { ffi::ts_query_pattern_count(ptr.0) as usize };
+
+        let mut capture_names = Vec::with_capacity(capture_count as usize);
+        let mut capture_quantifiers_vec = Vec::with_capacity(pattern_count as usize);
+        let mut text_predicates_vec = Vec::with_capacity(pattern_count);
+        let mut property_predicates_vec = Vec::with_capacity(pattern_count);
+        let mut property_settings_vec = Vec::with_capacity(pattern_count);
+        let mut general_predicates_vec = Vec::with_capacity(pattern_count);
+
         // Build a vector of strings to store the capture names.
         for i in 0..capture_count {
             unsafe {
                 let mut length = 0u32;
-                let name =
-                    ffi::ts_query_capture_name_for_id(ptr, i, &mut length as *mut u32) as *const u8;
+                let name = ffi::ts_query_capture_name_for_id(ptr.0, i, &mut length as *mut u32)
+                    as *const u8;
                 let name = slice::from_raw_parts(name, length as usize);
                 let name = str::from_utf8_unchecked(name);
-                result.capture_names.push(name.to_string());
+                capture_names.push(name);
             }
         }
 
@@ -1459,11 +1683,11 @@ impl Query {
             let mut capture_quantifiers = Vec::with_capacity(capture_count as usize);
             for j in 0..capture_count {
                 unsafe {
-                    let quantifier = ffi::ts_query_capture_quantifier_for_id(ptr, i as u32, j);
+                    let quantifier = ffi::ts_query_capture_quantifier_for_id(ptr.0, i as u32, j);
                     capture_quantifiers.push(quantifier.into());
                 }
             }
-            result.capture_quantifiers.push(capture_quantifiers);
+            capture_quantifiers_vec.push(capture_quantifiers.into());
         }
 
         // Build a vector of strings to represent literal values used in predicates.
@@ -1471,11 +1695,11 @@ impl Query {
             .map(|i| unsafe {
                 let mut length = 0u32;
                 let value =
-                    ffi::ts_query_string_value_for_id(ptr, i as u32, &mut length as *mut u32)
+                    ffi::ts_query_string_value_for_id(ptr.0, i as u32, &mut length as *mut u32)
                         as *const u8;
                 let value = slice::from_raw_parts(value, length as usize);
                 let value = str::from_utf8_unchecked(value);
-                value.to_string()
+                value
             })
             .collect::<Vec<_>>();
 
@@ -1484,48 +1708,47 @@ impl Query {
             let predicate_steps = unsafe {
                 let mut length = 0u32;
                 let raw_predicates =
-                    ffi::ts_query_predicates_for_pattern(ptr, i as u32, &mut length as *mut u32);
-                if length > 0 {
-                    slice::from_raw_parts(raw_predicates, length as usize)
-                } else {
-                    &[]
-                }
+                    ffi::ts_query_predicates_for_pattern(ptr.0, i as u32, &mut length as *mut u32);
+                (length > 0)
+                    .then(|| slice::from_raw_parts(raw_predicates, length as usize))
+                    .unwrap_or_default()
             };
 
-            let byte_offset = unsafe { ffi::ts_query_start_byte_for_pattern(ptr, i as u32) };
+            let byte_offset = unsafe { ffi::ts_query_start_byte_for_pattern(ptr.0, i as u32) };
             let row = source
                 .char_indices()
                 .take_while(|(i, _)| *i < byte_offset as usize)
                 .filter(|(_, c)| *c == '\n')
                 .count();
 
-            let type_done = ffi::TSQueryPredicateStepType_TSQueryPredicateStepTypeDone;
-            let type_capture = ffi::TSQueryPredicateStepType_TSQueryPredicateStepTypeCapture;
-            let type_string = ffi::TSQueryPredicateStepType_TSQueryPredicateStepTypeString;
+            use ffi::TSQueryPredicateStepType as T;
+            const TYPE_DONE: T = ffi::TSQueryPredicateStepTypeDone;
+            const TYPE_CAPTURE: T = ffi::TSQueryPredicateStepTypeCapture;
+            const TYPE_STRING: T = ffi::TSQueryPredicateStepTypeString;
 
             let mut text_predicates = Vec::new();
             let mut property_predicates = Vec::new();
             let mut property_settings = Vec::new();
             let mut general_predicates = Vec::new();
-            for p in predicate_steps.split(|s| s.type_ == type_done) {
+            for p in predicate_steps.split(|s| s.type_ == TYPE_DONE) {
                 if p.is_empty() {
                     continue;
                 }
 
-                if p[0].type_ != type_string {
+                if p[0].type_ != TYPE_STRING {
                     return Err(predicate_error(
                         row,
                         format!(
                             "Expected predicate to start with a function name. Got @{}.",
-                            result.capture_names[p[0].value_id as usize],
+                            capture_names[p[0].value_id as usize],
                         ),
                     ));
                 }
 
                 // Build a predicate for each of the known predicate function names.
-                let operator_name = &string_values[p[0].value_id as usize];
-                match operator_name.as_str() {
-                    "eq?" | "not-eq?" => {
+                let operator_name = string_values[p[0].value_id as usize];
+                match operator_name {
+                    "eq?" | "not-eq?" | "any-eq?" | "any-not-eq?" => {
                         if p.len() != 3 {
                             return Err(predicate_error(
                                 row,
@@ -1535,64 +1758,78 @@ impl Query {
                             ),
                             ));
                         }
-                        if p[1].type_ != type_capture {
+                        if p[1].type_ != TYPE_CAPTURE {
                             return Err(predicate_error(row, format!(
                                 "First argument to #eq? predicate must be a capture name. Got literal \"{}\".",
                                 string_values[p[1].value_id as usize],
                             )));
                         }
 
-                        let is_positive = operator_name == "eq?";
-                        text_predicates.push(if p[2].type_ == type_capture {
-                            TextPredicate::CaptureEqCapture(
+                        let is_positive = operator_name == "eq?" || operator_name == "any-eq?";
+                        let match_all = match operator_name {
+                            "eq?" | "not-eq?" => true,
+                            "any-eq?" | "any-not-eq?" => false,
+                            _ => unreachable!(),
+                        };
+                        text_predicates.push(if p[2].type_ == TYPE_CAPTURE {
+                            TextPredicateCapture::EqCapture(
                                 p[1].value_id,
                                 p[2].value_id,
                                 is_positive,
+                                match_all,
                             )
                         } else {
-                            TextPredicate::CaptureEqString(
+                            TextPredicateCapture::EqString(
                                 p[1].value_id,
-                                string_values[p[2].value_id as usize].clone(),
+                                string_values[p[2].value_id as usize].to_string().into(),
                                 is_positive,
+                                match_all,
                             )
                         });
                     }
 
-                    "match?" | "not-match?" => {
+                    "match?" | "not-match?" | "any-match?" | "any-not-match?" => {
                         if p.len() != 3 {
                             return Err(predicate_error(row, format!(
                                 "Wrong number of arguments to #match? predicate. Expected 2, got {}.",
                                 p.len() - 1
                             )));
                         }
-                        if p[1].type_ != type_capture {
+                        if p[1].type_ != TYPE_CAPTURE {
                             return Err(predicate_error(row, format!(
                                 "First argument to #match? predicate must be a capture name. Got literal \"{}\".",
                                 string_values[p[1].value_id as usize],
                             )));
                         }
-                        if p[2].type_ == type_capture {
+                        if p[2].type_ == TYPE_CAPTURE {
                             return Err(predicate_error(row, format!(
                                 "Second argument to #match? predicate must be a literal. Got capture @{}.",
-                                result.capture_names[p[2].value_id as usize],
+                                capture_names[p[2].value_id as usize],
                             )));
                         }
 
-                        let is_positive = operator_name == "match?";
+                        let is_positive =
+                            operator_name == "match?" || operator_name == "any-match?";
+                        let match_all = match operator_name {
+                            "match?" | "not-match?" => true,
+                            "any-match?" | "any-not-match?" => false,
+                            _ => unreachable!(),
+                        };
                         let regex = &string_values[p[2].value_id as usize];
-                        text_predicates.push(TextPredicate::CaptureMatchString(
+                        text_predicates.push(TextPredicateCapture::MatchString(
                             p[1].value_id,
                             regex::bytes::Regex::new(regex).map_err(|_| {
                                 predicate_error(row, format!("Invalid regex '{}'", regex))
                             })?,
                             is_positive,
+                            match_all,
                         ));
                     }
 
                     "set!" => property_settings.push(Self::parse_property(
                         row,
                         &operator_name,
-                        &result.capture_names,
+                        &capture_names,
                         &string_values,
                         &p[1..],
                     )?),
@@ -1601,23 +1838,59 @@ impl Query {
                         Self::parse_property(
                             row,
                             &operator_name,
-                            &result.capture_names,
+                            &capture_names,
                             &string_values,
                             &p[1..],
                         )?,
                         operator_name == "is?",
                     )),
 
+                    "any-of?" | "not-any-of?" => {
+                        if p.len() < 2 {
+                            return Err(predicate_error(row, format!(
+                                "Wrong number of arguments to #any-of? predicate. Expected at least 1, got {}.",
+                                p.len() - 1
+                            )));
+                        }
+                        if p[1].type_ != TYPE_CAPTURE {
+                            return Err(predicate_error(row, format!(
+                                "First argument to #any-of? predicate must be a capture name. Got literal \"{}\".",
+                                string_values[p[1].value_id as usize],
+                            )));
+                        }
+
+                        let is_positive = operator_name == "any-of?";
+                        let mut values = Vec::new();
+                        for arg in &p[2..] {
+                            if arg.type_ == TYPE_CAPTURE {
+                                return Err(predicate_error(row, format!(
+                                    "Arguments to #any-of? predicate must be literals. Got capture @{}.",
+                                    capture_names[arg.value_id as usize],
+                                )));
+                            }
+                            values.push(string_values[arg.value_id as usize]);
+                        }
+                        text_predicates.push(TextPredicateCapture::AnyString(
+                            p[1].value_id,
+                            values
+                                .iter()
+                                .map(|x| x.to_string().into())
+                                .collect::<Vec<_>>()
+                                .into(),
+                            is_positive,
+                        ));
+                    }
+
                     _ => general_predicates.push(QueryPredicate {
-                        operator: operator_name.clone().into_boxed_str(),
+                        operator: operator_name.to_string().into(),
                         args: p[1..]
                             .iter()
                             .map(|a| {
-                                if a.type_ == type_capture {
+                                if a.type_ == TYPE_CAPTURE {
                                     QueryPredicateArg::Capture(a.value_id)
                                 } else {
                                     QueryPredicateArg::String(
-                                        string_values[a.value_id as usize].clone().into_boxed_str(),
+                                        string_values[a.value_id as usize].to_string().into(),
                                     )
                                 }
                             })
@@ -1626,19 +1899,24 @@ impl Query {
                 }
             }
 
-            result
-                .text_predicates
-                .push(text_predicates.into_boxed_slice());
-            result
-                .property_predicates
-                .push(property_predicates.into_boxed_slice());
-            result
-                .property_settings
-                .push(property_settings.into_boxed_slice());
-            result
-                .general_predicates
-                .push(general_predicates.into_boxed_slice());
+            text_predicates_vec.push(text_predicates.into());
+            property_predicates_vec.push(property_predicates.into());
+            property_settings_vec.push(property_settings.into());
+            general_predicates_vec.push(general_predicates.into());
         }
+
+        let result = Query {
+            ptr: unsafe { NonNull::new_unchecked(ptr.0) },
+            capture_names: capture_names.into(),
+            capture_quantifiers: capture_quantifiers_vec.into(),
+            text_predicates: text_predicates_vec.into(),
+            property_predicates: property_predicates_vec.into(),
+            property_settings: property_settings_vec.into(),
+            general_predicates: general_predicates_vec.into(),
+        };
+
+        std::mem::forget(ptr);
+
         Ok(result)
     }
 
@@ -1664,7 +1942,7 @@ impl Query {
     }
 
     /// Get the names of the captures used in the query.
-    pub fn capture_names(&self) -> &[String] {
+    pub fn capture_names(&self) -> &[&str] {
         &self.capture_names
     }
 
@@ -1677,7 +1955,7 @@ impl Query {
     pub fn capture_index_for_name(&self, name: &str) -> Option<u32> {
         self.capture_names
             .iter()
-            .position(|n| n == name)
+            .position(|n| *n == name)
             .map(|ix| ix as u32)
     }
 
@@ -1731,11 +2009,17 @@ impl Query {
     }
 
     /// Check if a given pattern within a query has a single root node.
-    #[doc(alias = "ts_query_is_pattern_guaranteed_at_step")]
+    #[doc(alias = "ts_query_is_pattern_rooted")]
     pub fn is_pattern_rooted(&self, index: usize) -> bool {
         unsafe { ffi::ts_query_is_pattern_rooted(self.ptr.as_ptr(), index as u32) }
     }
 
+    /// Check if a given pattern within a query has a single root node.
+    #[doc(alias = "ts_query_is_pattern_non_local")]
+    pub fn is_pattern_non_local(&self, index: usize) -> bool {
+        unsafe { ffi::ts_query_is_pattern_non_local(self.ptr.as_ptr(), index as u32) }
+    }
+
     /// Check if a given step in a query is 'definite'.
     ///
     /// A query step is 'definite' if its parent pattern will be guaranteed to match
@@ -1750,8 +2034,8 @@ impl Query {
     fn parse_property(
         row: usize,
         function_name: &str,
-        capture_names: &[String],
-        string_values: &[String],
+        capture_names: &[&str],
+        string_values: &[&str],
         args: &[ffi::TSQueryPredicateStep],
     ) -> Result<QueryProperty, QueryError> {
         if args.len() == 0 || args.len() > 3 {
@@ -1770,7 +2054,7 @@ impl Query {
         let mut value = None;
 
         for arg in args {
-            if arg.type_ == ffi::TSQueryPredicateStepType_TSQueryPredicateStepTypeCapture {
+            if arg.type_ == ffi::TSQueryPredicateStepTypeCapture {
                 if capture_id.is_some() {
                     return Err(predicate_error(
                         row,
@@ -1784,7 +2068,7 @@ impl Query {
             } else if key.is_none() {
                 key = Some(&string_values[arg.value_id as usize]);
             } else if value.is_none() {
-                value = Some(string_values[arg.value_id as usize].as_str());
+                value = Some(string_values[arg.value_id as usize]);
             } else {
                 return Err(predicate_error(
                     row,
@@ -1849,12 +2133,12 @@ impl QueryCursor {
     /// Because multiple patterns can match the same set of nodes, one match may contain
     /// captures that appear *before* some of the captures from a previous match.
     #[doc(alias = "ts_query_cursor_exec")]
-    pub fn matches<'a, 'tree: 'a, T: TextProvider<'a> + 'a>(
-        &'a mut self,
-        query: &'a Query,
+    pub fn matches<'query, 'tree, T: TextProvider<I>, I: AsRef<[u8]>>(
+        &mut self,
+        query: &'query Query,
         node: Node<'tree>,
         text_provider: T,
-    ) -> QueryMatches<'a, 'tree, T> {
+    ) -> QueryMatches<'query, 'tree, T, I> {
         let ptr = self.ptr.as_ptr();
         unsafe { ffi::ts_query_cursor_exec(ptr, query.ptr.as_ptr(), node.0) };
         QueryMatches {
@@ -1863,7 +2147,7 @@ impl QueryCursor {
             text_provider,
             buffer1: Default::default(),
             buffer2: Default::default(),
-            _tree: PhantomData,
+            _phantom: PhantomData,
         }
     }
 
@@ -1872,21 +2156,21 @@ impl QueryCursor {
     /// This is useful if you don't care about which pattern matched, and just want a single,
     /// ordered sequence of captures.
     #[doc(alias = "ts_query_cursor_exec")]
-    pub fn captures<'a, 'tree: 'a, T: TextProvider<'a> + 'a>(
-        &'a mut self,
-        query: &'a Query,
+    pub fn captures<'query, 'tree, T: TextProvider<I>, I: AsRef<[u8]>>(
+        &mut self,
+        query: &'query Query,
         node: Node<'tree>,
         text_provider: T,
-    ) -> QueryCaptures<'a, 'tree, T> {
+    ) -> QueryCaptures<'query, 'tree, T, I> {
         let ptr = self.ptr.as_ptr();
-        unsafe { ffi::ts_query_cursor_exec(self.ptr.as_ptr(), query.ptr.as_ptr(), node.0) };
+        unsafe { ffi::ts_query_cursor_exec(ptr, query.ptr.as_ptr(), node.0) };
         QueryCaptures {
             ptr,
             query,
             text_provider,
             buffer1: Default::default(),
             buffer2: Default::default(),
-            _tree: PhantomData,
+            _phantom: PhantomData,
         }
     }
 
@@ -1915,9 +2199,32 @@ impl QueryCursor {
         }
         self
     }
+
+    /// Set the maximum start depth for a query cursor.
+    ///
+    /// This prevents cursors from exploring children nodes at a certain depth.
+    /// Note if a pattern includes many children, then they will still be checked.
+    ///
+    /// The zero max start depth value can be used as a special behavior and
+    /// it helps to destructure a subtree by staying on a node and using captures
+    /// for interested parts. Note that the zero max start depth only limit a search
+    /// depth for a pattern's root node but other nodes that are parts of the pattern
+    /// may be searched at any depth what defined by the pattern structure.
+    ///
+    /// Set to `None` to remove the maximum start depth.
+    #[doc(alias = "ts_query_cursor_set_max_start_depth")]
+    pub fn set_max_start_depth(&mut self, max_start_depth: Option<u32>) -> &mut Self {
+        unsafe {
+            ffi::ts_query_cursor_set_max_start_depth(
+                self.ptr.as_ptr(),
+                max_start_depth.unwrap_or(u32::MAX),
+            );
+        }
+        self
+    }
 }
 
-impl<'a, 'tree> QueryMatch<'a, 'tree> {
+impl<'tree> QueryMatch<'_, 'tree> {
     pub fn id(&self) -> u32 {
         self.id
     }
@@ -1931,13 +2238,9 @@ impl<'a, 'tree> QueryMatch<'a, 'tree> {
         &self,
         capture_ix: u32,
     ) -> impl Iterator<Item = Node<'tree>> + '_ {
-        self.captures.iter().filter_map(move |capture| {
-            if capture.index == capture_ix {
-                Some(capture.node)
-            } else {
-                None
-            }
-        })
+        self.captures
+            .iter()
+            .filter_map(move |capture| (capture.index == capture_ix).then_some(capture.node))
     }
 
     fn new(m: ffi::TSQueryMatch, cursor: *mut ffi::TSQueryCursor) -> Self {
@@ -1945,78 +2248,116 @@ impl<'a, 'tree> QueryMatch<'a, 'tree> {
             cursor,
             id: m.id,
             pattern_index: m.pattern_index as usize,
-            captures: if m.capture_count > 0 {
-                unsafe {
+            captures: (m.capture_count > 0)
+                .then(|| unsafe {
                     slice::from_raw_parts(
                         m.captures as *const QueryCapture<'tree>,
                         m.capture_count as usize,
                     )
-                }
-            } else {
-                &[]
-            },
+                })
+                .unwrap_or_default(),
         }
     }
 
-    fn satisfies_text_predicates(
+    fn satisfies_text_predicates<I: AsRef<[u8]>>(
         &self,
         query: &Query,
         buffer1: &mut Vec<u8>,
         buffer2: &mut Vec<u8>,
-        text_provider: &mut impl TextProvider<'a>,
+        text_provider: &mut impl TextProvider<I>,
     ) -> bool {
-        fn get_text<'a, 'b: 'a, I: Iterator<Item = &'b [u8]>>(
+        struct NodeText<'a, T> {
             buffer: &'a mut Vec<u8>,
-            mut chunks: I,
-        ) -> &'a [u8] {
-            let first_chunk = chunks.next().unwrap_or(&[]);
-            if let Some(next_chunk) = chunks.next() {
-                buffer.clear();
-                buffer.extend_from_slice(first_chunk);
-                buffer.extend_from_slice(next_chunk);
-                for chunk in chunks {
-                    buffer.extend_from_slice(chunk);
+            first_chunk: Option<T>,
+        }
+        impl<'a, T: AsRef<[u8]>> NodeText<'a, T> {
+            fn new(buffer: &'a mut Vec<u8>) -> Self {
+                Self {
+                    buffer,
+                    first_chunk: None,
+                }
+            }
+
+            fn get_text(&mut self, chunks: &mut impl Iterator<Item = T>) -> &[u8] {
+                self.first_chunk = chunks.next();
+                if let Some(next_chunk) = chunks.next() {
+                    self.buffer.clear();
+                    self.buffer
+                        .extend_from_slice(self.first_chunk.as_ref().unwrap().as_ref());
+                    self.buffer.extend_from_slice(next_chunk.as_ref());
+                    for chunk in chunks {
+                        self.buffer.extend_from_slice(chunk.as_ref());
+                    }
+                    self.buffer.as_slice()
+                } else if let Some(ref first_chunk) = self.first_chunk {
+                    first_chunk.as_ref()
+                } else {
+                    Default::default()
                 }
-                buffer.as_slice()
-            } else {
-                first_chunk
             }
         }
 
+        let mut node_text1 = NodeText::new(buffer1);
+        let mut node_text2 = NodeText::new(buffer2);
+
         query.text_predicates[self.pattern_index]
             .iter()
             .all(|predicate| match predicate {
-                TextPredicate::CaptureEqCapture(i, j, is_positive) => {
-                    let node1 = self.nodes_for_capture_index(*i).next();
-                    let node2 = self.nodes_for_capture_index(*j).next();
-                    match (node1, node2) {
-                        (Some(node1), Some(node2)) => {
-                            let text1 = get_text(buffer1, text_provider.text(node1));
-                            let text2 = get_text(buffer2, text_provider.text(node2));
-                            (text1 == text2) == *is_positive
+                TextPredicateCapture::EqCapture(i, j, is_positive, match_all_nodes) => {
+                    let mut nodes_1 = self.nodes_for_capture_index(*i);
+                    let mut nodes_2 = self.nodes_for_capture_index(*j);
+                    while let (Some(node1), Some(node2)) = (nodes_1.next(), nodes_2.next()) {
+                        let mut text1 = text_provider.text(node1);
+                        let mut text2 = text_provider.text(node2);
+                        let text1 = node_text1.get_text(&mut text1);
+                        let text2 = node_text2.get_text(&mut text2);
+                        if (text1 == text2) != *is_positive && *match_all_nodes {
+                            return false;
+                        }
+                        if (text1 == text2) == *is_positive && !*match_all_nodes {
+                            return true;
                         }
-                        _ => true,
                     }
+                    nodes_1.next().is_none() && nodes_2.next().is_none()
                 }
-                TextPredicate::CaptureEqString(i, s, is_positive) => {
-                    let node = self.nodes_for_capture_index(*i).next();
-                    match node {
-                        Some(node) => {
-                            let text = get_text(buffer1, text_provider.text(node));
-                            (text == s.as_bytes()) == *is_positive
+                TextPredicateCapture::EqString(i, s, is_positive, match_all_nodes) => {
+                    let nodes = self.nodes_for_capture_index(*i);
+                    for node in nodes {
+                        let mut text = text_provider.text(node);
+                        let text = node_text1.get_text(&mut text);
+                        if (text == s.as_bytes()) != *is_positive && *match_all_nodes {
+                            return false;
+                        }
+                        if (text == s.as_bytes()) == *is_positive && !*match_all_nodes {
+                            return true;
                         }
-                        None => true,
                     }
+                    true
                 }
-                TextPredicate::CaptureMatchString(i, r, is_positive) => {
-                    let node = self.nodes_for_capture_index(*i).next();
-                    match node {
-                        Some(node) => {
-                            let text = get_text(buffer1, text_provider.text(node));
-                            r.is_match(text) == *is_positive
+                TextPredicateCapture::MatchString(i, r, is_positive, match_all_nodes) => {
+                    let nodes = self.nodes_for_capture_index(*i);
+                    for node in nodes {
+                        let mut text = text_provider.text(node);
+                        let text = node_text1.get_text(&mut text);
+                        if (r.is_match(text)) != *is_positive && *match_all_nodes {
+                            return false;
+                        }
+                        if (r.is_match(text)) == *is_positive && !*match_all_nodes {
+                            return true;
                         }
-                        None => true,
                     }
+                    true
+                }
+                TextPredicateCapture::AnyString(i, v, is_positive) => {
+                    let nodes = self.nodes_for_capture_index(*i);
+                    for node in nodes {
+                        let mut text = text_provider.text(node);
+                        let text = node_text1.get_text(&mut text);
+                        if (v.iter().any(|s| text == s.as_bytes())) != *is_positive {
+                            return false;
+                        }
+                    }
+                    true
                 }
             })
     }
@@ -2026,14 +2367,16 @@ impl QueryProperty {
     pub fn new(key: &str, value: Option<&str>, capture_id: Option<usize>) -> Self {
         QueryProperty {
             capture_id,
-            key: key.to_string().into_boxed_str(),
-            value: value.map(|s| s.to_string().into_boxed_str()),
+            key: key.to_string().into(),
+            value: value.map(|s| s.to_string().into()),
         }
     }
 }
 
-impl<'a, 'tree, T: TextProvider<'a>> Iterator for QueryMatches<'a, 'tree, T> {
-    type Item = QueryMatch<'a, 'tree>;
+impl<'query, 'tree: 'query, T: TextProvider<I>, I: AsRef<[u8]>> Iterator
+    for QueryMatches<'query, 'tree, T, I>
+{
+    type Item = QueryMatch<'query, 'tree>;
 
     fn next(&mut self) -> Option<Self::Item> {
         unsafe {
@@ -2057,8 +2400,10 @@ impl<'a, 'tree, T: TextProvider<'a>> Iterator for QueryMatches<'a, 'tree, T> {
     }
 }
 
-impl<'a, 'tree, T: TextProvider<'a>> Iterator for QueryCaptures<'a, 'tree, T> {
-    type Item = (QueryMatch<'a, 'tree>, usize);
+impl<'query, 'tree: 'query, T: TextProvider<I>, I: AsRef<[u8]>> Iterator
+    for QueryCaptures<'query, 'tree, T, I>
+{
+    type Item = (QueryMatch<'query, 'tree>, usize);
 
     fn next(&mut self) -> Option<Self::Item> {
         unsafe {
@@ -2089,7 +2434,7 @@ impl<'a, 'tree, T: TextProvider<'a>> Iterator for QueryCaptures<'a, 'tree, T> {
     }
 }
 
-impl<'a, 'tree, T: TextProvider<'a>> QueryMatches<'a, 'tree, T> {
+impl<T: TextProvider<I>, I: AsRef<[u8]>> QueryMatches<'_, '_, T, I> {
     #[doc(alias = "ts_query_cursor_set_byte_range")]
     pub fn set_byte_range(&mut self, range: ops::Range<usize>) {
         unsafe {
@@ -2105,7 +2450,7 @@ impl<'a, 'tree, T: TextProvider<'a>> QueryMatches<'a, 'tree, T> {
     }
 }
 
-impl<'a, 'tree, T: TextProvider<'a>> QueryCaptures<'a, 'tree, T> {
+impl<T: TextProvider<I>, I: AsRef<[u8]>> QueryCaptures<'_, '_, T, I> {
     #[doc(alias = "ts_query_cursor_set_byte_range")]
     pub fn set_byte_range(&mut self, range: ops::Range<usize>) {
         unsafe {
@@ -2121,7 +2466,7 @@ impl<'a, 'tree, T: TextProvider<'a>> QueryCaptures<'a, 'tree, T> {
     }
 }
 
-impl<'cursor, 'tree> fmt::Debug for QueryMatch<'cursor, 'tree> {
+impl fmt::Debug for QueryMatch<'_, '_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
@@ -2131,19 +2476,20 @@ impl<'cursor, 'tree> fmt::Debug for QueryMatch<'cursor, 'tree> {
     }
 }
 
-impl<'a, F, I> TextProvider<'a> for F
+impl<F, R, I> TextProvider<I> for F
 where
-    F: FnMut(Node) -> I,
-    I: Iterator<Item = &'a [u8]> + 'a,
+    F: FnMut(Node) -> R,
+    R: Iterator<Item = I>,
+    I: AsRef<[u8]>,
 {
-    type I = I;
+    type I = R;
 
     fn text(&mut self, node: Node) -> Self::I {
         (self)(node)
     }
 }
 
-impl<'a> TextProvider<'a> for &'a [u8] {
+impl<'a> TextProvider<&'a [u8]> for &'a [u8] {
     type I = iter::Once<&'a [u8]>;
 
     fn text(&mut self, node: Node) -> Self::I {
@@ -2221,7 +2567,7 @@ impl From<ffi::TSRange> for Range {
     }
 }
 
-impl<'a> Into<ffi::TSInputEdit> for &'a InputEdit {
+impl Into<ffi::TSInputEdit> for &'_ InputEdit {
     fn into(self) -> ffi::TSInputEdit {
         ffi::TSInputEdit {
             start_byte: self.start_byte as u32,
@@ -2256,7 +2602,7 @@ impl<'a> Iterator for LossyUtf8<'a> {
         }
         match std::str::from_utf8(self.bytes) {
             Ok(valid) => {
-                self.bytes = &[];
+                self.bytes = Default::default();
                 Some(valid)
             }
             Err(error) => {
@@ -2354,12 +2700,28 @@ impl error::Error for LanguageError {}
 impl error::Error for QueryError {}
 
 unsafe impl Send for Language {}
-unsafe impl Send for Parser {}
-unsafe impl Send for Query {}
-unsafe impl Send for QueryCursor {}
-unsafe impl Send for Tree {}
 unsafe impl Sync for Language {}
+
+unsafe impl Send for Node<'_> {}
+unsafe impl Sync for Node<'_> {}
+
+unsafe impl Send for LookaheadIterator {}
+unsafe impl Sync for LookaheadIterator {}
+
+unsafe impl Send for LookaheadNamesIterator<'_> {}
+unsafe impl Sync for LookaheadNamesIterator<'_> {}
+
+unsafe impl Send for Parser {}
 unsafe impl Sync for Parser {}
+
+unsafe impl Send for Query {}
 unsafe impl Sync for Query {}
+
+unsafe impl Send for QueryCursor {}
 unsafe impl Sync for QueryCursor {}
+
+unsafe impl Send for Tree {}
 unsafe impl Sync for Tree {}
+
+unsafe impl Send for TreeCursor<'_> {}
+unsafe impl Sync for TreeCursor<'_> {}
diff --git a/lib/binding_rust/util.rs b/lib/binding_rust/util.rs
index 5eda71f4..d5a73437 100644
--- a/lib/binding_rust/util.rs
+++ b/lib/binding_rust/util.rs
@@ -37,6 +37,8 @@ impl<T: Copy> ExactSizeIterator for CBufferIter<T> {}
 
 impl<T> Drop for CBufferIter<T> {
     fn drop(&mut self) {
-        unsafe { (FREE_FN)(self.ptr as *mut c_void) };
+        if !self.ptr.is_null() {
+            unsafe { (FREE_FN)(self.ptr as *mut c_void) };
+        }
     }
 }
diff --git a/lib/binding_web/README.md b/lib/binding_web/README.md
index 0c0f5246..bfddd9ef 100644
--- a/lib/binding_web/README.md
+++ b/lib/binding_web/README.md
@@ -1,16 +1,18 @@
-Web Tree-sitter
-===============
+# Web Tree-sitter
 
-[![Build Status](https://travis-ci.org/tree-sitter/tree-sitter.svg?branch=master)](https://travis-ci.org/tree-sitter/tree-sitter)
+[![npmjs.com badge]][npmjs.com]
+
+[npmjs.com]: https://www.npmjs.org/package/web-tree-sitter
+[npmjs.com badge]: https://img.shields.io/npm/v/web-tree-sitter.svg?color=%23BF4A4A
 
 WebAssembly bindings to the [Tree-sitter](https://github.com/tree-sitter/tree-sitter) parsing library.
 
 ### Setup
 
-You can download the the `tree-sitter.js` and `tree-sitter.wasm` files from [the latest GitHub release](https://github.com/tree-sitter/tree-sitter/releases/latest) and load them using a standalone script:
+You can download the `tree-sitter.js` and `tree-sitter.wasm` files from [the latest GitHub release](https://github.com/tree-sitter/tree-sitter/releases/latest) and load them using a standalone script:
 
 ```html
-<script src="/the/path/to/tree-sitter.js"/>
+<script src="/the/path/to/tree-sitter.js"></script>
 
 <script>
   const Parser = window.TreeSitter;
@@ -118,7 +120,7 @@ First install `tree-sitter-cli` and the tree-sitter language for which to genera
 npm install --save-dev tree-sitter-cli tree-sitter-javascript
 ```
 
-Then just use tree-sitter cli tool to generate the `.wasm`. 
+Then just use tree-sitter cli tool to generate the `.wasm`.
 
 ```sh
 npx tree-sitter build-wasm node_modules/tree-sitter-javascript
@@ -149,13 +151,13 @@ const Parser = require('web-tree-sitter');
 
 ##### Loading the .wasm file
 
-`web-tree-sitter` needs to load the `tree-sitter.wasm` file. By default, it assumes that this file is available in the 
+`web-tree-sitter` needs to load the `tree-sitter.wasm` file. By default, it assumes that this file is available in the
 same path as the JavaScript code. Therefore, if the code is being served from `http://localhost:3000/bundle.js`, then
 the wasm file should be at `http://localhost:3000/tree-sitter.wasm`.
 
-For server side frameworks like NextJS, this can be tricky as pages are often served from a path such as 
+For server side frameworks like NextJS, this can be tricky as pages are often served from a path such as
 `http://localhost:3000/_next/static/chunks/pages/index.js`. The loader will therefore look for the wasm file at
-`http://localhost:3000/_next/static/chunks/pages/tree-sitter.wasm`. The solution is to pass a `locateFile` function in 
+`http://localhost:3000/_next/static/chunks/pages/tree-sitter.wasm`. The solution is to pass a `locateFile` function in
 the `moduleOptions` argument to `Parser.init()`:
 
 ```javascript
@@ -166,15 +168,15 @@ await Parser.init({
 });
 ```
 
-`locateFile` takes in two parameters, `scriptName`, i.e. the wasm file name, and `scriptDirectory`, i.e. the directory 
+`locateFile` takes in two parameters, `scriptName`, i.e. the wasm file name, and `scriptDirectory`, i.e. the directory
 where the loader expects the script to be. It returns the path where the loader will look for the wasm file. In the NextJS
 case, we want to return just the `scriptName` so that the loader will look at `http://localhost:3000/tree-sitter.wasm`
 and not `http://localhost:3000/_next/static/chunks/pages/tree-sitter.wasm`.
 
 ##### `Can't resolve 'fs' in 'node_modules/web-tree-sitter'`
 
-Most bundlers will notice that the `tree-sitter.js` file is attempting to import `fs`, i.e. node's file system library. 
-Since this doesn't exist in the browser, the bundlers will get confused. For webpack you can fix this by adding the 
+Most bundlers will notice that the `tree-sitter.js` file is attempting to import `fs`, i.e. node's file system library.
+Since this doesn't exist in the browser, the bundlers will get confused. For webpack you can fix this by adding the
 following to your webpack config:
 
 ```javascript
diff --git a/lib/binding_web/binding.c b/lib/binding_web/binding.c
index 27292911..4be22a7e 100644
--- a/lib/binding_web/binding.c
+++ b/lib/binding_web/binding.c
@@ -243,6 +243,13 @@ void ts_tree_cursor_reset_wasm(const TSTree *tree) {
   marshal_cursor(&cursor);
 }
 
+void ts_tree_cursor_reset_to_wasm(const TSTree *_dst, const TSTree *_src) {
+  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, _dst);
+  TSTreeCursor src = unmarshal_cursor(&TRANSFER_BUFFER[3], _src);
+  ts_tree_cursor_reset_to(&cursor, &src);
+  marshal_cursor(&cursor);
+}
+
 bool ts_tree_cursor_goto_first_child_wasm(const TSTree *tree) {
   TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
   bool result = ts_tree_cursor_goto_first_child(&cursor);
@@ -250,6 +257,13 @@ bool ts_tree_cursor_goto_first_child_wasm(const TSTree *tree) {
   return result;
 }
 
+bool ts_tree_cursor_goto_last_child_wasm(const TSTree *tree) {
+  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
+  bool result = ts_tree_cursor_goto_last_child(&cursor);
+  marshal_cursor(&cursor);
+  return result;
+}
+
 bool ts_tree_cursor_goto_next_sibling_wasm(const TSTree *tree) {
   TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
   bool result = ts_tree_cursor_goto_next_sibling(&cursor);
@@ -257,6 +271,13 @@ bool ts_tree_cursor_goto_next_sibling_wasm(const TSTree *tree) {
   return result;
 }
 
+bool ts_tree_cursor_goto_previous_sibling_wasm(const TSTree *tree) {
+  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
+  bool result = ts_tree_cursor_goto_previous_sibling(&cursor);
+  marshal_cursor(&cursor);
+  return result;
+}
+
 bool ts_tree_cursor_goto_parent_wasm(const TSTree *tree) {
   TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
   bool result = ts_tree_cursor_goto_parent(&cursor);
@@ -270,6 +291,12 @@ uint16_t ts_tree_cursor_current_node_type_id_wasm(const TSTree *tree) {
   return ts_node_symbol(node);
 }
 
+uint16_t ts_tree_cursor_current_node_state_id_wasm(const TSTree *tree) {
+  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
+  TSNode node = ts_tree_cursor_current_node(&cursor);
+  return ts_node_parse_state(node);
+}
+
 bool ts_tree_cursor_current_node_is_named_wasm(const TSTree *tree) {
   TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
   TSNode node = ts_tree_cursor_current_node(&cursor);
@@ -334,6 +361,16 @@ uint16_t ts_node_symbol_wasm(const TSTree *tree) {
   return ts_node_symbol(node);
 }
 
+const char *ts_node_field_name_for_child_wasm(const TSTree *tree, uint32_t index) {
+  TSNode node = unmarshal_node(tree);
+  return ts_node_field_name_for_child(node, index);
+}
+
+uint16_t ts_node_grammar_symbol_wasm(const TSTree *tree) {
+  TSNode node = unmarshal_node(tree);
+  return ts_node_grammar_symbol(node);
+}
+
 uint32_t ts_node_child_count_wasm(const TSTree *tree) {
   TSNode node = unmarshal_node(tree);
   return ts_node_child_count(node);
@@ -579,11 +616,26 @@ int ts_node_has_error_wasm(const TSTree *tree) {
   return ts_node_has_error(node);
 }
 
+int ts_node_is_error_wasm(const TSTree *tree) {
+  TSNode node = unmarshal_node(tree);
+  return ts_node_is_error(node);
+}
+
 int ts_node_is_missing_wasm(const TSTree *tree) {
   TSNode node = unmarshal_node(tree);
   return ts_node_is_missing(node);
 }
 
+uint16_t ts_node_parse_state_wasm(const TSTree *tree) {
+  TSNode node = unmarshal_node(tree);
+  return ts_node_parse_state(node);
+}
+
+uint16_t ts_node_next_parse_state_wasm(const TSTree *tree) {
+  TSNode node = unmarshal_node(tree);
+  return ts_node_next_parse_state(node);
+}
+
 /******************/
 /* Section - Query */
 /******************/
diff --git a/lib/binding_web/binding.js b/lib/binding_web/binding.js
index bc5885a0..9d548d32 100644
--- a/lib/binding_web/binding.js
+++ b/lib/binding_web/binding.js
@@ -1,6 +1,7 @@
 const C = Module;
 const INTERNAL = {};
 const SIZE_OF_INT = 4;
+const SIZE_OF_CURSOR = 3 * SIZE_OF_INT;
 const SIZE_OF_NODE = 5 * SIZE_OF_INT;
 const SIZE_OF_POINT = 2 * SIZE_OF_INT;
 const SIZE_OF_RANGE = 2 * SIZE_OF_INT + 2 * SIZE_OF_POINT;
@@ -208,10 +209,19 @@ class Node {
     return C._ts_node_symbol_wasm(this.tree[0]);
   }
 
+  get grammarId() {
+    marshalNode(this);
+    return C._ts_node_grammar_symbol_wasm(this.tree[0]);
+  }
+
   get type() {
     return this.tree.language.types[this.typeId] || 'ERROR';
   }
 
+  get grammarType() {
+    return this.tree.language.types[this.grammarId] || 'ERROR';
+  }
+
   get endPosition() {
     marshalNode(this);
     C._ts_node_end_point_wasm(this.tree[0]);
@@ -227,6 +237,16 @@ class Node {
     return getText(this.tree, this.startIndex, this.endIndex);
   }
 
+  get parseState() {
+    marshalNode(this);
+    return C._ts_node_parse_state_wasm(this.tree[0]);
+  }
+
+  get nextParseState() {
+    marshalNode(this);
+    return C._ts_node_next_parse_state_wasm(this.tree[0]);
+  }
+
   isNamed() {
     marshalNode(this);
     return C._ts_node_is_named_wasm(this.tree[0]) === 1;
@@ -242,6 +262,11 @@ class Node {
     return C._ts_node_has_changes_wasm(this.tree[0]) === 1;
   }
 
+  isError() {
+    marshalNode(this);
+    return C._ts_node_is_error_wasm(this.tree[0]) === 1;
+  }
+
   isMissing() {
     marshalNode(this);
     return C._ts_node_is_missing_wasm(this.tree[0]) === 1;
@@ -257,6 +282,17 @@ class Node {
     return unmarshalNode(this.tree);
   }
 
+  fieldNameForChild(index) {
+    marshalNode(this);
+    const address = C._ts_node_field_name_for_child_wasm(this.tree[0], index);
+    if (!address) {
+      return null;
+    }
+    const result = AsciiToString(address);
+    // must not free, the string memory is owned by the language
+    return result;
+  }
+
   namedChild(index) {
     marshalNode(this);
     C._ts_node_named_child_wasm(this.tree[0], index);
@@ -505,6 +541,13 @@ class TreeCursor {
     unmarshalTreeCursor(this);
   }
 
+  resetTo(cursor) {
+    marshalTreeCursor(this, TRANSFER_BUFFER);
+    marshalTreeCursor(cursor, TRANSFER_BUFFER + SIZE_OF_CURSOR);
+    C._ts_tree_cursor_reset_to_wasm(this.tree[0], cursor.tree[0]);
+    unmarshalTreeCursor(this);
+  }
+
   get nodeType() {
     return this.tree.language.types[this.nodeTypeId] || 'ERROR';
   }
@@ -514,6 +557,11 @@ class TreeCursor {
     return C._ts_tree_cursor_current_node_type_id_wasm(this.tree[0]);
   }
 
+  get nodeStateId() {
+    marshalTreeCursor(this);
+    return C._ts_tree_cursor_current_node_state_id_wasm(this.tree[0]);
+  }
+
   get nodeId() {
     marshalTreeCursor(this);
     return C._ts_tree_cursor_current_node_id_wasm(this.tree[0]);
@@ -580,6 +628,13 @@ class TreeCursor {
     return result === 1;
   }
 
+  gotoLastChild() {
+    marshalTreeCursor(this);
+    const result = C._ts_tree_cursor_goto_last_child_wasm(this.tree[0]);
+    unmarshalTreeCursor(this);
+    return result === 1;
+  }
+
   gotoNextSibling() {
     marshalTreeCursor(this);
     const result = C._ts_tree_cursor_goto_next_sibling_wasm(this.tree[0]);
@@ -587,6 +642,13 @@ class TreeCursor {
     return result === 1;
   }
 
+  gotoPreviousSibling() {
+    marshalTreeCursor(this);
+    const result = C._ts_tree_cursor_goto_previous_sibling_wasm(this.tree[0]);
+    unmarshalTreeCursor(this);
+    return result === 1;
+  }
+
   gotoParent() {
     marshalTreeCursor(this);
     const result = C._ts_tree_cursor_goto_parent_wasm(this.tree[0]);
@@ -624,6 +686,10 @@ class Language {
     return this.fields.length - 1;
   }
 
+  get stateCount() {
+    return C._ts_language_state_count(this[0]);
+  }
+
   fieldIdForName(fieldName) {
     const result = this.fields.indexOf(fieldName);
     if (result !== -1) {
@@ -663,6 +729,15 @@ class Language {
     return C._ts_language_type_is_visible_wasm(this[0], typeId) ? true : false;
   }
 
+  nextState(stateId, typeId) {
+    return C._ts_language_next_state(this[0], stateId, typeId);
+  }
+
+  lookaheadIterator(stateId) {
+    const address = C._ts_lookahead_iterator_new(this[0], stateId);
+    if (address) return new LookaheadIterable(INTERNAL, address, this);
+  }
+
   query(source) {
     const sourceLength = lengthBytesUTF8(source);
     const sourceAddress = C._malloc(sourceLength + 1);
@@ -766,7 +841,13 @@ class Language {
           }
           const operator = steps[0].value;
           let isPositive = true;
+          let matchAll = true;
           switch (operator) {
+            case 'any-not-eq?':
+              isPositive = false;
+              matchAll = false;
+            case 'any-eq?':
+              matchAll = false;
             case 'not-eq?':
               isPositive = false;
             case 'eq?':
@@ -780,28 +861,36 @@ class Language {
                 const captureName1 = steps[1].name;
                 const captureName2 = steps[2].name;
                 textPredicates[i].push(function(captures) {
-                  let node1, node2
+                  let nodes_1 = [];
+                  let nodes_2 = [];
                   for (const c of captures) {
-                    if (c.name === captureName1) node1 = c.node;
-                    if (c.name === captureName2) node2 = c.node;
+                    if (c.name === captureName1) nodes_1.push(c.node);
+                    if (c.name === captureName2) nodes_2.push(c.node);
                   }
-                  if(node1 === undefined || node2 === undefined) return true;
-                  return (node1.text === node2.text) === isPositive;
+                  return matchAll
+                    ? nodes_1.every(n1 => nodes_2.some(n2 => n1.text === n2.text)) === isPositive
+                    : nodes_1.some(n1 => nodes_2.some(n2 => n1.text === n2.text)) === isPositive;
                 });
               } else {
                 const captureName = steps[1].name;
                 const stringValue = steps[2].value;
                 textPredicates[i].push(function(captures) {
+                  let nodes = [];
                   for (const c of captures) {
-                    if (c.name === captureName) {
-                      return (c.node.text === stringValue) === isPositive;
-                    };
+                    if (c.name === captureName) nodes.push(c.node);
                   }
-                  return true;
+                  return matchAll
+                    ? nodes.every(n => n.text === stringValue) === isPositive
+                    : nodes.some(n => n.text === stringValue) === isPositive;
                 });
               }
               break;
 
+            case 'not-any-match?':
+              isPositive = false;
+              matchAll = false;
+            case 'any-match?':
+              matchAll = false;
             case 'not-match?':
               isPositive = false;
             case 'match?':
@@ -817,10 +906,14 @@ class Language {
               const captureName = steps[1].name;
               const regex = new RegExp(steps[2].value);
               textPredicates[i].push(function(captures) {
+                const nodes = [];
                 for (const c of captures) {
-                  if (c.name === captureName) return regex.test(c.node.text) === isPositive;
+                  if (c.name === captureName) nodes.push(c.node.text);
                 }
-                return true;
+                if (nodes.length === 0) return !isPositive;
+                return matchAll
+                  ? nodes.every(text => regex.test(text)) === isPositive
+                  : nodes.some(text => regex.test(text)) === isPositive;
               });
               break;
 
@@ -848,6 +941,32 @@ class Language {
               properties[i][steps[1].value] = steps[2] ? steps[2].value : null;
               break;
 
+            case 'not-any-of?':
+              isPositive = false;
+            case 'any-of?':
+              if (steps.length < 2) throw new Error(
+                `Wrong number of arguments to \`#${operator}\` predicate. Expected at least 1. Got ${steps.length - 1}.`
+              );
+              if (steps[1].type !== 'capture') throw new Error(
+                `First argument of \`#${operator}\` predicate must be a capture. Got "${steps[1].value}".`
+              );
+              for (let i = 2; i < steps.length; i++) {
+                if (steps[i].type !== 'string') throw new Error(
+                  `Arguments to \`#${operator}\` predicate must be a strings.".`
+                );
+              }
+              captureName = steps[1].name;
+              const values = steps.slice(2).map(s => s.value);
+              textPredicates[i].push(function(captures) {
+                const nodes = [];
+                for (const c of captures) {
+                  if (c.name === captureName) nodes.push(c.node.text);
+                }
+                if (nodes.length === 0) return !isPositive;
+                return nodes.every(text => values.includes(text)) === isPositive;
+              });
+              break;
+
             default:
               predicates[i].push({operator, operands: steps.slice(1)});
           }
@@ -918,6 +1037,53 @@ class Language {
   }
 }
 
+class LookaheadIterable {
+  constructor(internal, address, language) {
+    assertInternal(internal);
+    this[0] = address;
+    this.language = language;
+  }
+
+  get currentTypeId() {
+    return C._ts_lookahead_iterator_current_symbol(this[0]);
+  }
+
+  get currentType() {
+    return this.language.types[this.currentTypeId] || 'ERROR'
+  }
+
+  delete() {
+    C._ts_lookahead_iterator_delete(this[0]);
+    this[0] = 0;
+  }
+
+  resetState(stateId) {
+    return C._ts_lookahead_iterator_reset_state(this[0], stateId);
+  }
+
+  reset(language, stateId) {
+    if (C._ts_lookahead_iterator_reset(this[0], language[0], stateId)) {
+      this.language = language;
+      return true;
+    }
+
+    return false;
+  }
+
+  [Symbol.iterator]() {
+    const self = this;
+    return {
+      next() {
+        if (C._ts_lookahead_iterator_next(self[0])) {
+          return { done: false, value: self.currentType };
+        }
+
+        return { done: true, value: "" };
+      }
+    };
+  }
+}
+
 class Query {
   constructor(
     internal, address, captureNames, textPredicates, predicates,
diff --git a/lib/binding_web/exports.json b/lib/binding_web/exports.json
index 3fe11cdf..dfc9ff54 100644
--- a/lib/binding_web/exports.json
+++ b/lib/binding_web/exports.json
@@ -4,22 +4,27 @@
   "_malloc",
   "_realloc",
 
-  "__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm",
   "__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm",
-  "__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm",
   "__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm",
   "__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc",
-  "__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev",
   "__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw",
+  "__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm",
+  "__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm",
+  "__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6resizeEmw",
+  "__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev",
   "__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev",
   "__ZdlPv",
   "__Znwm",
   "___cxa_atexit",
   "_abort",
+  "_isalpha",
+  "_isspace",
   "_iswalnum",
   "_iswalpha",
+  "_iswblank",
   "_iswdigit",
   "_iswlower",
+  "_iswupper",
   "_iswspace",
   "_memchr",
   "_memcmp",
@@ -27,7 +32,12 @@
   "_memmove",
   "_memset",
   "_strlen",
+  "_strcmp",
+  "_strncpy",
+  "_tolower",
+  "_towlower",
   "_towupper",
+  "_stderr",
 
   "_ts_init",
   "_ts_language_field_count",
@@ -35,10 +45,13 @@
   "_ts_language_type_is_named_wasm",
   "_ts_language_type_is_visible_wasm",
   "_ts_language_symbol_count",
+  "_ts_language_state_count",
   "_ts_language_symbol_for_name",
   "_ts_language_symbol_name",
   "_ts_language_symbol_type",
   "_ts_language_version",
+  "_ts_language_next_state",
+  "_ts_node_field_name_for_child_wasm",
   "_ts_node_child_by_field_id_wasm",
   "_ts_node_child_count_wasm",
   "_ts_node_child_wasm",
@@ -50,8 +63,11 @@
   "_ts_node_end_point_wasm",
   "_ts_node_has_changes_wasm",
   "_ts_node_has_error_wasm",
+  "_ts_node_is_error_wasm",
   "_ts_node_is_missing_wasm",
   "_ts_node_is_named_wasm",
+  "_ts_node_parse_state_wasm",
+  "_ts_node_next_parse_state_wasm",
   "_ts_node_named_child_count_wasm",
   "_ts_node_named_child_wasm",
   "_ts_node_named_children_wasm",
@@ -65,6 +81,7 @@
   "_ts_node_start_index_wasm",
   "_ts_node_start_point_wasm",
   "_ts_node_symbol_wasm",
+  "_ts_node_grammar_symbol_wasm",
   "_ts_node_to_string_wasm",
   "_ts_parser_delete",
   "_ts_parser_enable_logger_wasm",
@@ -90,19 +107,29 @@
   "_ts_tree_cursor_current_node_is_missing_wasm",
   "_ts_tree_cursor_current_node_is_named_wasm",
   "_ts_tree_cursor_current_node_type_id_wasm",
+  "_ts_tree_cursor_current_node_state_id_wasm",
   "_ts_tree_cursor_current_node_wasm",
   "_ts_tree_cursor_delete_wasm",
   "_ts_tree_cursor_end_index_wasm",
   "_ts_tree_cursor_end_position_wasm",
   "_ts_tree_cursor_goto_first_child_wasm",
+  "_ts_tree_cursor_goto_last_child_wasm",
   "_ts_tree_cursor_goto_next_sibling_wasm",
+  "_ts_tree_cursor_goto_previous_sibling_wasm",
   "_ts_tree_cursor_goto_parent_wasm",
   "_ts_tree_cursor_new_wasm",
   "_ts_tree_cursor_reset_wasm",
+  "_ts_tree_cursor_reset_to_wasm",
   "_ts_tree_cursor_start_index_wasm",
   "_ts_tree_cursor_start_position_wasm",
   "_ts_tree_delete",
   "_ts_tree_edit_wasm",
   "_ts_tree_get_changed_ranges_wasm",
-  "_ts_tree_root_node_wasm"
+  "_ts_tree_root_node_wasm",
+  "_ts_lookahead_iterator_new",
+  "_ts_lookahead_iterator_delete",
+  "_ts_lookahead_iterator_reset_state",
+  "_ts_lookahead_iterator_reset",
+  "_ts_lookahead_iterator_next",
+  "_ts_lookahead_iterator_current_symbol"
 ]
diff --git a/lib/binding_web/package.json b/lib/binding_web/package.json
index 2cfcf72e..42fdc518 100644
--- a/lib/binding_web/package.json
+++ b/lib/binding_web/package.json
@@ -1,6 +1,6 @@
 {
   "name": "web-tree-sitter",
-  "version": "0.20.7",
+  "version": "0.20.8",
   "description": "Tree-sitter bindings for the web",
   "main": "tree-sitter.js",
   "types": "tree-sitter-web.d.ts",
@@ -27,8 +27,8 @@
   },
   "homepage": "https://github.com/tree-sitter/tree-sitter/tree/master/lib/binding_web",
   "devDependencies": {
-    "chai": "^4.2.0",
-    "mocha": "^6.1.4",
-    "terser": "^3.17.0"
+    "chai": "^4.3.7",
+    "mocha": "^10.2.0",
+    "terser": "^5.16.6"
   }
 }
diff --git a/lib/binding_web/test/language-test.js b/lib/binding_web/test/language-test.js
index 385b77ed..394e32b4 100644
--- a/lib/binding_web/test/language-test.js
+++ b/lib/binding_web/test/language-test.js
@@ -42,3 +42,46 @@ describe("Language", () => {
     });
   });
 });
+
+describe("Lookahead iterator", () => {
+  let lookahead;
+  let state;
+  before(async () => {
+    let Parser;
+    ({ JavaScript, Parser } = await require("./helper"));
+    const parser = new Parser().setLanguage(JavaScript);
+    const tree = parser.parse("function fn() {}");
+    parser.delete();
+    const cursor = tree.walk();
+    assert(cursor.gotoFirstChild());
+    assert(cursor.gotoFirstChild());
+    state = cursor.currentNode().nextParseState;
+    lookahead = JavaScript.lookaheadIterator(state);
+    assert.exists(lookahead);
+  });
+
+  after(() => {
+    lookahead.delete();
+  });
+
+  const expected = ["identifier", "comment", "(", "*", "formal_parameters"];
+  it("should iterate over valid symbols in the state", () => {
+    const symbols = Array.from(lookahead);
+    assert.includeMembers(symbols, expected);
+    assert.lengthOf(symbols, expected.length);
+  });
+
+  it("should reset to the initial state", () => {
+    assert(lookahead.resetState(state));
+    const symbols = Array.from(lookahead);
+    assert.includeMembers(symbols, expected);
+    assert.lengthOf(symbols, expected.length);
+  });
+
+  it("should reset", () => {
+    assert(lookahead.reset(JavaScript, state));
+    const symbols = Array.from(lookahead);
+    assert.includeMembers(symbols, expected);
+    assert.lengthOf(symbols, expected.length);
+  });
+});
diff --git a/lib/binding_web/test/node-test.js b/lib/binding_web/test/node-test.js
index 6bbcafb0..a1011154 100644
--- a/lib/binding_web/test/node-test.js
+++ b/lib/binding_web/test/node-test.js
@@ -268,6 +268,24 @@ describe("Node", () => {
     });
   });
 
+  describe(".isError()", () => {
+    it("returns true if the node is an error", () => {
+      tree = parser.parse("2 * * 3");
+      const node = tree.rootNode;
+      assert.equal(
+        node.toString(),
+        '(program (expression_statement (binary_expression left: (number) (ERROR) right: (number))))'
+      );
+
+      const multi = node.firstChild.firstChild;
+      assert(multi.hasError());
+      assert(!multi.children[0].isError());
+      assert(!multi.children[1].isError());
+      assert(multi.children[2].isError());
+      assert(!multi.children[3].isError());
+    });
+  });
+
   describe(".isMissing()", () => {
     it("returns true if the node is missing from the source and was inserted via error recovery", () => {
       tree = parser.parse("(2 ||)");
@@ -308,6 +326,34 @@ describe("Node", () => {
     );
   });
 
+  describe(".parseState, .nextParseState", () => {
+    const text = "10 / 5";
+
+    it("returns node parse state ids", async () => {
+      tree = await parser.parse(text)
+      const quotientNode = tree.rootNode.firstChild.firstChild;
+      const [numerator, slash, denominator] = quotientNode.children;
+
+      assert.equal(tree.rootNode.parseState, 0);
+      // parse states will change on any change to the grammar so test that it
+      // returns something instead
+      assert.isAbove(numerator.parseState, 0);
+      assert.isAbove(slash.parseState, 0);
+      assert.isAbove(denominator.parseState, 0);
+    })
+
+    it("returns next parse state equal to the language", async () => {
+      tree = await parser.parse(text);
+      const quotientNode = tree.rootNode.firstChild.firstChild;
+      quotientNode.children.forEach(node => {
+        assert.equal(
+          node.nextParseState,
+          JavaScript.nextState(node.parseState, node.grammarId)
+        );
+      });
+    });
+  });
+
   describe('.descendantsOfType(type, min, max)', () => {
     it('finds all of the descendants of the given type in the given range', () => {
       tree = parser.parse("a + 1 * b * 2 + c + 3");
@@ -408,4 +454,20 @@ describe("Node", () => {
       assert(!node1.equals(node2));
     });
   });
+
+  describe('.fieldNameForChild(index)', () => {
+    it('returns the field of a child or null', () => {
+      tree = parser.parse('let a = 5');
+
+      const noField = tree.rootNode.fieldNameForChild(0);
+      const name = tree.rootNode.firstChild.children[1].fieldNameForChild(0);
+      const value = tree.rootNode.firstChild.children[1].fieldNameForChild(2);
+      const overflow = tree.rootNode.firstChild.children[1].fieldNameForChild(3);
+
+      assert.equal(noField, null);
+      assert.equal(name, 'name');
+      assert.equal(value, 'value');
+      assert.equal(overflow, null);
+    });
+  });
 });
diff --git a/lib/binding_web/test/parser-test.js b/lib/binding_web/test/parser-test.js
index c76b49c7..a25e5dc5 100644
--- a/lib/binding_web/test/parser-test.js
+++ b/lib/binding_web/test/parser-test.js
@@ -127,19 +127,19 @@ describe("Parser", () => {
 
     it("can use the bash parser", async () => {
       parser.setLanguage(await Parser.Language.load(languageURL('bash')));
-      tree = parser.parse("FOO=bar echo <<EOF 2> err.txt > hello.txt \nhello\nEOF");
+      tree = parser.parse("FOO=bar echo <<EOF 2> err.txt > hello.txt \nhello${FOO}\nEOF");
       assert.equal(
         tree.rootNode.toString(),
-        '(program (redirected_statement ' +
-          'body: (command ' +
-            '(variable_assignment ' +
-              'name: (variable_name) ' +
-              'value: (word)) ' +
-            'name: (command_name (word))) ' +
-          'redirect: (heredoc_redirect (heredoc_start)) ' +
-          'redirect: (file_redirect descriptor: (file_descriptor) destination: (word)) ' +
-          'redirect: (file_redirect destination: (word))) ' +
-          '(heredoc_body))'
+          '(program ' +
+            '(redirected_statement ' +
+              'body: (command ' +
+                '(variable_assignment name: (variable_name) value: (word)) ' +
+                'name: (command_name (word))) ' +
+              'redirect: (heredoc_redirect (heredoc_start) ' +
+                'redirect: (file_redirect descriptor: (file_descriptor) destination: (word)) ' +
+                'redirect: (file_redirect destination: (word)) ' +
+                '(heredoc_body ' +
+                  '(expansion (variable_name)) (heredoc_content)) (heredoc_end))))'
       );
     }).timeout(5000);
 
@@ -153,7 +153,7 @@ describe("Parser", () => {
           'type: (primitive_type) ' +
           'declarator: (init_declarator ' +
             'declarator: (pointer_declarator declarator: (identifier)) ' +
-            'value: (raw_string_literal))))'
+            'value: (raw_string_literal delimiter: (raw_string_delimiter) (raw_string_content) (raw_string_delimiter)))))'
       );
     }).timeout(5000);
 
diff --git a/lib/binding_web/test/tree-test.js b/lib/binding_web/test/tree-test.js
index 8c04e63e..a98d216a 100644
--- a/lib/binding_web/test/tree-test.js
+++ b/lib/binding_web/test/tree-test.js
@@ -244,6 +244,50 @@ describe("Tree", () => {
         endIndex: 13
       });
 
+      {
+        const copy = tree.walk();
+        copy.resetTo(cursor);
+
+        assert(copy.gotoPreviousSibling());
+        assertCursorState(copy, {
+          nodeType: '+',
+          nodeIsNamed: false,
+          startPosition: {row: 0, column: 6},
+          endPosition: {row: 0, column: 7},
+          startIndex: 6,
+          endIndex: 7
+        });
+
+        assert(copy.gotoPreviousSibling());
+        assertCursorState(copy, {
+          nodeType: 'binary_expression',
+          nodeIsNamed: true,
+          startPosition: {row: 0, column: 0},
+          endPosition: {row: 0, column: 5},
+          startIndex: 0,
+          endIndex: 5
+        });
+
+        assert(copy.gotoLastChild());
+        assertCursorState(copy, {
+          nodeType: "identifier",
+          nodeIsNamed: true,
+          startPosition: {row: 0, column: 4},
+          endPosition: {row: 0, column: 5},
+          startIndex: 4,
+          endIndex: 5
+        })
+
+        assert(copy.gotoParent());
+        assert(copy.gotoParent());
+        assert.equal(copy.nodeType, 'binary_expression')
+        assert(copy.gotoParent());
+        assert.equal(copy.nodeType, 'expression_statement')
+        assert(copy.gotoParent());
+        assert.equal(copy.nodeType, 'program')
+        assert(!copy.gotoParent());
+    }
+
       // const childIndex = cursor.gotoFirstChildForIndex(12);
       // assertCursorState(cursor, {
       //   nodeType: 'identifier',
diff --git a/lib/binding_web/tree-sitter-web.d.ts b/lib/binding_web/tree-sitter-web.d.ts
index 016af4ae..dfe7766c 100644
--- a/lib/binding_web/tree-sitter-web.d.ts
+++ b/lib/binding_web/tree-sitter-web.d.ts
@@ -55,10 +55,14 @@ declare module 'web-tree-sitter' {
     ) => string | null;
 
     export interface SyntaxNode {
-      id: number;
+      typeId: number;
+      grammarId: number;
       tree: Tree;
       type: string;
+      grammarType: string;
       text: string;
+      parseState: number;
+      nextParseState: number;
       startPosition: Point;
       endPosition: Point;
       startIndex: number;
@@ -80,6 +84,7 @@ declare module 'web-tree-sitter' {
       hasChanges(): boolean;
       hasError(): boolean;
       equals(other: SyntaxNode): boolean;
+      isError(): boolean;
       isMissing(): boolean;
       isNamed(): boolean;
       toString(): string;
@@ -104,6 +109,7 @@ declare module 'web-tree-sitter' {
     export interface TreeCursor {
       nodeType: string;
       nodeTypeId: number;
+      nodeStateId: number;
       nodeText: string;
       nodeId: number;
       nodeIsNamed: boolean;
@@ -114,14 +120,17 @@ declare module 'web-tree-sitter' {
       endIndex: number;
 
       reset(node: SyntaxNode): void;
+      resetTo(cursor: TreeCursor): void;
       delete(): void;
       currentNode(): SyntaxNode;
       currentFieldId(): number;
       currentFieldName(): string;
       gotoParent(): boolean;
       gotoFirstChild(): boolean;
+      gotoLastChild(): boolean;
       gotoFirstChildForIndex(index: number): boolean;
       gotoNextSibling(): boolean;
+      gotoPreviousSibling(): boolean;
     }
 
     export interface Tree {
@@ -141,6 +150,7 @@ declare module 'web-tree-sitter' {
 
       readonly version: number;
       readonly fieldCount: number;
+      readonly stateCount: number;
       readonly nodeTypeCount: number;
 
       fieldNameForId(fieldId: number): string | null;
@@ -149,7 +159,20 @@ declare module 'web-tree-sitter' {
       nodeTypeForId(typeId: number): string | null;
       nodeTypeIsNamed(typeId: number): boolean;
       nodeTypeIsVisible(typeId: number): boolean;
+      nextState(stateId: number, typeId: number): number;
       query(source: string): Query;
+      lookaheadIterator(stateId: number): LookaheadIterable | null;
+    }
+
+    class LookaheadIterable {
+      readonly language: Language;
+      readonly currentTypeId: number;
+      readonly currentType: string;
+
+      delete(): void;
+      resetState(stateId: number): boolean;
+      reset(language: Language, stateId: number): boolean;
+      [Symbol.iterator](): Iterator<string>;
     }
 
     interface QueryCapture {
diff --git a/lib/include/tree_sitter/api.h b/lib/include/tree_sitter/api.h
index 0944adc9..7c770832 100644
--- a/lib/include/tree_sitter/api.h
+++ b/lib/include/tree_sitter/api.h
@@ -1,11 +1,14 @@
 #ifndef TREE_SITTER_API_H_
 #define TREE_SITTER_API_H_
 
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC visibility push(default)
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdbool.h>
@@ -33,6 +36,7 @@ extern "C" {
 /* Section - Types */
 /*******************/
 
+typedef uint16_t TSStateId;
 typedef uint16_t TSSymbol;
 typedef uint16_t TSFieldId;
 typedef struct TSLanguage TSLanguage;
@@ -40,6 +44,7 @@ typedef struct TSParser TSParser;
 typedef struct TSTree TSTree;
 typedef struct TSQuery TSQuery;
 typedef struct TSQueryCursor TSQueryCursor;
+typedef struct TSLookaheadIterator TSLookaheadIterator;
 
 typedef enum {
   TSInputEncodingUTF8,
@@ -77,7 +82,7 @@ typedef enum {
 
 typedef struct {
   void *payload;
-  void (*log)(void *payload, TSLogType, const char *);
+  void (*log)(void *payload, TSLogType log_type, const char *buffer);
 } TSLogger;
 
 typedef struct {
@@ -154,7 +159,12 @@ TSParser *ts_parser_new(void);
 /**
  * Delete the parser, freeing all of the memory that it used.
  */
-void ts_parser_delete(TSParser *parser);
+void ts_parser_delete(TSParser *self);
+
+/**
+ * Get the parser's current language.
+ */
+const TSLanguage *ts_parser_language(const TSParser *self);
 
 /**
  * Set the language that the parser should use for parsing.
@@ -162,17 +172,12 @@ void ts_parser_delete(TSParser *parser);
  * Returns a boolean indicating whether or not the language was successfully
  * assigned. True means assignment succeeded. False means there was a version
  * mismatch: the language was generated with an incompatible version of the
- * Tree-sitter CLI. Check the language's version using `ts_language_version`
- * and compare it to this library's `TREE_SITTER_LANGUAGE_VERSION` and
- * `TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION` constants.
+ * Tree-sitter CLI. Check the language's version using [`ts_language_version`]
+ * and compare it to this library's [`TREE_SITTER_LANGUAGE_VERSION`] and
+ * [`TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION`] constants.
  */
 bool ts_parser_set_language(TSParser *self, const TSLanguage *language);
 
-/**
- * Get the parser's current language.
- */
-const TSLanguage *ts_parser_language(const TSParser *self);
-
 /**
  * Set the ranges of text that the parser should include when parsing.
  *
@@ -185,10 +190,11 @@ const TSLanguage *ts_parser_language(const TSParser *self);
  * of ranges. The parser does *not* take ownership of these ranges; it copies
  * the data, so it doesn't matter how these ranges are allocated.
  *
- * If `length` is zero, then the entire document will be parsed. Otherwise,
+ * If `count` is zero, then the entire document will be parsed. Otherwise,
  * the given ranges must be ordered from earliest to latest in the document,
- * and they must not overlap. That is, the following must hold for all
- * `i` < `length - 1`: ranges[i].end_byte <= ranges[i + 1].start_byte
+ * and they must not overlap. That is, the following must hold for all:
+ *
+ * `i < count - 1`: `ranges[i].end_byte <= ranges[i + 1].start_byte`
  *
  * If this requirement is not satisfied, the operation will fail, the ranges
  * will not be assigned, and this function will return `false`. On success,
@@ -197,7 +203,7 @@ const TSLanguage *ts_parser_language(const TSParser *self);
 bool ts_parser_set_included_ranges(
   TSParser *self,
   const TSRange *ranges,
-  uint32_t length
+  uint32_t count
 );
 
 /**
@@ -205,11 +211,11 @@ bool ts_parser_set_included_ranges(
  *
  * The returned pointer is owned by the parser. The caller should not free it
  * or write to it. The length of the array will be written to the given
- * `length` pointer.
+ * `count` pointer.
  */
 const TSRange *ts_parser_included_ranges(
   const TSParser *self,
-  uint32_t *length
+  uint32_t *count
 );
 
 /**
@@ -220,35 +226,40 @@ const TSRange *ts_parser_included_ranges(
  * version of this document and the document has since been edited, pass the
  * previous syntax tree so that the unchanged parts of it can be reused.
  * This will save time and memory. For this to work correctly, you must have
- * already edited the old syntax tree using the `ts_tree_edit` function in a
+ * already edited the old syntax tree using the [`ts_tree_edit`] function in a
  * way that exactly matches the source code changes.
  *
- * The `TSInput` parameter lets you specify how to read the text. It has the
+ * The [`TSInput`] parameter lets you specify how to read the text. It has the
  * following three fields:
- * 1. `read`: A function to retrieve a chunk of text at a given byte offset
+ * 1. [`read`]: A function to retrieve a chunk of text at a given byte offset
  *    and (row, column) position. The function should return a pointer to the
- *    text and write its length to the `bytes_read` pointer. The parser does
+ *    text and write its length to the [`bytes_read`] pointer. The parser does
  *    not take ownership of this buffer; it just borrows it until it has
  *    finished reading it. The function should write a zero value to the
- *    `bytes_read` pointer to indicate the end of the document.
- * 2. `payload`: An arbitrary pointer that will be passed to each invocation
- *    of the `read` function.
- * 3. `encoding`: An indication of how the text is encoded. Either
+ *    [`bytes_read`] pointer to indicate the end of the document.
+ * 2. [`payload`]: An arbitrary pointer that will be passed to each invocation
+ *    of the [`read`] function.
+ * 3. [`encoding`]: An indication of how the text is encoded. Either
  *    `TSInputEncodingUTF8` or `TSInputEncodingUTF16`.
  *
  * This function returns a syntax tree on success, and `NULL` on failure. There
  * are three possible reasons for failure:
  * 1. The parser does not have a language assigned. Check for this using the
-      `ts_parser_language` function.
+      [`ts_parser_language`] function.
  * 2. Parsing was cancelled due to a timeout that was set by an earlier call to
- *    the `ts_parser_set_timeout_micros` function. You can resume parsing from
- *    where the parser left out by calling `ts_parser_parse` again with the
+ *    the [`ts_parser_set_timeout_micros`] function. You can resume parsing from
+ *    where the parser left out by calling [`ts_parser_parse`] again with the
  *    same arguments. Or you can start parsing from scratch by first calling
- *    `ts_parser_reset`.
+ *    [`ts_parser_reset`].
  * 3. Parsing was cancelled using a cancellation flag that was set by an
- *    earlier call to `ts_parser_set_cancellation_flag`. You can resume parsing
- *    from where the parser left out by calling `ts_parser_parse` again with
+ *    earlier call to [`ts_parser_set_cancellation_flag`]. You can resume parsing
+ *    from where the parser left out by calling [`ts_parser_parse`] again with
  *    the same arguments.
+ *
+ * [`read`]: TSInput::read
+ * [`payload`]: TSInput::payload
+ * [`encoding`]: TSInput::encoding
+ * [`bytes_read`]: TSInput::read
  */
 TSTree *ts_parser_parse(
   TSParser *self,
@@ -258,7 +269,7 @@ TSTree *ts_parser_parse(
 
 /**
  * Use the parser to parse some source code stored in one contiguous buffer.
- * The first two parameters are the same as in the `ts_parser_parse` function
+ * The first two parameters are the same as in the [`ts_parser_parse`] function
  * above. The second two parameters indicate the location of the buffer and its
  * length in bytes.
  */
@@ -272,7 +283,7 @@ TSTree *ts_parser_parse_string(
 /**
  * Use the parser to parse some source code stored in one contiguous buffer with
  * a given encoding. The first four parameters work the same as in the
- * `ts_parser_parse_string` method above. The final parameter indicates whether
+ * [`ts_parser_parse_string`] method above. The final parameter indicates whether
  * the text is encoded as UTF8 or UTF16.
  */
 TSTree *ts_parser_parse_string_encoding(
@@ -288,9 +299,9 @@ TSTree *ts_parser_parse_string_encoding(
  *
  * If the parser previously failed because of a timeout or a cancellation, then
  * by default, it will resume where it left off on the next call to
- * `ts_parser_parse` or other parsing functions. If you don't want to resume,
+ * [`ts_parser_parse`] or other parsing functions. If you don't want to resume,
  * and instead intend to use this parser to parse some other document, you must
- * call `ts_parser_reset` first.
+ * call [`ts_parser_reset`] first.
  */
 void ts_parser_reset(TSParser *self);
 
@@ -299,9 +310,9 @@ void ts_parser_reset(TSParser *self);
  * take before halting.
  *
  * If parsing takes longer than this, it will halt early, returning NULL.
- * See `ts_parser_parse` for more information.
+ * See [`ts_parser_parse`] for more information.
  */
-void ts_parser_set_timeout_micros(TSParser *self, uint64_t timeout);
+void ts_parser_set_timeout_micros(TSParser *self, uint64_t timeout_micros);
 
 /**
  * Get the duration in microseconds that parsing is allowed to take.
@@ -313,7 +324,7 @@ uint64_t ts_parser_timeout_micros(const TSParser *self);
  *
  * If a non-null pointer is assigned, then the parser will periodically read
  * from this pointer during parsing. If it reads a non-zero value, it will
- * halt early, returning NULL. See `ts_parser_parse` for more information.
+ * halt early, returning NULL. See [`ts_parser_parse`] for more information.
  */
 void ts_parser_set_cancellation_flag(TSParser *self, const size_t *flag);
 
@@ -342,7 +353,7 @@ TSLogger ts_parser_logger(const TSParser *self);
  * to pipe these graphs directly to a `dot(1)` process in order to generate
  * SVG output. You can turn off this logging by passing a negative number.
  */
-void ts_parser_print_dot_graphs(TSParser *self, int file);
+void ts_parser_print_dot_graphs(TSParser *self, int fd);
 
 /******************/
 /* Section - Tree */
@@ -373,20 +384,20 @@ TSNode ts_tree_root_node(const TSTree *self);
 TSNode ts_tree_root_node_with_offset(
   const TSTree *self,
   uint32_t offset_bytes,
-  TSPoint offset_point
+  TSPoint offset_extent
 );
 
 /**
  * Get the language that was used to parse the syntax tree.
  */
-const TSLanguage *ts_tree_language(const TSTree *);
+const TSLanguage *ts_tree_language(const TSTree *self);
 
 /**
  * Get the array of included ranges that was used to parse the syntax tree.
  *
  * The returned pointer must be freed by the caller.
  */
-TSRange *ts_tree_included_ranges(const TSTree *, uint32_t *length);
+TSRange *ts_tree_included_ranges(const TSTree *self, uint32_t *length);
 
 /**
  * Edit the syntax tree to keep it in sync with source code that has been
@@ -403,7 +414,7 @@ void ts_tree_edit(TSTree *self, const TSInputEdit *edit);
  *
  * For this to work correctly, the old syntax tree must have been edited such
  * that its ranges match up to the new tree. Generally, you'll want to call
- * this function right after calling one of the `ts_parser_parse` functions.
+ * this function right after calling one of the [`ts_parser_parse`] functions.
  * You need to pass the old tree that was passed to parse, as well as the new
  * tree that was returned from that function.
  *
@@ -420,7 +431,7 @@ TSRange *ts_tree_get_changed_ranges(
 /**
  * Write a DOT graph describing the syntax tree to the given file.
  */
-void ts_tree_print_dot_graph(const TSTree *, FILE *);
+void ts_tree_print_dot_graph(const TSTree *self, int file_descriptor);
 
 /******************/
 /* Section - Node */
@@ -429,32 +440,50 @@ void ts_tree_print_dot_graph(const TSTree *, FILE *);
 /**
  * Get the node's type as a null-terminated string.
  */
-const char *ts_node_type(TSNode);
+const char *ts_node_type(TSNode self);
 
 /**
  * Get the node's type as a numerical id.
  */
-TSSymbol ts_node_symbol(TSNode);
+TSSymbol ts_node_symbol(TSNode self);
+
+/**
+ * Get the node's language.
+ */
+const TSLanguage *ts_node_language(TSNode self);
+
+/**
+ * Get the node's type as it appears in the grammar ignoring aliases as a
+ * null-terminated string.
+ */
+const char *ts_node_grammar_type(TSNode self);
+
+/**
+ * Get the node's type as a numerical id as it appears in the grammar ignoring
+ * aliases. This should be used in [`ts_language_next_state`] instead of
+ * [`ts_node_symbol`].
+ */
+TSSymbol ts_node_grammar_symbol(TSNode self);
 
 /**
  * Get the node's start byte.
  */
-uint32_t ts_node_start_byte(TSNode);
+uint32_t ts_node_start_byte(TSNode self);
 
 /**
  * Get the node's start position in terms of rows and columns.
  */
-TSPoint ts_node_start_point(TSNode);
+TSPoint ts_node_start_point(TSNode self);
 
 /**
  * Get the node's end byte.
  */
-uint32_t ts_node_end_byte(TSNode);
+uint32_t ts_node_end_byte(TSNode self);
 
 /**
  * Get the node's end position in terms of rows and columns.
  */
-TSPoint ts_node_end_point(TSNode);
+TSPoint ts_node_end_point(TSNode self);
 
 /**
  * Get an S-expression representing the node as a string.
@@ -462,148 +491,168 @@ TSPoint ts_node_end_point(TSNode);
  * This string is allocated with `malloc` and the caller is responsible for
  * freeing it using `free`.
  */
-char *ts_node_string(TSNode);
+char *ts_node_string(TSNode self);
 
 /**
- * Check if the node is null. Functions like `ts_node_child` and
- * `ts_node_next_sibling` will return a null node to indicate that no such node
+ * Check if the node is null. Functions like [`ts_node_child`] and
+ * [`ts_node_next_sibling`] will return a null node to indicate that no such node
  * was found.
  */
-bool ts_node_is_null(TSNode);
+bool ts_node_is_null(TSNode self);
 
 /**
  * Check if the node is *named*. Named nodes correspond to named rules in the
  * grammar, whereas *anonymous* nodes correspond to string literals in the
  * grammar.
  */
-bool ts_node_is_named(TSNode);
+bool ts_node_is_named(TSNode self);
 
 /**
  * Check if the node is *missing*. Missing nodes are inserted by the parser in
  * order to recover from certain kinds of syntax errors.
  */
-bool ts_node_is_missing(TSNode);
+bool ts_node_is_missing(TSNode self);
 
 /**
  * Check if the node is *extra*. Extra nodes represent things like comments,
  * which are not required the grammar, but can appear anywhere.
  */
-bool ts_node_is_extra(TSNode);
+bool ts_node_is_extra(TSNode self);
 
 /**
  * Check if a syntax node has been edited.
  */
-bool ts_node_has_changes(TSNode);
+bool ts_node_has_changes(TSNode self);
 
 /**
  * Check if the node is a syntax error or contains any syntax errors.
  */
-bool ts_node_has_error(TSNode);
+bool ts_node_has_error(TSNode self);
+
+/**
+ * Check if the node is a syntax error.
+*/
+bool ts_node_is_error(TSNode self);
+
+/**
+ * Get this node's parse state.
+*/
+TSStateId ts_node_parse_state(TSNode self);
+
+/**
+ * Get the parse state after this node.
+*/
+TSStateId ts_node_next_parse_state(TSNode self);
 
 /**
  * Get the node's immediate parent.
  */
-TSNode ts_node_parent(TSNode);
+TSNode ts_node_parent(TSNode self);
 
 /**
  * Get the node's child at the given index, where zero represents the first
  * child.
  */
-TSNode ts_node_child(TSNode, uint32_t);
+TSNode ts_node_child(TSNode self, uint32_t child_index);
 
 /**
  * Get the field name for node's child at the given index, where zero represents
  * the first child. Returns NULL, if no field is found.
  */
-const char *ts_node_field_name_for_child(TSNode, uint32_t);
+const char *ts_node_field_name_for_child(TSNode self, uint32_t child_index);
 
 /**
  * Get the node's number of children.
  */
-uint32_t ts_node_child_count(TSNode);
+uint32_t ts_node_child_count(TSNode self);
 
 /**
  * Get the node's *named* child at the given index.
  *
- * See also `ts_node_is_named`.
+ * See also [`ts_node_is_named`].
  */
-TSNode ts_node_named_child(TSNode, uint32_t);
+TSNode ts_node_named_child(TSNode self, uint32_t child_index);
 
 /**
  * Get the node's number of *named* children.
  *
- * See also `ts_node_is_named`.
+ * See also [`ts_node_is_named`].
  */
-uint32_t ts_node_named_child_count(TSNode);
+uint32_t ts_node_named_child_count(TSNode self);
 
 /**
  * Get the node's child with the given field name.
  */
 TSNode ts_node_child_by_field_name(
   TSNode self,
-  const char *field_name,
-  uint32_t field_name_length
+  const char *name,
+  uint32_t name_length
 );
 
 /**
  * Get the node's child with the given numerical field id.
  *
  * You can convert a field name to an id using the
- * `ts_language_field_id_for_name` function.
+ * [`ts_language_field_id_for_name`] function.
  */
-TSNode ts_node_child_by_field_id(TSNode, TSFieldId);
+TSNode ts_node_child_by_field_id(TSNode self, TSFieldId field_id);
 
 /**
  * Get the node's next / previous sibling.
  */
-TSNode ts_node_next_sibling(TSNode);
-TSNode ts_node_prev_sibling(TSNode);
+TSNode ts_node_next_sibling(TSNode self);
+TSNode ts_node_prev_sibling(TSNode self);
 
 /**
  * Get the node's next / previous *named* sibling.
  */
-TSNode ts_node_next_named_sibling(TSNode);
-TSNode ts_node_prev_named_sibling(TSNode);
+TSNode ts_node_next_named_sibling(TSNode self);
+TSNode ts_node_prev_named_sibling(TSNode self);
 
 /**
  * Get the node's first child that extends beyond the given byte offset.
  */
-TSNode ts_node_first_child_for_byte(TSNode, uint32_t);
+TSNode ts_node_first_child_for_byte(TSNode self, uint32_t byte);
 
 /**
  * Get the node's first named child that extends beyond the given byte offset.
  */
-TSNode ts_node_first_named_child_for_byte(TSNode, uint32_t);
+TSNode ts_node_first_named_child_for_byte(TSNode self, uint32_t byte);
+
+/**
+ * Get the node's number of descendants, including one for the node itself.
+ */
+uint32_t ts_node_descendant_count(TSNode self);
 
 /**
  * Get the smallest node within this node that spans the given range of bytes
  * or (row, column) positions.
  */
-TSNode ts_node_descendant_for_byte_range(TSNode, uint32_t, uint32_t);
-TSNode ts_node_descendant_for_point_range(TSNode, TSPoint, TSPoint);
+TSNode ts_node_descendant_for_byte_range(TSNode self, uint32_t start, uint32_t end);
+TSNode ts_node_descendant_for_point_range(TSNode self, TSPoint start, TSPoint end);
 
 /**
  * Get the smallest named node within this node that spans the given range of
  * bytes or (row, column) positions.
  */
-TSNode ts_node_named_descendant_for_byte_range(TSNode, uint32_t, uint32_t);
-TSNode ts_node_named_descendant_for_point_range(TSNode, TSPoint, TSPoint);
+TSNode ts_node_named_descendant_for_byte_range(TSNode self, uint32_t start, uint32_t end);
+TSNode ts_node_named_descendant_for_point_range(TSNode self, TSPoint start, TSPoint end);
 
 /**
  * Edit the node to keep it in-sync with source code that has been edited.
  *
  * This function is only rarely needed. When you edit a syntax tree with the
- * `ts_tree_edit` function, all of the nodes that you retrieve from the tree
- * afterward will already reflect the edit. You only need to use `ts_node_edit`
- * when you have a `TSNode` instance that you want to keep and continue to use
+ * [`ts_tree_edit`] function, all of the nodes that you retrieve from the tree
+ * afterward will already reflect the edit. You only need to use [`ts_node_edit`]
+ * when you have a [`TSNode`] instance that you want to keep and continue to use
  * after an edit.
  */
-void ts_node_edit(TSNode *, const TSInputEdit *);
+void ts_node_edit(TSNode *self, const TSInputEdit *edit);
 
 /**
  * Check if two nodes are identical.
  */
-bool ts_node_eq(TSNode, TSNode);
+bool ts_node_eq(TSNode self, TSNode other);
 
 /************************/
 /* Section - TreeCursor */
@@ -613,41 +662,49 @@ bool ts_node_eq(TSNode, TSNode);
  * Create a new tree cursor starting from the given node.
  *
  * A tree cursor allows you to walk a syntax tree more efficiently than is
- * possible using the `TSNode` functions. It is a mutable object that is always
+ * possible using the [`TSNode`] functions. It is a mutable object that is always
  * on a certain syntax node, and can be moved imperatively to different nodes.
  */
-TSTreeCursor ts_tree_cursor_new(TSNode);
+TSTreeCursor ts_tree_cursor_new(TSNode node);
 
 /**
  * Delete a tree cursor, freeing all of the memory that it used.
  */
-void ts_tree_cursor_delete(TSTreeCursor *);
+void ts_tree_cursor_delete(TSTreeCursor *self);
 
 /**
  * Re-initialize a tree cursor to start at a different node.
  */
-void ts_tree_cursor_reset(TSTreeCursor *, TSNode);
+void ts_tree_cursor_reset(TSTreeCursor *self, TSNode node);
+
+/**
+ * Re-initialize a tree cursor to the same position as another cursor.
+ *
+ * Unlike [`ts_tree_cursor_reset`], this will not lose parent information and
+ * allows reusing already created cursors.
+*/
+void ts_tree_cursor_reset_to(TSTreeCursor *dst, const TSTreeCursor *src);
 
 /**
  * Get the tree cursor's current node.
  */
-TSNode ts_tree_cursor_current_node(const TSTreeCursor *);
+TSNode ts_tree_cursor_current_node(const TSTreeCursor *self);
 
 /**
  * Get the field name of the tree cursor's current node.
  *
  * This returns `NULL` if the current node doesn't have a field.
- * See also `ts_node_child_by_field_name`.
+ * See also [`ts_node_child_by_field_name`].
  */
-const char *ts_tree_cursor_current_field_name(const TSTreeCursor *);
+const char *ts_tree_cursor_current_field_name(const TSTreeCursor *self);
 
 /**
  * Get the field id of the tree cursor's current node.
  *
  * This returns zero if the current node doesn't have a field.
- * See also `ts_node_child_by_field_id`, `ts_language_field_id_for_name`.
+ * See also [`ts_node_child_by_field_id`], [`ts_language_field_id_for_name`].
  */
-TSFieldId ts_tree_cursor_current_field_id(const TSTreeCursor *);
+TSFieldId ts_tree_cursor_current_field_id(const TSTreeCursor *self);
 
 /**
  * Move the cursor to the parent of its current node.
@@ -655,7 +712,7 @@ TSFieldId ts_tree_cursor_current_field_id(const TSTreeCursor *);
  * This returns `true` if the cursor successfully moved, and returns `false`
  * if there was no parent node (the cursor was already on the root node).
  */
-bool ts_tree_cursor_goto_parent(TSTreeCursor *);
+bool ts_tree_cursor_goto_parent(TSTreeCursor *self);
 
 /**
  * Move the cursor to the next sibling of its current node.
@@ -663,7 +720,20 @@ bool ts_tree_cursor_goto_parent(TSTreeCursor *);
  * This returns `true` if the cursor successfully moved, and returns `false`
  * if there was no next sibling node.
  */
-bool ts_tree_cursor_goto_next_sibling(TSTreeCursor *);
+bool ts_tree_cursor_goto_next_sibling(TSTreeCursor *self);
+
+/**
+ * Move the cursor to the previous sibling of its current node.
+ *
+ * This returns `true` if the cursor successfully moved, and returns `false` if
+ * there was no previous sibling node.
+ *
+ * Note, that this function may be slower than
+ * [`ts_tree_cursor_goto_next_sibling`] due to how node positions are stored. In
+ * the worst case, this will need to iterate through all the children upto the
+ * previous sibling node to recalculate its position.
+ */
+bool ts_tree_cursor_goto_previous_sibling(TSTreeCursor *self);
 
 /**
  * Move the cursor to the first child of its current node.
@@ -671,7 +741,38 @@ bool ts_tree_cursor_goto_next_sibling(TSTreeCursor *);
  * This returns `true` if the cursor successfully moved, and returns `false`
  * if there were no children.
  */
-bool ts_tree_cursor_goto_first_child(TSTreeCursor *);
+bool ts_tree_cursor_goto_first_child(TSTreeCursor *self);
+
+/**
+ * Move the cursor to the last child of its current node.
+ *
+ * This returns `true` if the cursor successfully moved, and returns `false` if
+ * there were no children.
+ *
+ * Note that this function may be slower than [`ts_tree_cursor_goto_first_child`]
+ * because it needs to iterate through all the children to compute the child's
+ * position.
+ */
+bool ts_tree_cursor_goto_last_child(TSTreeCursor *self);
+
+/**
+ * Move the cursor to the node that is the nth descendant of
+ * the original node that the cursor was constructed with, where
+ * zero represents the original node itself.
+ */
+void ts_tree_cursor_goto_descendant(TSTreeCursor *self, uint32_t goal_descendant_index);
+
+/**
+ * Get the index of the cursor's current node out of all of the
+ * descendants of the original node that the cursor was constructed with.
+ */
+uint32_t ts_tree_cursor_current_descendant_index(const TSTreeCursor *self);
+
+/**
+ * Get the depth of the cursor's current node relative to the original
+ * node that the cursor was constructed with.
+ */
+uint32_t ts_tree_cursor_current_depth(const TSTreeCursor *self);
 
 /**
  * Move the cursor to the first child of its current node that extends beyond
@@ -680,10 +781,10 @@ bool ts_tree_cursor_goto_first_child(TSTreeCursor *);
  * This returns the index of the child node if one was found, and returns -1
  * if no such child was found.
  */
-int64_t ts_tree_cursor_goto_first_child_for_byte(TSTreeCursor *, uint32_t);
-int64_t ts_tree_cursor_goto_first_child_for_point(TSTreeCursor *, TSPoint);
+int64_t ts_tree_cursor_goto_first_child_for_byte(TSTreeCursor *self, uint32_t goal_byte);
+int64_t ts_tree_cursor_goto_first_child_for_point(TSTreeCursor *self, TSPoint goal_point);
 
-TSTreeCursor ts_tree_cursor_copy(const TSTreeCursor *);
+TSTreeCursor ts_tree_cursor_copy(const TSTreeCursor *cursor);
 
 /*******************/
 /* Section - Query */
@@ -694,7 +795,7 @@ TSTreeCursor ts_tree_cursor_copy(const TSTreeCursor *);
  * patterns. The query is associated with a particular language, and can
  * only be run on syntax nodes parsed with that language.
  *
- * If all of the given patterns are valid, this returns a `TSQuery`.
+ * If all of the given patterns are valid, this returns a [`TSQuery`].
  * If a pattern is invalid, this returns `NULL`, and provides two pieces
  * of information about the problem:
  * 1. The byte offset of the error is written to the `error_offset` parameter.
@@ -711,14 +812,14 @@ TSQuery *ts_query_new(
 /**
  * Delete a query, freeing all of the memory that it used.
  */
-void ts_query_delete(TSQuery *);
+void ts_query_delete(TSQuery *self);
 
 /**
  * Get the number of patterns, captures, or string literals in the query.
  */
-uint32_t ts_query_pattern_count(const TSQuery *);
-uint32_t ts_query_capture_count(const TSQuery *);
-uint32_t ts_query_string_count(const TSQuery *);
+uint32_t ts_query_pattern_count(const TSQuery *self);
+uint32_t ts_query_capture_count(const TSQuery *self);
+uint32_t ts_query_string_count(const TSQuery *self);
 
 /**
  * Get the byte offset where the given pattern starts in the query's source.
@@ -726,7 +827,7 @@ uint32_t ts_query_string_count(const TSQuery *);
  * This can be useful when combining queries by concatenating their source
  * code strings.
  */
-uint32_t ts_query_start_byte_for_pattern(const TSQuery *, uint32_t);
+uint32_t ts_query_start_byte_for_pattern(const TSQuery *self, uint32_t pattern_index);
 
 /**
  * Get all of the predicates for the given pattern in the query.
@@ -736,10 +837,10 @@ uint32_t ts_query_start_byte_for_pattern(const TSQuery *, uint32_t);
  * the `type` field:
  * - `TSQueryPredicateStepTypeCapture` - Steps with this type represent names
  *    of captures. Their `value_id` can be used with the
- *   `ts_query_capture_name_for_id` function to obtain the name of the capture.
+ *   [`ts_query_capture_name_for_id`] function to obtain the name of the capture.
  * - `TSQueryPredicateStepTypeString` - Steps with this type represent literal
  *    strings. Their `value_id` can be used with the
- *    `ts_query_string_value_for_id` function to obtain their string value.
+ *    [`ts_query_string_value_for_id`] function to obtain their string value.
  * - `TSQueryPredicateStepTypeDone` - Steps with this type are *sentinels*
  *    that represent the end of an individual predicate. If a pattern has two
  *    predicates, then there will be two steps with this `type` in the array.
@@ -747,18 +848,29 @@ uint32_t ts_query_start_byte_for_pattern(const TSQuery *, uint32_t);
 const TSQueryPredicateStep *ts_query_predicates_for_pattern(
   const TSQuery *self,
   uint32_t pattern_index,
-  uint32_t *length
+  uint32_t *step_count
 );
 
-bool ts_query_is_pattern_rooted(
-  const TSQuery *self,
-  uint32_t pattern_index
-);
+/*
+ * Check if the given pattern in the query has a single root node.
+ */
+bool ts_query_is_pattern_rooted(const TSQuery *self, uint32_t pattern_index);
 
-bool ts_query_is_pattern_guaranteed_at_step(
-  const TSQuery *self,
-  uint32_t byte_offset
-);
+/*
+ * Check if the given pattern in the query is 'non local'.
+ *
+ * A non-local pattern has multiple root nodes and can match within a
+ * repeating sequence of nodes, as specified by the grammar. Non-local
+ * patterns disable certain optimizations that would otherwise be possible
+ * when executing a query on a specific range of a syntax tree.
+ */
+bool ts_query_is_pattern_non_local(const TSQuery *self, uint32_t pattern_index);
+
+/*
+ * Check if a given pattern is guaranteed to match once a given step is reached.
+ * The step is specified by its byte offset in the query's source code.
+ */
+bool ts_query_is_pattern_guaranteed_at_step(const TSQuery *self, uint32_t byte_offset);
 
 /**
  * Get the name and length of one of the query's captures, or one of the
@@ -766,8 +878,8 @@ bool ts_query_is_pattern_guaranteed_at_step(
  * numeric id based on the order that it appeared in the query's source.
  */
 const char *ts_query_capture_name_for_id(
-  const TSQuery *,
-  uint32_t id,
+  const TSQuery *self,
+  uint32_t index,
   uint32_t *length
 );
 
@@ -776,14 +888,14 @@ const char *ts_query_capture_name_for_id(
  * with a numeric id based on the order that it appeared in the query's source.
  */
 TSQuantifier ts_query_capture_quantifier_for_id(
-  const TSQuery *,
-  uint32_t pattern_id,
-  uint32_t capture_id
+  const TSQuery *self,
+  uint32_t pattern_index,
+  uint32_t capture_index
 );
 
 const char *ts_query_string_value_for_id(
-  const TSQuery *,
-  uint32_t id,
+  const TSQuery *self,
+  uint32_t index,
   uint32_t *length
 );
 
@@ -794,7 +906,7 @@ const char *ts_query_string_value_for_id(
  * any resource usage associated with recording the capture. Currently, there
  * is no way to undo this.
  */
-void ts_query_disable_capture(TSQuery *, const char *, uint32_t);
+void ts_query_disable_capture(TSQuery *self, const char *name, uint32_t length);
 
 /**
  * Disable a certain pattern within a query.
@@ -802,41 +914,41 @@ void ts_query_disable_capture(TSQuery *, const char *, uint32_t);
  * This prevents the pattern from matching and removes most of the overhead
  * associated with the pattern. Currently, there is no way to undo this.
  */
-void ts_query_disable_pattern(TSQuery *, uint32_t);
+void ts_query_disable_pattern(TSQuery *self, uint32_t pattern_index);
 
 /**
  * Create a new cursor for executing a given query.
  *
  * The cursor stores the state that is needed to iteratively search
- * for matches. To use the query cursor, first call `ts_query_cursor_exec`
+ * for matches. To use the query cursor, first call [`ts_query_cursor_exec`]
  * to start running a given query on a given syntax node. Then, there are
  * two options for consuming the results of the query:
- * 1. Repeatedly call `ts_query_cursor_next_match` to iterate over all of the
+ * 1. Repeatedly call [`ts_query_cursor_next_match`] to iterate over all of the
  *    *matches* in the order that they were found. Each match contains the
  *    index of the pattern that matched, and an array of captures. Because
  *    multiple patterns can match the same set of nodes, one match may contain
  *    captures that appear *before* some of the captures from a previous match.
- * 2. Repeatedly call `ts_query_cursor_next_capture` to iterate over all of the
+ * 2. Repeatedly call [`ts_query_cursor_next_capture`] to iterate over all of the
  *    individual *captures* in the order that they appear. This is useful if
  *    don't care about which pattern matched, and just want a single ordered
  *    sequence of captures.
  *
  * If you don't care about consuming all of the results, you can stop calling
- * `ts_query_cursor_next_match` or `ts_query_cursor_next_capture` at any point.
+ * [`ts_query_cursor_next_match`] or [`ts_query_cursor_next_capture`] at any point.
  *  You can then start executing another query on another node by calling
- *  `ts_query_cursor_exec` again.
+ *  [`ts_query_cursor_exec`] again.
  */
 TSQueryCursor *ts_query_cursor_new(void);
 
 /**
  * Delete a query cursor, freeing all of the memory that it used.
  */
-void ts_query_cursor_delete(TSQueryCursor *);
+void ts_query_cursor_delete(TSQueryCursor *self);
 
 /**
  * Start running a given query on a given node.
  */
-void ts_query_cursor_exec(TSQueryCursor *, const TSQuery *, TSNode);
+void ts_query_cursor_exec(TSQueryCursor *self, const TSQuery *query, TSNode node);
 
 /**
  * Manage the maximum number of in-progress matches allowed by this query
@@ -849,16 +961,16 @@ void ts_query_cursor_exec(TSQueryCursor *, const TSQuery *, TSNode);
  * any number of pending matches, dynamically allocating new space for them as
  * needed as the query is executed.
  */
-bool ts_query_cursor_did_exceed_match_limit(const TSQueryCursor *);
-uint32_t ts_query_cursor_match_limit(const TSQueryCursor *);
-void ts_query_cursor_set_match_limit(TSQueryCursor *, uint32_t);
+bool ts_query_cursor_did_exceed_match_limit(const TSQueryCursor *self);
+uint32_t ts_query_cursor_match_limit(const TSQueryCursor *self);
+void ts_query_cursor_set_match_limit(TSQueryCursor *self, uint32_t limit);
 
 /**
  * Set the range of bytes or (row, column) positions in which the query
  * will be executed.
  */
-void ts_query_cursor_set_byte_range(TSQueryCursor *, uint32_t, uint32_t);
-void ts_query_cursor_set_point_range(TSQueryCursor *, TSPoint, TSPoint);
+void ts_query_cursor_set_byte_range(TSQueryCursor *self, uint32_t start_byte, uint32_t end_byte);
+void ts_query_cursor_set_point_range(TSQueryCursor *self, TSPoint start_point, TSPoint end_point);
 
 /**
  * Advance to the next match of the currently running query.
@@ -866,8 +978,8 @@ void ts_query_cursor_set_point_range(TSQueryCursor *, TSPoint, TSPoint);
  * If there is a match, write it to `*match` and return `true`.
  * Otherwise, return `false`.
  */
-bool ts_query_cursor_next_match(TSQueryCursor *, TSQueryMatch *match);
-void ts_query_cursor_remove_match(TSQueryCursor *, uint32_t id);
+bool ts_query_cursor_next_match(TSQueryCursor *self, TSQueryMatch *match);
+void ts_query_cursor_remove_match(TSQueryCursor *self, uint32_t match_id);
 
 /**
  * Advance to the next capture of the currently running query.
@@ -876,11 +988,27 @@ void ts_query_cursor_remove_match(TSQueryCursor *, uint32_t id);
  * the matche's capture list to `*capture_index`. Otherwise, return `false`.
  */
 bool ts_query_cursor_next_capture(
-  TSQueryCursor *,
+  TSQueryCursor *self,
   TSQueryMatch *match,
   uint32_t *capture_index
 );
 
+/**
+ * Set the maximum start depth for a query cursor.
+ *
+ * This prevents cursors from exploring children nodes at a certain depth.
+ * Note if a pattern includes many children, then they will still be checked.
+ *
+ * The zero max start depth value can be used as a special behavior and
+ * it helps to destructure a subtree by staying on a node and using captures
+ * for interested parts. Note that the zero max start depth only limit a search
+ * depth for a pattern's root node but other nodes that are parts of the pattern
+ * may be searched at any depth what defined by the pattern structure.
+ *
+ * Set to `UINT32_MAX` to remove the maximum start depth.
+ */
+void ts_query_cursor_set_max_start_depth(TSQueryCursor *self, uint32_t max_start_depth);
+
 /**********************/
 /* Section - Language */
 /**********************/
@@ -888,12 +1016,17 @@ bool ts_query_cursor_next_capture(
 /**
  * Get the number of distinct node types in the language.
  */
-uint32_t ts_language_symbol_count(const TSLanguage *);
+uint32_t ts_language_symbol_count(const TSLanguage *self);
+
+/**
+ * Get the number of valid states in this language.
+*/
+uint32_t ts_language_state_count(const TSLanguage *self);
 
 /**
  * Get a node type string for the given numerical id.
  */
-const char *ts_language_symbol_name(const TSLanguage *, TSSymbol);
+const char *ts_language_symbol_name(const TSLanguage *self, TSSymbol symbol);
 
 /**
  * Get the numerical id for the given node type string.
@@ -908,34 +1041,106 @@ TSSymbol ts_language_symbol_for_name(
 /**
  * Get the number of distinct field names in the language.
  */
-uint32_t ts_language_field_count(const TSLanguage *);
+uint32_t ts_language_field_count(const TSLanguage *self);
 
 /**
  * Get the field name string for the given numerical id.
  */
-const char *ts_language_field_name_for_id(const TSLanguage *, TSFieldId);
+const char *ts_language_field_name_for_id(const TSLanguage *self, TSFieldId id);
 
 /**
  * Get the numerical id for the given field name string.
  */
-TSFieldId ts_language_field_id_for_name(const TSLanguage *, const char *, uint32_t);
+TSFieldId ts_language_field_id_for_name(const TSLanguage *self, const char *name, uint32_t name_length);
 
 /**
  * Check whether the given node type id belongs to named nodes, anonymous nodes,
  * or a hidden nodes.
  *
- * See also `ts_node_is_named`. Hidden nodes are never returned from the API.
+ * See also [`ts_node_is_named`]. Hidden nodes are never returned from the API.
  */
-TSSymbolType ts_language_symbol_type(const TSLanguage *, TSSymbol);
+TSSymbolType ts_language_symbol_type(const TSLanguage *self, TSSymbol symbol);
 
 /**
  * Get the ABI version number for this language. This version number is used
  * to ensure that languages were generated by a compatible version of
  * Tree-sitter.
  *
- * See also `ts_parser_set_language`.
+ * See also [`ts_parser_set_language`].
  */
-uint32_t ts_language_version(const TSLanguage *);
+uint32_t ts_language_version(const TSLanguage *self);
+
+/**
+ * Get the next parse state. Combine this with lookahead iterators to generate
+ * completion suggestions or valid symbols in error nodes. Use
+ * [`ts_node_grammar_symbol`] for valid symbols.
+*/
+TSStateId ts_language_next_state(const TSLanguage *self, TSStateId state, TSSymbol symbol);
+
+/********************************/
+/* Section - Lookahead Iterator */
+/********************************/
+
+/**
+ * Create a new lookahead iterator for the given language and parse state.
+ *
+ * This returns `NULL` if state is invalid for the language.
+ *
+ * Repeatedly using [`ts_lookahead_iterator_next`] and
+ * [`ts_lookahead_iterator_current_symbol`] will generate valid symbols in the
+ * given parse state. Newly created lookahead iterators will contain the `ERROR`
+ * symbol.
+ *
+ * Lookahead iterators can be useful to generate suggestions and improve syntax
+ * error diagnostics. To get symbols valid in an ERROR node, use the lookahead
+ * iterator on its first leaf node state. For `MISSING` nodes, a lookahead
+ * iterator created on the previous non-extra leaf node may be appropriate.
+*/
+TSLookaheadIterator *ts_lookahead_iterator_new(const TSLanguage *self, TSStateId state);
+
+/**
+ * Delete a lookahead iterator freeing all the memory used.
+*/
+void ts_lookahead_iterator_delete(TSLookaheadIterator *self);
+
+/**
+ * Reset the lookahead iterator to another state.
+ *
+ * This returns `true` if the iterator was reset to the given state and `false`
+ * otherwise.
+*/
+bool ts_lookahead_iterator_reset_state(TSLookaheadIterator *self, TSStateId state);
+
+/**
+ * Reset the lookahead iterator.
+ *
+ * This returns `true` if the language was set successfully and `false`
+ * otherwise.
+*/
+bool ts_lookahead_iterator_reset(TSLookaheadIterator *self, const TSLanguage *language, TSStateId state);
+
+/**
+ * Get the current language of the lookahead iterator.
+*/
+const TSLanguage *ts_lookahead_iterator_language(const TSLookaheadIterator *self);
+
+/**
+ * Advance the lookahead iterator to the next symbol.
+ *
+ * This returns `true` if there is a new symbol and `false` otherwise.
+*/
+bool ts_lookahead_iterator_next(TSLookaheadIterator *self);
+
+/**
+ * Get the current symbol of the lookahead iterator;
+*/
+TSSymbol ts_lookahead_iterator_current_symbol(const TSLookaheadIterator *self);
+
+/**
+ * Get the current symbol type of the lookahead iterator as a null terminated
+ * string.
+*/
+const char *ts_lookahead_iterator_current_symbol_name(const TSLookaheadIterator *self);
 
 /*************************************/
 /* Section - WebAssembly Integration */
@@ -996,10 +1201,10 @@ TSWasmStore *ts_parser_take_wasm_store(TSParser *);
  * By default, Tree-sitter uses the standard libc allocation functions,
  * but aborts the process when an allocation fails. This function lets
  * you supply alternative allocation functions at runtime.
- * 
+ *
  * If you pass `NULL` for any parameter, Tree-sitter will switch back to
  * its default implementation of that function.
- * 
+ *
  * If you call this function after the library has already been used, then
  * you must ensure that either:
  *  1. All the existing objects have been freed.
@@ -1017,4 +1222,8 @@ void ts_set_allocator(
 }
 #endif
 
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC visibility pop
+#endif
+
 #endif  // TREE_SITTER_API_H_
diff --git a/lib/include/tree_sitter/parser.h b/lib/include/tree_sitter/parser.h
index 2b14ac10..d2103259 100644
--- a/lib/include/tree_sitter/parser.h
+++ b/lib/include/tree_sitter/parser.h
@@ -13,9 +13,8 @@ extern "C" {
 #define ts_builtin_sym_end 0
 #define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
 
-typedef uint16_t TSStateId;
-
 #ifndef TREE_SITTER_API_H_
+typedef uint16_t TSStateId;
 typedef uint16_t TSSymbol;
 typedef uint16_t TSFieldId;
 typedef struct TSLanguage TSLanguage;
@@ -140,7 +139,8 @@ struct TSLanguage {
   lexer->advance(lexer, skip);  \
   start:                        \
   skip = false;                 \
-  lookahead = lexer->lookahead;
+  lookahead = lexer->lookahead; \
+  eof = lexer->eof(lexer);
 
 #define ADVANCE(state_value) \
   {                          \
@@ -166,7 +166,7 @@ struct TSLanguage {
  *  Parse Table Macros
  */
 
-#define SMALL_STATE(id) id - LARGE_STATE_COUNT
+#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT)
 
 #define STATE(id) id
 
@@ -176,7 +176,7 @@ struct TSLanguage {
   {{                                  \
     .shift = {                        \
       .type = TSParseActionTypeShift, \
-      .state = state_value            \
+      .state = (state_value)          \
     }                                 \
   }}
 
@@ -184,7 +184,7 @@ struct TSLanguage {
   {{                                  \
     .shift = {                        \
       .type = TSParseActionTypeShift, \
-      .state = state_value,           \
+      .state = (state_value),         \
       .repetition = true              \
     }                                 \
   }}
diff --git a/lib/src/alloc.c b/lib/src/alloc.c
index a5d86fcd..78b8057d 100644
--- a/lib/src/alloc.c
+++ b/lib/src/alloc.c
@@ -5,7 +5,7 @@ static void *ts_malloc_default(size_t size) {
   void *result = malloc(size);
   if (size > 0 && !result) {
     fprintf(stderr, "tree-sitter failed to allocate %zu bytes", size);
-    exit(1);
+    abort();
   }
   return result;
 }
@@ -14,7 +14,7 @@ static void *ts_calloc_default(size_t count, size_t size) {
   void *result = calloc(count, size);
   if (count > 0 && !result) {
     fprintf(stderr, "tree-sitter failed to allocate %zu bytes", count * size);
-    exit(1);
+    abort();
   }
   return result;
 }
@@ -23,7 +23,7 @@ static void *ts_realloc_default(void *buffer, size_t size) {
   void *result = realloc(buffer, size);
   if (size > 0 && !result) {
     fprintf(stderr, "tree-sitter failed to reallocate %zu bytes", size);
-    exit(1);
+    abort();
   }
   return result;
 }
@@ -35,10 +35,10 @@ void *(*ts_current_realloc)(void *, size_t) = ts_realloc_default;
 void (*ts_current_free)(void *) = free;
 
 void ts_set_allocator(
-  void *(*new_malloc)(size_t),
-  void *(*new_calloc)(size_t, size_t),
-  void *(*new_realloc)(void *, size_t),
-  void (*new_free)(void *)
+  void *(*new_malloc)(size_t size),
+  void *(*new_calloc)(size_t count, size_t size),
+  void *(*new_realloc)(void *ptr, size_t size),
+  void (*new_free)(void *ptr)
 ) {
   ts_current_malloc = new_malloc ? new_malloc : ts_malloc_default;
   ts_current_calloc = new_calloc ? new_calloc : ts_calloc_default;
diff --git a/lib/src/array.h b/lib/src/array.h
index abec9410..e026f6b2 100644
--- a/lib/src/array.h
+++ b/lib/src/array.h
@@ -25,8 +25,8 @@ extern "C" {
 #define array_new() \
   { NULL, 0, 0 }
 
-#define array_get(self, index) \
-  (assert((uint32_t)index < (self)->size), &(self)->contents[index])
+#define array_get(self, _index) \
+  (assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index])
 
 #define array_front(self) array_get(self, 0)
 
@@ -38,7 +38,7 @@ extern "C" {
   array__reserve((VoidArray *)(self), array__elem_size(self), new_capacity)
 
 // Free any memory allocated for this array.
-#define array_delete(self) array__delete((VoidArray *)self)
+#define array_delete(self) array__delete((VoidArray *)(self))
 
 #define array_push(self, element)                            \
   (array__grow((VoidArray *)(self), 1, array__elem_size(self)), \
@@ -65,19 +65,19 @@ extern "C" {
 // Remove `old_count` elements from the array starting at the given `index`. At
 // the same index, insert `new_count` new elements, reading their values from the
 // `new_contents` pointer.
-#define array_splice(self, index, old_count, new_count, new_contents)  \
+#define array_splice(self, _index, old_count, new_count, new_contents)  \
   array__splice(                                                       \
-    (VoidArray *)(self), array__elem_size(self), index,                \
+    (VoidArray *)(self), array__elem_size(self), _index,                \
     old_count, new_count, new_contents                                 \
   )
 
 // Insert one `element` into the array at the given `index`.
-#define array_insert(self, index, element) \
-  array__splice((VoidArray *)(self), array__elem_size(self), index, 0, 1, &element)
+#define array_insert(self, _index, element) \
+  array__splice((VoidArray *)(self), array__elem_size(self), _index, 0, 1, &(element))
 
 // Remove one `element` from the array at the given `index`.
-#define array_erase(self, index) \
-  array__erase((VoidArray *)(self), array__elem_size(self), index)
+#define array_erase(self, _index) \
+  array__erase((VoidArray *)(self), array__elem_size(self), _index)
 
 #define array_pop(self) ((self)->contents[--(self)->size])
 
@@ -95,23 +95,23 @@ extern "C" {
 // out-parameter is set to true. Otherwise, `index` is set to an index where
 // `needle` should be inserted in order to preserve the sorting, and `exists`
 // is set to false.
-#define array_search_sorted_with(self, compare, needle, index, exists) \
-  array__search_sorted(self, 0, compare, , needle, index, exists)
+#define array_search_sorted_with(self, compare, needle, _index, _exists) \
+  array__search_sorted(self, 0, compare, , needle, _index, _exists)
 
 // Search a sorted array for a given `needle` value, using integer comparisons
 // of a given struct field (specified with a leading dot) to determine the order.
 //
 // See also `array_search_sorted_with`.
-#define array_search_sorted_by(self, field, needle, index, exists) \
-  array__search_sorted(self, 0, _compare_int, field, needle, index, exists)
+#define array_search_sorted_by(self, field, needle, _index, _exists) \
+  array__search_sorted(self, 0, compare_int, field, needle, _index, _exists)
 
 // Insert a given `value` into a sorted array, using the given `compare`
 // callback to determine the order.
 #define array_insert_sorted_with(self, compare, value) \
   do { \
-    unsigned index, exists; \
-    array_search_sorted_with(self, compare, &(value), &index, &exists); \
-    if (!exists) array_insert(self, index, value); \
+    unsigned _index, _exists; \
+    array_search_sorted_with(self, compare, &(value), &_index, &_exists); \
+    if (!_exists) array_insert(self, _index, value); \
   } while (0)
 
 // Insert a given `value` into a sorted array, using integer comparisons of
@@ -120,9 +120,9 @@ extern "C" {
 // See also `array_search_sorted_by`.
 #define array_insert_sorted_by(self, field, value) \
   do { \
-    unsigned index, exists; \
-    array_search_sorted_by(self, field, (value) field, &index, &exists); \
-    if (!exists) array_insert(self, index, value); \
+    unsigned _index, _exists; \
+    array_search_sorted_by(self, field, (value) field, &_index, &_exists); \
+    if (!_exists) array_insert(self, _index, value); \
   } while (0)
 
 // Private
@@ -132,10 +132,12 @@ typedef Array(void) VoidArray;
 #define array__elem_size(self) sizeof(*(self)->contents)
 
 static inline void array__delete(VoidArray *self) {
-  ts_free(self->contents);
-  self->contents = NULL;
-  self->size = 0;
-  self->capacity = 0;
+  if (self->contents) {
+    ts_free(self->contents);
+    self->contents = NULL;
+    self->size = 0;
+    self->capacity = 0;
+  }
 }
 
 static inline void array__erase(VoidArray *self, size_t element_size,
@@ -217,28 +219,28 @@ static inline void array__splice(VoidArray *self, size_t element_size,
 }
 
 // A binary search routine, based on Rust's `std::slice::binary_search_by`.
-#define array__search_sorted(self, start, compare, suffix, needle, index, exists) \
+#define array__search_sorted(self, start, compare, suffix, needle, _index, _exists) \
   do { \
-    *(index) = start; \
-    *(exists) = false; \
-    uint32_t size = (self)->size - *(index); \
+    *(_index) = start; \
+    *(_exists) = false; \
+    uint32_t size = (self)->size - *(_index); \
     if (size == 0) break; \
     int comparison; \
     while (size > 1) { \
       uint32_t half_size = size / 2; \
-      uint32_t mid_index = *(index) + half_size; \
+      uint32_t mid_index = *(_index) + half_size; \
       comparison = compare(&((self)->contents[mid_index] suffix), (needle)); \
-      if (comparison <= 0) *(index) = mid_index; \
+      if (comparison <= 0) *(_index) = mid_index; \
       size -= half_size; \
     } \
-    comparison = compare(&((self)->contents[*(index)] suffix), (needle)); \
-    if (comparison == 0) *(exists) = true; \
-    else if (comparison < 0) *(index) += 1; \
+    comparison = compare(&((self)->contents[*(_index)] suffix), (needle)); \
+    if (comparison == 0) *(_exists) = true; \
+    else if (comparison < 0) *(_index) += 1; \
   } while (0)
 
 // Helper macro for the `_sorted_by` routines below. This takes the left (existing)
 // parameter by reference in order to work with the generic sorting function above.
-#define _compare_int(a, b) ((int)*(a) - (int)(b))
+#define compare_int(a, b) ((int)*(a) - (int)(b))
 
 #ifdef __cplusplus
 }
diff --git a/lib/src/atomic.h b/lib/src/atomic.h
index 573a133f..e680b60e 100644
--- a/lib/src/atomic.h
+++ b/lib/src/atomic.h
@@ -1,6 +1,7 @@
 #ifndef TREE_SITTER_ATOMIC_H_
 #define TREE_SITTER_ATOMIC_H_
 
+#include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
 
@@ -47,11 +48,19 @@ static inline size_t atomic_load(const volatile size_t *p) {
 }
 
 static inline uint32_t atomic_inc(volatile uint32_t *p) {
-  return __sync_add_and_fetch(p, 1u);
+  #ifdef __ATOMIC_RELAXED
+    return __atomic_add_fetch(p, 1U, __ATOMIC_SEQ_CST);
+  #else
+    return __sync_add_and_fetch(p, 1U);
+  #endif
 }
 
 static inline uint32_t atomic_dec(volatile uint32_t *p) {
-  return __sync_sub_and_fetch(p, 1u);
+  #ifdef __ATOMIC_RELAXED
+    return __atomic_sub_fetch(p, 1U, __ATOMIC_SEQ_CST);
+  #else
+    return __sync_sub_and_fetch(p, 1U);
+  #endif
 }
 
 #endif
diff --git a/lib/src/clock.h b/lib/src/clock.h
index 94545f35..6e75729e 100644
--- a/lib/src/clock.h
+++ b/lib/src/clock.h
@@ -1,6 +1,7 @@
 #ifndef TREE_SITTER_CLOCK_H_
 #define TREE_SITTER_CLOCK_H_
 
+#include <stdbool.h>
 #include <stdint.h>
 
 typedef uint64_t TSDuration;
@@ -82,6 +83,10 @@ static inline TSClock clock_after(TSClock base, TSDuration duration) {
   TSClock result = base;
   result.tv_sec += duration / 1000000;
   result.tv_nsec += (duration % 1000000) * 1000;
+  if (result.tv_nsec >= 1000000000) {
+    result.tv_nsec -= 1000000000;
+    ++(result.tv_sec);
+  }
   return result;
 }
 
diff --git a/lib/src/get_changed_ranges.c b/lib/src/get_changed_ranges.c
index 18a42417..bcf8da94 100644
--- a/lib/src/get_changed_ranges.c
+++ b/lib/src/get_changed_ranges.c
@@ -210,7 +210,7 @@ static void iterator_ascend(Iterator *self) {
 static bool iterator_descend(Iterator *self, uint32_t goal_position) {
   if (self->in_padding) return false;
 
-  bool did_descend;
+  bool did_descend = false;
   do {
     did_descend = false;
     TreeCursorEntry entry = *array_back(&self->cursor.stack);
diff --git a/lib/src/language.c b/lib/src/language.c
index d0b497d6..f30329de 100644
--- a/lib/src/language.c
+++ b/lib/src/language.c
@@ -7,6 +7,10 @@ uint32_t ts_language_symbol_count(const TSLanguage *self) {
   return self->symbol_count + self->alias_count;
 }
 
+uint32_t ts_language_state_count(const TSLanguage *self) {
+  return self->state_count;
+}
+
 uint32_t ts_language_version(const TSLanguage *self) {
   return self->version;
 }
@@ -56,6 +60,28 @@ TSSymbol ts_language_public_symbol(
   return self->public_symbol_map[symbol];
 }
 
+TSStateId ts_language_next_state(
+  const TSLanguage *self,
+  TSStateId state,
+  TSSymbol symbol
+) {
+  if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) {
+    return 0;
+  } else if (symbol < self->token_count) {
+    uint32_t count;
+    const TSParseAction *actions = ts_language_actions(self, state, symbol, &count);
+    if (count > 0) {
+      TSParseAction action = actions[count - 1];
+      if (action.type == TSParseActionTypeShift) {
+        return action.shift.extra ? state : action.shift.state;
+      }
+    }
+    return 0;
+  } else {
+    return ts_language_lookup(self, state, symbol);
+  }
+}
+
 const char *ts_language_symbol_name(
   const TSLanguage *self,
   TSSymbol symbol
@@ -78,7 +104,7 @@ TSSymbol ts_language_symbol_for_name(
   bool is_named
 ) {
   if (!strncmp(string, "ERROR", length)) return ts_builtin_sym_error;
-  uint32_t count = ts_language_symbol_count(self);
+  uint16_t count = (uint16_t)ts_language_symbol_count(self);
   for (TSSymbol i = 0; i < count; i++) {
     TSSymbolMetadata metadata = ts_language_symbol_metadata(self, i);
     if ((!metadata.visible && !metadata.supertype) || metadata.named != is_named) continue;
@@ -121,7 +147,7 @@ TSFieldId ts_language_field_id_for_name(
   const char *name,
   uint32_t name_length
 ) {
-  uint32_t count = ts_language_field_count(self);
+  uint16_t count = (uint16_t)ts_language_field_count(self);
   for (TSSymbol i = 1; i < count + 1; i++) {
     switch (strncmp(name, self->field_names[i], name_length)) {
       case 0:
@@ -135,3 +161,48 @@ TSFieldId ts_language_field_id_for_name(
   }
   return 0;
 }
+
+TSLookaheadIterator *ts_lookahead_iterator_new(const TSLanguage *self, TSStateId state) {
+  if (state >= self->state_count) return NULL;
+  LookaheadIterator *iterator = ts_malloc(sizeof(LookaheadIterator));
+  *iterator = ts_language_lookaheads(self, state);
+  return (TSLookaheadIterator *)iterator;
+}
+
+void ts_lookahead_iterator_delete(TSLookaheadIterator *self) {
+  ts_free(self);
+}
+
+bool ts_lookahead_iterator_reset_state(TSLookaheadIterator * self, TSStateId state) {
+  LookaheadIterator *iterator = (LookaheadIterator *)self;
+  if (state >= iterator->language->state_count) return false;
+  *iterator = ts_language_lookaheads(iterator->language, state);
+  return true;
+}
+
+const TSLanguage *ts_lookahead_iterator_language(const TSLookaheadIterator *self) {
+  const LookaheadIterator *iterator = (const LookaheadIterator *)self;
+  return iterator->language;
+}
+
+bool ts_lookahead_iterator_reset(TSLookaheadIterator *self, const TSLanguage *language, TSStateId state) {
+  if (state >= language->state_count) return false;
+  LookaheadIterator *iterator = (LookaheadIterator *)self;
+  *iterator = ts_language_lookaheads(language, state);
+  return true;
+}
+
+bool ts_lookahead_iterator_next(TSLookaheadIterator *self) {
+  LookaheadIterator *iterator = (LookaheadIterator *)self;
+  return ts_lookahead_iterator__next(iterator);
+}
+
+TSSymbol ts_lookahead_iterator_current_symbol(const TSLookaheadIterator *self) {
+  const LookaheadIterator *iterator = (const LookaheadIterator *)self;
+  return iterator->symbol;
+}
+
+const char *ts_lookahead_iterator_current_symbol_name(const TSLookaheadIterator *self) {
+  const LookaheadIterator *iterator = (const LookaheadIterator *)self;
+  return ts_language_symbol_name(iterator->language, iterator->symbol);
+}
diff --git a/lib/src/language.h b/lib/src/language.h
index 7234685e..55b5d89b 100644
--- a/lib/src/language.h
+++ b/lib/src/language.h
@@ -38,6 +38,8 @@ TSSymbolMetadata ts_language_symbol_metadata(const TSLanguage *, TSSymbol);
 
 TSSymbol ts_language_public_symbol(const TSLanguage *, TSSymbol);
 
+TSStateId ts_language_next_state(const TSLanguage *self, TSStateId state, TSSymbol symbol);
+
 static inline bool ts_language_is_symbol_external(const TSLanguage *self, TSSymbol symbol) {
   return 0 < symbol && symbol < self->external_token_count + 1;
 }
@@ -83,7 +85,7 @@ static inline uint16_t ts_language_lookup(
     for (unsigned i = 0; i < group_count; i++) {
       uint16_t section_value = *(data++);
       uint16_t symbol_count = *(data++);
-      for (unsigned i = 0; i < symbol_count; i++) {
+      for (unsigned j = 0; j < symbol_count; j++) {
         if (*(data++) == symbol) return section_value;
       }
     }
@@ -134,7 +136,7 @@ static inline LookaheadIterator ts_language_lookaheads(
   };
 }
 
-static inline bool ts_lookahead_iterator_next(LookaheadIterator *self) {
+static inline bool ts_lookahead_iterator__next(LookaheadIterator *self) {
   // For small parse states, valid symbols are listed explicitly,
   // grouped by their value. There's no need to look up the actions
   // again until moving to the next group.
@@ -178,28 +180,6 @@ static inline bool ts_lookahead_iterator_next(LookaheadIterator *self) {
   return true;
 }
 
-static inline TSStateId ts_language_next_state(
-  const TSLanguage *self,
-  TSStateId state,
-  TSSymbol symbol
-) {
-  if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) {
-    return 0;
-  } else if (symbol < self->token_count) {
-    uint32_t count;
-    const TSParseAction *actions = ts_language_actions(self, state, symbol, &count);
-    if (count > 0) {
-      TSParseAction action = actions[count - 1];
-      if (action.type == TSParseActionTypeShift) {
-        return action.shift.extra ? state : action.shift.state;
-      }
-    }
-    return 0;
-  } else {
-    return ts_language_lookup(self, state, symbol);
-  }
-}
-
 // Whether the state is a "primary state". If this returns false, it indicates that there exists
 // another state that behaves identically to this one with respect to query analysis.
 static inline bool ts_language_state_is_primary(
@@ -269,17 +249,17 @@ static inline void ts_language_aliases_for_symbol(
   *start = &self->public_symbol_map[original_symbol];
   *end = *start + 1;
 
-  unsigned i = 0;
+  unsigned idx = 0;
   for (;;) {
-    TSSymbol symbol = self->alias_map[i++];
+    TSSymbol symbol = self->alias_map[idx++];
     if (symbol == 0 || symbol > original_symbol) break;
-    uint16_t count = self->alias_map[i++];
+    uint16_t count = self->alias_map[idx++];
     if (symbol == original_symbol) {
-      *start = &self->alias_map[i];
-      *end = &self->alias_map[i + count];
+      *start = &self->alias_map[idx];
+      *end = &self->alias_map[idx + count];
       break;
     }
-    i += count;
+    idx += count;
   }
 }
 
@@ -289,21 +269,21 @@ static inline void ts_language_write_symbol_as_dot_string(
   TSSymbol symbol
 ) {
   const char *name = ts_language_symbol_name(self, symbol);
-  for (const char *c = name; *c; c++) {
-    switch (*c) {
+  for (const char *chr = name; *chr; chr++) {
+    switch (*chr) {
       case '"':
       case '\\':
         fputc('\\', f);
-        fputc(*c, f);
+        fputc(*chr, f);
         break;
       case '\n':
         fputs("\\n", f);
         break;
       case '\t':
-        fputs("\\n", f);
+        fputs("\\t", f);
         break;
       default:
-        fputc(*c, f);
+        fputc(*chr, f);
         break;
     }
   }
diff --git a/lib/src/lexer.c b/lib/src/lexer.c
index acaf3e8c..d108c04e 100644
--- a/lib/src/lexer.c
+++ b/lib/src/lexer.c
@@ -172,7 +172,9 @@ static void ts_lexer__do_advance(Lexer *self, bool skip) {
     self->current_position.bytes >= current_range->end_byte ||
     current_range->end_byte == current_range->start_byte
   ) {
-    self->current_included_range_index++;
+    if (self->current_included_range_index < self->included_range_count) {
+      self->current_included_range_index++;
+    }
     if (self->current_included_range_index < self->included_range_count) {
       current_range++;
       self->current_position = (Length) {
@@ -209,11 +211,11 @@ static void ts_lexer__advance(TSLexer *_self, bool skip) {
   if (!self->chunk) return;
 
   if (skip) {
-    LOG("skip", self->data.lookahead);
+    LOG("skip", self->data.lookahead)
   } else {
-    LOG("consume", self->data.lookahead);
+    LOG("consume", self->data.lookahead)
   }
-  
+
   ts_lexer__do_advance(self, skip);
 }
 
@@ -245,9 +247,9 @@ static void ts_lexer__mark_end(TSLexer *_self) {
 
 static uint32_t ts_lexer__get_column(TSLexer *_self) {
   Lexer *self = (Lexer *)_self;
-  
+
   uint32_t goal_byte = self->current_position.bytes;
-  
+
   self->did_get_column = true;
   self->current_position.bytes -= self->current_position.extent.column;
   self->current_position.extent.column = 0;
@@ -257,10 +259,13 @@ static uint32_t ts_lexer__get_column(TSLexer *_self) {
   }
 
   uint32_t result = 0;
-  ts_lexer__get_lookahead(self);
-  while (self->current_position.bytes < goal_byte && !ts_lexer__eof(_self) && self->chunk) {
-    ts_lexer__do_advance(self, false);
-    result++;
+  if (!ts_lexer__eof(_self)) {
+    ts_lexer__get_lookahead(self);
+    while (self->current_position.bytes < goal_byte && self->chunk) {
+      result++;
+      ts_lexer__do_advance(self, false);
+      if (ts_lexer__eof(_self)) break;
+    }
   }
 
   return result;
diff --git a/lib/src/node.c b/lib/src/node.c
index de59504e..546b9099 100644
--- a/lib/src/node.c
+++ b/lib/src/node.c
@@ -237,6 +237,8 @@ static inline TSNode ts_node__prev_sibling(TSNode self, bool include_anonymous)
       return earlier_node;
     } else {
       node = earlier_node;
+      earlier_node = ts_node__null();
+      earlier_node_is_relevant = false;
     }
   }
 
@@ -423,6 +425,19 @@ const char *ts_node_type(TSNode self) {
   return ts_language_symbol_name(self.tree->language, symbol);
 }
 
+const TSLanguage *ts_node_language(TSNode self) {
+  return self.tree->language;
+}
+
+TSSymbol ts_node_grammar_symbol(TSNode self) {
+  return ts_subtree_symbol(ts_node__subtree(self));
+}
+
+const char *ts_node_grammar_type(TSNode self) {
+  TSSymbol symbol = ts_subtree_symbol(ts_node__subtree(self));
+  return ts_language_symbol_name(self.tree->language, symbol);
+}
+
 char *ts_node_string(TSNode self) {
   return ts_subtree_string(ts_node__subtree(self), self.tree->language, false);
 }
@@ -458,6 +473,29 @@ bool ts_node_has_error(TSNode self) {
   return ts_subtree_error_cost(ts_node__subtree(self)) > 0;
 }
 
+bool ts_node_is_error(TSNode self) {
+  TSSymbol symbol = ts_node_symbol(self);
+  return symbol == ts_builtin_sym_error;
+}
+
+uint32_t ts_node_descendant_count(TSNode self) {
+  return ts_subtree_visible_descendant_count(ts_node__subtree(self)) + 1;
+}
+
+TSStateId ts_node_parse_state(TSNode self) {
+  return ts_subtree_parse_state(ts_node__subtree(self));
+}
+
+TSStateId ts_node_next_parse_state(TSNode self) {
+  const TSLanguage *language = self.tree->language;
+  uint16_t state = ts_node_parse_state(self);
+  if (state == TS_TREE_STATE_NONE) {
+    return TS_TREE_STATE_NONE;
+  }
+  uint16_t symbol = ts_node_grammar_symbol(self);
+  return ts_language_next_state(language, state, symbol);
+}
+
 TSNode ts_node_parent(TSNode self) {
   TSNode node = ts_tree_root_node(self.tree);
   uint32_t end_byte = ts_node_end_byte(self);
@@ -569,24 +607,58 @@ recur:
   return ts_node__null();
 }
 
-const char *ts_node_field_name_for_child(TSNode self, uint32_t child_index) {
-  const TSFieldMapEntry *field_map_start = NULL, *field_map_end = NULL;
-  if (!ts_node_child_count(self)) {
+static inline const char *ts_node__field_name_from_language(TSNode self, uint32_t structural_child_index) {
+    const TSFieldMapEntry *field_map, *field_map_end;
+    ts_language_field_map(
+      self.tree->language,
+      ts_node__subtree(self).ptr->production_id,
+      &field_map,
+      &field_map_end
+    );
+    for (; field_map != field_map_end; field_map++) {
+      if (!field_map->inherited && field_map->child_index == structural_child_index) {
+        return self.tree->language->field_names[field_map->field_id];
+      }
+    }
     return NULL;
-  }
+}
 
-  ts_language_field_map(
-    self.tree->language,
-    ts_node__subtree(self).ptr->production_id,
-    &field_map_start,
-    &field_map_end
-  );
+const char *ts_node_field_name_for_child(TSNode self, uint32_t child_index) {
+  TSNode result = self;
+  bool did_descend = true;
+  const char *inherited_field_name = NULL;
 
-  for (const TSFieldMapEntry *i = field_map_start; i < field_map_end; i++) {
-    if (i->child_index == child_index) {
-      return self.tree->language->field_names[i->field_id];
+  while (did_descend) {
+    did_descend = false;
+
+    TSNode child;
+    uint32_t index = 0;
+    NodeChildIterator iterator = ts_node_iterate_children(&result);
+    while (ts_node_child_iterator_next(&iterator, &child)) {
+      if (ts_node__is_relevant(child, true)) {
+        if (index == child_index) {
+          const char *field_name = ts_node__field_name_from_language(result, iterator.structural_child_index - 1);
+          if (field_name) return field_name;
+          return inherited_field_name;
+        }
+        index++;
+      } else {
+        uint32_t grandchild_index = child_index - index;
+        uint32_t grandchild_count = ts_node__relevant_child_count(child, true);
+        if (grandchild_index < grandchild_count) {
+          const char *field_name = ts_node__field_name_from_language(result, iterator.structural_child_index - 1);
+          if (field_name) inherited_field_name = field_name;
+
+          did_descend = true;
+          result = child;
+          child_index = grandchild_index;
+          break;
+        }
+        index += grandchild_count;
+      }
     }
   }
+
   return NULL;
 }
 
diff --git a/lib/src/parser.c b/lib/src/parser.c
index 924c1afc..1265e423 100644
--- a/lib/src/parser.c
+++ b/lib/src/parser.c
@@ -134,10 +134,10 @@ typedef struct {
 static const char *ts_string_input_read(
   void *_self,
   uint32_t byte,
-  TSPoint pt,
+  TSPoint point,
   uint32_t *length
 ) {
-  (void)pt;
+  (void)point;
   TSStringInput *self = (TSStringInput *)_self;
   if (byte >= self->length) {
     *length = 0;
@@ -161,9 +161,9 @@ static void ts_parser__log(TSParser *self) {
 
   if (self->dot_graph_file) {
     fprintf(self->dot_graph_file, "graph {\nlabel=\"");
-    for (char *c = &self->lexer.debug_buffer[0]; *c != 0; c++) {
-      if (*c == '"' || *c == '\\') fputc('\\', self->dot_graph_file);
-      fputc(*c, self->dot_graph_file);
+    for (char *chr = &self->lexer.debug_buffer[0]; *chr != 0; chr++) {
+      if (*chr == '"' || *chr == '\\') fputc('\\', self->dot_graph_file);
+      fputc(*chr, self->dot_graph_file);
     }
     fprintf(self->dot_graph_file, "\"\n}\n\n");
   }
@@ -957,19 +957,19 @@ static StackVersion ts_parser__reduce(
       if (next_slice.version != slice.version) break;
       i++;
 
-      SubtreeArray children = next_slice.subtrees;
-      ts_subtree_array_remove_trailing_extras(&children, &self->trailing_extras2);
+      SubtreeArray next_slice_children = next_slice.subtrees;
+      ts_subtree_array_remove_trailing_extras(&next_slice_children, &self->trailing_extras2);
 
       if (ts_parser__select_children(
         self,
         ts_subtree_from_mut(parent),
-        &children
+        &next_slice_children
       )) {
         ts_subtree_array_clear(&self->tree_pool, &self->trailing_extras);
         ts_subtree_release(&self->tree_pool, ts_subtree_from_mut(parent));
         array_swap(&self->trailing_extras, &self->trailing_extras2);
         parent = ts_subtree_new_node(
-          symbol, &children, production_id, self->language
+          symbol, &next_slice_children, production_id, self->language
         );
       } else {
         array_clear(&self->trailing_extras2);
@@ -1080,8 +1080,8 @@ static bool ts_parser__do_all_potential_reductions(
     if (version >= version_count) break;
 
     bool merged = false;
-    for (StackVersion i = initial_version_count; i < version; i++) {
-      if (ts_stack_merge(self->stack, i, version)) {
+    for (StackVersion j = initial_version_count; j < version; j++) {
+      if (ts_stack_merge(self->stack, j, version)) {
         merged = true;
         break;
       }
@@ -1104,8 +1104,8 @@ static bool ts_parser__do_all_potential_reductions(
     for (TSSymbol symbol = first_symbol; symbol < end_symbol; symbol++) {
       TableEntry entry;
       ts_language_table_entry(self->language, state, symbol, &entry);
-      for (uint32_t i = 0; i < entry.action_count; i++) {
-        TSParseAction action = entry.actions[i];
+      for (uint32_t j = 0; j < entry.action_count; j++) {
+        TSParseAction action = entry.actions[j];
         switch (action.type) {
           case TSParseActionTypeShift:
           case TSParseActionTypeRecover:
@@ -1127,8 +1127,8 @@ static bool ts_parser__do_all_potential_reductions(
     }
 
     StackVersion reduction_version = STACK_VERSION_NONE;
-    for (uint32_t i = 0; i < self->reduce_actions.size; i++) {
-      ReduceAction action = self->reduce_actions.contents[i];
+    for (uint32_t j = 0; j < self->reduce_actions.size; j++) {
+      ReduceAction action = self->reduce_actions.contents[j];
 
       reduction_version = ts_parser__reduce(
         self, version, action.symbol, action.count,
@@ -1414,7 +1414,7 @@ static void ts_parser__handle_error(
       TSStateId state = ts_stack_state(self->stack, v);
       for (
         TSSymbol missing_symbol = 1;
-        missing_symbol < self->language->token_count;
+        missing_symbol < (uint16_t)self->language->token_count;
         missing_symbol++
       ) {
         TSStateId state_after_missing_symbol = ts_language_next_state(
@@ -1905,7 +1905,11 @@ void ts_parser_print_dot_graphs(TSParser *self, int fd) {
   }
 
   if (fd >= 0) {
+    #ifdef _WIN32
+    self->dot_graph_file = _fdopen(fd, "a");
+    #else
     self->dot_graph_file = fdopen(fd, "a");
+    #endif
   } else {
     self->dot_graph_file = NULL;
   }
@@ -2039,8 +2043,16 @@ TSTree *ts_parser_parse(
       }
     }
 
+    // After advancing each version of the stack, re-sort the versions by their cost,
+    // removing any versions that are no longer worth pursuing.
     unsigned min_error_cost = ts_parser__condense_stack(self);
+
+    // If there's already a finished parse tree that's better than any in-progress version,
+    // then terminate parsing. Clear the parse stack to remove any extra references to subtrees
+    // within the finished tree, ensuring that these subtrees can be safely mutated in-place
+    // for rebalancing.
     if (self->finished_tree.ptr && ts_subtree_error_cost(self->finished_tree) < min_error_cost) {
+      ts_stack_clear(self->stack);
       break;
     }
 
diff --git a/lib/src/query.c b/lib/src/query.c
index 710a9209..4e623ae7 100644
--- a/lib/src/query.c
+++ b/lib/src/query.c
@@ -143,9 +143,10 @@ typedef struct {
 } PatternEntry;
 
 typedef struct {
-  Slice steps;
-  Slice predicate_steps;
+  Slice step;
+  Slice predicate_step;
   uint32_t start_byte;
+  bool is_non_local;
 } QueryPattern;
 
 typedef struct {
@@ -228,11 +229,20 @@ typedef struct {
   AnalysisStateEntry stack[MAX_ANALYSIS_STATE_DEPTH];
   uint16_t depth;
   uint16_t step_index;
+  TSSymbol root_symbol;
 } AnalysisState;
 
 typedef Array(AnalysisState *) AnalysisStateSet;
 
-typedef Array(AnalysisState *) AnalysisStatePool;
+typedef struct {
+  AnalysisStateSet states;
+  AnalysisStateSet next_states;
+  AnalysisStateSet deeper_states;
+  AnalysisStateSet state_pool;
+  Array(uint16_t) final_step_indices;
+  Array(TSSymbol) finished_parent_symbols;
+  bool did_abort;
+} QueryAnalysis;
 
 /*
  * AnalysisSubgraph - A subset of the states in the parse table that are used
@@ -253,6 +263,8 @@ typedef struct {
   Array(AnalysisSubgraphNode) nodes;
 } AnalysisSubgraph;
 
+typedef Array(AnalysisSubgraph) AnalysisSubgraphArray;
+
 /*
  * StatePredecessorMap - A map that stores the predecessors of each parse state.
  * This is used during query analysis to determine which parse states can lead
@@ -269,8 +281,8 @@ typedef struct {
  */
 struct TSQuery {
   SymbolTable captures;
-  Array(CaptureQuantifiers) capture_quantifiers;
   SymbolTable predicate_values;
+  Array(CaptureQuantifiers) capture_quantifiers;
   Array(QueryStep) steps;
   Array(PatternEntry) pattern_map;
   Array(TSQueryPredicateStep) predicate_steps;
@@ -278,6 +290,7 @@ struct TSQuery {
   Array(StepOffset) step_offsets;
   Array(TSFieldId) negated_fields;
   Array(char) string_buffer;
+  Array(TSSymbol) repeat_symbols_with_rootless_patterns;
   const TSLanguage *language;
   uint16_t wildcard_root_pattern_count;
 };
@@ -292,11 +305,13 @@ struct TSQueryCursor {
   Array(QueryState) finished_states;
   CaptureListPool capture_list_pool;
   uint32_t depth;
+  uint32_t max_start_depth;
   uint32_t start_byte;
   uint32_t end_byte;
   TSPoint start_point;
   TSPoint end_point;
   uint32_t next_state_id;
+  bool on_visible_node;
   bool ascending;
   bool halted;
   bool did_exceed_match_limit;
@@ -317,7 +332,7 @@ static bool stream_advance(Stream *self) {
   if (self->input < self->end) {
     uint32_t size = ts_decode_utf8(
       (const uint8_t *)self->input,
-      self->end - self->input,
+      (uint32_t)(self->end - self->input),
       &self->next
     );
     if (size > 0) {
@@ -384,7 +399,7 @@ static void stream_scan_identifier(Stream *stream) {
 }
 
 static uint32_t stream_offset(Stream *self) {
-  return self->input - self->start;
+  return (uint32_t)(self->input - self->start);
 }
 
 /******************
@@ -401,7 +416,7 @@ static CaptureListPool capture_list_pool_new(void) {
 }
 
 static void capture_list_pool_reset(CaptureListPool *self) {
-  for (uint16_t i = 0; i < self->list.size; i++) {
+  for (uint16_t i = 0; i < (uint16_t)self->list.size; i++) {
     // This invalid size means that the list is not in use.
     self->list.contents[i].size = UINT32_MAX;
   }
@@ -409,7 +424,7 @@ static void capture_list_pool_reset(CaptureListPool *self) {
 }
 
 static void capture_list_pool_delete(CaptureListPool *self) {
-  for (uint16_t i = 0; i < self->list.size; i++) {
+  for (uint16_t i = 0; i < (uint16_t)self->list.size; i++) {
     array_delete(&self->list.contents[i]);
   }
   array_delete(&self->list);
@@ -434,7 +449,7 @@ static bool capture_list_pool_is_empty(const CaptureListPool *self) {
 static uint16_t capture_list_pool_acquire(CaptureListPool *self) {
   // First see if any already allocated capture list is currently unused.
   if (self->free_capture_list_count > 0) {
-    for (uint16_t i = 0; i < self->list.size; i++) {
+    for (uint16_t i = 0; i < (uint16_t)self->list.size; i++) {
       if (self->list.contents[i].size == UINT32_MAX) {
         array_clear(&self->list.contents[i]);
         self->free_capture_list_count--;
@@ -681,7 +696,7 @@ static void capture_quantifiers_add_all(
   if (self->size < quantifiers->size) {
     array_grow_by(self, quantifiers->size - self->size);
   }
-  for (uint16_t id = 0; id < quantifiers->size; id++) {
+  for (uint16_t id = 0; id < (uint16_t)quantifiers->size; id++) {
     uint8_t *quantifier = array_get(quantifiers, id);
     uint8_t *own_quantifier = array_get(self, id);
     *own_quantifier = (uint8_t) quantifier_add((TSQuantifier) *own_quantifier, (TSQuantifier) *quantifier);
@@ -693,7 +708,7 @@ static void capture_quantifiers_mul(
   CaptureQuantifiers *self,
   TSQuantifier quantifier
 ) {
-  for (uint16_t id = 0; id < self->size; id++) {
+  for (uint16_t id = 0; id < (uint16_t)self->size; id++) {
     uint8_t *own_quantifier = array_get(self, id);
     *own_quantifier = (uint8_t) quantifier_mul((TSQuantifier) *own_quantifier, quantifier);
   }
@@ -786,11 +801,10 @@ static QueryStep query_step__new(
   uint16_t depth,
   bool is_immediate
 ) {
-  return (QueryStep) {
+  QueryStep step = {
     .symbol = symbol,
     .depth = depth,
     .field = 0,
-    .capture_ids = {NONE, NONE, NONE},
     .alternative_index = NONE,
     .negated_field_list_id = 0,
     .contains_captures = false,
@@ -802,6 +816,10 @@ static QueryStep query_step__new(
     .is_immediate = is_immediate,
     .alternative_is_immediate = false,
   };
+  for (unsigned i = 0; i < MAX_STEP_CAPTURE_COUNT; i++) {
+    step.capture_ids[i] = NONE;
+  }
+  return step;
 }
 
 static void query_step__add_capture(QueryStep *self, uint16_t capture_id) {
@@ -924,6 +942,9 @@ static inline int analysis_state__compare(
 }
 
 static inline AnalysisStateEntry *analysis_state__top(AnalysisState *self) {
+  if (self->depth == 0) {
+    return &self->stack[0];
+  }
   return &self->stack[self->depth - 1];
 }
 
@@ -934,30 +955,23 @@ static inline bool analysis_state__has_supertype(AnalysisState *self, TSSymbol s
   return false;
 }
 
-static inline AnalysisState *analysis_state__clone(AnalysisState const *self) {
-  AnalysisState *new_state = ts_malloc(sizeof(AnalysisState));
-  *new_state = *self;
-  return new_state;
-}
-
-/****************
+/******************
  * AnalysisStateSet
- ****************/
+ ******************/
 
 // Obtains an `AnalysisState` instance, either by consuming one from this set's object pool, or by
 // cloning one from scratch.
 static inline AnalysisState *analysis_state_pool__clone_or_reuse(
-  AnalysisStatePool *self,
+  AnalysisStateSet *self,
   AnalysisState *borrowed_item
 ) {
   AnalysisState *new_item;
   if (self->size) {
     new_item = array_pop(self);
-    *new_item = *borrowed_item;
   } else {
-    new_item = analysis_state__clone(borrowed_item);
+    new_item = ts_malloc(sizeof(AnalysisState));
   }
-
+  *new_item = *borrowed_item;
   return new_item;
 }
 
@@ -967,9 +981,9 @@ static inline AnalysisState *analysis_state_pool__clone_or_reuse(
 //
 // The caller retains ownership of the passed-in memory. However, the clone that is created by this
 // function will be managed by the state set.
-static inline void analysis_state_set__insert_sorted_by_clone(
+static inline void analysis_state_set__insert_sorted(
   AnalysisStateSet *self,
-  AnalysisStatePool *pool,
+  AnalysisStateSet *pool,
   AnalysisState *borrowed_item
 ) {
   unsigned index, exists;
@@ -988,9 +1002,9 @@ static inline void analysis_state_set__insert_sorted_by_clone(
 //
 // The caller retains ownership of the passed-in memory. However, the clone that is created by this
 // function will be managed by the state set.
-static inline void analysis_state_set__push_by_clone(
+static inline void analysis_state_set__push(
   AnalysisStateSet *self,
-  AnalysisStatePool *pool,
+  AnalysisStateSet *pool,
   AnalysisState *borrowed_item
 ) {
   AnalysisState *new_item = analysis_state_pool__clone_or_reuse(pool, borrowed_item);
@@ -998,7 +1012,7 @@ static inline void analysis_state_set__push_by_clone(
 }
 
 // Removes all items from this set, returning it to an empty state.
-static inline void analysis_state_set__clear(AnalysisStateSet *self, AnalysisStatePool *pool) {
+static inline void analysis_state_set__clear(AnalysisStateSet *self, AnalysisStateSet *pool) {
   array_push_all(pool, self);
   array_clear(self);
 }
@@ -1012,6 +1026,31 @@ static inline void analysis_state_set__delete(AnalysisStateSet *self) {
   array_delete(self);
 }
 
+/****************
+ * QueryAnalyzer
+ ****************/
+
+static inline QueryAnalysis query_analysis__new() {
+  return (QueryAnalysis) {
+    .states = array_new(),
+    .next_states = array_new(),
+    .deeper_states = array_new(),
+    .state_pool = array_new(),
+    .final_step_indices = array_new(),
+    .finished_parent_symbols = array_new(),
+    .did_abort = false,
+  };
+}
+
+static inline void query_analysis__delete(QueryAnalysis *self) {
+  analysis_state_set__delete(&self->states);
+  analysis_state_set__delete(&self->next_states);
+  analysis_state_set__delete(&self->deeper_states);
+  analysis_state_set__delete(&self->state_pool);
+  array_delete(&self->final_step_indices);
+  array_delete(&self->finished_parent_symbols);
+}
+
 /***********************
  * AnalysisSubgraphNode
  ***********************/
@@ -1113,7 +1152,322 @@ static inline void ts_query__pattern_map_insert(
   array_insert(&self->pattern_map, index, new_entry);
 }
 
+// Walk the subgraph for this non-terminal, tracking all of the possible
+// sequences of progress within the pattern.
+static void ts_query__perform_analysis(
+  TSQuery *self,
+  const AnalysisSubgraphArray *subgraphs,
+  QueryAnalysis *analysis
+) {
+  unsigned recursion_depth_limit = 0;
+  unsigned prev_final_step_count = 0;
+  array_clear(&analysis->final_step_indices);
+  array_clear(&analysis->finished_parent_symbols);
+
+  for (unsigned iteration = 0;; iteration++) {
+    if (iteration == MAX_ANALYSIS_ITERATION_COUNT) {
+      analysis->did_abort = true;
+      break;
+    }
+
+    #ifdef DEBUG_ANALYZE_QUERY
+      printf("Iteration: %u. Final step indices:", iteration);
+      for (unsigned j = 0; j < analysis->final_step_indices.size; j++) {
+        printf(" %4u", analysis->final_step_indices.contents[j]);
+      }
+      printf("\n");
+      for (unsigned j = 0; j < analysis->states.size; j++) {
+        AnalysisState *state = analysis->states.contents[j];
+        printf("  %3u: step: %u, stack: [", j, state->step_index);
+        for (unsigned k = 0; k < state->depth; k++) {
+          printf(
+            " {%s, child: %u, state: %4u",
+            self->language->symbol_names[state->stack[k].parent_symbol],
+            state->stack[k].child_index,
+            state->stack[k].parse_state
+          );
+          if (state->stack[k].field_id) printf(", field: %s", self->language->field_names[state->stack[k].field_id]);
+          if (state->stack[k].done) printf(", DONE");
+          printf("}");
+        }
+        printf(" ]\n");
+      }
+    #endif
+
+    // If no further progress can be made within the current recursion depth limit, then
+    // bump the depth limit by one, and continue to process the states the exceeded the
+    // limit. But only allow this if progress has been made since the last time the depth
+    // limit was increased.
+    if (analysis->states.size == 0) {
+      if (
+        analysis->deeper_states.size > 0 &&
+        analysis->final_step_indices.size > prev_final_step_count
+      ) {
+        #ifdef DEBUG_ANALYZE_QUERY
+          printf("Increase recursion depth limit to %u\n", recursion_depth_limit + 1);
+        #endif
+
+        prev_final_step_count = analysis->final_step_indices.size;
+        recursion_depth_limit++;
+        AnalysisStateSet _states = analysis->states;
+        analysis->states = analysis->deeper_states;
+        analysis->deeper_states = _states;
+        continue;
+      }
+
+      break;
+    }
+
+    analysis_state_set__clear(&analysis->next_states, &analysis->state_pool);
+    for (unsigned j = 0; j < analysis->states.size; j++) {
+      AnalysisState * const state = analysis->states.contents[j];
+
+      // For efficiency, it's important to avoid processing the same analysis state more
+      // than once. To achieve this, keep the states in order of ascending position within
+      // their hypothetical syntax trees. In each iteration of this loop, start by advancing
+      // the states that have made the least progress. Avoid advancing states that have already
+      // made more progress.
+      if (analysis->next_states.size > 0) {
+        int comparison = analysis_state__compare_position(
+          &state,
+          array_back(&analysis->next_states)
+        );
+        if (comparison == 0) {
+          analysis_state_set__insert_sorted(&analysis->next_states, &analysis->state_pool, state);
+          continue;
+        } else if (comparison > 0) {
+          #ifdef DEBUG_ANALYZE_QUERY
+            printf("Terminate iteration at state %u\n", j);
+          #endif
+          while (j < analysis->states.size) {
+            analysis_state_set__push(
+              &analysis->next_states,
+              &analysis->state_pool,
+              analysis->states.contents[j]
+            );
+            j++;
+          }
+          break;
+        }
+      }
+
+      const TSStateId parse_state = analysis_state__top(state)->parse_state;
+      const TSSymbol parent_symbol = analysis_state__top(state)->parent_symbol;
+      const TSFieldId parent_field_id = analysis_state__top(state)->field_id;
+      const unsigned child_index = analysis_state__top(state)->child_index;
+      const QueryStep * const step = &self->steps.contents[state->step_index];
+
+      unsigned subgraph_index, exists;
+      array_search_sorted_by(subgraphs, .symbol, parent_symbol, &subgraph_index, &exists);
+      if (!exists) continue;
+      const AnalysisSubgraph *subgraph = &subgraphs->contents[subgraph_index];
+
+      // Follow every possible path in the parse table, but only visit states that
+      // are part of the subgraph for the current symbol.
+      LookaheadIterator lookahead_iterator = ts_language_lookaheads(self->language, parse_state);
+      while (ts_lookahead_iterator__next(&lookahead_iterator)) {
+        TSSymbol sym = lookahead_iterator.symbol;
+
+        AnalysisSubgraphNode successor = {
+          .state = parse_state,
+          .child_index = child_index,
+        };
+        if (lookahead_iterator.action_count) {
+          const TSParseAction *action = &lookahead_iterator.actions[lookahead_iterator.action_count - 1];
+          if (action->type == TSParseActionTypeShift) {
+            if (!action->shift.extra) {
+              successor.state = action->shift.state;
+              successor.child_index++;
+            }
+          } else {
+            continue;
+          }
+        } else if (lookahead_iterator.next_state != 0) {
+          successor.state = lookahead_iterator.next_state;
+          successor.child_index++;
+        } else {
+          continue;
+        }
+
+        unsigned node_index;
+        array_search_sorted_with(
+          &subgraph->nodes,
+          analysis_subgraph_node__compare, &successor,
+          &node_index, &exists
+        );
+        while (node_index < subgraph->nodes.size) {
+          AnalysisSubgraphNode *node = &subgraph->nodes.contents[node_index++];
+          if (node->state != successor.state || node->child_index != successor.child_index) break;
+
+          // Use the subgraph to determine what alias and field will eventually be applied
+          // to this child node.
+          TSSymbol alias = ts_language_alias_at(self->language, node->production_id, child_index);
+          TSSymbol visible_symbol = alias
+            ? alias
+            : self->language->symbol_metadata[sym].visible
+              ? self->language->public_symbol_map[sym]
+              : 0;
+          TSFieldId field_id = parent_field_id;
+          if (!field_id) {
+            const TSFieldMapEntry *field_map, *field_map_end;
+            ts_language_field_map(self->language, node->production_id, &field_map, &field_map_end);
+            for (; field_map != field_map_end; field_map++) {
+              if (!field_map->inherited && field_map->child_index == child_index) {
+                field_id = field_map->field_id;
+                break;
+              }
+            }
+          }
+
+          // Create a new state that has advanced past this hypothetical subtree.
+          AnalysisState next_state = *state;
+          AnalysisStateEntry *next_state_top = analysis_state__top(&next_state);
+          next_state_top->child_index = successor.child_index;
+          next_state_top->parse_state = successor.state;
+          if (node->done) next_state_top->done = true;
+
+          // Determine if this hypothetical child node would match the current step
+          // of the query pattern.
+          bool does_match = false;
+          if (visible_symbol) {
+            does_match = true;
+            if (step->symbol == WILDCARD_SYMBOL) {
+              if (
+                step->is_named &&
+                !self->language->symbol_metadata[visible_symbol].named
+              ) does_match = false;
+            } else if (step->symbol != visible_symbol) {
+              does_match = false;
+            }
+            if (step->field && step->field != field_id) {
+              does_match = false;
+            }
+            if (
+              step->supertype_symbol &&
+              !analysis_state__has_supertype(state, step->supertype_symbol)
+            ) does_match = false;
+          }
+
+          // If this child is hidden, then descend into it and walk through its children.
+          // If the top entry of the stack is at the end of its rule, then that entry can
+          // be replaced. Otherwise, push a new entry onto the stack.
+          else if (sym >= self->language->token_count) {
+            if (!next_state_top->done) {
+              if (next_state.depth + 1 >= MAX_ANALYSIS_STATE_DEPTH) {
+                #ifdef DEBUG_ANALYZE_QUERY
+                  printf("Exceeded depth limit for state %u\n", j);
+                #endif
+
+                analysis->did_abort = true;
+                continue;
+              }
+
+              next_state.depth++;
+              next_state_top = analysis_state__top(&next_state);
+            }
+
+            *next_state_top = (AnalysisStateEntry) {
+              .parse_state = parse_state,
+              .parent_symbol = sym,
+              .child_index = 0,
+              .field_id = field_id,
+              .done = false,
+            };
+
+            if (analysis_state__recursion_depth(&next_state) > recursion_depth_limit) {
+              analysis_state_set__insert_sorted(
+                &analysis->deeper_states,
+                &analysis->state_pool,
+                &next_state
+              );
+              continue;
+            }
+          }
+
+          // Pop from the stack when this state reached the end of its current syntax node.
+          while (next_state.depth > 0 && next_state_top->done) {
+            next_state.depth--;
+            next_state_top = analysis_state__top(&next_state);
+          }
+
+          // If this hypothetical child did match the current step of the query pattern,
+          // then advance to the next step at the current depth. This involves skipping
+          // over any descendant steps of the current child.
+          const QueryStep *next_step = step;
+          if (does_match) {
+            for (;;) {
+              next_state.step_index++;
+              next_step = &self->steps.contents[next_state.step_index];
+              if (
+                next_step->depth == PATTERN_DONE_MARKER ||
+                next_step->depth <= step->depth
+              ) break;
+            }
+          } else if (successor.state == parse_state) {
+            continue;
+          }
+
+          for (;;) {
+            // Skip pass-through states. Although these states have alternatives, they are only
+            // used to implement repetitions, and query analysis does not need to process
+            // repetitions in order to determine whether steps are possible and definite.
+            if (next_step->is_pass_through) {
+              next_state.step_index++;
+              next_step++;
+              continue;
+            }
+
+            // If the pattern is finished or hypothetical parent node is complete, then
+            // record that matching can terminate at this step of the pattern. Otherwise,
+            // add this state to the list of states to process on the next iteration.
+            if (!next_step->is_dead_end) {
+              bool did_finish_pattern = self->steps.contents[next_state.step_index].depth != step->depth;
+              if (did_finish_pattern) {
+                array_insert_sorted_by(&analysis->finished_parent_symbols, , state->root_symbol);
+              } else if (next_state.depth == 0) {
+                array_insert_sorted_by(&analysis->final_step_indices, , next_state.step_index);
+              } else {
+                analysis_state_set__insert_sorted(&analysis->next_states, &analysis->state_pool, &next_state);
+              }
+            }
+
+            // If the state has advanced to a step with an alternative step, then add another state
+            // at that alternative step. This process is simpler than the process of actually matching a
+            // pattern during query execution, because for the purposes of query analysis, there is no
+            // need to process repetitions.
+            if (
+              does_match &&
+              next_step->alternative_index != NONE &&
+              next_step->alternative_index > next_state.step_index
+            ) {
+              next_state.step_index = next_step->alternative_index;
+              next_step = &self->steps.contents[next_state.step_index];
+            } else {
+              break;
+            }
+          }
+        }
+      }
+    }
+
+    AnalysisStateSet _states = analysis->states;
+    analysis->states = analysis->next_states;
+    analysis->next_states = _states;
+  }
+}
+
 static bool ts_query__analyze_patterns(TSQuery *self, unsigned *error_offset) {
+  Array(uint16_t) non_rooted_pattern_start_steps = array_new();
+  for (unsigned i = 0; i < self->pattern_map.size; i++) {
+    PatternEntry *pattern = &self->pattern_map.contents[i];
+    if (!pattern->is_rooted) {
+      QueryStep *step = &self->steps.contents[pattern->step_index];
+      if (step->symbol != WILDCARD_SYMBOL) {
+        array_push(&non_rooted_pattern_start_steps, i);
+      }
+    }
+  }
+
   // Walk forward through all of the steps in the query, computing some
   // basic information about each step. Mark all of the steps that contain
   // captures, and record the indices of all of the steps that have child steps.
@@ -1158,14 +1512,14 @@ static bool ts_query__analyze_patterns(TSQuery *self, unsigned *error_offset) {
   // of the hidden symbols in the grammar, because these might occur within
   // one of the parent nodes, such that their children appear to belong to the
   // parent.
-  Array(AnalysisSubgraph) subgraphs = array_new();
+  AnalysisSubgraphArray subgraphs = array_new();
   for (unsigned i = 0; i < parent_step_indices.size; i++) {
     uint32_t parent_step_index = parent_step_indices.contents[i];
     TSSymbol parent_symbol = self->steps.contents[parent_step_index].symbol;
     AnalysisSubgraph subgraph = { .symbol = parent_symbol };
     array_insert_sorted_by(&subgraphs, .symbol, subgraph);
   }
-  for (TSSymbol sym = self->language->token_count; sym < self->language->symbol_count; sym++) {
+  for (TSSymbol sym = (uint16_t)self->language->token_count; sym < (uint16_t)self->language->symbol_count; sym++) {
     if (!ts_language_symbol_metadata(self->language, sym).visible) {
       AnalysisSubgraph subgraph = { .symbol = sym };
       array_insert_sorted_by(&subgraphs, .symbol, subgraph);
@@ -1179,10 +1533,10 @@ static bool ts_query__analyze_patterns(TSQuery *self, unsigned *error_offset) {
   //      with information about the node that would be created.
   //   3) A list of predecessor states for each state.
   StatePredecessorMap predecessor_map = state_predecessor_map_new(self->language);
-  for (TSStateId state = 1; state < self->language->state_count; state++) {
+  for (TSStateId state = 1; state < (uint16_t)self->language->state_count; state++) {
     unsigned subgraph_index, exists;
     LookaheadIterator lookahead_iterator = ts_language_lookaheads(self->language, state);
-    while (ts_lookahead_iterator_next(&lookahead_iterator)) {
+    while (ts_lookahead_iterator__next(&lookahead_iterator)) {
       if (lookahead_iterator.action_count) {
         for (unsigned i = 0; i < lookahead_iterator.action_count; i++) {
           const TSParseAction *action = &lookahead_iterator.actions[i];
@@ -1320,11 +1674,7 @@ static bool ts_query__analyze_patterns(TSQuery *self, unsigned *error_offset) {
   // For each non-terminal pattern, determine if the pattern can successfully match,
   // and identify all of the possible children within the pattern where matching could fail.
   bool all_patterns_are_valid = true;
-  AnalysisStateSet states = array_new();
-  AnalysisStateSet next_states = array_new();
-  AnalysisStateSet deeper_states = array_new();
-  AnalysisStatePool state_pool = array_new();
-  Array(uint16_t) final_step_indices = array_new();
+  QueryAnalysis analysis = query_analysis__new();
   for (unsigned i = 0; i < parent_step_indices.size; i++) {
     uint16_t parent_step_index = parent_step_indices.contents[i];
     uint16_t parent_depth = self->steps.contents[parent_step_index].depth;
@@ -1337,10 +1687,10 @@ static bool ts_query__analyze_patterns(TSQuery *self, unsigned *error_offset) {
     array_search_sorted_by(&subgraphs, .symbol, parent_symbol, &subgraph_index, &exists);
     if (!exists) {
       unsigned first_child_step_index = parent_step_index + 1;
-      uint32_t i, exists;
-      array_search_sorted_by(&self->step_offsets, .step_index, first_child_step_index, &i, &exists);
-      assert(exists);
-      *error_offset = self->step_offsets.contents[i].byte_offset;
+      uint32_t j, child_exists;
+      array_search_sorted_by(&self->step_offsets, .step_index, first_child_step_index, &j, &child_exists);
+      assert(child_exists);
+      *error_offset = self->step_offsets.contents[j].byte_offset;
       all_patterns_are_valid = false;
       break;
     }
@@ -1348,11 +1698,11 @@ static bool ts_query__analyze_patterns(TSQuery *self, unsigned *error_offset) {
     // Initialize an analysis state at every parse state in the table where
     // this parent symbol can occur.
     AnalysisSubgraph *subgraph = &subgraphs.contents[subgraph_index];
-    analysis_state_set__clear(&states, &state_pool);
-    analysis_state_set__clear(&deeper_states, &state_pool);
+    analysis_state_set__clear(&analysis.states, &analysis.state_pool);
+    analysis_state_set__clear(&analysis.deeper_states, &analysis.state_pool);
     for (unsigned j = 0; j < subgraph->start_states.size; j++) {
       TSStateId parse_state = subgraph->start_states.contents[j];
-      analysis_state_set__push_by_clone(&states, &state_pool, &((AnalysisState) {
+      analysis_state_set__push(&analysis.states, &analysis.state_pool, &((AnalysisState) {
         .step_index = parent_step_index + 1,
         .stack = {
           [0] = {
@@ -1364,312 +1714,23 @@ static bool ts_query__analyze_patterns(TSQuery *self, unsigned *error_offset) {
           },
         },
         .depth = 1,
+        .root_symbol = parent_symbol,
       }));
     }
 
-    // Walk the subgraph for this non-terminal, tracking all of the possible
-    // sequences of progress within the pattern.
-    bool can_finish_pattern = false;
-    bool did_abort_analysis = false;
-    unsigned recursion_depth_limit = 0;
-    unsigned prev_final_step_count = 0;
-    array_clear(&final_step_indices);
-    for (unsigned iteration = 0;; iteration++) {
-      if (iteration == MAX_ANALYSIS_ITERATION_COUNT) {
-        did_abort_analysis = true;
-        break;
-      }
+    #ifdef DEBUG_ANALYZE_QUERY
+      printf(
+        "\nWalk states for %s:\n",
+        ts_language_symbol_name(self->language, analysis.states.contents[0]->stack[0].parent_symbol)
+      );
+    #endif
 
-      #ifdef DEBUG_ANALYZE_QUERY
-        printf("Iteration: %u. Final step indices:", iteration);
-        for (unsigned j = 0; j < final_step_indices.size; j++) {
-          printf(" %4u", final_step_indices.contents[j]);
-        }
-        printf("\nWalk states for %u %s:\n", i, ts_language_symbol_name(self->language, parent_symbol));
-        for (unsigned j = 0; j < states.size; j++) {
-          AnalysisState *state = states.contents[j];
-          printf("  %3u: step: %u, stack: [", j, state->step_index);
-          for (unsigned k = 0; k < state->depth; k++) {
-            printf(
-              " {%s, child: %u, state: %4u",
-              self->language->symbol_names[state->stack[k].parent_symbol],
-              state->stack[k].child_index,
-              state->stack[k].parse_state
-            );
-            if (state->stack[k].field_id) printf(", field: %s", self->language->field_names[state->stack[k].field_id]);
-            if (state->stack[k].done) printf(", DONE");
-            printf("}");
-          }
-          printf(" ]\n");
-        }
-      #endif
-
-      // If no further progress can be made within the current recursion depth limit, then
-      // bump the depth limit by one, and continue to process the states the exceeded the
-      // limit. But only allow this if progress has been made since the last time the depth
-      // limit was increased.
-      if (states.size == 0) {
-        if (
-            deeper_states.size > 0
-            && final_step_indices.size > prev_final_step_count
-        ) {
-          #ifdef DEBUG_ANALYZE_QUERY
-            printf("Increase recursion depth limit to %u\n", recursion_depth_limit + 1);
-          #endif
-
-          prev_final_step_count = final_step_indices.size;
-          recursion_depth_limit++;
-          AnalysisStateSet _states = states;
-          states = deeper_states;
-          deeper_states = _states;
-          continue;
-        }
-
-        break;
-      }
-
-      analysis_state_set__clear(&next_states, &state_pool);
-      for (unsigned j = 0; j < states.size; j++) {
-        AnalysisState * const state = states.contents[j];
-
-        // For efficiency, it's important to avoid processing the same analysis state more
-        // than once. To achieve this, keep the states in order of ascending position within
-        // their hypothetical syntax trees. In each iteration of this loop, start by advancing
-        // the states that have made the least progress. Avoid advancing states that have already
-        // made more progress.
-        if (next_states.size > 0) {
-          int comparison = analysis_state__compare_position(
-            &state,
-            array_back(&next_states)
-          );
-          if (comparison == 0) {
-            #ifdef DEBUG_ANALYZE_QUERY
-              printf("Skip iteration for state %u\n", j);
-            #endif
-            analysis_state_set__insert_sorted_by_clone(&next_states, &state_pool, state);
-            continue;
-          } else if (comparison > 0) {
-            #ifdef DEBUG_ANALYZE_QUERY
-              printf("Terminate iteration at state %u\n", j);
-            #endif
-            while (j < states.size) {
-              analysis_state_set__push_by_clone(
-                &next_states,
-                &state_pool,
-                states.contents[j]
-              );
-              j++;
-            }
-            break;
-          }
-        }
-
-        const TSStateId parse_state = analysis_state__top(state)->parse_state;
-        const TSSymbol parent_symbol = analysis_state__top(state)->parent_symbol;
-        const TSFieldId parent_field_id = analysis_state__top(state)->field_id;
-        const unsigned child_index = analysis_state__top(state)->child_index;
-        const QueryStep * const step = &self->steps.contents[state->step_index];
-
-        unsigned subgraph_index, exists;
-        array_search_sorted_by(&subgraphs, .symbol, parent_symbol, &subgraph_index, &exists);
-        if (!exists) continue;
-        const AnalysisSubgraph *subgraph = &subgraphs.contents[subgraph_index];
-
-        // Follow every possible path in the parse table, but only visit states that
-        // are part of the subgraph for the current symbol.
-        LookaheadIterator lookahead_iterator = ts_language_lookaheads(self->language, parse_state);
-        while (ts_lookahead_iterator_next(&lookahead_iterator)) {
-          TSSymbol sym = lookahead_iterator.symbol;
-
-          AnalysisSubgraphNode successor = {
-            .state = parse_state,
-            .child_index = child_index,
-          };
-          if (lookahead_iterator.action_count) {
-            const TSParseAction *action = &lookahead_iterator.actions[lookahead_iterator.action_count - 1];
-            if (action->type == TSParseActionTypeShift) {
-              if (!action->shift.extra) {
-                successor.state = action->shift.state;
-                successor.child_index++;
-              }
-            } else {
-              continue;
-            }
-          } else if (lookahead_iterator.next_state != 0) {
-            successor.state = lookahead_iterator.next_state;
-            successor.child_index++;
-          } else {
-            continue;
-          }
-
-          unsigned node_index;
-          array_search_sorted_with(
-            &subgraph->nodes,
-            analysis_subgraph_node__compare, &successor,
-            &node_index, &exists
-          );
-          while (node_index < subgraph->nodes.size) {
-            AnalysisSubgraphNode *node = &subgraph->nodes.contents[node_index++];
-            if (node->state != successor.state || node->child_index != successor.child_index) break;
-
-            // Use the subgraph to determine what alias and field will eventually be applied
-            // to this child node.
-            TSSymbol alias = ts_language_alias_at(self->language, node->production_id, child_index);
-            TSSymbol visible_symbol = alias
-              ? alias
-              : self->language->symbol_metadata[sym].visible
-                ? self->language->public_symbol_map[sym]
-                : 0;
-            TSFieldId field_id = parent_field_id;
-            if (!field_id) {
-              const TSFieldMapEntry *field_map, *field_map_end;
-              ts_language_field_map(self->language, node->production_id, &field_map, &field_map_end);
-              for (; field_map != field_map_end; field_map++) {
-                if (!field_map->inherited && field_map->child_index == child_index) {
-                  field_id = field_map->field_id;
-                  break;
-                }
-              }
-            }
-
-            // Create a new state that has advanced past this hypothetical subtree.
-            AnalysisState next_state = *state;
-            AnalysisStateEntry *next_state_top = analysis_state__top(&next_state);
-            next_state_top->child_index = successor.child_index;
-            next_state_top->parse_state = successor.state;
-            if (node->done) next_state_top->done = true;
-
-            // Determine if this hypothetical child node would match the current step
-            // of the query pattern.
-            bool does_match = false;
-            if (visible_symbol) {
-              does_match = true;
-              if (step->symbol == WILDCARD_SYMBOL) {
-                if (
-                  step->is_named &&
-                  !self->language->symbol_metadata[visible_symbol].named
-                ) does_match = false;
-              } else if (step->symbol != visible_symbol) {
-                does_match = false;
-              }
-              if (step->field && step->field != field_id) {
-                does_match = false;
-              }
-              if (
-                step->supertype_symbol &&
-                !analysis_state__has_supertype(state, step->supertype_symbol)
-              ) does_match = false;
-            }
-
-            // If this child is hidden, then descend into it and walk through its children.
-            // If the top entry of the stack is at the end of its rule, then that entry can
-            // be replaced. Otherwise, push a new entry onto the stack.
-            else if (sym >= self->language->token_count) {
-              if (!next_state_top->done) {
-                if (next_state.depth + 1 >= MAX_ANALYSIS_STATE_DEPTH) {
-                  #ifdef DEBUG_ANALYZE_QUERY
-                    printf("Exceeded depth limit for state %u\n", j);
-                  #endif
-
-                  did_abort_analysis = true;
-                  continue;
-                }
-
-                next_state.depth++;
-                next_state_top = analysis_state__top(&next_state);
-              }
-
-              *next_state_top = (AnalysisStateEntry) {
-                .parse_state = parse_state,
-                .parent_symbol = sym,
-                .child_index = 0,
-                .field_id = field_id,
-                .done = false,
-              };
-
-              if (analysis_state__recursion_depth(&next_state) > recursion_depth_limit) {
-                analysis_state_set__insert_sorted_by_clone(
-                  &deeper_states,
-                  &state_pool,
-                  &next_state
-                );
-                continue;
-              }
-            }
-
-            // Pop from the stack when this state reached the end of its current syntax node.
-            while (next_state.depth > 0 && next_state_top->done) {
-              next_state.depth--;
-              next_state_top = analysis_state__top(&next_state);
-            }
-
-            // If this hypothetical child did match the current step of the query pattern,
-            // then advance to the next step at the current depth. This involves skipping
-            // over any descendant steps of the current child.
-            const QueryStep *next_step = step;
-            if (does_match) {
-              for (;;) {
-                next_state.step_index++;
-                next_step = &self->steps.contents[next_state.step_index];
-                if (
-                  next_step->depth == PATTERN_DONE_MARKER ||
-                  next_step->depth <= parent_depth + 1
-                ) break;
-              }
-            } else if (successor.state == parse_state) {
-              continue;
-            }
-
-            for (;;) {
-              // Skip pass-through states. Although these states have alternatives, they are only
-              // used to implement repetitions, and query analysis does not need to process
-              // repetitions in order to determine whether steps are possible and definite.
-              if (next_step->is_pass_through) {
-                next_state.step_index++;
-                next_step++;
-                continue;
-              }
-
-              // If the pattern is finished or hypothetical parent node is complete, then
-              // record that matching can terminate at this step of the pattern. Otherwise,
-              // add this state to the list of states to process on the next iteration.
-              if (!next_step->is_dead_end) {
-                bool did_finish_pattern = self->steps.contents[next_state.step_index].depth != parent_depth + 1;
-                if (did_finish_pattern) can_finish_pattern = true;
-                if (did_finish_pattern || next_state.depth == 0) {
-                  array_insert_sorted_by(&final_step_indices, , next_state.step_index);
-                } else {
-                  analysis_state_set__insert_sorted_by_clone(&next_states, &state_pool, &next_state);
-                }
-              }
-
-              // If the state has advanced to a step with an alternative step, then add another state
-              // at that alternative step. This process is simpler than the process of actually matching a
-              // pattern during query execution, because for the purposes of query analysis, there is no
-              // need to process repetitions.
-              if (
-                does_match &&
-                next_step->alternative_index != NONE &&
-                next_step->alternative_index > next_state.step_index
-              ) {
-                next_state.step_index = next_step->alternative_index;
-                next_step = &self->steps.contents[next_state.step_index];
-              } else {
-                break;
-              }
-            }
-          }
-        }
-      }
-
-      AnalysisStateSet _states = states;
-      states = next_states;
-      next_states = _states;
-    }
+    analysis.did_abort = false;
+    ts_query__perform_analysis(self, &subgraphs, &analysis);
 
     // If this pattern could not be fully analyzed, then every step should
     // be considered fallible.
-    if (did_abort_analysis) {
+    if (analysis.did_abort) {
       for (unsigned j = parent_step_index + 1; j < self->steps.size; j++) {
         QueryStep *step = &self->steps.contents[j];
         if (
@@ -1686,21 +1747,21 @@ static bool ts_query__analyze_patterns(TSQuery *self, unsigned *error_offset) {
 
     // If this pattern cannot match, store the pattern index so that it can be
     // returned to the caller.
-    if (!can_finish_pattern) {
-      assert(final_step_indices.size > 0);
-      uint16_t impossible_step_index = *array_back(&final_step_indices);
-      uint32_t i, exists;
-      array_search_sorted_by(&self->step_offsets, .step_index, impossible_step_index, &i, &exists);
-      if (i >= self->step_offsets.size) i = self->step_offsets.size - 1;
-      *error_offset = self->step_offsets.contents[i].byte_offset;
+    if (analysis.finished_parent_symbols.size == 0) {
+      assert(analysis.final_step_indices.size > 0);
+      uint16_t impossible_step_index = *array_back(&analysis.final_step_indices);
+      uint32_t j, impossible_exists;
+      array_search_sorted_by(&self->step_offsets, .step_index, impossible_step_index, &j, &impossible_exists);
+      if (j >= self->step_offsets.size) j = self->step_offsets.size - 1;
+      *error_offset = self->step_offsets.contents[j].byte_offset;
       all_patterns_are_valid = false;
       break;
     }
 
     // Mark as fallible any step where a match terminated.
     // Later, this property will be propagated to all of the step's predecessors.
-    for (unsigned j = 0; j < final_step_indices.size; j++) {
-      uint32_t final_step_index = final_step_indices.contents[j];
+    for (unsigned j = 0; j < analysis.final_step_indices.size; j++) {
+      uint32_t final_step_index = analysis.final_step_indices.contents[j];
       QueryStep *step = &self->steps.contents[final_step_index];
       if (
         step->depth != PATTERN_DONE_MARKER &&
@@ -1721,20 +1782,21 @@ static bool ts_query__analyze_patterns(TSQuery *self, unsigned *error_offset) {
     // Gather all of the captures that are used in predicates for this pattern.
     array_clear(&predicate_capture_ids);
     for (
-      unsigned start = pattern->predicate_steps.offset,
-      end = start + pattern->predicate_steps.length,
+      unsigned start = pattern->predicate_step.offset,
+      end = start + pattern->predicate_step.length,
       j = start; j < end; j++
     ) {
       TSQueryPredicateStep *step = &self->predicate_steps.contents[j];
       if (step->type == TSQueryPredicateStepTypeCapture) {
-        array_insert_sorted_by(&predicate_capture_ids, , step->value_id);
+        uint16_t value_id = step->value_id;
+        array_insert_sorted_by(&predicate_capture_ids, , value_id);
       }
     }
 
     // Find all of the steps that have these captures.
     for (
-      unsigned start = pattern->steps.offset,
-      end = start + pattern->steps.length,
+      unsigned start = pattern->step.offset,
+      end = start + pattern->step.length,
       j = start; j < end; j++
     ) {
       QueryStep *step = &self->steps.contents[j];
@@ -1810,21 +1872,81 @@ static bool ts_query__analyze_patterns(TSQuery *self, unsigned *error_offset) {
     }
   #endif
 
+  // Determine which repetition symbols in this language have the possibility
+  // of matching non-rooted patterns in this query. These repetition symbols
+  // prevent certain optimizations with range restrictions.
+  analysis.did_abort = false;
+  for (uint32_t i = 0; i < non_rooted_pattern_start_steps.size; i++) {
+    uint16_t pattern_entry_index = non_rooted_pattern_start_steps.contents[i];
+    PatternEntry *pattern_entry = &self->pattern_map.contents[pattern_entry_index];
+
+    analysis_state_set__clear(&analysis.states, &analysis.state_pool);
+    analysis_state_set__clear(&analysis.deeper_states, &analysis.state_pool);
+    for (unsigned j = 0; j < subgraphs.size; j++) {
+      AnalysisSubgraph *subgraph = &subgraphs.contents[j];
+      TSSymbolMetadata metadata = ts_language_symbol_metadata(self->language, subgraph->symbol);
+      if (metadata.visible || metadata.named) continue;
+
+      for (uint32_t k = 0; k < subgraph->start_states.size; k++) {
+        TSStateId parse_state = subgraph->start_states.contents[k];
+        analysis_state_set__push(&analysis.states, &analysis.state_pool, &((AnalysisState) {
+          .step_index = pattern_entry->step_index,
+          .stack = {
+            [0] = {
+              .parse_state = parse_state,
+              .parent_symbol = subgraph->symbol,
+              .child_index = 0,
+              .field_id = 0,
+              .done = false,
+            },
+          },
+          .root_symbol = subgraph->symbol,
+          .depth = 1,
+        }));
+      }
+    }
+
+    #ifdef DEBUG_ANALYZE_QUERY
+      printf("\nWalk states for rootless pattern step %u:\n", pattern_entry->step_index);
+    #endif
+
+    ts_query__perform_analysis(
+      self,
+      &subgraphs,
+      &analysis
+    );
+
+    if (analysis.finished_parent_symbols.size > 0) {
+      self->patterns.contents[pattern_entry->pattern_index].is_non_local = true;
+    }
+
+    for (unsigned k = 0; k < analysis.finished_parent_symbols.size; k++) {
+      TSSymbol symbol = analysis.finished_parent_symbols.contents[k];
+      array_insert_sorted_by(&self->repeat_symbols_with_rootless_patterns, , symbol);
+    }
+  }
+
+  #ifdef DEBUG_ANALYZE_QUERY
+    if (self->repeat_symbols_with_rootless_patterns.size > 0) {
+      printf("\nRepetition symbols with rootless patterns:\n");
+      printf("aborted analysis: %d\n", analysis.did_abort);
+      for (unsigned i = 0; i < self->repeat_symbols_with_rootless_patterns.size; i++) {
+        TSSymbol symbol = self->repeat_symbols_with_rootless_patterns.contents[i];
+        printf("  %u, %s\n", symbol, ts_language_symbol_name(self->language, symbol));
+      }
+      printf("\n");
+    }
+  #endif
+
   // Cleanup
   for (unsigned i = 0; i < subgraphs.size; i++) {
     array_delete(&subgraphs.contents[i].start_states);
     array_delete(&subgraphs.contents[i].nodes);
   }
   array_delete(&subgraphs);
-  for (unsigned i = 0; i < state_pool.size; i++) {
-    ts_free(state_pool.contents[i]);
-  }
-  array_delete(&state_pool);
+  query_analysis__delete(&analysis);
   array_delete(&next_nodes);
-  analysis_state_set__delete(&states);
-  analysis_state_set__delete(&next_states);
-  analysis_state_set__delete(&deeper_states);
-  array_delete(&final_step_indices);
+  array_delete(&non_rooted_pattern_start_steps);
   array_delete(&parent_step_indices);
   array_delete(&predicate_capture_ids);
   state_predecessor_map_delete(&predecessor_map);
@@ -1950,7 +2072,7 @@ static TSQueryError ts_query__parse_predicate(
   if (!stream_is_ident_start(stream)) return TSQueryErrorSyntax;
   const char *predicate_name = stream->input;
   stream_scan_identifier(stream);
-  uint32_t length = stream->input - predicate_name;
+  uint32_t length = (uint32_t)(stream->input - predicate_name);
   uint16_t id = symbol_table_insert_name(
     &self->predicate_values,
     predicate_name,
@@ -1981,13 +2103,13 @@ static TSQueryError ts_query__parse_predicate(
       if (!stream_is_ident_start(stream)) return TSQueryErrorSyntax;
       const char *capture_name = stream->input;
       stream_scan_identifier(stream);
-      uint32_t length = stream->input - capture_name;
+      uint32_t capture_length = (uint32_t)(stream->input - capture_name);
 
       // Add the capture id to the first step of the pattern
       int capture_id = symbol_table_id_for_name(
         &self->captures,
         capture_name,
-        length
+        capture_length
       );
       if (capture_id == -1) {
         stream_reset(stream, capture_name);
@@ -2004,14 +2126,14 @@ static TSQueryError ts_query__parse_predicate(
     else if (stream->next == '"') {
       TSQueryError e = ts_query__parse_string_literal(self, stream);
       if (e) return e;
-      uint16_t id = symbol_table_insert_name(
+      uint16_t query_id = symbol_table_insert_name(
         &self->predicate_values,
         self->string_buffer.contents,
         self->string_buffer.size
       );
       array_push(&self->predicate_steps, ((TSQueryPredicateStep) {
         .type = TSQueryPredicateStepTypeString,
-        .value_id = id,
+        .value_id = query_id,
       }));
     }
 
@@ -2019,15 +2141,15 @@ static TSQueryError ts_query__parse_predicate(
     else if (stream_is_ident_start(stream)) {
       const char *symbol_start = stream->input;
       stream_scan_identifier(stream);
-      uint32_t length = stream->input - symbol_start;
-      uint16_t id = symbol_table_insert_name(
+      uint32_t symbol_length = (uint32_t)(stream->input - symbol_start);
+      uint16_t query_id = symbol_table_insert_name(
         &self->predicate_values,
         symbol_start,
-        length
+        symbol_length
       );
       array_push(&self->predicate_steps, ((TSQueryPredicateStep) {
         .type = TSQueryPredicateStepTypeString,
-        .value_id = id,
+        .value_id = query_id,
       }));
     }
 
@@ -2139,7 +2261,7 @@ static TSQueryError ts_query__parse_pattern(
 
     // If this parenthesis is followed by a node, then it represents a grouped sequence.
     if (stream->next == '(' || stream->next == '"' || stream->next == '[') {
-      bool child_is_immediate = false;
+      bool child_is_immediate = is_immediate;
       CaptureQuantifiers child_capture_quantifiers = capture_quantifiers_new();
       for (;;) {
         if (stream->next == '.') {
@@ -2188,7 +2310,7 @@ static TSQueryError ts_query__parse_pattern(
       if (stream_is_ident_start(stream)) {
         const char *node_name = stream->input;
         stream_scan_identifier(stream);
-        uint32_t length = stream->input - node_name;
+        uint32_t length = (uint32_t)(stream->input - node_name);
 
         // TODO - remove.
         // For temporary backward compatibility, handle predicates without the leading '#' sign.
@@ -2239,7 +2361,7 @@ static TSQueryError ts_query__parse_pattern(
 
         const char *node_name = stream->input;
         stream_scan_identifier(stream);
-        uint32_t length = stream->input - node_name;
+        uint32_t length = (uint32_t)(stream->input - node_name);
 
         step->symbol = ts_language_symbol_for_name(
           self->language,
@@ -2272,7 +2394,7 @@ static TSQueryError ts_query__parse_pattern(
           }
           const char *field_name = stream->input;
           stream_scan_identifier(stream);
-          uint32_t length = stream->input - field_name;
+          uint32_t length = (uint32_t)(stream->input - field_name);
           stream_skip_whitespace(stream);
 
           TSFieldId field_id = ts_language_field_id_for_name(
@@ -2383,7 +2505,7 @@ static TSQueryError ts_query__parse_pattern(
     // Parse the field name
     const char *field_name = stream->input;
     stream_scan_identifier(stream);
-    uint32_t length = stream->input - field_name;
+    uint32_t length = (uint32_t)(stream->input - field_name);
     stream_skip_whitespace(stream);
 
     if (stream->next != ':') {
@@ -2475,8 +2597,11 @@ static TSQueryError ts_query__parse_pattern(
       repeat_step.alternative_is_immediate = true;
       array_push(&self->steps, repeat_step);
 
+      // Stop when `step->alternative_index` is `NONE` or it points to
+      // `repeat_step` or beyond. Note that having just been pushed,
+      // `repeat_step` occupies slot `self->steps.size - 1`.
       QueryStep *step = &self->steps.contents[starting_step_index];
-      while (step->alternative_index != NONE) {
+      while (step->alternative_index != NONE && step->alternative_index < self->steps.size - 1) {
         step = &self->steps.contents[step->alternative_index];
       }
       step->alternative_index = self->steps.size;
@@ -2490,7 +2615,7 @@ static TSQueryError ts_query__parse_pattern(
       stream_skip_whitespace(stream);
 
       QueryStep *step = &self->steps.contents[starting_step_index];
-      while (step->alternative_index != NONE) {
+      while (step->alternative_index != NONE && step->alternative_index < self->steps.size) {
         step = &self->steps.contents[step->alternative_index];
       }
       step->alternative_index = self->steps.size;
@@ -2502,7 +2627,7 @@ static TSQueryError ts_query__parse_pattern(
       if (!stream_is_ident_start(stream)) return TSQueryErrorSyntax;
       const char *capture_name = stream->input;
       stream_scan_identifier(stream);
-      uint32_t length = stream->input - capture_name;
+      uint32_t length = (uint32_t)(stream->input - capture_name);
       stream_skip_whitespace(stream);
 
       // Add the capture id to the first step of the pattern
@@ -2571,6 +2696,7 @@ TSQuery *ts_query_new(
     .step_offsets = array_new(),
     .string_buffer = array_new(),
     .negated_fields = array_new(),
+    .repeat_symbols_with_rootless_patterns = array_new(),
     .wildcard_root_pattern_count = 0,
     .language = language,
   };
@@ -2585,17 +2711,18 @@ TSQuery *ts_query_new(
     uint32_t start_step_index = self->steps.size;
     uint32_t start_predicate_step_index = self->predicate_steps.size;
     array_push(&self->patterns, ((QueryPattern) {
-      .steps = (Slice) {.offset = start_step_index},
-      .predicate_steps = (Slice) {.offset = start_predicate_step_index},
+      .step = (Slice) {.offset = start_step_index},
+      .predicate_step = (Slice) {.offset = start_predicate_step_index},
       .start_byte = stream_offset(&stream),
+      .is_non_local = false,
     }));
     CaptureQuantifiers capture_quantifiers = capture_quantifiers_new();
     *error_type = ts_query__parse_pattern(self, &stream, 0, false, &capture_quantifiers);
     array_push(&self->steps, query_step__new(0, PATTERN_DONE_MARKER, false));
 
     QueryPattern *pattern = array_back(&self->patterns);
-    pattern->steps.length = self->steps.size - start_step_index;
-    pattern->predicate_steps.length = self->predicate_steps.size - start_predicate_step_index;
+    pattern->step.length = self->steps.size - start_step_index;
+    pattern->predicate_step.length = self->predicate_steps.size - start_predicate_step_index;
 
     // If any pattern could not be parsed, then report the error information
     // and terminate.
@@ -2635,9 +2762,9 @@ TSQuery *ts_query_new(
       uint32_t start_depth = step->depth;
       bool is_rooted = start_depth == 0;
       for (uint32_t step_index = start_step_index + 1; step_index < self->steps.size; step_index++) {
-        QueryStep *step = &self->steps.contents[step_index];
-        if (step->is_dead_end) break;
-        if (step->depth == start_depth) {
+        QueryStep *child_step = &self->steps.contents[step_index];
+        if (child_step->is_dead_end) break;
+        if (child_step->depth == start_depth) {
           is_rooted = false;
           break;
         }
@@ -2656,7 +2783,6 @@ TSQuery *ts_query_new(
       // then add multiple entries to the pattern map.
       if (step->alternative_index != NONE) {
         start_step_index = step->alternative_index;
-        step->alternative_index = NONE;
       } else if (wildcard_root_alternative_index != NONE) {
         start_step_index = wildcard_root_alternative_index;
         wildcard_root_alternative_index = NONE;
@@ -2685,6 +2811,7 @@ void ts_query_delete(TSQuery *self) {
     array_delete(&self->step_offsets);
     array_delete(&self->string_buffer);
     array_delete(&self->negated_fields);
+    array_delete(&self->repeat_symbols_with_rootless_patterns);
     symbol_table_delete(&self->captures);
     symbol_table_delete(&self->predicate_values);
     for (uint32_t index = 0; index < self->capture_quantifiers.size; index++) {
@@ -2738,7 +2865,7 @@ const TSQueryPredicateStep *ts_query_predicates_for_pattern(
   uint32_t pattern_index,
   uint32_t *step_count
 ) {
-  Slice slice = self->patterns.contents[pattern_index].predicate_steps;
+  Slice slice = self->patterns.contents[pattern_index].predicate_step;
   *step_count = slice.length;
   if (self->predicate_steps.contents == NULL) {
     return NULL;
@@ -2766,6 +2893,17 @@ bool ts_query_is_pattern_rooted(
   return true;
 }
 
+bool ts_query_is_pattern_non_local(
+  const TSQuery *self,
+  uint32_t pattern_index
+) {
+  if (pattern_index < self->patterns.size) {
+    return self->patterns.contents[pattern_index].is_non_local;
+  } else {
+    return false;
+  }
+}
+
 bool ts_query_is_pattern_guaranteed_at_step(
   const TSQuery *self,
   uint32_t byte_offset
@@ -2845,6 +2983,7 @@ TSQueryCursor *ts_query_cursor_new(void) {
     .end_byte = UINT32_MAX,
     .start_point = {0, 0},
     .end_point = POINT_MAX,
+    .max_start_depth = UINT32_MAX,
   };
   array_reserve(&self->states, 8);
   array_reserve(&self->finished_states, 8);
@@ -2871,15 +3010,48 @@ void ts_query_cursor_set_match_limit(TSQueryCursor *self, uint32_t limit) {
   self->capture_list_pool.max_capture_list_count = limit;
 }
 
+#ifdef DEBUG_EXECUTE_QUERY
+#define LOG(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define LOG(...)
+#endif
+
 void ts_query_cursor_exec(
   TSQueryCursor *self,
   const TSQuery *query,
   TSNode node
 ) {
+  if  (query) {
+    LOG("query steps:\n");
+    for (unsigned i = 0; i < query->steps.size; i++) {
+      QueryStep *step = &query->steps.contents[i];
+      LOG("  %u: {", i);
+      if (step->depth == PATTERN_DONE_MARKER) {
+        LOG("DONE");
+      } else if (step->is_dead_end) {
+        LOG("dead_end");
+      } else if (step->is_pass_through) {
+        LOG("pass_through");
+      } else if (step->symbol != WILDCARD_SYMBOL) {
+        LOG("symbol: %s", query->language->symbol_names[step->symbol]);
+      } else {
+        LOG("symbol: *");
+      }
+      if (step->field) {
+        LOG(", field: %s", query->language->field_names[step->field]);
+      }
+      if (step->alternative_index != NONE) {
+        LOG(", alternative: %u", step->alternative_index);
+      }
+      LOG("},\n");
+    }
+  }
+
   array_clear(&self->states);
   array_clear(&self->finished_states);
   ts_tree_cursor_reset(&self->cursor, node);
   capture_list_pool_reset(&self->capture_list_pool);
+  self->on_visible_node = true;
   self->next_state_id = 0;
   self->depth = 0;
   self->ascending = false;
@@ -3042,12 +3214,6 @@ void ts_query_cursor__compare_captures(
   }
 }
 
-#ifdef DEBUG_EXECUTE_QUERY
-#define LOG(...) fprintf(stderr, __VA_ARGS__)
-#else
-#define LOG(...)
-#endif
-
 static void ts_query_cursor__add_state(
   TSQueryCursor *self,
   const PatternEntry *pattern
@@ -3194,7 +3360,7 @@ static QueryState *ts_query_cursor__copy_state(
   QueryState **state_ref
 ) {
   const QueryState *state = *state_ref;
-  uint32_t state_index = state - self->states.contents;
+  uint32_t state_index = (uint32_t)(state - self->states.contents);
   QueryState copy = *state;
   copy.capture_list_id = NONE;
 
@@ -3214,6 +3380,60 @@ static QueryState *ts_query_cursor__copy_state(
   return &self->states.contents[state_index + 1];
 }
 
+static inline bool ts_query_cursor__should_descend(
+  TSQueryCursor *self,
+  bool node_intersects_range
+) {
+
+  if (node_intersects_range && self->depth < self->max_start_depth) {
+    return true;
+  }
+
+  // If there are in-progress matches whose remaining steps occur
+  // deeper in the tree, then descend.
+  for (unsigned i = 0; i < self->states.size; i++) {
+    QueryState *state = &self->states.contents[i];;
+    QueryStep *next_step = &self->query->steps.contents[state->step_index];
+    if (
+      next_step->depth != PATTERN_DONE_MARKER &&
+      state->start_depth + next_step->depth > self->depth
+    ) {
+      return true;
+    }
+  }
+
+  if (self->depth >= self->max_start_depth) {
+    return false;
+  }
+
+  // If the current node is hidden, then a non-rooted pattern might match
+  // one if its roots inside of this node, and match another of its roots
+  // as part of a sibling node, so we may need to descend.
+  if (!self->on_visible_node) {
+    // Descending into a repetition node outside of the range can be
+    // expensive, because these nodes can have many visible children.
+    // Avoid descending into repetition nodes unless we have already
+    // determined that this query can match rootless patterns inside
+    // of this type of repetition node.
+    Subtree subtree = ts_tree_cursor_current_subtree(&self->cursor);
+    if (ts_subtree_is_repetition(subtree)) {
+      bool exists;
+      uint32_t index;
+      array_search_sorted_by(
+        &self->query->repeat_symbols_with_rootless_patterns,,
+        ts_subtree_symbol(subtree),
+        &index,
+        &exists
+      );
+      return exists;
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
 // Walk the tree, processing patterns until at least one pattern finishes,
 // If one or more patterns finish, return `true` and store their states in the
 // `finished_states` array. Multiple patterns can finish on the same node. If
@@ -3238,226 +3458,39 @@ static inline bool ts_query_cursor__advance(
 
     // Exit the current node.
     if (self->ascending) {
-      LOG(
-        "leave node. depth:%u, type:%s\n",
-        self->depth,
-        ts_node_type(ts_tree_cursor_current_node(&self->cursor))
-      );
+      if (self->on_visible_node) {
+        LOG(
+          "leave node. depth:%u, type:%s\n",
+          self->depth,
+          ts_node_type(ts_tree_cursor_current_node(&self->cursor))
+        );
 
-      // Leave this node by stepping to its next sibling or to its parent.
-      if (ts_tree_cursor_goto_next_sibling(&self->cursor)) {
-        self->ascending = false;
-      } else if (ts_tree_cursor_goto_parent(&self->cursor)) {
-        self->depth--;
-      } else {
-        LOG("halt at root\n");
-        self->halted = true;
-      }
+        // After leaving a node, remove any states that cannot make further progress.
+        uint32_t deleted_count = 0;
+        for (unsigned i = 0, n = self->states.size; i < n; i++) {
+          QueryState *state = &self->states.contents[i];
+          QueryStep *step = &self->query->steps.contents[state->step_index];
 
-      // After leaving a node, remove any states that cannot make further progress.
-      uint32_t deleted_count = 0;
-      for (unsigned i = 0, n = self->states.size; i < n; i++) {
-        QueryState *state = &self->states.contents[i];
-        QueryStep *step = &self->query->steps.contents[state->step_index];
-
-        // If a state completed its pattern inside of this node, but was deferred from finishing
-        // in order to search for longer matches, mark it as finished.
-        if (step->depth == PATTERN_DONE_MARKER) {
-          if (state->start_depth > self->depth || self->halted) {
+          // If a state completed its pattern inside of this node, but was deferred from finishing
+          // in order to search for longer matches, mark it as finished.
+          if (
+            step->depth == PATTERN_DONE_MARKER &&
+            (state->start_depth > self->depth || self->depth == 0)
+          ) {
             LOG("  finish pattern %u\n", state->pattern_index);
             array_push(&self->finished_states, *state);
             did_match = true;
             deleted_count++;
-            continue;
           }
-        }
 
-        // If a state needed to match something within this node, then remove that state
-        // as it has failed to match.
-        else if ((uint32_t)state->start_depth + (uint32_t)step->depth > self->depth) {
-          LOG(
-            "  failed to match. pattern:%u, step:%u\n",
-            state->pattern_index,
-            state->step_index
-          );
-          capture_list_pool_release(
-            &self->capture_list_pool,
-            state->capture_list_id
-          );
-          deleted_count++;
-          continue;
-        }
-
-        if (deleted_count > 0) {
-          self->states.contents[i - deleted_count] = *state;
-        }
-      }
-      self->states.size -= deleted_count;
-    }
-
-    // Enter a new node.
-    else {
-      // Get the properties of the current node.
-      TSNode node = ts_tree_cursor_current_node(&self->cursor);
-      TSNode parent_node = ts_tree_cursor_parent_node(&self->cursor);
-      TSSymbol symbol = ts_node_symbol(node);
-      bool is_named = ts_node_is_named(node);
-      bool has_later_siblings;
-      bool has_later_named_siblings;
-      bool can_have_later_siblings_with_this_field;
-      TSFieldId field_id = 0;
-      TSSymbol supertypes[8] = {0};
-      unsigned supertype_count = 8;
-      ts_tree_cursor_current_status(
-        &self->cursor,
-        &field_id,
-        &has_later_siblings,
-        &has_later_named_siblings,
-        &can_have_later_siblings_with_this_field,
-        supertypes,
-        &supertype_count
-      );
-      LOG(
-        "enter node. depth:%u, type:%s, field:%s, row:%u state_count:%u, finished_state_count:%u\n",
-        self->depth,
-        ts_node_type(node),
-        ts_language_field_name_for_id(self->query->language, field_id),
-        ts_node_start_point(node).row,
-        self->states.size,
-        self->finished_states.size
-      );
-
-      bool node_intersects_range = (
-        ts_node_end_byte(node) > self->start_byte &&
-        ts_node_start_byte(node) < self->end_byte &&
-        point_gt(ts_node_end_point(node), self->start_point) &&
-        point_lt(ts_node_start_point(node), self->end_point)
-      );
-      bool parent_intersects_range = ts_node_is_null(parent_node) || (
-        ts_node_end_byte(parent_node) > self->start_byte &&
-        ts_node_start_byte(parent_node) < self->end_byte &&
-        point_gt(ts_node_end_point(parent_node), self->start_point) &&
-        point_lt(ts_node_start_point(parent_node), self->end_point)
-      );
-      bool node_is_error = symbol == ts_builtin_sym_error;
-      bool parent_is_error =
-        !ts_node_is_null(parent_node) &&
-        ts_node_symbol(parent_node) == ts_builtin_sym_error;
-
-      // Add new states for any patterns whose root node is a wildcard.
-      if (!node_is_error) {
-        for (unsigned i = 0; i < self->query->wildcard_root_pattern_count; i++) {
-          PatternEntry *pattern = &self->query->pattern_map.contents[i];
-
-          // If this node matches the first step of the pattern, then add a new
-          // state at the start of this pattern.
-          QueryStep *step = &self->query->steps.contents[pattern->step_index];
-          if (
-            (pattern->is_rooted ?
-              node_intersects_range :
-              (parent_intersects_range && !parent_is_error)) &&
-            (!step->field || field_id == step->field) &&
-            (!step->supertype_symbol || supertype_count > 0)
+          // If a state needed to match something within this node, then remove that state
+          // as it has failed to match.
+          else if (
+            step->depth != PATTERN_DONE_MARKER &&
+            (uint32_t)state->start_depth + (uint32_t)step->depth > self->depth
           ) {
-            ts_query_cursor__add_state(self, pattern);
-          }
-        }
-      }
-
-      // Add new states for any patterns whose root node matches this node.
-      unsigned i;
-      if (ts_query__pattern_map_search(self->query, symbol, &i)) {
-        PatternEntry *pattern = &self->query->pattern_map.contents[i];
-
-        QueryStep *step = &self->query->steps.contents[pattern->step_index];
-        do {
-          // If this node matches the first step of the pattern, then add a new
-          // state at the start of this pattern.
-          if (
-            (pattern->is_rooted ?
-              node_intersects_range :
-              (parent_intersects_range && !parent_is_error)) &&
-            (!step->field || field_id == step->field)
-          ) {
-            ts_query_cursor__add_state(self, pattern);
-          }
-
-          // Advance to the next pattern whose root node matches this node.
-          i++;
-          if (i == self->query->pattern_map.size) break;
-          pattern = &self->query->pattern_map.contents[i];
-          step = &self->query->steps.contents[pattern->step_index];
-        } while (step->symbol == symbol);
-      }
-
-      // Update all of the in-progress states with current node.
-      for (unsigned i = 0, copy_count = 0; i < self->states.size; i += 1 + copy_count) {
-        QueryState *state = &self->states.contents[i];
-        QueryStep *step = &self->query->steps.contents[state->step_index];
-        state->has_in_progress_alternatives = false;
-        copy_count = 0;
-
-        // Check that the node matches all of the criteria for the next
-        // step of the pattern.
-        if ((uint32_t)state->start_depth + (uint32_t)step->depth != self->depth) continue;
-
-        // Determine if this node matches this step of the pattern, and also
-        // if this node can have later siblings that match this step of the
-        // pattern.
-        bool node_does_match = false;
-        if (step->symbol == WILDCARD_SYMBOL) {
-          node_does_match = !node_is_error && (is_named || !step->is_named);
-        } else {
-          node_does_match = symbol == step->symbol;
-        }
-        bool later_sibling_can_match = has_later_siblings;
-        if ((step->is_immediate && is_named) || state->seeking_immediate_match) {
-          later_sibling_can_match = false;
-        }
-        if (step->is_last_child && has_later_named_siblings) {
-          node_does_match = false;
-        }
-        if (step->supertype_symbol) {
-          bool has_supertype = false;
-          for (unsigned j = 0; j < supertype_count; j++) {
-            if (supertypes[j] == step->supertype_symbol) {
-              has_supertype = true;
-              break;
-            }
-          }
-          if (!has_supertype) node_does_match = false;
-        }
-        if (step->field) {
-          if (step->field == field_id) {
-            if (!can_have_later_siblings_with_this_field) {
-              later_sibling_can_match = false;
-            }
-          } else {
-            node_does_match = false;
-          }
-        }
-
-        if (step->negated_field_list_id) {
-          TSFieldId *negated_field_ids = &self->query->negated_fields.contents[step->negated_field_list_id];
-          for (;;) {
-            TSFieldId negated_field_id = *negated_field_ids;
-            if (negated_field_id) {
-              negated_field_ids++;
-              if (ts_node_child_by_field_id(node, negated_field_id).id) {
-                node_does_match = false;
-                break;
-              }
-            } else {
-              break;
-            }
-          }
-        }
-
-        // Remove states immediately if it is ever clear that they cannot match.
-        if (!node_does_match) {
-          if (!later_sibling_can_match) {
             LOG(
-              "  discard state. pattern:%u, step:%u\n",
+              "  failed to match. pattern:%u, step:%u\n",
               state->pattern_index,
               state->step_index
             );
@@ -3465,248 +3498,452 @@ static inline bool ts_query_cursor__advance(
               &self->capture_list_pool,
               state->capture_list_id
             );
-            array_erase(&self->states, i);
-            i--;
+            deleted_count++;
           }
-          continue;
-        }
 
-        // Some patterns can match their root node in multiple ways, capturing different
-        // children. If this pattern step could match later children within the same
-        // parent, then this query state cannot simply be updated in place. It must be
-        // split into two states: one that matches this node, and one which skips over
-        // this node, to preserve the possibility of matching later siblings.
-        if (later_sibling_can_match && (
-          step->contains_captures ||
-          ts_query__step_is_fallible(self->query, state->step_index)
-        )) {
-          if (ts_query_cursor__copy_state(self, &state)) {
-            LOG(
-              "  split state for capture. pattern:%u, step:%u\n",
-              state->pattern_index,
-              state->step_index
-            );
-            copy_count++;
+          else if (deleted_count > 0) {
+            self->states.contents[i - deleted_count] = *state;
           }
         }
+        self->states.size -= deleted_count;
+      }
 
-        // If this pattern started with a wildcard, such that the pattern map
-        // actually points to the *second* step of the pattern, then check
-        // that the node has a parent, and capture the parent node if necessary.
-        if (state->needs_parent) {
-          TSNode parent = ts_tree_cursor_parent_node(&self->cursor);
-          if (ts_node_is_null(parent)) {
-            LOG("  missing parent node\n");
-            state->dead = true;
+      // Leave this node by stepping to its next sibling or to its parent.
+      switch (ts_tree_cursor_goto_next_sibling_internal(&self->cursor)) {
+        case TreeCursorStepVisible:
+          if (!self->on_visible_node) {
+            self->depth++;
+            self->on_visible_node = true;
+          }
+          self->ascending = false;
+          break;
+        case TreeCursorStepHidden:
+          if (self->on_visible_node) {
+            self->depth--;
+            self->on_visible_node = false;
+          }
+          self->ascending = false;
+          break;
+        default:
+          if (ts_tree_cursor_goto_parent(&self->cursor)) {
+            self->depth--;
           } else {
-            state->needs_parent = false;
-            QueryStep *skipped_wildcard_step = step;
-            do {
-              skipped_wildcard_step--;
-            } while (
-              skipped_wildcard_step->is_dead_end ||
-              skipped_wildcard_step->is_pass_through ||
-              skipped_wildcard_step->depth > 0
-            );
-            if (skipped_wildcard_step->capture_ids[0] != NONE) {
-              LOG("  capture wildcard parent\n");
-              ts_query_cursor__capture(
-                self,
-                state,
-                skipped_wildcard_step,
-                parent
-              );
-            }
+            LOG("halt at root\n");
+            self->halted = true;
           }
-        }
+      }
+    }
 
-        // If the current node is captured in this pattern, add it to the capture list.
-        if (step->capture_ids[0] != NONE) {
-          ts_query_cursor__capture(self, state, step, node);
-        }
+    // Enter a new node.
+    else {
+      // Get the properties of the current node.
+      TSNode node = ts_tree_cursor_current_node(&self->cursor);
+      TSNode parent_node = ts_tree_cursor_parent_node(&self->cursor);
+      bool parent_precedes_range = !ts_node_is_null(parent_node) && (
+        ts_node_end_byte(parent_node) <= self->start_byte ||
+        point_lte(ts_node_end_point(parent_node), self->start_point)
+      );
+      bool parent_follows_range = !ts_node_is_null(parent_node) && (
+        ts_node_start_byte(parent_node) >= self->end_byte ||
+        point_gte(ts_node_start_point(parent_node), self->end_point)
+      );
+      bool node_precedes_range = parent_precedes_range || (
+        ts_node_end_byte(node) <= self->start_byte ||
+        point_lte(ts_node_end_point(node), self->start_point)
+      );
+      bool node_follows_range = parent_follows_range || (
+        ts_node_start_byte(node) >= self->end_byte ||
+        point_gte(ts_node_start_point(node), self->end_point)
+      );
+      bool parent_intersects_range = !parent_precedes_range && !parent_follows_range;
+      bool node_intersects_range = !node_precedes_range && !node_follows_range;
 
-        if (state->dead) {
-          array_erase(&self->states, i);
-          i--;
-          continue;
-        }
-
-        // Advance this state to the next step of its pattern.
-        state->step_index++;
-        state->seeking_immediate_match = false;
+      if (self->on_visible_node) {
+        TSSymbol symbol = ts_node_symbol(node);
+        bool is_named = ts_node_is_named(node);
+        bool has_later_siblings;
+        bool has_later_named_siblings;
+        bool can_have_later_siblings_with_this_field;
+        TSFieldId field_id = 0;
+        TSSymbol supertypes[8] = {0};
+        unsigned supertype_count = 8;
+        ts_tree_cursor_current_status(
+          &self->cursor,
+          &field_id,
+          &has_later_siblings,
+          &has_later_named_siblings,
+          &can_have_later_siblings_with_this_field,
+          supertypes,
+          &supertype_count
+        );
         LOG(
-          "  advance state. pattern:%u, step:%u\n",
-          state->pattern_index,
-          state->step_index
+          "enter node. depth:%u, type:%s, field:%s, row:%u state_count:%u, finished_state_count:%u\n",
+          self->depth,
+          ts_node_type(node),
+          ts_language_field_name_for_id(self->query->language, field_id),
+          ts_node_start_point(node).row,
+          self->states.size,
+          self->finished_states.size
         );
 
-        QueryStep *next_step = &self->query->steps.contents[state->step_index];
-        if (stop_on_definite_step && next_step->root_pattern_guaranteed) did_match = true;
+        bool node_is_error = symbol == ts_builtin_sym_error;
+        bool parent_is_error =
+          !ts_node_is_null(parent_node) &&
+          ts_node_symbol(parent_node) == ts_builtin_sym_error;
 
-        // If this state's next step has an alternative step, then copy the state in order
-        // to pursue both alternatives. The alternative step itself may have an alternative,
-        // so this is an interactive process.
-        unsigned end_index = i + 1;
-        for (unsigned j = i; j < end_index; j++) {
+        // Add new states for any patterns whose root node is a wildcard.
+        if (!node_is_error) {
+          for (unsigned i = 0; i < self->query->wildcard_root_pattern_count; i++) {
+            PatternEntry *pattern = &self->query->pattern_map.contents[i];
+
+            // If this node matches the first step of the pattern, then add a new
+            // state at the start of this pattern.
+            QueryStep *step = &self->query->steps.contents[pattern->step_index];
+            uint32_t start_depth = self->depth - step->depth;
+            if (
+              (pattern->is_rooted ?
+                node_intersects_range :
+                (parent_intersects_range && !parent_is_error)) &&
+              (!step->field || field_id == step->field) &&
+              (!step->supertype_symbol || supertype_count > 0) &&
+              (start_depth <= self->max_start_depth)
+            ) {
+              ts_query_cursor__add_state(self, pattern);
+            }
+          }
+        }
+
+        // Add new states for any patterns whose root node matches this node.
+        unsigned i;
+        if (ts_query__pattern_map_search(self->query, symbol, &i)) {
+          PatternEntry *pattern = &self->query->pattern_map.contents[i];
+
+          QueryStep *step = &self->query->steps.contents[pattern->step_index];
+          uint32_t start_depth = self->depth - step->depth;
+          do {
+            // If this node matches the first step of the pattern, then add a new
+            // state at the start of this pattern.
+            if (
+              (pattern->is_rooted ?
+                node_intersects_range :
+                (parent_intersects_range && !parent_is_error)) &&
+              (!step->field || field_id == step->field) &&
+              (start_depth <= self->max_start_depth)
+            ) {
+              ts_query_cursor__add_state(self, pattern);
+            }
+
+            // Advance to the next pattern whose root node matches this node.
+            i++;
+            if (i == self->query->pattern_map.size) break;
+            pattern = &self->query->pattern_map.contents[i];
+            step = &self->query->steps.contents[pattern->step_index];
+          } while (step->symbol == symbol);
+        }
+
+        // Update all of the in-progress states with current node.
+        for (unsigned j = 0, copy_count = 0; j < self->states.size; j += 1 + copy_count) {
           QueryState *state = &self->states.contents[j];
-          QueryStep *next_step = &self->query->steps.contents[state->step_index];
-          if (next_step->alternative_index != NONE) {
-            // A "dead-end" step exists only to add a non-sequential jump into the step sequence,
-            // via its alternative index. When a state reaches a dead-end step, it jumps straight
-            // to the step's alternative.
-            if (next_step->is_dead_end) {
-              state->step_index = next_step->alternative_index;
-              j--;
-              continue;
-            }
+          QueryStep *step = &self->query->steps.contents[state->step_index];
+          state->has_in_progress_alternatives = false;
+          copy_count = 0;
 
-            // A "pass-through" step exists only to add a branch into the step sequence,
-            // via its alternative_index. When a state reaches a pass-through step, it splits
-            // in order to process the alternative step, and then it advances to the next step.
-            if (next_step->is_pass_through) {
-              state->step_index++;
-              j--;
-            }
+          // Check that the node matches all of the criteria for the next
+          // step of the pattern.
+          if ((uint32_t)state->start_depth + (uint32_t)step->depth != self->depth) continue;
 
-            QueryState *copy = ts_query_cursor__copy_state(self, &state);
-            if (copy) {
+          // Determine if this node matches this step of the pattern, and also
+          // if this node can have later siblings that match this step of the
+          // pattern.
+          bool node_does_match = false;
+          if (step->symbol == WILDCARD_SYMBOL) {
+            node_does_match = !node_is_error && (is_named || !step->is_named);
+          } else {
+            node_does_match = symbol == step->symbol;
+          }
+          bool later_sibling_can_match = has_later_siblings;
+          if ((step->is_immediate && is_named) || state->seeking_immediate_match) {
+            later_sibling_can_match = false;
+          }
+          if (step->is_last_child && has_later_named_siblings) {
+            node_does_match = false;
+          }
+          if (step->supertype_symbol) {
+            bool has_supertype = false;
+            for (unsigned k = 0; k < supertype_count; k++) {
+              if (supertypes[k] == step->supertype_symbol) {
+                has_supertype = true;
+                break;
+              }
+            }
+            if (!has_supertype) node_does_match = false;
+          }
+          if (step->field) {
+            if (step->field == field_id) {
+              if (!can_have_later_siblings_with_this_field) {
+                later_sibling_can_match = false;
+              }
+            } else {
+              node_does_match = false;
+            }
+          }
+
+          if (step->negated_field_list_id) {
+            TSFieldId *negated_field_ids = &self->query->negated_fields.contents[step->negated_field_list_id];
+            for (;;) {
+              TSFieldId negated_field_id = *negated_field_ids;
+              if (negated_field_id) {
+                negated_field_ids++;
+                if (ts_node_child_by_field_id(node, negated_field_id).id) {
+                  node_does_match = false;
+                  break;
+                }
+              } else {
+                break;
+              }
+            }
+          }
+
+          // Remove states immediately if it is ever clear that they cannot match.
+          if (!node_does_match) {
+            if (!later_sibling_can_match) {
               LOG(
-                "  split state for branch. pattern:%u, from_step:%u, to_step:%u, immediate:%d, capture_count: %u\n",
-                copy->pattern_index,
-                copy->step_index,
-                next_step->alternative_index,
-                next_step->alternative_is_immediate,
-                capture_list_pool_get(&self->capture_list_pool, copy->capture_list_id)->size
+                "  discard state. pattern:%u, step:%u\n",
+                state->pattern_index,
+                state->step_index
+              );
+              capture_list_pool_release(
+                &self->capture_list_pool,
+                state->capture_list_id
+              );
+              array_erase(&self->states, j);
+              j--;
+            }
+            continue;
+          }
+
+          // Some patterns can match their root node in multiple ways, capturing different
+          // children. If this pattern step could match later children within the same
+          // parent, then this query state cannot simply be updated in place. It must be
+          // split into two states: one that matches this node, and one which skips over
+          // this node, to preserve the possibility of matching later siblings.
+          if (later_sibling_can_match && (
+            step->contains_captures ||
+            ts_query__step_is_fallible(self->query, state->step_index)
+          )) {
+            if (ts_query_cursor__copy_state(self, &state)) {
+              LOG(
+                "  split state for capture. pattern:%u, step:%u\n",
+                state->pattern_index,
+                state->step_index
               );
-              end_index++;
               copy_count++;
-              copy->step_index = next_step->alternative_index;
-              if (next_step->alternative_is_immediate) {
-                copy->seeking_immediate_match = true;
+            }
+          }
+
+          // If this pattern started with a wildcard, such that the pattern map
+          // actually points to the *second* step of the pattern, then check
+          // that the node has a parent, and capture the parent node if necessary.
+          if (state->needs_parent) {
+            TSNode parent = ts_tree_cursor_parent_node(&self->cursor);
+            if (ts_node_is_null(parent)) {
+              LOG("  missing parent node\n");
+              state->dead = true;
+            } else {
+              state->needs_parent = false;
+              QueryStep *skipped_wildcard_step = step;
+              do {
+                skipped_wildcard_step--;
+              } while (
+                skipped_wildcard_step->is_dead_end ||
+                skipped_wildcard_step->is_pass_through ||
+                skipped_wildcard_step->depth > 0
+              );
+              if (skipped_wildcard_step->capture_ids[0] != NONE) {
+                LOG("  capture wildcard parent\n");
+                ts_query_cursor__capture(
+                  self,
+                  state,
+                  skipped_wildcard_step,
+                  parent
+                );
+              }
+            }
+          }
+
+          // If the current node is captured in this pattern, add it to the capture list.
+          if (step->capture_ids[0] != NONE) {
+            ts_query_cursor__capture(self, state, step, node);
+          }
+
+          if (state->dead) {
+            array_erase(&self->states, j);
+            j--;
+            continue;
+          }
+
+          // Advance this state to the next step of its pattern.
+          state->step_index++;
+          state->seeking_immediate_match = false;
+          LOG(
+            "  advance state. pattern:%u, step:%u\n",
+            state->pattern_index,
+            state->step_index
+          );
+
+          QueryStep *next_step = &self->query->steps.contents[state->step_index];
+          if (stop_on_definite_step && next_step->root_pattern_guaranteed) did_match = true;
+
+          // If this state's next step has an alternative step, then copy the state in order
+          // to pursue both alternatives. The alternative step itself may have an alternative,
+          // so this is an interactive process.
+          unsigned end_index = j + 1;
+          for (unsigned k = j; k < end_index; k++) {
+            QueryState *child_state = &self->states.contents[k];
+            QueryStep *child_step = &self->query->steps.contents[child_state->step_index];
+            if (child_step->alternative_index != NONE) {
+              // A "dead-end" step exists only to add a non-sequential jump into the step sequence,
+              // via its alternative index. When a state reaches a dead-end step, it jumps straight
+              // to the step's alternative.
+              if (child_step->is_dead_end) {
+                child_state->step_index = child_step->alternative_index;
+                k--;
+                continue;
+              }
+
+              // A "pass-through" step exists only to add a branch into the step sequence,
+              // via its alternative_index. When a state reaches a pass-through step, it splits
+              // in order to process the alternative step, and then it advances to the next step.
+              if (child_step->is_pass_through) {
+                child_state->step_index++;
+                k--;
+              }
+
+              QueryState *copy = ts_query_cursor__copy_state(self, &child_state);
+              if (copy) {
+                LOG(
+                  "  split state for branch. pattern:%u, from_step:%u, to_step:%u, immediate:%d, capture_count: %u\n",
+                  copy->pattern_index,
+                  copy->step_index,
+                  next_step->alternative_index,
+                  next_step->alternative_is_immediate,
+                  capture_list_pool_get(&self->capture_list_pool, copy->capture_list_id)->size
+                );
+                end_index++;
+                copy_count++;
+                copy->step_index = child_step->alternative_index;
+                if (child_step->alternative_is_immediate) {
+                  copy->seeking_immediate_match = true;
+                }
+              }
+            }
+          }
+        }
+
+        for (unsigned j = 0; j < self->states.size; j++) {
+          QueryState *state = &self->states.contents[j];
+          if (state->dead) {
+            array_erase(&self->states, j);
+            j--;
+            continue;
+          }
+
+          // Enfore the longest-match criteria. When a query pattern contains optional or
+          // repeated nodes, this is necessary to avoid multiple redundant states, where
+          // one state has a strict subset of another state's captures.
+          bool did_remove = false;
+          for (unsigned k = j + 1; k < self->states.size; k++) {
+            QueryState *other_state = &self->states.contents[k];
+
+            // Query states are kept in ascending order of start_depth and pattern_index.
+            // Since the longest-match criteria is only used for deduping matches of the same
+            // pattern and root node, we only need to perform pairwise comparisons within a
+            // small slice of the states array.
+            if (
+              other_state->start_depth != state->start_depth ||
+              other_state->pattern_index != state->pattern_index
+            ) break;
+
+            bool left_contains_right, right_contains_left;
+            ts_query_cursor__compare_captures(
+              self,
+              state,
+              other_state,
+              &left_contains_right,
+              &right_contains_left
+            );
+            if (left_contains_right) {
+              if (state->step_index == other_state->step_index) {
+                LOG(
+                  "  drop shorter state. pattern: %u, step_index: %u\n",
+                  state->pattern_index,
+                  state->step_index
+                );
+                capture_list_pool_release(&self->capture_list_pool, other_state->capture_list_id);
+                array_erase(&self->states, k);
+                k--;
+                continue;
+              }
+              other_state->has_in_progress_alternatives = true;
+            }
+            if (right_contains_left) {
+              if (state->step_index == other_state->step_index) {
+                LOG(
+                  "  drop shorter state. pattern: %u, step_index: %u\n",
+                  state->pattern_index,
+                  state->step_index
+                );
+                capture_list_pool_release(&self->capture_list_pool, state->capture_list_id);
+                array_erase(&self->states, j);
+                j--;
+                did_remove = true;
+                break;
+              }
+              state->has_in_progress_alternatives = true;
+            }
+          }
+
+          // If the state is at the end of its pattern, remove it from the list
+          // of in-progress states and add it to the list of finished states.
+          if (!did_remove) {
+            LOG(
+              "  keep state. pattern: %u, start_depth: %u, step_index: %u, capture_count: %u\n",
+              state->pattern_index,
+              state->start_depth,
+              state->step_index,
+              capture_list_pool_get(&self->capture_list_pool, state->capture_list_id)->size
+            );
+            QueryStep *next_step = &self->query->steps.contents[state->step_index];
+            if (next_step->depth == PATTERN_DONE_MARKER) {
+              if (state->has_in_progress_alternatives) {
+                LOG("  defer finishing pattern %u\n", state->pattern_index);
+              } else {
+                LOG("  finish pattern %u\n", state->pattern_index);
+                array_push(&self->finished_states, *state);
+                array_erase(&self->states, (uint32_t)(state - self->states.contents));
+                did_match = true;
+                j--;
               }
             }
           }
         }
       }
 
-      for (unsigned i = 0; i < self->states.size; i++) {
-        QueryState *state = &self->states.contents[i];
-        if (state->dead) {
-          array_erase(&self->states, i);
-          i--;
-          continue;
-        }
-
-        // Enfore the longest-match criteria. When a query pattern contains optional or
-        // repeated nodes, this is necessary to avoid multiple redundant states, where
-        // one state has a strict subset of another state's captures.
-        bool did_remove = false;
-        for (unsigned j = i + 1; j < self->states.size; j++) {
-          QueryState *other_state = &self->states.contents[j];
-
-          // Query states are kept in ascending order of start_depth and pattern_index.
-          // Since the longest-match criteria is only used for deduping matches of the same
-          // pattern and root node, we only need to perform pairwise comparisons within a
-          // small slice of the states array.
-          if (
-            other_state->start_depth != state->start_depth ||
-            other_state->pattern_index != state->pattern_index
-          ) break;
-
-          bool left_contains_right, right_contains_left;
-          ts_query_cursor__compare_captures(
-            self,
-            state,
-            other_state,
-            &left_contains_right,
-            &right_contains_left
-          );
-          if (left_contains_right) {
-            if (state->step_index == other_state->step_index) {
-              LOG(
-                "  drop shorter state. pattern: %u, step_index: %u\n",
-                state->pattern_index,
-                state->step_index
-              );
-              capture_list_pool_release(&self->capture_list_pool, other_state->capture_list_id);
-              array_erase(&self->states, j);
-              j--;
-              continue;
-            }
-            other_state->has_in_progress_alternatives = true;
-          }
-          if (right_contains_left) {
-            if (state->step_index == other_state->step_index) {
-              LOG(
-                "  drop shorter state. pattern: %u, step_index: %u\n",
-                state->pattern_index,
-                state->step_index
-              );
-              capture_list_pool_release(&self->capture_list_pool, state->capture_list_id);
-              array_erase(&self->states, i);
-              i--;
-              did_remove = true;
-              break;
-            }
-            state->has_in_progress_alternatives = true;
-          }
-        }
-
-        // If the state is at the end of its pattern, remove it from the list
-        // of in-progress states and add it to the list of finished states.
-        if (!did_remove) {
-          LOG(
-            "  keep state. pattern: %u, start_depth: %u, step_index: %u, capture_count: %u\n",
-            state->pattern_index,
-            state->start_depth,
-            state->step_index,
-            capture_list_pool_get(&self->capture_list_pool, state->capture_list_id)->size
-          );
-          QueryStep *next_step = &self->query->steps.contents[state->step_index];
-          if (next_step->depth == PATTERN_DONE_MARKER) {
-            if (state->has_in_progress_alternatives) {
-              LOG("  defer finishing pattern %u\n", state->pattern_index);
-            } else {
-              LOG("  finish pattern %u\n", state->pattern_index);
-              array_push(&self->finished_states, *state);
-              array_erase(&self->states, (uint32_t)(state - self->states.contents));
-              did_match = true;
-              i--;
-            }
-          }
-        }
-      }
-
-      // When the current node ends prior to the desired start offset,
-      // only descend for the purpose of continuing in-progress matches.
-      bool should_descend = node_intersects_range;
-      if (!should_descend) {
-        for (unsigned i = 0; i < self->states.size; i++) {
-          QueryState *state = &self->states.contents[i];;
-          QueryStep *next_step = &self->query->steps.contents[state->step_index];
-          if (
-            next_step->depth != PATTERN_DONE_MARKER &&
-            state->start_depth + next_step->depth > self->depth
-          ) {
-            should_descend = true;
+      if (ts_query_cursor__should_descend(self, node_intersects_range)) {
+        switch (ts_tree_cursor_goto_first_child_internal(&self->cursor)) {
+          case TreeCursorStepVisible:
+            self->depth++;
+            self->on_visible_node = true;
+            continue;
+          case TreeCursorStepHidden:
+            self->on_visible_node = false;
+            continue;
+          default:
             break;
-          }
         }
       }
 
-      if (!should_descend) {
-        LOG(
-          "  not descending. node end byte: %u, start byte: %u\n",
-          ts_node_end_byte(node),
-          self->start_byte
-        );
-      }
-
-      if (should_descend && ts_tree_cursor_goto_first_child(&self->cursor)) {
-        self->depth++;
-      } else {
-        self->ascending = true;
-      }
+      self->ascending = true;
     }
   }
 }
@@ -3883,4 +4120,11 @@ bool ts_query_cursor_next_capture(
   }
 }
 
+void ts_query_cursor_set_max_start_depth(
+  TSQueryCursor *self,
+  uint32_t max_start_depth
+) {
+  self->max_start_depth = max_start_depth;
+}
+
 #undef LOG
diff --git a/lib/src/stack.c b/lib/src/stack.c
index 98e3a96f..34846352 100644
--- a/lib/src/stack.c
+++ b/lib/src/stack.c
@@ -120,6 +120,20 @@ recur:
   }
 }
 
+/// Get the number of nodes in the subtree, for the purpose of measuring
+/// how much progress has been made by a given version of the stack.
+static uint32_t stack__subtree_node_count(Subtree subtree) {
+  uint32_t count = ts_subtree_visible_descendant_count(subtree);
+  if (ts_subtree_visible(subtree)) count++;
+
+  // Count intermediate error nodes even though they are not visible,
+  // because a stack version's node count is used to check whether it
+  // has made any progress since the last time it encountered an error.
+  if (ts_subtree_symbol(subtree) == ts_builtin_sym_error_repeat) count++;
+
+  return count;
+}
+
 static StackNode *stack_node_new(
   StackNode *previous_node,
   Subtree subtree,
@@ -152,7 +166,7 @@ static StackNode *stack_node_new(
     if (subtree.ptr) {
       node->error_cost += ts_subtree_error_cost(subtree);
       node->position = length_add(node->position, ts_subtree_total_size(subtree));
-      node->node_count += ts_subtree_node_count(subtree);
+      node->node_count += stack__subtree_node_count(subtree);
       node->dynamic_precedence += ts_subtree_dynamic_precedence(subtree);
     }
   } else {
@@ -239,7 +253,7 @@ static void stack_node_add_link(
 
   if (link.subtree.ptr) {
     ts_subtree_retain(link.subtree);
-    node_count += ts_subtree_node_count(link.subtree);
+    node_count += stack__subtree_node_count(link.subtree);
     dynamic_precedence += ts_subtree_dynamic_precedence(link.subtree);
   }
 
@@ -305,7 +319,7 @@ static void ts_stack__add_slice(
   array_push(&self->slices, slice);
 }
 
-inline StackSliceArray stack__iter(
+static StackSliceArray stack__iter(
   Stack *self,
   StackVersion version,
   StackCallback callback,
@@ -316,7 +330,7 @@ inline StackSliceArray stack__iter(
   array_clear(&self->iterators);
 
   StackHead *head = array_get(&self->heads, version);
-  StackIterator iterator = {
+  StackIterator new_iterator = {
     .node = head->node,
     .subtrees = array_new(),
     .subtree_count = 0,
@@ -326,10 +340,10 @@ inline StackSliceArray stack__iter(
   bool include_subtrees = false;
   if (goal_subtree_count >= 0) {
     include_subtrees = true;
-    array_reserve(&iterator.subtrees, (uint32_t)ts_subtree_alloc_size(goal_subtree_count) / sizeof(Subtree));
+    array_reserve(&new_iterator.subtrees, (uint32_t)ts_subtree_alloc_size(goal_subtree_count) / sizeof(Subtree));
   }
 
-  array_push(&self->iterators, iterator);
+  array_push(&self->iterators, new_iterator);
 
   while (self->iterators.size > 0) {
     for (uint32_t i = 0, size = self->iterators.size; i < size; i++) {
@@ -505,7 +519,7 @@ inline StackAction pop_count_callback(void *payload, const StackIterator *iterat
 }
 
 StackSliceArray ts_stack_pop_count(Stack *self, StackVersion version, uint32_t count) {
-  return stack__iter(self, version, pop_count_callback, &count, count);
+  return stack__iter(self, version, pop_count_callback, &count, (int)count);
 }
 
 inline StackAction pop_pending_callback(void *payload, const StackIterator *iterator) {
diff --git a/lib/src/subtree.c b/lib/src/subtree.c
index f8f82951..51bc2ef6 100644
--- a/lib/src/subtree.c
+++ b/lib/src/subtree.c
@@ -56,10 +56,10 @@ const char *ts_external_scanner_state_data(const ExternalScannerState *self) {
   }
 }
 
-bool ts_external_scanner_state_eq(const ExternalScannerState *a, const char *buffer, unsigned length) {
+bool ts_external_scanner_state_eq(const ExternalScannerState *self, const char *buffer, unsigned length) {
   return
-    a->length == length &&
-    memcmp(ts_external_scanner_state_data(a), buffer, length) == 0;
+    self->length == length &&
+    memcmp(ts_external_scanner_state_data(self), buffer, length) == 0;
 }
 
 // SubtreeArray
@@ -348,7 +348,7 @@ void ts_subtree_balance(Subtree self, SubtreePool *pool, const TSLanguage *langu
       Subtree child2 = ts_subtree_children(tree)[tree.ptr->child_count - 1];
       long repeat_delta = (long)ts_subtree_repeat_depth(child1) - (long)ts_subtree_repeat_depth(child2);
       if (repeat_delta > 0) {
-        unsigned n = repeat_delta;
+        unsigned n = (unsigned)repeat_delta;
         for (unsigned i = n / 2; i > 0; i /= 2) {
           ts_subtree__compress(tree, i, language, &pool->tree_stack);
           n -= i;
@@ -376,7 +376,7 @@ void ts_subtree_summarize_children(
   self.ptr->visible_child_count = 0;
   self.ptr->error_cost = 0;
   self.ptr->repeat_depth = 0;
-  self.ptr->node_count = 1;
+  self.ptr->visible_descendant_count = 0;
   self.ptr->has_external_tokens = false;
   self.ptr->depends_on_column = false;
   self.ptr->has_external_scanner_state_change = false;
@@ -435,14 +435,16 @@ void ts_subtree_summarize_children(
     }
 
     self.ptr->dynamic_precedence += ts_subtree_dynamic_precedence(child);
-    self.ptr->node_count += ts_subtree_node_count(child);
+    self.ptr->visible_descendant_count += ts_subtree_visible_descendant_count(child);
 
     if (alias_sequence && alias_sequence[structural_index] != 0 && !ts_subtree_extra(child)) {
+      self.ptr->visible_descendant_count++;
       self.ptr->visible_child_count++;
       if (ts_language_symbol_metadata(language, alias_sequence[structural_index]).named) {
         self.ptr->named_child_count++;
       }
     } else if (ts_subtree_visible(child)) {
+      self.ptr->visible_descendant_count++;
       self.ptr->visible_child_count++;
       if (ts_subtree_named(child)) self.ptr->named_child_count++;
     } else if (grandchild_count > 0) {
@@ -513,7 +515,7 @@ MutableSubtree ts_subtree_new_node(
   size_t new_byte_size = ts_subtree_alloc_size(children->size);
   if (children->capacity * sizeof(Subtree) < new_byte_size) {
     children->contents = ts_realloc(children->contents, new_byte_size);
-    children->capacity = new_byte_size / sizeof(Subtree);
+    children->capacity = (uint32_t)(new_byte_size / sizeof(Subtree));
   }
   SubtreeHeapData *data = (SubtreeHeapData *)&children->contents[children->size];
 
@@ -529,7 +531,7 @@ MutableSubtree ts_subtree_new_node(
     .fragile_right = fragile,
     .is_keyword = false,
     {{
-      .node_count = 0,
+      .visible_descendant_count = 0,
       .production_id = production_id,
       .first_leaf = {.symbol = 0, .parse_state = 0},
     }}
@@ -641,24 +643,24 @@ static inline void ts_subtree_set_has_changes(MutableSubtree *self) {
   }
 }
 
-Subtree ts_subtree_edit(Subtree self, const TSInputEdit *edit, SubtreePool *pool) {
+Subtree ts_subtree_edit(Subtree self, const TSInputEdit *input_edit, SubtreePool *pool) {
   typedef struct {
     Subtree *tree;
     Edit edit;
-  } StackEntry;
+  } EditEntry;
 
-  Array(StackEntry) stack = array_new();
-  array_push(&stack, ((StackEntry) {
+  Array(EditEntry) stack = array_new();
+  array_push(&stack, ((EditEntry) {
     .tree = &self,
     .edit = (Edit) {
-      .start = {edit->start_byte, edit->start_point},
-      .old_end = {edit->old_end_byte, edit->old_end_point},
-      .new_end = {edit->new_end_byte, edit->new_end_point},
+      .start = {input_edit->start_byte, input_edit->start_point},
+      .old_end = {input_edit->old_end_byte, input_edit->old_end_point},
+      .new_end = {input_edit->new_end_byte, input_edit->new_end_point},
     },
   }));
 
   while (stack.size) {
-    StackEntry entry = array_pop(&stack);
+    EditEntry entry = array_pop(&stack);
     Edit edit = entry.edit;
     bool is_noop = edit.old_end.bytes == edit.start.bytes && edit.new_end.bytes == edit.start.bytes;
     bool is_pure_insertion = edit.old_end.bytes == edit.start.bytes;
@@ -786,7 +788,7 @@ Subtree ts_subtree_edit(Subtree self, const TSInputEdit *edit, SubtreePool *pool
       }
 
       // Queue processing of this child's subtree.
-      array_push(&stack, ((StackEntry) {
+      array_push(&stack, ((EditEntry) {
         .tree = child,
         .edit = child_edit,
       }));
@@ -811,24 +813,24 @@ Subtree ts_subtree_last_external_token(Subtree tree) {
   return tree;
 }
 
-static size_t ts_subtree__write_char_to_string(char *s, size_t n, int32_t c) {
-  if (c == -1)
-    return snprintf(s, n, "INVALID");
-  else if (c == '\0')
-    return snprintf(s, n, "'\\0'");
-  else if (c == '\n')
-    return snprintf(s, n, "'\\n'");
-  else if (c == '\t')
-    return snprintf(s, n, "'\\t'");
-  else if (c == '\r')
-    return snprintf(s, n, "'\\r'");
-  else if (0 < c && c < 128 && isprint(c))
-    return snprintf(s, n, "'%c'", c);
+static size_t ts_subtree__write_char_to_string(char *str, size_t n, int32_t chr) {
+  if (chr == -1)
+    return snprintf(str, n, "INVALID");
+  else if (chr == '\0')
+    return snprintf(str, n, "'\\0'");
+  else if (chr == '\n')
+    return snprintf(str, n, "'\\n'");
+  else if (chr == '\t')
+    return snprintf(str, n, "'\\t'");
+  else if (chr == '\r')
+    return snprintf(str, n, "'\\r'");
+  else if (0 < chr && chr < 128 && isprint(chr))
+    return snprintf(str, n, "'%c'", chr);
   else
-    return snprintf(s, n, "%d", c);
+    return snprintf(str, n, "%d", chr);
 }
 
-static const char *ROOT_FIELD = "__ROOT__";
+static const char *const ROOT_FIELD = "__ROOT__";
 
 static size_t ts_subtree__write_to_string(
   Subtree self, char *string, size_t limit,
@@ -900,17 +902,17 @@ static size_t ts_subtree__write_to_string(
           0, false, NULL
         );
       } else {
-        TSSymbol alias_symbol = alias_sequence
+        TSSymbol subtree_alias_symbol = alias_sequence
           ? alias_sequence[structural_child_index]
           : 0;
-        bool alias_is_named = alias_symbol
-          ? ts_language_symbol_metadata(language, alias_symbol).named
+        bool subtree_alias_is_named = subtree_alias_symbol
+          ? ts_language_symbol_metadata(language, subtree_alias_symbol).named
           : false;
 
         const char *child_field_name = is_visible ? NULL : field_name;
-        for (const TSFieldMapEntry *i = field_map; i < field_map_end; i++) {
-          if (!i->inherited && i->child_index == structural_child_index) {
-            child_field_name = language->field_names[i->field_id];
+        for (const TSFieldMapEntry *map = field_map; map < field_map_end; map++) {
+          if (!map->inherited && map->child_index == structural_child_index) {
+            child_field_name = language->field_names[map->field_id];
             break;
           }
         }
@@ -918,7 +920,7 @@ static size_t ts_subtree__write_to_string(
         cursor += ts_subtree__write_to_string(
           child, *writer, limit,
           language, include_all,
-          alias_symbol, alias_is_named, child_field_name
+          subtree_alias_symbol, subtree_alias_is_named, child_field_name
         );
         structural_child_index++;
       }
@@ -969,6 +971,7 @@ void ts_subtree__print_dot_graph(const Subtree *self, uint32_t start_offset,
     "error-cost: %u\n"
     "has-changes: %u\n"
     "depends-on-column: %u\n"
+    "descendant-count: %u\n"
     "repeat-depth: %u\n"
     "lookahead-bytes: %u",
     start_offset, end_offset,
@@ -976,6 +979,7 @@ void ts_subtree__print_dot_graph(const Subtree *self, uint32_t start_offset,
     ts_subtree_error_cost(*self),
     ts_subtree_has_changes(*self),
     ts_subtree_depends_on_column(*self),
+    ts_subtree_visible_descendant_count(*self),
     ts_subtree_repeat_depth(*self),
     ts_subtree_lookahead_bytes(*self)
   );
@@ -992,12 +996,12 @@ void ts_subtree__print_dot_graph(const Subtree *self, uint32_t start_offset,
     ts_subtree_production_id(*self);
   for (uint32_t i = 0, n = ts_subtree_child_count(*self); i < n; i++) {
     const Subtree *child = &ts_subtree_children(*self)[i];
-    TSSymbol alias_symbol = 0;
+    TSSymbol subtree_alias_symbol = 0;
     if (!ts_subtree_extra(*child) && child_info_offset) {
-      alias_symbol = language->alias_sequences[child_info_offset];
+      subtree_alias_symbol = language->alias_sequences[child_info_offset];
       child_info_offset++;
     }
-    ts_subtree__print_dot_graph(child, child_start_offset, language, alias_symbol, f);
+    ts_subtree__print_dot_graph(child, child_start_offset, language, subtree_alias_symbol, f);
     fprintf(f, "tree_%p -> tree_%p [tooltip=%u]\n", (void *)self, (void *)child, i);
     child_start_offset += ts_subtree_total_bytes(*child);
   }
@@ -1024,12 +1028,12 @@ const ExternalScannerState *ts_subtree_external_scanner_state(Subtree self) {
   }
 }
 
-bool ts_subtree_external_scanner_state_eq(Subtree a, Subtree b) {
-  const ExternalScannerState *state_a = ts_subtree_external_scanner_state(a);
-  const ExternalScannerState *state_b = ts_subtree_external_scanner_state(b);
+bool ts_subtree_external_scanner_state_eq(Subtree self, Subtree other) {
+  const ExternalScannerState *state_self = ts_subtree_external_scanner_state(self);
+  const ExternalScannerState *state_other = ts_subtree_external_scanner_state(other);
   return ts_external_scanner_state_eq(
-    state_a,
-    ts_external_scanner_state_data(state_b),
-    state_b->length
+    state_self,
+    ts_external_scanner_state_data(state_other),
+    state_other->length
   );
 }
diff --git a/lib/src/subtree.h b/lib/src/subtree.h
index 8456d2f1..cac657fd 100644
--- a/lib/src/subtree.h
+++ b/lib/src/subtree.h
@@ -135,7 +135,7 @@ typedef struct {
     struct {
       uint32_t visible_child_count;
       uint32_t named_child_count;
-      uint32_t node_count;
+      uint32_t visible_descendant_count;
       int32_t dynamic_precedence;
       uint16_t repeat_depth;
       uint16_t production_id;
@@ -175,7 +175,7 @@ typedef struct {
 
 void ts_external_scanner_state_init(ExternalScannerState *, const char *, unsigned);
 const char *ts_external_scanner_state_data(const ExternalScannerState *);
-bool ts_external_scanner_state_eq(const ExternalScannerState *a, const char *, unsigned);
+bool ts_external_scanner_state_eq(const ExternalScannerState *self, const char *, unsigned);
 void ts_external_scanner_state_delete(ExternalScannerState *self);
 
 void ts_subtree_array_copy(SubtreeArray, SubtreeArray *);
@@ -212,7 +212,7 @@ Subtree ts_subtree_last_external_token(Subtree);
 const ExternalScannerState *ts_subtree_external_scanner_state(Subtree self);
 bool ts_subtree_external_scanner_state_eq(Subtree, Subtree);
 
-#define SUBTREE_GET(self, name) (self.data.is_inline ? self.data.name : self.ptr->name)
+#define SUBTREE_GET(self, name) ((self).data.is_inline ? (self).data.name : (self).ptr->name)
 
 static inline TSSymbol ts_subtree_symbol(Subtree self) { return SUBTREE_GET(self, symbol); }
 static inline bool ts_subtree_visible(Subtree self) { return SUBTREE_GET(self, visible); }
@@ -291,8 +291,16 @@ static inline uint32_t ts_subtree_repeat_depth(Subtree self) {
   return self.data.is_inline ? 0 : self.ptr->repeat_depth;
 }
 
-static inline uint32_t ts_subtree_node_count(Subtree self) {
-  return (self.data.is_inline || self.ptr->child_count == 0) ? 1 : self.ptr->node_count;
+static inline uint32_t ts_subtree_is_repetition(Subtree self) {
+  return self.data.is_inline
+    ? 0
+    : !self.ptr->named && !self.ptr->visible && self.ptr->child_count != 0;
+}
+
+static inline uint32_t ts_subtree_visible_descendant_count(Subtree self) {
+  return (self.data.is_inline || self.ptr->child_count == 0)
+    ? 0
+    : self.ptr->visible_descendant_count;
 }
 
 static inline uint32_t ts_subtree_visible_child_count(Subtree self) {
diff --git a/lib/src/tree.c b/lib/src/tree.c
index f6bd2c72..784c51fd 100644
--- a/lib/src/tree.c
+++ b/lib/src/tree.c
@@ -98,23 +98,23 @@ TSRange *ts_tree_included_ranges(const TSTree *self, uint32_t *length) {
   return ranges;
 }
 
-TSRange *ts_tree_get_changed_ranges(const TSTree *self, const TSTree *other, uint32_t *count) {
+TSRange *ts_tree_get_changed_ranges(const TSTree *old_tree, const TSTree *new_tree, uint32_t *length) {
   TreeCursor cursor1 = {NULL, array_new()};
   TreeCursor cursor2 = {NULL, array_new()};
-  ts_tree_cursor_init(&cursor1, ts_tree_root_node(self));
-  ts_tree_cursor_init(&cursor2, ts_tree_root_node(other));
+  ts_tree_cursor_init(&cursor1, ts_tree_root_node(old_tree));
+  ts_tree_cursor_init(&cursor2, ts_tree_root_node(new_tree));
 
   TSRangeArray included_range_differences = array_new();
   ts_range_array_get_changed_ranges(
-    self->included_ranges, self->included_range_count,
-    other->included_ranges, other->included_range_count,
+    old_tree->included_ranges, old_tree->included_range_count,
+    new_tree->included_ranges, new_tree->included_range_count,
     &included_range_differences
   );
 
   TSRange *result;
-  *count = ts_subtree_get_changed_ranges(
-    &self->root, &other->root, &cursor1, &cursor2,
-    self->language, &included_range_differences, &result
+  *length = ts_subtree_get_changed_ranges(
+    &old_tree->root, &new_tree->root, &cursor1, &cursor2,
+    old_tree->language, &included_range_differences, &result
   );
 
   array_delete(&included_range_differences);
@@ -123,6 +123,21 @@ TSRange *ts_tree_get_changed_ranges(const TSTree *self, const TSTree *other, uin
   return result;
 }
 
-void ts_tree_print_dot_graph(const TSTree *self, FILE *file) {
-  ts_subtree_print_dot_graph(self->root, self->language, file);
+#ifdef _WIN32
+
+void ts_tree_print_dot_graph(const TSTree *self, int fd) {
+  (void)self;
+  (void)fd;
 }
+
+#else
+
+#include <unistd.h>
+
+void ts_tree_print_dot_graph(const TSTree *self, int file_descriptor) {
+  FILE *file = fdopen(dup(file_descriptor), "a");
+  ts_subtree_print_dot_graph(self->root, self->language, file);
+  fclose(file);
+}
+
+#endif
diff --git a/lib/src/tree.h b/lib/src/tree.h
index 0334b824..f012f888 100644
--- a/lib/src/tree.h
+++ b/lib/src/tree.h
@@ -1,6 +1,8 @@
 #ifndef TREE_SITTER_TREE_H_
 #define TREE_SITTER_TREE_H_
 
+#include "./subtree.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
diff --git a/lib/src/tree_cursor.c b/lib/src/tree_cursor.c
index e8dc98a9..63d22c8b 100644
--- a/lib/src/tree_cursor.c
+++ b/lib/src/tree_cursor.c
@@ -10,26 +10,50 @@ typedef struct {
   Length position;
   uint32_t child_index;
   uint32_t structural_child_index;
+  uint32_t descendant_index;
   const TSSymbol *alias_sequence;
 } CursorChildIterator;
 
 // CursorChildIterator
 
+static inline bool ts_tree_cursor_is_entry_visible(const TreeCursor *self, uint32_t index) {
+  TreeCursorEntry *entry = &self->stack.contents[index];
+  if (index == 0 || ts_subtree_visible(*entry->subtree)) {
+    return true;
+  } else if (!ts_subtree_extra(*entry->subtree)) {
+    TreeCursorEntry *parent_entry = &self->stack.contents[index - 1];
+    return ts_language_alias_at(
+      self->tree->language,
+      parent_entry->subtree->ptr->production_id,
+      entry->structural_child_index
+    );
+  } else {
+    return false;
+  }
+}
+
 static inline CursorChildIterator ts_tree_cursor_iterate_children(const TreeCursor *self) {
   TreeCursorEntry *last_entry = array_back(&self->stack);
   if (ts_subtree_child_count(*last_entry->subtree) == 0) {
-    return (CursorChildIterator) {NULL_SUBTREE, self->tree, length_zero(), 0, 0, NULL};
+    return (CursorChildIterator) {NULL_SUBTREE, self->tree, length_zero(), 0, 0, 0, NULL};
   }
   const TSSymbol *alias_sequence = ts_language_alias_sequence(
     self->tree->language,
     last_entry->subtree->ptr->production_id
   );
+
+  uint32_t descendant_index = last_entry->descendant_index;
+  if (ts_tree_cursor_is_entry_visible(self, self->stack.size - 1)) {
+    descendant_index += 1;
+  }
+
   return (CursorChildIterator) {
     .tree = self->tree,
     .parent = *last_entry->subtree,
     .position = last_entry->position,
     .child_index = 0,
     .structural_child_index = 0,
+    .descendant_index = descendant_index,
     .alias_sequence = alias_sequence,
   };
 }
@@ -46,14 +70,22 @@ static inline bool ts_tree_cursor_child_iterator_next(
     .position = self->position,
     .child_index = self->child_index,
     .structural_child_index = self->structural_child_index,
+    .descendant_index = self->descendant_index,
   };
   *visible = ts_subtree_visible(*child);
   bool extra = ts_subtree_extra(*child);
-  if (!extra && self->alias_sequence) {
-    *visible |= self->alias_sequence[self->structural_child_index];
+  if (!extra) {
+    if (self->alias_sequence) {
+      *visible |= self->alias_sequence[self->structural_child_index];
+    }
     self->structural_child_index++;
   }
 
+  self->descendant_index += ts_subtree_visible_descendant_count(*child);
+  if (*visible) {
+    self->descendant_index += 1;
+  }
+
   self->position = length_add(self->position, ts_subtree_size(*child));
   self->child_index++;
 
@@ -65,6 +97,57 @@ static inline bool ts_tree_cursor_child_iterator_next(
   return true;
 }
 
+// Return a position that, when `b` is added to it, yields `a`. This
+// can only be computed if `b` has zero rows. Otherwise, this function
+// returns `LENGTH_UNDEFINED`, and the caller needs to recompute
+// the position some other way.
+static inline Length length_backtrack(Length a, Length b) {
+  if (length_is_undefined(a) || b.extent.row != 0) {
+    return LENGTH_UNDEFINED;
+  }
+
+  Length result;
+  result.bytes = a.bytes - b.bytes;
+  result.extent.row = a.extent.row;
+  result.extent.column = a.extent.column - b.extent.column;
+  return result;
+}
+
+static inline bool ts_tree_cursor_child_iterator_previous(
+  CursorChildIterator *self,
+  TreeCursorEntry *result,
+  bool *visible
+) {
+  // this is mostly a reverse `ts_tree_cursor_child_iterator_next` taking into
+  // account unsigned underflow
+  if (!self->parent.ptr || (int8_t)self->child_index == -1) return false;
+  const Subtree *child = &ts_subtree_children(self->parent)[self->child_index];
+  *result = (TreeCursorEntry) {
+    .subtree = child,
+    .position = self->position,
+    .child_index = self->child_index,
+    .structural_child_index = self->structural_child_index,
+  };
+  *visible = ts_subtree_visible(*child);
+  bool extra = ts_subtree_extra(*child);
+  if (!extra && self->alias_sequence) {
+    *visible |= self->alias_sequence[self->structural_child_index];
+    self->structural_child_index--;
+  }
+
+  self->position = length_backtrack(self->position, ts_subtree_padding(*child));
+  self->child_index--;
+
+  // unsigned can underflow so compare it to child_count
+  if (self->child_index < self->parent.ptr->child_count) {
+    Subtree previous_child = ts_subtree_children(self->parent)[self->child_index];
+    Length size = ts_subtree_size(previous_child);
+    self->position = length_backtrack(self->position, size);
+  }
+
+  return true;
+}
+
 // TSTreeCursor - lifecycle
 
 TSTreeCursor ts_tree_cursor_new(TSNode node) {
@@ -88,6 +171,7 @@ void ts_tree_cursor_init(TreeCursor *self, TSNode node) {
     },
     .child_index = 0,
     .structural_child_index = 0,
+    .descendant_index = 0,
   }));
 }
 
@@ -98,74 +182,84 @@ void ts_tree_cursor_delete(TSTreeCursor *_self) {
 
 // TSTreeCursor - walking the tree
 
-bool ts_tree_cursor_goto_first_child(TSTreeCursor *_self) {
+TreeCursorStep ts_tree_cursor_goto_first_child_internal(TSTreeCursor *_self) {
   TreeCursor *self = (TreeCursor *)_self;
-
-  bool did_descend;
-  do {
-    did_descend = false;
-
-    bool visible;
-    TreeCursorEntry entry;
-    CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
-    while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
-      if (visible) {
-        array_push(&self->stack, entry);
-        return true;
-      }
-
-      if (ts_subtree_visible_child_count(*entry.subtree) > 0) {
-        array_push(&self->stack, entry);
-        did_descend = true;
-        break;
-      }
+  bool visible;
+  TreeCursorEntry entry;
+  CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
+  while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
+    if (visible) {
+      array_push(&self->stack, entry);
+      return TreeCursorStepVisible;
     }
-  } while (did_descend);
+    if (ts_subtree_visible_child_count(*entry.subtree) > 0) {
+      array_push(&self->stack, entry);
+      return TreeCursorStepHidden;
+    }
+  }
+  return TreeCursorStepNone;
+}
 
+bool ts_tree_cursor_goto_first_child(TSTreeCursor *self) {
+  for (;;) {
+    switch (ts_tree_cursor_goto_first_child_internal(self)) {
+      case TreeCursorStepHidden:
+        continue;
+      case TreeCursorStepVisible:
+        return true;
+      default:
+        return false;
+    }
+  }
   return false;
 }
 
-int64_t ts_tree_cursor_goto_first_child_for_byte(TSTreeCursor *_self, uint32_t goal_byte) {
+TreeCursorStep ts_tree_cursor_goto_last_child_internal(TSTreeCursor *_self) {
   TreeCursor *self = (TreeCursor *)_self;
-  uint32_t initial_size = self->stack.size;
-  uint32_t visible_child_index = 0;
+  bool visible;
+  TreeCursorEntry entry;
+  CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
+  if (!iterator.parent.ptr || iterator.parent.ptr->child_count == 0) return TreeCursorStepNone;
 
-  bool did_descend;
-  do {
-    did_descend = false;
-
-    bool visible;
-    TreeCursorEntry entry;
-    CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
-    while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
-      uint32_t end_byte = entry.position.bytes + ts_subtree_size(*entry.subtree).bytes;
-      bool at_goal = end_byte >= goal_byte;
-      uint32_t visible_child_count = ts_subtree_visible_child_count(*entry.subtree);
-
-      if (at_goal) {
-        if (visible) {
-          array_push(&self->stack, entry);
-          return visible_child_index;
-        }
-
-        if (visible_child_count > 0) {
-          array_push(&self->stack, entry);
-          did_descend = true;
-          break;
-        }
-      } else if (visible) {
-        visible_child_index++;
-      } else {
-        visible_child_index += visible_child_count;
-      }
+  TreeCursorEntry last_entry;
+  TreeCursorStep last_step = TreeCursorStepNone;
+  while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
+    if (visible) {
+      last_entry = entry;
+      last_step = TreeCursorStepVisible;
     }
-  } while (did_descend);
+    else if (ts_subtree_visible_child_count(*entry.subtree) > 0) {
+      last_entry = entry;
+      last_step = TreeCursorStepHidden;
+    }
+  }
+  if (last_entry.subtree) {
+    array_push(&self->stack, last_entry);
+    return last_step;
+  }
 
-  self->stack.size = initial_size;
-  return -1;
+  return TreeCursorStepNone;
 }
 
-int64_t ts_tree_cursor_goto_first_child_for_point(TSTreeCursor *_self, TSPoint goal_point) {
+bool ts_tree_cursor_goto_last_child(TSTreeCursor *self) {
+  for (;;) {
+    switch (ts_tree_cursor_goto_last_child_internal(self)) {
+      case TreeCursorStepHidden:
+        continue;
+      case TreeCursorStepVisible:
+        return true;
+      default:
+        return false;
+    }
+  }
+  return false;
+}
+
+static inline int64_t ts_tree_cursor_goto_first_child_for_byte_and_point(
+  TSTreeCursor *_self,
+  uint32_t goal_byte,
+  TSPoint goal_point
+) {
   TreeCursor *self = (TreeCursor *)_self;
   uint32_t initial_size = self->stack.size;
   uint32_t visible_child_index = 0;
@@ -178,8 +272,8 @@ int64_t ts_tree_cursor_goto_first_child_for_point(TSTreeCursor *_self, TSPoint g
     TreeCursorEntry entry;
     CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
     while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
-      TSPoint end_point = point_add(entry.position.extent, ts_subtree_size(*entry.subtree).extent);
-      bool at_goal = point_gte(end_point, goal_point);
+      Length entry_end = length_add(entry.position, ts_subtree_size(*entry.subtree));
+      bool at_goal = entry_end.bytes >= goal_byte && point_gte(entry_end.extent, goal_point);
       uint32_t visible_child_count = ts_subtree_visible_child_count(*entry.subtree);
       if (at_goal) {
         if (visible) {
@@ -203,7 +297,17 @@ int64_t ts_tree_cursor_goto_first_child_for_point(TSTreeCursor *_self, TSPoint g
   return -1;
 }
 
-bool ts_tree_cursor_goto_next_sibling(TSTreeCursor *_self) {
+int64_t ts_tree_cursor_goto_first_child_for_byte(TSTreeCursor *self, uint32_t goal_byte) {
+  return ts_tree_cursor_goto_first_child_for_byte_and_point(self, goal_byte, POINT_ZERO);
+}
+
+int64_t ts_tree_cursor_goto_first_child_for_point(TSTreeCursor *self, TSPoint goal_point) {
+  return ts_tree_cursor_goto_first_child_for_byte_and_point(self, 0, goal_point);
+}
+
+TreeCursorStep ts_tree_cursor_goto_sibling_internal(
+    TSTreeCursor *_self,
+    bool (*advance)(CursorChildIterator *, TreeCursorEntry *, bool *)) {
   TreeCursor *self = (TreeCursor *)_self;
   uint32_t initial_size = self->stack.size;
 
@@ -213,52 +317,161 @@ bool ts_tree_cursor_goto_next_sibling(TSTreeCursor *_self) {
     iterator.child_index = entry.child_index;
     iterator.structural_child_index = entry.structural_child_index;
     iterator.position = entry.position;
+    iterator.descendant_index = entry.descendant_index;
 
     bool visible = false;
-    ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible);
+    advance(&iterator, &entry, &visible);
     if (visible && self->stack.size + 1 < initial_size) break;
 
-    while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
+    while (advance(&iterator, &entry, &visible)) {
       if (visible) {
         array_push(&self->stack, entry);
-        return true;
+        return TreeCursorStepVisible;
       }
 
       if (ts_subtree_visible_child_count(*entry.subtree)) {
         array_push(&self->stack, entry);
-        ts_tree_cursor_goto_first_child(_self);
-        return true;
+        return TreeCursorStepHidden;
       }
     }
   }
 
   self->stack.size = initial_size;
-  return false;
+  return TreeCursorStepNone;
+}
+
+TreeCursorStep ts_tree_cursor_goto_next_sibling_internal(TSTreeCursor *_self) {
+  return ts_tree_cursor_goto_sibling_internal(_self, ts_tree_cursor_child_iterator_next);
+}
+
+bool ts_tree_cursor_goto_next_sibling(TSTreeCursor *self) {
+  switch (ts_tree_cursor_goto_next_sibling_internal(self)) {
+    case TreeCursorStepHidden:
+      ts_tree_cursor_goto_first_child(self);
+      return true;
+    case TreeCursorStepVisible:
+      return true;
+    default:
+      return false;
+  }
+}
+
+TreeCursorStep ts_tree_cursor_goto_previous_sibling_internal(TSTreeCursor *_self) {
+  // since subtracting across row loses column information, we may have to
+  // restore it
+  TreeCursor *self = (TreeCursor *)_self;
+
+  // for that, save current position before traversing
+  Length position = array_back(&self->stack)->position;
+  TreeCursorStep step = ts_tree_cursor_goto_sibling_internal(
+      _self, ts_tree_cursor_child_iterator_previous);
+  if (step == TreeCursorStepNone)
+    return step;
+
+  // if length is already valid, there's no need to recompute it
+  if (!length_is_undefined(array_back(&self->stack)->position))
+    return step;
+
+  // restore position from the parent node
+  const TreeCursorEntry *parent = &self->stack.contents[self->stack.size - 2];
+  position = parent->position;
+  uint32_t child_index = array_back(&self->stack)->child_index;
+  const Subtree *children = ts_subtree_children((*(parent->subtree)));
+
+  if (child_index > 0) {
+    // skip first child padding since its position should match the position of the parent
+    position = length_add(position, ts_subtree_size(children[0]));
+    for (uint32_t i = 1; i < child_index; ++i) {
+      position = length_add(position, ts_subtree_total_size(children[i]));
+    }
+    position = length_add(position, ts_subtree_padding(children[child_index]));
+  }
+
+  array_back(&self->stack)->position = position;
+
+  return step;
+}
+
+bool ts_tree_cursor_goto_previous_sibling(TSTreeCursor *self) {
+  switch (ts_tree_cursor_goto_previous_sibling_internal(self)) {
+    case TreeCursorStepHidden:
+      ts_tree_cursor_goto_last_child(self);
+      return true;
+    case TreeCursorStepVisible:
+      return true;
+    default:
+      return false;
+  }
 }
 
 bool ts_tree_cursor_goto_parent(TSTreeCursor *_self) {
   TreeCursor *self = (TreeCursor *)_self;
   for (unsigned i = self->stack.size - 2; i + 1 > 0; i--) {
-    TreeCursorEntry *entry = &self->stack.contents[i];
-    if (ts_subtree_visible(*entry->subtree)) {
+    if (ts_tree_cursor_is_entry_visible(self, i)) {
       self->stack.size = i + 1;
       return true;
     }
-    if (i > 0 && !ts_subtree_extra(*entry->subtree)) {
-      TreeCursorEntry *parent_entry = &self->stack.contents[i - 1];
-      if (ts_language_alias_at(
-        self->tree->language,
-        parent_entry->subtree->ptr->production_id,
-        entry->structural_child_index
-      )) {
-        self->stack.size = i + 1;
-        return true;
-      }
-    }
   }
   return false;
 }
 
+void ts_tree_cursor_goto_descendant(
+  TSTreeCursor *_self,
+  uint32_t goal_descendant_index
+) {
+  TreeCursor *self = (TreeCursor *)_self;
+
+  // Ascend to the lowest ancestor that contains the goal node.
+  for (;;) {
+    uint32_t i = self->stack.size - 1;
+    TreeCursorEntry *entry = &self->stack.contents[i];
+    uint32_t next_descendant_index =
+      entry->descendant_index +
+      (ts_tree_cursor_is_entry_visible(self, i) ? 1 : 0) +
+      ts_subtree_visible_descendant_count(*entry->subtree);
+    if (
+      (entry->descendant_index <= goal_descendant_index) &&
+      (next_descendant_index > goal_descendant_index)
+    ) {
+      break;
+    } else if (self->stack.size <= 1) {
+      return;
+    } else {
+      self->stack.size--;
+    }
+  }
+
+  // Descend to the goal node.
+  bool did_descend = true;
+  do {
+    did_descend = false;
+    bool visible;
+    TreeCursorEntry entry;
+    CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
+    if (iterator.descendant_index > goal_descendant_index) {
+      return;
+    }
+
+    while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
+      if (iterator.descendant_index > goal_descendant_index) {
+        array_push(&self->stack, entry);
+        if (visible && entry.descendant_index == goal_descendant_index) {
+          return;
+        } else {
+          did_descend = true;
+          break;
+        }
+      }
+    }
+  } while (did_descend);
+}
+
+uint32_t ts_tree_cursor_current_descendant_index(const TSTreeCursor *_self) {
+  const TreeCursor *self = (const TreeCursor *)_self;
+  TreeCursorEntry *last_entry = array_back(&self->stack);
+  return last_entry->descendant_index;
+}
+
 TSNode ts_tree_cursor_current_node(const TSTreeCursor *_self) {
   const TreeCursor *self = (const TreeCursor *)_self;
   TreeCursorEntry *last_entry = array_back(&self->stack);
@@ -377,9 +590,9 @@ void ts_tree_cursor_current_status(
 
       // Look for a field name associated with the current node.
       if (!*field_id) {
-        for (const TSFieldMapEntry *i = field_map; i < field_map_end; i++) {
-          if (!i->inherited && i->child_index == entry->structural_child_index) {
-            *field_id = i->field_id;
+        for (const TSFieldMapEntry *map = field_map; map < field_map_end; map++) {
+          if (!map->inherited && map->child_index == entry->structural_child_index) {
+            *field_id = map->field_id;
             break;
           }
         }
@@ -387,10 +600,10 @@ void ts_tree_cursor_current_status(
 
       // Determine if the current node can have later siblings with the same field name.
       if (*field_id) {
-        for (const TSFieldMapEntry *i = field_map; i < field_map_end; i++) {
+        for (const TSFieldMapEntry *map = field_map; map < field_map_end; map++) {
           if (
-            i->field_id == *field_id &&
-            i->child_index > entry->structural_child_index
+            map->field_id == *field_id &&
+            map->child_index > entry->structural_child_index
           ) {
             *can_have_later_siblings_with_this_field = true;
             break;
@@ -401,6 +614,17 @@ void ts_tree_cursor_current_status(
   }
 }
 
+uint32_t ts_tree_cursor_current_depth(const TSTreeCursor *_self) {
+  const TreeCursor *self = (const TreeCursor *)_self;
+  uint32_t depth = 0;
+  for (unsigned i = 1; i < self->stack.size; i++) {
+    if (ts_tree_cursor_is_entry_visible(self, i)) {
+      depth++;
+    }
+  }
+  return depth;
+}
+
 TSNode ts_tree_cursor_parent_node(const TSTreeCursor *_self) {
   const TreeCursor *self = (const TreeCursor *)_self;
   for (int i = (int)self->stack.size - 2; i >= 0; i--) {
@@ -437,17 +661,10 @@ TSFieldId ts_tree_cursor_current_field_id(const TSTreeCursor *_self) {
     TreeCursorEntry *parent_entry = &self->stack.contents[i - 1];
 
     // Stop walking up when another visible node is found.
-    if (i != self->stack.size - 1) {
-      if (ts_subtree_visible(*entry->subtree)) break;
-      if (
-        !ts_subtree_extra(*entry->subtree) &&
-        ts_language_alias_at(
-          self->tree->language,
-          parent_entry->subtree->ptr->production_id,
-          entry->structural_child_index
-        )
-      ) break;
-    }
+    if (
+      i != self->stack.size - 1 &&
+      ts_tree_cursor_is_entry_visible(self, i)
+    ) break;
 
     if (ts_subtree_extra(*entry->subtree)) break;
 
@@ -457,9 +674,9 @@ TSFieldId ts_tree_cursor_current_field_id(const TSTreeCursor *_self) {
       parent_entry->subtree->ptr->production_id,
       &field_map, &field_map_end
     );
-    for (const TSFieldMapEntry *i = field_map; i < field_map_end; i++) {
-      if (!i->inherited && i->child_index == entry->structural_child_index) {
-        return i->field_id;
+    for (const TSFieldMapEntry *map = field_map; map < field_map_end; map++) {
+      if (!map->inherited && map->child_index == entry->structural_child_index) {
+        return map->field_id;
       }
     }
   }
@@ -485,3 +702,11 @@ TSTreeCursor ts_tree_cursor_copy(const TSTreeCursor *_cursor) {
   array_push_all(&copy->stack, &cursor->stack);
   return res;
 }
+
+void ts_tree_cursor_reset_to(TSTreeCursor *_dst, const TSTreeCursor *_src) {
+  const TreeCursor *cursor = (const TreeCursor *)_src;
+  TreeCursor *copy = (TreeCursor *)_dst;
+  copy->tree = cursor->tree;
+  array_clear(&copy->stack);
+  array_push_all(&copy->stack, &cursor->stack);
+}
diff --git a/lib/src/tree_cursor.h b/lib/src/tree_cursor.h
index 69647d1d..6d4c688b 100644
--- a/lib/src/tree_cursor.h
+++ b/lib/src/tree_cursor.h
@@ -8,6 +8,7 @@ typedef struct {
   Length position;
   uint32_t child_index;
   uint32_t structural_child_index;
+  uint32_t descendant_index;
 } TreeCursorEntry;
 
 typedef struct {
@@ -15,6 +16,12 @@ typedef struct {
   Array(TreeCursorEntry) stack;
 } TreeCursor;
 
+typedef enum {
+  TreeCursorStepNone,
+  TreeCursorStepHidden,
+  TreeCursorStepVisible,
+} TreeCursorStep;
+
 void ts_tree_cursor_init(TreeCursor *, TSNode);
 void ts_tree_cursor_current_status(
   const TSTreeCursor *,
@@ -26,6 +33,15 @@ void ts_tree_cursor_current_status(
   unsigned *
 );
 
+TreeCursorStep ts_tree_cursor_goto_first_child_internal(TSTreeCursor *);
+TreeCursorStep ts_tree_cursor_goto_next_sibling_internal(TSTreeCursor *);
+
+static inline Subtree ts_tree_cursor_current_subtree(const TSTreeCursor *_self) {
+  const TreeCursor *self = (const TreeCursor *)_self;
+  TreeCursorEntry *last_entry = array_back(&self->stack);
+  return *last_entry->subtree;
+}
+
 TSNode ts_tree_cursor_parent_node(const TSTreeCursor *);
 
 #endif  // TREE_SITTER_TREE_CURSOR_H_
diff --git a/script/build-fuzzers b/script/build-fuzzers
index bff43c8b..1d07cba7 100755
--- a/script/build-fuzzers
+++ b/script/build-fuzzers
@@ -6,14 +6,8 @@ if [[ "$(uname -s)" != Linux ]]; then
   exit 1
 fi
 
-if [[ -z "$LIB_FUZZER_PATH" ]]; then
-  echo "LIB_FUZZER_PATH not set"
-  exit 1
-fi
-
 CC=${CC:-clang}
 CXX=${CXX:-clang++}
-LINK=${LINK:-clang++}
 
 default_fuzz_flags="-fsanitize=fuzzer,address,undefined"
 
@@ -21,7 +15,7 @@ CFLAGS=${CFLAGS:-"$default_fuzz_flags"}
 CXXFLAGS=${CXXFLAGS:-"$default_fuzz_flags"}
 
 export CFLAGS
-make
+make CC="$CC" CXX="$CXX"
 
 if [ -z "$@" ]; then
   languages=$(ls test/fixtures/grammars)
@@ -29,7 +23,13 @@ else
   languages="$@"
 fi
 
+mkdir -p test/fuzz/out
+
 for lang in ${languages[@]}; do
+  # skip typescript
+  if [[ $lang == "typescript" ]]; then
+	continue
+  fi
   echo "Building $lang fuzzer..."
   lang_dir="test/fixtures/grammars/$lang"
 
@@ -54,7 +54,7 @@ for lang in ${languages[@]}; do
   highlights_filename="${lang_dir}/queries/highlights.scm"
   if [ -e "${highlights_filename}" ]; then
     ts_lang_query_filename="${lang}.scm"
-    cp "${highlights_filename}" "out/${ts_lang_query_filename}"
+    cp "${highlights_filename}" "test/fuzz/out/${ts_lang_query_filename}"
   else
     ts_lang_query_filename=""
   fi
@@ -62,11 +62,16 @@ for lang in ${languages[@]}; do
   # FIXME: We should extract the grammar name from grammar.js. Use the name of
   # the directory instead. Also, the grammar name needs to be a valid C
   # identifier so replace any '-' characters
-  ts_lang="tree_sitter_$(echo $lang | tr -- - _)"
+  ts_lang="tree_sitter_$(echo "$lang" | tr -- - _)"
   $CXX $CXXFLAGS -std=c++11 -I lib/include -D TS_LANG="$ts_lang" -D TS_LANG_QUERY_FILENAME="\"${ts_lang_query_filename}\"" \
     "test/fuzz/fuzzer.cc" "${objects[@]}" \
-    libtree-sitter.a "$LIB_FUZZER_PATH" \
-    -o "out/${lang}_fuzzer"
+    libtree-sitter.a \
+    -o "test/fuzz/out/${lang}_fuzzer"
 
-  python test/fuzz/gen-dict.py "${lang_dir}/src/grammar.json" > "out/$lang.dict"
+  jq '
+    [ ..
+      | if .type? == "STRING" or (.type? == "ALIAS" and .named? == false) then .value else empty end
+      | select(test("\\S") and length == utf8bytelength)
+    ] | unique | .[]
+  ' | sort
 done
diff --git a/script/build-wasm b/script/build-wasm
index 4ab78447..ce6995bc 100755
--- a/script/build-wasm
+++ b/script/build-wasm
@@ -51,6 +51,10 @@ while [[ $# > 0 ]]; do
       force_docker=1
       ;;
 
+    -v|--verbose)
+      emscripten_flags="-s VERBOSE=1 -v $emscripten_flags"
+      ;;
+
     *)
       usage
       echo "Unrecognized argument '$1'"
@@ -71,7 +75,11 @@ elif which docker > /dev/null; then
     emscripten/emsdk:$emscripen_version  \
     emcc"
 else
-  echo 'You must have either `docker` or `emcc` on your PATH to run this script'
+  if [[ "$force_docker" == "1" ]]; then
+    echo 'You must have `docker` on your PATH to run this script with --docker'
+  else
+    echo 'You must have either `docker` or `emcc` on your PATH to run this script'
+  fi
   exit 1
 fi
 
@@ -83,10 +91,10 @@ runtime_methods='stringToUTF16','AsciiToString'
 # in the `target/scratch` directory
 $emcc                                            \
   -s WASM=1                                      \
-  -s TOTAL_MEMORY=33554432                       \
+  -s INITIAL_MEMORY=33554432                     \
   -s ALLOW_MEMORY_GROWTH=1                       \
   -s MAIN_MODULE=2                               \
-  -s NO_FILESYSTEM=1                             \
+  -s FILESYSTEM=0                                \
   -s NODEJS_CATCH_EXIT=0                         \
   -s NODEJS_CATCH_REJECTION=0                    \
   -s EXPORTED_FUNCTIONS=@${web_dir}/exports.json \
diff --git a/script/fetch-fixtures b/script/fetch-fixtures
index 8d21193e..1eec16ee 100755
--- a/script/fetch-fixtures
+++ b/script/fetch-fixtures
@@ -28,7 +28,7 @@ fetch_grammar embedded-template master
 fetch_grammar go                master
 fetch_grammar html              master
 fetch_grammar java              master
-fetch_grammar javascript        partial-order-precedences
+fetch_grammar javascript        master
 fetch_grammar jsdoc             master
 fetch_grammar json              master
 fetch_grammar php               master
diff --git a/script/fetch-fixtures.cmd b/script/fetch-fixtures.cmd
index 3dad731f..32727b0c 100644
--- a/script/fetch-fixtures.cmd
+++ b/script/fetch-fixtures.cmd
@@ -7,7 +7,7 @@ call:fetch_grammar embedded-template master
 call:fetch_grammar go                master
 call:fetch_grammar html              master
 call:fetch_grammar java              master
-call:fetch_grammar javascript        partial-order-precedences
+call:fetch_grammar javascript        master
 call:fetch_grammar jsdoc             master
 call:fetch_grammar json              master
 call:fetch_grammar php               master
diff --git a/script/generate-bindings b/script/generate-bindings
index b2bae662..0e5c8ca5 100755
--- a/script/generate-bindings
+++ b/script/generate-bindings
@@ -2,14 +2,41 @@
 
 output_path=lib/binding_rust/bindings.rs
 header_path='lib/include/tree_sitter/api.h'
+no_derive_copy=(
+  TSInput
+  TSLanguage
+  TSLogger
+  TSLookaheadIterator
+  TSParser
+  TSTree
+  TSQuery
+  TSQueryCursor
+  TSQueryCapture
+  TSQueryMatch
+  TSQueryPredicateStep
+)
+no_copy=$(IFS='|'; echo "${no_derive_copy[*]}")
+
+file_version=$(head -n1 "$output_path" | cut -d' ' -f6)
+tool_version=$(bindgen --version | cut -d' ' -f2)
+higher_version=$(echo -e "${file_version}\n${tool_version}" | sort -V | tail -n1)
+
+if [ "$higher_version" != "$tool_version" ]; then
+  echo "Latest used bindgen version was $file_version" >&2
+  echo "Currently installed bindgen CLI version is $tool_version" >&2
+  echo >&2
+  echo "It's needed to upgrade bindgen CLI first with \`cargo install bindgen-cli\`" >&2
+  exit 1
+fi
 
 bindgen                                        \
   --no-layout-tests                            \
-  --whitelist-type '^TS.*'                     \
-  --whitelist-function '^ts_.*'                \
-  --opaque-type FILE                           \
-  --blocklist-type FILE                        \
+  --allowlist-type '^TS.*'                     \
+  --allowlist-function '^ts_.*'                \
+  --allowlist-var "^TREE_SITTER.*"             \
   --blocklist-type '^__.*'                     \
+  --no-prepend-enum-name                       \
+  --no-copy "$no_copy"                         \
   --blocklist-function ts_tree_print_dot_graph \
   --size_t-is-usize                            \
   $header_path                                 \
diff --git a/script/generate-fixtures b/script/generate-fixtures
index 85298c46..2c3b178a 100755
--- a/script/generate-fixtures
+++ b/script/generate-fixtures
@@ -2,12 +2,18 @@
 
 set -e
 
-cargo build --release
+root_dir=$PWD
+
+if [ "$CI" == true ]; then
+  set -x
+  tree_sitter="$TREE_SITTER"
+else
+  cargo build --release
+  tree_sitter=${root_dir}/target/release/tree-sitter
+fi
 
 filter_grammar_name=$1
 
-root_dir=$PWD
-tree_sitter=${root_dir}/target/release/tree-sitter
 grammars_dir=${root_dir}/test/fixtures/grammars
 grammar_files=$(find $grammars_dir -name grammar.js | grep -v node_modules)
 
diff --git a/script/generate-fixtures-wasm b/script/generate-fixtures-wasm
index 9d44b58c..4bba56ae 100755
--- a/script/generate-fixtures-wasm
+++ b/script/generate-fixtures-wasm
@@ -2,7 +2,15 @@
 
 set -e
 
-cargo build --release
+root_dir=$PWD
+
+if [ "$CI" == true ]; then
+  set -x
+  tree_sitter="$TREE_SITTER"
+else
+  cargo build --release
+  tree_sitter=${root_dir}/target/release/tree-sitter
+fi
 
 build_wasm_args=
 if [[ $1 == "--docker" ]]; then
@@ -12,8 +20,6 @@ fi
 
 filter_grammar_name=$1
 
-root_dir=$PWD
-tree_sitter=${root_dir}/target/release/tree-sitter
 grammars_dir=${root_dir}/test/fixtures/grammars
 grammar_files=$(find $grammars_dir -name grammar.js | grep -v node_modules)
 
diff --git a/script/run-fuzzer b/script/run-fuzzer
index ddd481d9..ae73958b 100755
--- a/script/run-fuzzer
+++ b/script/run-fuzzer
@@ -6,7 +6,13 @@ root=$(dirname "$0")/..
 export ASAN_OPTIONS="quarantine_size_mb=10:detect_leaks=1:symbolize=1"
 export UBSAN="print_stacktrace=1:halt_on_error=1:symbolize=1"
 
-declare -A mode_config=( ["halt"]="-timeout=1 -rss_limit_mb=256" ["recover"]="-timeout=10 -rss_limit_mb=256" )
+# check if CI env var exists
+
+if [ -z "${CI:-}" ]; then
+  declare -A mode_config=( ["halt"]="-timeout=1 -rss_limit_mb=2048" ["recover"]="-timeout=10 -rss_limit_mb=2048" )
+else
+  declare -A mode_config=( ["halt"]="-max_total_time=120 -timeout=1 -rss_limit_mb=2048" ["recover"]="-time=120 -timeout=10 -rss_limit_mb=2048" )
+fi
 
 run_fuzzer() {
   if [ "$#" -lt 2 ]; then
@@ -21,7 +27,7 @@ run_fuzzer() {
   # Treat remainder of arguments as libFuzzer arguments
 
   # Fuzzing logs and testcases are always written to `pwd`, so `cd` there first
-  results="${root}/out/fuzz-results/${lang}_${mode}"
+  results="${root}/test/fuzz/out/fuzz-results/${lang}"
   mkdir -p "${results}"
   cd "${results}"
 
@@ -29,7 +35,8 @@ run_fuzzer() {
   # then be loaded on subsequent fuzzing runs
   mkdir -p corpus
 
-  "../../${lang}_fuzzer_${mode}" "-dict=../../${lang}.dict" "-artifact_prefix=${lang}_${mode}_" -max_len=2048 ${mode_config[$mode]} "./corpus" "$@"
+  pwd
+  "../../${lang}_fuzzer" "-dict=../../${lang}.dict" "-artifact_prefix=${lang}_" -max_len=2048 "${mode_config[$mode]}" "./corpus" "$@"
 }
 
 reproduce() {
@@ -46,7 +53,7 @@ reproduce() {
   shift
   # Treat remainder of arguments as libFuzzer arguments
 
-  "${root}/out/${lang}_fuzzer_${mode}" ${mode_config[$mode]} -runs=1 "${testcase}" "$@"
+  "${root}/test/fuzz/out/${lang}_fuzzer" "${mode_config[$mode]}" -runs=1 "${testcase}" "$@"
 }
 
 script=$(basename "$0")
diff --git a/script/test b/script/test
index 619c190f..1abd2053 100755
--- a/script/test
+++ b/script/test
@@ -6,7 +6,7 @@ function usage {
   cat <<-EOF
 USAGE
 
-  $0 [-adDg] [-s SEED] [-l LANGUAGE] [-e EXAMPLE] [-t TRIAL]
+  $0 [-adDg] [-s SEED] [-l LANGUAGE] [-e EXAMPLE]
 
 OPTIONS
 
diff --git a/tags/Cargo.toml b/tags/Cargo.toml
index d954a573..02799403 100644
--- a/tags/Cargo.toml
+++ b/tags/Cargo.toml
@@ -3,8 +3,8 @@ name = "tree-sitter-tags"
 description = "Library for extracting tag information"
 version = "0.20.2"
 authors = [
-  "Max Brunsfeld <maxbrunsfeld@gmail.com>",
-  "Patrick Thomson <patrickt@github.com>",
+	"Max Brunsfeld <maxbrunsfeld@gmail.com>",
+	"Patrick Thomson <patrickt@github.com>",
 ]
 license = "MIT"
 readme = "README.md"
@@ -12,14 +12,15 @@ edition = "2018"
 keywords = ["incremental", "parsing", "syntax", "tagging"]
 categories = ["parsing", "text-editors"]
 repository = "https://github.com/tree-sitter/tree-sitter"
+rust-version.workspace = true
 
 [lib]
 crate-type = ["lib", "staticlib"]
 
 [dependencies]
-regex = "1"
-memchr = "2.3"
-thiserror = "1.0"
+regex = "1.9.1"
+memchr = "2.5.0"
+thiserror = "1.0.43"
 
 [dependencies.tree-sitter]
 version = "0.20"
diff --git a/tags/README.md b/tags/README.md
index 36efa494..d7daac79 100644
--- a/tags/README.md
+++ b/tags/README.md
@@ -1,4 +1,9 @@
-# `tree-sitter-tags`
+# Tree-sitter Tags
+
+[![crates.io badge]][crates.io]
+
+[crates.io]: https://crates.io/crates/tree-sitter-tags
+[crates.io badge]: https://img.shields.io/crates/v/tree-sitter-tags.svg?color=%23B48723
 
 ### Usage
 
diff --git a/tags/src/c_lib.rs b/tags/src/c_lib.rs
index 088cc7bc..915b0220 100644
--- a/tags/src/c_lib.rs
+++ b/tags/src/c_lib.rs
@@ -66,13 +66,29 @@ pub extern "C" fn ts_tagger_new() -> *mut TSTagger {
     }))
 }
 
+/// Delete a TSTagger.
+///
+/// # Safety
+///
+/// `this` must be non-null and a valid pointer to a [`TSTagger`] instance.
 #[no_mangle]
-pub extern "C" fn ts_tagger_delete(this: *mut TSTagger) {
-    drop(unsafe { Box::from_raw(this) })
+pub unsafe extern "C" fn ts_tagger_delete(this: *mut TSTagger) {
+    drop(Box::from_raw(this))
 }
 
+/// Add a language to a TSTagger.
+///
+/// Returns a [`TSTagsError`] indicating whether the operation was successful or not.
+///
+/// # Safety
+///
+/// `this` must be non-null and a valid pointer to a [`TSTagger`] instance.
+/// `scope_name` must be non-null and a valid pointer to a null-terminated string.
+/// `tags_query` and `locals_query` must be non-null and valid pointers to strings.
+///
+/// The caller must ensure that the lengths of `tags_query` and `locals_query` are correct.
 #[no_mangle]
-pub extern "C" fn ts_tagger_add_language(
+pub unsafe extern "C" fn ts_tagger_add_language(
     this: *mut TSTagger,
     scope_name: *const c_char,
     language: Language,
@@ -82,9 +98,13 @@ pub extern "C" fn ts_tagger_add_language(
     locals_query_len: u32,
 ) -> TSTagsError {
     let tagger = unwrap_mut_ptr(this);
-    let scope_name = unsafe { unwrap(CStr::from_ptr(scope_name).to_str()) };
-    let tags_query = unsafe { slice::from_raw_parts(tags_query, tags_query_len as usize) };
-    let locals_query = unsafe { slice::from_raw_parts(locals_query, locals_query_len as usize) };
+    let scope_name = unwrap(CStr::from_ptr(scope_name).to_str());
+    let tags_query = slice::from_raw_parts(tags_query, tags_query_len as usize);
+    let locals_query = if !locals_query.is_null() {
+        slice::from_raw_parts(locals_query, locals_query_len as usize)
+    } else {
+        &[]
+    };
     let tags_query = match str::from_utf8(tags_query) {
         Ok(e) => e,
         Err(_) => return TSTagsError::InvalidUtf8,
@@ -107,8 +127,19 @@ pub extern "C" fn ts_tagger_add_language(
     }
 }
 
+/// Tags some source code.
+///
+/// Returns a [`TSTagsError`] indicating whether the operation was successful or not.
+///
+/// # Safety
+///
+/// `this` must be a non-null valid pointer to a [`TSTagger`] instance.
+/// `scope_name` must be a non-null valid pointer to a null-terminated string.
+/// `source_code` must be a non-null valid pointer to a slice of bytes.
+/// `output` must be a non-null valid pointer to a [`TSTagsBuffer`] instance.
+/// `cancellation_flag` must be a non-null valid pointer to an [`AtomicUsize`] instance.
 #[no_mangle]
-pub extern "C" fn ts_tagger_tag(
+pub unsafe extern "C" fn ts_tagger_tag(
     this: *mut TSTagger,
     scope_name: *const c_char,
     source_code: *const u8,
@@ -118,14 +149,14 @@ pub extern "C" fn ts_tagger_tag(
 ) -> TSTagsError {
     let tagger = unwrap_mut_ptr(this);
     let buffer = unwrap_mut_ptr(output);
-    let scope_name = unsafe { unwrap(CStr::from_ptr(scope_name).to_str()) };
+    let scope_name = unwrap(CStr::from_ptr(scope_name).to_str());
 
     if let Some(config) = tagger.languages.get(scope_name) {
         shrink_and_clear(&mut buffer.tags, BUFFER_TAGS_RESERVE_CAPACITY);
         shrink_and_clear(&mut buffer.docs, BUFFER_DOCS_RESERVE_CAPACITY);
 
-        let source_code = unsafe { slice::from_raw_parts(source_code, source_code_len as usize) };
-        let cancellation_flag = unsafe { cancellation_flag.as_ref() };
+        let source_code = slice::from_raw_parts(source_code, source_code_len as usize);
+        let cancellation_flag = cancellation_flag.as_ref();
 
         let tags = match buffer
             .context
@@ -197,49 +228,108 @@ pub extern "C" fn ts_tags_buffer_new() -> *mut TSTagsBuffer {
     }))
 }
 
+/// Delete a TSTagsBuffer.
+///
+/// # Safety
+///
+/// `this` must be non-null and a valid pointer to a [`TSTagsBuffer`] instance created by
+/// [`ts_tags_buffer_new`].
 #[no_mangle]
-pub extern "C" fn ts_tags_buffer_delete(this: *mut TSTagsBuffer) {
-    drop(unsafe { Box::from_raw(this) })
+pub unsafe extern "C" fn ts_tags_buffer_delete(this: *mut TSTagsBuffer) {
+    drop(Box::from_raw(this))
 }
 
+/// Get the tags from a TSTagsBuffer.
+///
+/// # Safety
+///
+/// `this` must be non-null and a valid pointer to a [`TSTagsBuffer`] instance created by
+/// [`ts_tags_buffer_new`].
+///
+/// The caller must ensure that the returned pointer is not used after the [`TSTagsBuffer`]
+/// is deleted with [`ts_tags_buffer_delete`], else the data will point to garbage.
 #[no_mangle]
-pub extern "C" fn ts_tags_buffer_tags(this: *const TSTagsBuffer) -> *const TSTag {
+pub unsafe extern "C" fn ts_tags_buffer_tags(this: *const TSTagsBuffer) -> *const TSTag {
     let buffer = unwrap_ptr(this);
     buffer.tags.as_ptr()
 }
 
+/// Get the number of tags in a TSTagsBuffer.
+///
+/// # Safety
+///
+/// `this` must be non-null and a valid pointer to a [`TSTagsBuffer`] instance.
 #[no_mangle]
-pub extern "C" fn ts_tags_buffer_tags_len(this: *const TSTagsBuffer) -> u32 {
+pub unsafe extern "C" fn ts_tags_buffer_tags_len(this: *const TSTagsBuffer) -> u32 {
     let buffer = unwrap_ptr(this);
     buffer.tags.len() as u32
 }
 
+/// Get the documentation strings from a TSTagsBuffer.
+///
+/// # Safety
+///
+/// `this` must be non-null and a valid pointer to a [`TSTagsBuffer`] instance created by
+/// [`ts_tags_buffer_new`].
+///
+/// The caller must ensure that the returned pointer is not used after the [`TSTagsBuffer`]
+/// is deleted with [`ts_tags_buffer_delete`], else the data will point to garbage.
+///
+/// The returned pointer points to a C-style string.
+/// To get the length of the string, use [`ts_tags_buffer_docs_len`].
 #[no_mangle]
-pub extern "C" fn ts_tags_buffer_docs(this: *const TSTagsBuffer) -> *const c_char {
+pub unsafe extern "C" fn ts_tags_buffer_docs(this: *const TSTagsBuffer) -> *const c_char {
     let buffer = unwrap_ptr(this);
     buffer.docs.as_ptr() as *const c_char
 }
 
+/// Get the length of the documentation strings in a TSTagsBuffer.
+///
+/// # Safety
+///
+/// `this` must be non-null and a valid pointer to a [`TSTagsBuffer`] instance created by
+/// [`ts_tags_buffer_new`].
 #[no_mangle]
-pub extern "C" fn ts_tags_buffer_docs_len(this: *const TSTagsBuffer) -> u32 {
+pub unsafe extern "C" fn ts_tags_buffer_docs_len(this: *const TSTagsBuffer) -> u32 {
     let buffer = unwrap_ptr(this);
     buffer.docs.len() as u32
 }
 
+/// Get whether or not a TSTagsBuffer contains any parse errors.
+///
+/// # Safety
+///
+/// `this` must be non-null and a valid pointer to a [`TSTagsBuffer`] instance created by
+/// [`ts_tags_buffer_new`].
 #[no_mangle]
-pub extern "C" fn ts_tags_buffer_found_parse_error(this: *const TSTagsBuffer) -> bool {
+pub unsafe extern "C" fn ts_tags_buffer_found_parse_error(this: *const TSTagsBuffer) -> bool {
     let buffer = unwrap_ptr(this);
     buffer.errors_present
 }
 
+/// Get the syntax kinds for a given scope name.
+///
+/// Returns a pointer to a null-terminated array of null-terminated strings.
+///
+/// # Safety
+///
+/// `this` must be non-null and a valid pointer to a [`TSTagger`] instance created by
+/// [`ts_tagger_new`].
+/// `scope_name` must be non-null and a valid pointer to a null-terminated string.
+/// `len` must be non-null and a valid pointer to a `u32`.
+///
+/// The caller must ensure that the returned pointer is not used after the [`TSTagger`]
+/// is deleted with [`ts_tagger_delete`], else the data will point to garbage.
+///
+/// The returned pointer points to a C-style string array.
 #[no_mangle]
-pub extern "C" fn ts_tagger_syntax_kinds_for_scope_name(
+pub unsafe extern "C" fn ts_tagger_syntax_kinds_for_scope_name(
     this: *mut TSTagger,
     scope_name: *const c_char,
     len: *mut u32,
 ) -> *const *const c_char {
     let tagger = unwrap_mut_ptr(this);
-    let scope_name = unsafe { unwrap(CStr::from_ptr(scope_name).to_str()) };
+    let scope_name = unwrap(CStr::from_ptr(scope_name).to_str());
     let len = unwrap_mut_ptr(len);
 
     *len = 0;
@@ -250,15 +340,15 @@ pub extern "C" fn ts_tagger_syntax_kinds_for_scope_name(
     std::ptr::null()
 }
 
-fn unwrap_ptr<'a, T>(result: *const T) -> &'a T {
-    unsafe { result.as_ref() }.unwrap_or_else(|| {
+unsafe fn unwrap_ptr<'a, T>(result: *const T) -> &'a T {
+    result.as_ref().unwrap_or_else(|| {
         eprintln!("{}:{} - pointer must not be null", file!(), line!());
         abort();
     })
 }
 
-fn unwrap_mut_ptr<'a, T>(result: *mut T) -> &'a mut T {
-    unsafe { result.as_mut() }.unwrap_or_else(|| {
+unsafe fn unwrap_mut_ptr<'a, T>(result: *mut T) -> &'a mut T {
+    result.as_mut().unwrap_or_else(|| {
         eprintln!("{}:{} - pointer must not be null", file!(), line!());
         abort();
     })
diff --git a/tags/src/lib.rs b/tags/src/lib.rs
index 13499d86..e151e3ee 100644
--- a/tags/src/lib.rs
+++ b/tags/src/lib.rs
@@ -1,3 +1,5 @@
+#![doc = include_str!("../README.md")]
+
 pub mod c_lib;
 
 use memchr::memchr;
@@ -134,7 +136,7 @@ impl TagsConfiguration {
         let mut local_scope_capture_index = None;
         let mut local_definition_capture_index = None;
         for (i, name) in query.capture_names().iter().enumerate() {
-            match name.as_str() {
+            match *name {
                 "" => continue,
                 "name" => name_capture_index = Some(i as u32),
                 "ignore" => ignore_capture_index = Some(i as u32),
diff --git a/test/fixtures/error_corpus/c_errors.txt b/test/fixtures/error_corpus/c_errors.txt
index 97c75f0c..d44400cf 100644
--- a/test/fixtures/error_corpus/c_errors.txt
+++ b/test/fixtures/error_corpus/c_errors.txt
@@ -14,8 +14,8 @@ int main() {
     (primitive_type)
     (function_declarator (identifier) (parameter_list))
     (compound_statement
-      (expression_statement (call_expression (identifier) (argument_list (string_literal))) (MISSING ";"))
-      (expression_statement (call_expression (identifier) (argument_list (string_literal))) (MISSING ";")))))
+      (expression_statement (call_expression (identifier) (argument_list (string_literal (string_content)))) (MISSING ";"))
+      (expression_statement (call_expression (identifier) (argument_list (string_literal (string_content)))) (MISSING ";")))))
 
 ==============================================
 Top-level declarations with missing semicolons
@@ -53,7 +53,7 @@ int c() {
 
 (translation_unit
   (preproc_ifdef (identifier)
-    (linkage_specification (string_literal) (declaration_list
+    (linkage_specification (string_literal (string_content)) (declaration_list
       (preproc_call (preproc_directive))
       (comment)
       (declaration (primitive_type) (identifier))
@@ -108,7 +108,7 @@ int main() {
     (function_declarator (identifier) (parameter_list))
     (compound_statement
       (declaration (primitive_type) (identifier))
-      (ERROR (primitive_type) (UNEXPECTED '$')))))
+      (ERROR (primitive_type) (ERROR) (identifier) (UNEXPECTED '@')))))
 
 =========================================
 Extra values in parenthesized expressions
diff --git a/test/fixtures/error_corpus/javascript_errors.txt b/test/fixtures/error_corpus/javascript_errors.txt
index 4359ae68..e2f21176 100644
--- a/test/fixtures/error_corpus/javascript_errors.txt
+++ b/test/fixtures/error_corpus/javascript_errors.txt
@@ -74,8 +74,8 @@ if ({a: 'b'} {c: 'd'}) {
 (program
   (if_statement
     (parenthesized_expression
-      (ERROR (object (pair (property_identifier) (string))))
-      (object (pair (property_identifier) (string))))
+      (ERROR (object (pair (property_identifier) (string (string_fragment)))))
+      (object (pair (property_identifier) (string (string_fragment)))))
     (statement_block
       (expression_statement
         (assignment_expression
@@ -178,12 +178,12 @@ function main(x) {
       (expression_statement
         (call_expression
           (member_expression (identifier) (property_identifier))
-          (arguments (string))))
+          (arguments (string (string_fragment)))))
       (expression_statement
         (binary_expression
           (identifier)
           (ERROR)
           (call_expression
             (member_expression (identifier) (property_identifier))
-            (arguments (string)))))
+            (arguments (string (string_fragment))))))
       (return_statement (object)))))
diff --git a/test/fixtures/error_corpus/json_errors.txt b/test/fixtures/error_corpus/json_errors.txt
index 53ce94e4..065fa88c 100644
--- a/test/fixtures/error_corpus/json_errors.txt
+++ b/test/fixtures/error_corpus/json_errors.txt
@@ -6,7 +6,8 @@ top-level errors
 
 ---
 
-(ERROR)
+(document
+  (ERROR))
 
 ==========================================
 unexpected tokens
@@ -16,7 +17,9 @@ barf
 
 ---
 
-(ERROR (UNEXPECTED 'b'))
+(document
+  (ERROR
+    (UNEXPECTED 'b')))
 
 ==========================================
 errors inside arrays
@@ -26,10 +29,11 @@ errors inside arrays
 
 ---
 
-(document (array
-  (number)
-  (ERROR)
-  (number)))
+(document
+  (array
+    (number)
+    (ERROR)
+    (number)))
 
 ==========================================
 errors inside objects
@@ -39,9 +43,14 @@ errors inside objects
 
 ---
 
-(document (object
-  (pair (string (string_content)) (number))
-  (ERROR (UNEXPECTED 'o'))))
+(document
+  (object
+    (pair
+      (string
+        (string_content))
+      (number))
+    (ERROR
+      (UNEXPECTED 'o'))))
 
 ==========================================
 errors inside nested objects
@@ -51,12 +60,23 @@ errors inside nested objects
 
 ---
 
-(document (object
-  (pair (string (string_content)) (object
-    (pair (string (string_content)) (number))
-    (ERROR (number))))
-  (pair (string (string_content)) (number))
-  (ERROR)))
+(document
+  (object
+    (pair
+      (string
+        (string_content))
+      (object
+        (pair
+          (string
+            (string_content))
+          (number))
+        (ERROR
+          (number))))
+    (pair
+      (string
+        (string_content))
+      (number))
+    (ERROR)))
 
 ===============================
 incomplete tokens at EOF
@@ -65,4 +85,6 @@ incomplete tokens at EOF
 nul
 ---
 
-(ERROR (UNEXPECTED '\0'))
+(document
+  (ERROR
+    (UNEXPECTED '\0')))
diff --git a/test/fixtures/error_corpus/python_errors.txt b/test/fixtures/error_corpus/python_errors.txt
index edabb510..d5b4a5dd 100644
--- a/test/fixtures/error_corpus/python_errors.txt
+++ b/test/fixtures/error_corpus/python_errors.txt
@@ -89,7 +89,10 @@ def a():
     parameters: (parameters)
     (ERROR (identifier))
     body: (block
-      (expression_statement (string)))))
+      (expression_statement (string
+        (string_start)
+        (string_content)
+        (string_end))))))
 
 ===========================================
 incomplete definition in class definition
@@ -108,4 +111,4 @@ b
     (ERROR)
     body: (block))
   (expression_statement
-    (identifier)))
\ No newline at end of file
+    (identifier)))
diff --git a/test/fixtures/error_corpus/ruby_errors.txt b/test/fixtures/error_corpus/ruby_errors.txt
index df160811..88e7ee37 100644
--- a/test/fixtures/error_corpus/ruby_errors.txt
+++ b/test/fixtures/error_corpus/ruby_errors.txt
@@ -1,10 +1,11 @@
 ==========================
-Heredocs with errors
+Heredocs with errors 2
 ==========================
 
-joins(<<~SQL(
+joins <<~SQL
   b
 SQL
+)
 c
 
 ---
@@ -12,8 +13,10 @@ c
 (program
   (call
     method: (identifier)
-    (ERROR (heredoc_beginning))
     arguments: (argument_list
-      (heredoc_body (heredoc_content) (heredoc_end))
-      (identifier)
-      (MISSING ")"))))
+      (heredoc_beginning)))
+  (heredoc_body
+    (heredoc_content)
+    (heredoc_end))
+  (ERROR)
+  (identifier))
diff --git a/test/fixtures/test_grammars/get_col_should_hang_not_crash/corpus.txt b/test/fixtures/test_grammars/get_col_should_hang_not_crash/corpus.txt
new file mode 100644
index 00000000..e69de29b
diff --git a/test/fixtures/test_grammars/get_col_should_hang_not_crash/grammar.js b/test/fixtures/test_grammars/get_col_should_hang_not_crash/grammar.js
new file mode 100644
index 00000000..83d57d2c
--- /dev/null
+++ b/test/fixtures/test_grammars/get_col_should_hang_not_crash/grammar.js
@@ -0,0 +1,13 @@
+module.exports = grammar({
+  name: 'get_col_should_hang_not_crash',
+
+  externals: $ => [
+    $.test,
+  ],
+
+  rules: {
+    source_file: $ => seq(
+      $.test
+    ),
+  },
+});
diff --git a/test/fixtures/test_grammars/get_col_should_hang_not_crash/scanner.c b/test/fixtures/test_grammars/get_col_should_hang_not_crash/scanner.c
new file mode 100644
index 00000000..d21ec6d4
--- /dev/null
+++ b/test/fixtures/test_grammars/get_col_should_hang_not_crash/scanner.c
@@ -0,0 +1,17 @@
+#include <tree_sitter/parser.h>
+
+unsigned tree_sitter_get_col_should_hang_not_crash_external_scanner_serialize() { return 0; }
+
+void tree_sitter_get_col_should_hang_not_crash_external_scanner_deserialize() {}
+
+void *tree_sitter_get_col_should_hang_not_crash_external_scanner_create() { return NULL; }
+
+void tree_sitter_get_col_should_hang_not_crash_external_scanner_destroy() {}
+
+bool tree_sitter_get_col_should_hang_not_crash_external_scanner_scan(void *payload, TSLexer *lexer,
+                                            const bool *valid_symbols) {
+    while (true) {
+        lexer->advance(lexer, false);
+        lexer->get_column(lexer);
+    }
+}
diff --git a/test/fuzz/fuzzer.cc b/test/fuzz/fuzzer.cc
index ef800883..3b933746 100644
--- a/test/fuzz/fuzzer.cc
+++ b/test/fuzz/fuzzer.cc
@@ -47,7 +47,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   TSTree *tree = ts_parser_parse_string(parser, NULL, str, size);
   TSNode root_node = ts_tree_root_node(tree);
 
-  if (lang_query) {
+  if (lang_query != nullptr) {
     {
       TSQueryCursor *cursor = ts_query_cursor_new();
 
diff --git a/test/fuzz/gen-dict.py b/test/fuzz/gen-dict.py
deleted file mode 100644
index f8cf834e..00000000
--- a/test/fuzz/gen-dict.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import json
-import sys
-
-def find_literals(literals, node):
-  '''Recursively find STRING literals in the grammar definition'''
-
-  if type(node) is dict:
-    if 'type' in node and node['type'] == 'STRING' and 'value' in node:
-      literals.add(node['value'])
-
-    for key, value in node.iteritems():
-      find_literals(literals, value)
-
-  elif type(node) is list:
-    for item in node:
-      find_literals(literals, item)
-
-def main():
-  '''Generate a libFuzzer / AFL dictionary from a tree-sitter grammar.json'''
-  with open(sys.argv[1]) as f:
-    grammar = json.load(f)
-
-  literals = set()
-  find_literals(literals, grammar)
-
-  for lit in sorted(literals):
-    if lit:
-      print '"%s"' % ''.join(['\\x%02x' % ord(b) for b in lit.encode('utf-8')])
-
-if __name__ == '__main__':
-  main()