chore(treesitter): update nvim-treesitter to 0.9.1 for Nvim-0.8.x

autoload/SpaceVim/layers/treesitter.vim

@@ -13,7 +13,12 @@
 
 function! SpaceVim#layers#treesitter#plugins() abort
   let plugins = []
-  call add(plugins, [g:_spacevim_root_dir . 'bundle/nvim-treesitter',
+  if has('nvim-0.8.0')
+    let l:version = '-0.9.1'
+  else
+    let l:version = ''
+  endif
+  call add(plugins, [g:_spacevim_root_dir . 'bundle/nvim-treesitter' . l:version,
         \ {
           \ 'merged' : 0,
           \ 'loadconf' : 1 ,

bundle/nvim-treesitter-0.9.1/.editorconfig

@@ -0,0 +1,20 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+tab_width = 8
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+
+[*.lua]
+tab_width = 2
+
+[*.py]
+indent_size = 4
+tab_width = 4
+
+[{Makefile,**/Makefile,runtime/doc/*.txt}]
+indent_style = tab
+indent_size = 8

bundle/nvim-treesitter-0.9.1/.github/CODEOWNERS

@@ -0,0 +1,7 @@
+/lua/nvim-treesitter/textobjects/ @theHamsta
+/lua/nvim-treesitter/incremental_selection.lua @theHamsta
+
+/lua/nvim-treesitter/fold.lua @vigoux
+/lua/nvim-treesitter/highlight.lua @vigoux
+
+/lua/nvim-treesitter/refactor/ @steelsojka

bundle/nvim-treesitter-0.9.1/.github/FUNDING.yml

@@ -0,0 +1,2 @@
+open_collective: "nvim-treesitter"
+github: "nvim-treesitter"

bundle/nvim-treesitter-0.9.1/.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,58 @@
+name: Bug report
+description: Create a report to help us improve
+labels: [bug]
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        # Before reporting
+        Please do the following steps before reporting an issue.
+
+        - I have updated my neovim version to latest _master_
+        - I have updated my plugin to the latest version
+        - I have run `:TSUpdate`
+        - I have read the [troubleshooting section](https://github.com/nvim-treesitter/nvim-treesitter#troubleshooting)
+
+  - type: textarea
+    attributes:
+      label: Describe the bug
+      description: A clear and concise description of what the bug is.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: To Reproduce
+      description: Steps to reproduce the behavior.
+      placeholder: |
+        1. Go to '...'
+        2. Click on '....'
+        3. Scroll down to '....'
+        4. See error
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Expected behavior
+      description: A clear and concise description of what you expected to happen.
+
+  - type: textarea
+    attributes:
+      label: Output of `:checkhealth nvim-treesitter`
+      render: markdown
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Output of `nvim --version`
+      render: text
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add any context about the problem here.

bundle/nvim-treesitter-0.9.1/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,19 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ""
+labels: enhancement
+assignees: ""
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

bundle/nvim-treesitter-0.9.1/.github/ISSUE_TEMPLATE/highlighting_issue.yml

@@ -0,0 +1,98 @@
+name: Highlighting issue
+description: Missing or incorrect highlights or you want to change the way something is highlighted
+labels: [highlights]
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        # Before reporting
+        Please perform the following steps before reporting an issue.
+        - I have updated my neovim version to latest _master_.
+        - I have updated my plugin to the latest version.
+        - I have run `:TSUpdate`.
+        - I have inspected the syntax tree using https://github.com/nvim-treesitter/playground and made sure
+          that no `ERROR` nodes are in the syntax tree. nvim-treesitter can not guarantee correct highlighting in the
+          presence of `ERROR`s -- in this case, please report the bug directly at corresponding parser's repository. (You can find all repository URLs in [README.md](https://github.com/nvim-treesitter/nvim-treesitter#supported-languages).)
+        - I have used `:TSHighlightCapturesUnderCursor` from https://github.com/nvim-treesitter/playground to inspect which highlight groups Neovim is using and that legacy syntax highlighting is not interfering (i.e., what you are observing is actual tree-sitter highlighting).
+
+  - type: textarea
+    attributes:
+      label: Describe the highlighting problem
+      description: A clear and concise description of what should be highlighted in a different way.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Example snippet that causes the problem
+      description: Please provide an example snippet in plain text that causes the problem.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Tree-sitter parsing result
+      description: |
+        Please provide the output of `:TSPlaygroundToggle` from https://github.com/nvim-treesitter/playground
+        (screenshot or plain text) with the following options enabled (pressing the key):
+        - `I` (name of the parsed language)
+        - `t` (toggle injected languages)
+        - `a` (show anonymous nodes)
+      placeholder: |
+        This should look somehow like this:
+        ```
+        preproc_ifdef [0, 0] - [4, 6] cpp                                                                                                                                                                                                                                                                             
+          "#ifdef" [0, 0] - [0, 6] cpp                                                                                                                                                                                                                                                                                
+          name: identifier [0, 7] - [0, 17] cpp                                                                                                                                                                                                                                                                       
+          preproc_def [1, 0] - [2, 0] cpp                                                                                                                                                                                                                                                                             
+            "#define" [1, 0] - [1, 7] cpp                                                                                                                                                                                                                                                                             
+            name: identifier [1, 8] - [1, 16] cpp                                                                                                                                                                                                                                                                     
+            value: preproc_arg [1, 16] - [1, 27] cpp                                                                                                                                                                                                                                                                  
+            "\n" [1, 27] - [2, 0] cpp                                                                                                                                                                                                                                                                                 
+          alternative: preproc_else [2, 0] - [4, 0] cpp                                                                                                                                                                                                                                                               
+            "#else" [2, 0] - [2, 5] cpp                                                                                                                                                                                                                                                                               
+            preproc_def [3, 0] - [4, 0] cpp                                                                                                                                                                                                                                                                           
+              "#define" [3, 0] - [3, 7] cpp                                                                                                                                                                                                                                                                           
+              name: identifier [3, 8] - [3, 16] cpp                                                                                                                                                                                                                                                                   
+              value: preproc_arg [3, 16] - [3, 29] cpp        
+         ```
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Example screenshot
+      description: |
+        Please provide a screenshot of the current highlighting. Please also tell us the `:h colorscheme` you are using
+        and how to install it. If applicable, you can also upload a screenshot with the contents of
+        `:TSHighlightCapturesUnderCursor`.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Expected behavior
+      description: |
+        A clear and concise description of what you expect to be changed. You can provide screenshot of
+        other editors or traditional Vim highlighting that don't show this problem or show a screenshot how
+        nvim-treesitter highlighting would look like when a problematic query would be removed/altered.
+
+  - type: textarea
+    attributes:
+      label: Output of `:checkhealth nvim-treesitter`
+      render: markdown
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Output of `nvim --version`
+      render: text
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add any context about the problem here.

bundle/nvim-treesitter-0.9.1/.github/mergify.yml

@@ -0,0 +1,37 @@
+pull_request_rules:
+  - name: Merge lockfile updates
+    conditions:
+      - "title=Update lockfile.json"
+    actions:
+      review:
+        type: APPROVE
+        message: Automatically approving lockfile updates
+      merge:
+        method: merge
+
+  - name: Prepare for merge
+    conditions:
+      - and:
+        - "-draft"
+        - "#approved-reviews-by=1"
+        - "#review-requested=0"
+    actions:
+      comment:
+        message: |
+          This PR is ready to be merged, and will be in 1 day if nothing happens before.
+          If you want other people to review your PR, request their reviews.
+          If you don't want this PR to be merged now, mark it as a Draft.
+
+  - name: Merge on approval
+    conditions:
+      - and:
+        - or:
+          - "#approved-reviews-by>=2"
+          - and:
+            - "#approved-reviews-by=1"
+            - "updated-at>=1 day ago"
+        - "-draft"
+        - "#review-requested=0"
+    actions:
+      merge:
+        method: rebase

bundle/nvim-treesitter-0.9.1/.github/workflows/lint.yml

@@ -0,0 +1,33 @@
+name: Linting and style checking
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  luacheck:
+    name: Luacheck
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          sudo apt-get update
+          sudo apt-get install luarocks -y
+          sudo luarocks install luacheck
+
+      - name: Run Luacheck
+        run: luacheck .
+
+  stylua:
+    name: StyLua
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Lint with stylua
+        uses: JohnnyMorganz/stylua-action@v3
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          version: latest
+          args: --check .

bundle/nvim-treesitter-0.9.1/.github/workflows/release.yml

@@ -0,0 +1,17 @@
+name: "release"
+on:
+  push:
+    tags:
+      - '*'
+jobs:
+  luarocks-upload:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: nvim-neorocks/luarocks-tag-release@v2.2.0
+        env:
+          LUAROCKS_API_KEY: ${{ secrets.LUAROCKS_API_KEY }}
+        with:
+          detailed_description: |
+            The goal of nvim-treesitter is both to provide a simple and easy way to use the interface for tree-sitter in Neovim
+            and to provide some basic functionality such as highlighting based on it.
+          build_type: "make"

bundle/nvim-treesitter-0.9.1/.github/workflows/test-queries.yml

@@ -0,0 +1,87 @@
+name: Test queries
+
+on:
+  push:
+    branches:
+      - "master"
+  pull_request:
+    branches:
+      - "master"
+
+# Cancel any in-progress CI runs for a PR if it is updated
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.head_ref || github.sha }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  check_compilation:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-2022, macos-latest]
+        cc: [gcc, clang]
+        nvim_tag: [stable]
+        exclude:
+          - os: ubuntu-latest
+            cc: clang
+            nvim_tag: stable
+
+          - os: macos-latest
+            cc: gcc
+            nvim_tag: stable
+
+          - os: windows-2022
+            cc: clang
+            nvim_tag: stable
+
+        include:
+          - os: windows-2022
+            cc: cl
+            nvim_tag: stable
+
+          - os: ubuntu-latest
+            cc: gcc
+            nvim_tag: nightly
+
+    name: Parser compilation
+    runs-on: ${{ matrix.os }}
+    env:
+      CC: ${{ matrix.cc }}
+      NVIM: ${{ matrix.os == 'windows-2022' && 'nvim-win64\\bin\\nvim.exe' || 'nvim' }}
+      ALLOWED_INSTALLATION_FAILURES: ${{ matrix.os == 'windows-2022' && 'rnoweb' }}
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ilammy/msvc-dev-cmd@v1
+      - uses: actions/setup-node@v3
+
+      - name: Install tree-sitter CLI
+        run: npm i -g tree-sitter-cli
+
+      - name: Install and prepare Neovim
+        env:
+          NVIM_TAG: ${{ matrix.nvim_tag }}
+        run: |
+          bash ./scripts/ci-install-${{ matrix.os }}.sh
+
+      - name: Setup Parsers Cache
+        id: parsers-cache
+        uses: actions/cache@v3
+        with:
+          path: |
+            ./parser/
+            ~/AppData/Local/nvim/pack/nvim-treesitter/start/nvim-treesitter/parser/
+          key: ${{ matrix.os }}-${{ matrix.cc }}-${{ matrix.nvim_tag }}-parsers-v1-${{ hashFiles('./lockfile.json', './lua/nvim-treesitter/parsers.lua', './lua/nvim-treesitter/install.lua', './lua/nvim-treesitter/shell_command_selectors.lua') }}
+
+      - name: Compile parsers
+        run: $NVIM --headless -c "lua require'nvim-treesitter.install'.prefer_git=false" -c "TSInstallSync all" -c "q"
+
+      - name: Post compile Windows
+        if: matrix.os == 'windows-2022'
+        run: cp -r ~/AppData/Local/nvim/pack/nvim-treesitter/start/nvim-treesitter/parser/* parser
+
+      - name: Check query files
+        run: $NVIM --headless -c "luafile ./scripts/check-queries.lua" -c "q"

bundle/nvim-treesitter-0.9.1/.github/workflows/tests.yml

@@ -0,0 +1,65 @@
+name: Tests
+
+on:
+  push:
+    branches:
+      - "master"
+  pull_request:
+    branches:
+      - "master"
+
+# Cancel any in-progress CI runs for a PR if it is updated
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.head_ref || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  check_compilation:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        cc: [gcc]
+
+    name: Run tests
+    runs-on: ${{ matrix.os }}
+    env:
+      CC: ${{ matrix.cc }}
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+
+      - name: Install tree-sitter CLI
+        run: npm i -g tree-sitter-cli
+
+      - name: Test Dependencies
+        run: |
+          mkdir -p ~/.local/share/nvim/site/pack/plenary.nvim/start
+          cd ~/.local/share/nvim/site/pack/plenary.nvim/start
+          git clone https://github.com/nvim-lua/plenary.nvim
+          curl -L https://github.com/theHamsta/highlight-assertions/releases/download/v0.1.6/highlight-assertions_v0.1.6_x86_64-unknown-linux-gnu.tar.gz | tar -xz
+          cp highlight-assertions /usr/local/bin
+
+      - name: Install and prepare Neovim
+        env:
+          NVIM_TAG: stable
+          TREE_SITTER_CLI_TAG: v0.20.8
+        run: |
+          bash ./scripts/ci-install-${{ matrix.os }}.sh
+
+      - name: Setup Parsers Cache
+        id: parsers-cache
+        uses: actions/cache@v3
+        with:
+          path: |
+            ./parser/
+            ~/AppData/Local/nvim/pack/nvim-treesitter/start/nvim-treesitter/parser/
+          key: ${{ matrix.os }}-${{ matrix.cc }}-parsers-v1-${{ hashFiles('./lockfile.json', './lua/nvim-treesitter/parsers.lua', './lua/nvim-treesitter/install.lua', './lua/nvim-treesitter/shell_selectors.lua') }}
+
+      - name: Compile parsers Unix like
+        if: ${{ matrix.os != 'windows-latest' && steps.parsers-cache.outputs.cache-hit != 'true' }}
+        run: |
+          nvim --headless -c "TSInstallSync all" -c "q"
+
+      - name: Tests
+        run: PATH=/usr/local/bin:$PATH ./scripts/run_tests.sh

bundle/nvim-treesitter-0.9.1/.github/workflows/update-lockfile.yml

@@ -0,0 +1,56 @@
+name: Update lockfile
+
+on:
+  schedule:
+    - cron: "30 6 * * *"
+  workflow_dispatch:
+
+jobs:
+  update-lockfile:
+    name: Update lockfile
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          ref: master
+
+      - name: Prepare
+        env:
+          NVIM_TAG: stable
+        run: |
+          wget https://github.com/josephburnett/jd/releases/download/v1.6.1/jd-amd64-linux
+          mv ./jd-amd64-linux /tmp/jd
+          chmod +x /tmp/jd
+          sudo apt install libfuse2
+          wget https://github.com/neovim/neovim/releases/download/${NVIM_TAG}/nvim.appimage
+          chmod u+x nvim.appimage
+          mkdir -p ~/.local/share/nvim/site/pack/nvim-treesitter/start
+          ln -s $(pwd) ~/.local/share/nvim/site/pack/nvim-treesitter/start
+
+      - name: Update parsers
+        env:
+          SKIP_LOCKFILE_UPDATE_FOR_LANGS: ""
+        run: |
+          cp lockfile.json /tmp/old_lockfile.json
+          ./nvim.appimage --headless -c "luafile ./scripts/write-lockfile.lua" -c "q"
+          # Pretty print
+          cp lockfile.json /tmp/lockfile.json
+          cat /tmp/lockfile.json | jq --sort-keys > lockfile.json
+
+      - name: Commit changes
+        run: |
+          git config user.name "GitHub"
+          git config user.email "noreply@github.com"
+          git add lockfile.json
+          UPDATED_PARSERS=$(/tmp/jd -f merge /tmp/old_lockfile.json lockfile.json | jq -r 'keys | join(", ")')
+          echo "UPDATED_PARSERS=$UPDATED_PARSERS" >> $GITHUB_ENV
+          git commit -m "Update parsers: $UPDATED_PARSERS" || echo 'No commit necessary!'
+          git clean -xf
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v5
+        with:
+          title: "Update lockfile.json: ${{ env.UPDATED_PARSERS }}"
+          branch: update-lockfile-pr
+          base: ${{ github.head_ref }}
+          draft: true

bundle/nvim-treesitter-0.9.1/.github/workflows/update-readme.yml

@@ -0,0 +1,42 @@
+name: Update README
+
+on:
+  push:
+    branches:
+      - master
+  workflow_dispatch:
+
+jobs:
+  update-readme:
+    name: Update README
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        env:
+          NVIM_TAG: stable
+        run: |
+          sudo apt install libfuse2
+          wget https://github.com/neovim/neovim/releases/download/${NVIM_TAG}/nvim.appimage
+          chmod u+x nvim.appimage
+          mkdir -p ~/.local/share/nvim/site/pack/nvim-treesitter/start
+          ln -s $(pwd) ~/.local/share/nvim/site/pack/nvim-treesitter/start
+
+      - name: Check README
+        run: |
+          git config user.email "actions@github"
+          git config user.name "Github Actions"
+          ./nvim.appimage --headless -c "luafile ./scripts/update-readme.lua" -c "q" || echo "Needs update"
+          git add README.md
+          git commit -m "Update README" || echo 'No commit necessary!'
+          git clean -xf
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v5
+        with:
+          commit-message: Update README
+          title: Update README
+          branch: update-readme-pr
+          base: ${{ github.head_ref }}
+          draft: true

bundle/nvim-treesitter-0.9.1/.gitignore

@@ -0,0 +1,4 @@
+doc/tags
+.luacheckcache
+/tags
+nvim.appimage

bundle/nvim-treesitter-0.9.1/.luacheckrc

@@ -0,0 +1,21 @@
+-- Rerun tests only if their modification time changed.
+cache = true
+codes = true
+
+exclude_files = {
+  "tests/indent/lua/"
+}
+
+-- Glorious list of warnings: https://luacheck.readthedocs.io/en/stable/warnings.html
+ignore = {
+  "212", -- Unused argument, In the case of callback function, _arg_name is easier to understand than _, so this option is set to off.
+  "411", -- Redefining a local variable.
+  "412", -- Redefining an argument.
+  "422", -- Shadowing an argument
+  "122" -- Indirectly setting a readonly global
+}
+
+-- Global objects defined by the C code
+read_globals = {
+  "vim",
+}

bundle/nvim-treesitter-0.9.1/.luarc.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://raw.githubusercontent.com/LuaLS/vscode-lua/master/setting/schema.json",
+  "runtime": {
+      "version": "LuaJIT"
+  },
+  "workspace": {
+    "library": [
+      "lua",
+      "$VIMRUNTIME",
+      "${3rd}/luv/library"
+    ],
+    "checkThirdParty": false
+  },
+  "diagnostics": {
+    "groupFileStatus": {
+      "strict": "Opened",
+      "strong": "Opened"
+    },
+    "groupSeverity": {
+      "strong": "Warning",
+      "strict": "Warning"
+    },
+    "unusedLocalExclude": [ "_*" ]
+  }
+}

bundle/nvim-treesitter-0.9.1/.stylua.toml

@@ -0,0 +1,6 @@
+column_width = 120
+line_endings = "Unix"
+indent_type = "Spaces"
+indent_width = 2
+quote_style = "AutoPreferDouble"
+call_parentheses = "None"

bundle/nvim-treesitter-0.9.1/.styluaignore

@@ -0,0 +1 @@
+tests/indent/lua/

bundle/nvim-treesitter-0.9.1/CONTRIBUTING.md

@@ -0,0 +1,347 @@
+# Contributing to `nvim-treesitter`
+
+First of all, thank you very much for contributing to `nvim-treesitter`.
+
+If you haven't already, you should really come and reach out to us on our
+[Matrix channel], so we can help you with any question you might have!
+
+As you know, `nvim-treesitter` is roughly split in two parts:
+
+- Parser configurations : for various things like `locals`, `highlights`
+- What we like to call _modules_ : tiny lua modules that provide a given feature, based on parser configurations
+
+Depending on which part of the plugin you want to contribute to, please read the appropriate section.
+
+## Style Checks and Tests
+
+We haven't implemented any functional tests yet. Feel free to contribute.
+However, we check code style with `luacheck` and `stylua`!
+Please install luacheck and activate our `pre-push` hook to automatically check style before
+every push:
+
+```bash
+luarocks install luacheck
+cargo install stylua
+ln -s ../../scripts/pre-push .git/hooks/pre-push
+```
+
+## Adding new modules
+
+If you want to see a new functionality added to `nvim-treesitter` feel free to first open an issue
+to that we can track our solution!
+Thus far, there is basically two types of modules:
+
+- Little modules (like `incremental selection`) that are built in `nvim-treesitter`, we call them
+  `builtin modules`.
+- Bigger modules (like `completion-treesitter`, or `nvim-tree-docs`), or modules that integrate
+  with other plugins, that we call `remote modules`.
+
+In any case, you can build your own module! To help you started in the process, we have a template
+repository designed to build new modules [here](https://github.com/nvim-treesitter/module-template).
+Feel free to use it, and contact us over on our
+on the "Neovim tree-sitter" [Matrix channel].
+
+## Parser configurations
+
+Contributing to parser configurations is basically modifying one of the `queries/*/*.scm`.
+Each of these `scheme` files contains a _tree-sitter query_ for a given purpose.
+Before going any further, we highly suggest that you [read more about tree-sitter queries](https://tree-sitter.github.io/tree-sitter/using-parsers#pattern-matching-with-queries).
+
+Each query has an appropriate name, which is then used by modules to extract data from the syntax tree.
+For now these are the types of queries used by `nvim-treesitter`:
+
+- `highlights.scm`: used for syntax highlighting, using the `highlight` module.
+- `locals.scm`: used to extract keyword definitions, scopes, references, etc, using the `locals` module.
+- `textobjects.scm`: used to define text objects.
+- `folds.scm`: used to define folds.
+- `injections.scm`: used to define injections.
+
+For these types there is a _norm_ you will have to follow so that features work fine.
+Here are some global advices:
+
+- If your language is listed [here](https://github.com/nvim-treesitter/nvim-treesitter#supported-languages),
+  you can install the [playground plugin](https://github.com/nvim-treesitter/playground).
+- If your language is listed [here](https://github.com/nvim-treesitter/nvim-treesitter#supported-languages),
+  you can debug and experiment with your queries there.
+- If not, you should consider installing the [tree-sitter cli](https://github.com/tree-sitter/tree-sitter/tree/master/cli),
+  you should then be able to open a local playground using `tree-sitter build-wasm && tree-sitter web-ui` within the
+  parsers repo.
+- Examples of queries can be found in [queries/](queries/)
+- Matches in the bottom will override queries that are above of them.
+
+If your language is an extension of a language (TypeScript is an extension of JavaScript for
+example), you can include the queries from your base language by adding the following _as the first
+line of your file_.
+
+```query
+; inherits: lang1,(optionallang)
+```
+
+If you want to inherit a language, but don't want the languages inheriting from yours to inherit it,
+you can mark the language as optional (by putting it between parenthesis).
+
+### Highlights
+
+As languages differ quite a lot, here is a set of captures available to you when building a `highlights.scm` query. Note that your colorscheme needs to define (or link) these captures as highlight groups.
+
+#### Misc
+
+```scheme
+@comment               ; line and block comments
+@comment.documentation ; comments documenting code
+@error                 ; syntax/parser errors
+@none                  ; completely disable the highlight
+@preproc               ; various preprocessor directives & shebangs
+@define                ; preprocessor definition directives
+@operator              ; symbolic operators (e.g. `+` / `*`)
+```
+
+#### Punctuation
+
+```scheme
+@punctuation.delimiter ; delimiters (e.g. `;` / `.` / `,`)
+@punctuation.bracket   ; brackets (e.g. `()` / `{}` / `[]`)
+@punctuation.special   ; special symbols (e.g. `{}` in string interpolation)
+```
+
+#### Literals
+
+```scheme
+@string               ; string literals
+@string.documentation ; string documenting code (e.g. Python docstrings)
+@string.regex         ; regular expressions
+@string.escape        ; escape sequences
+@string.special       ; other special strings (e.g. dates)
+
+@character            ; character literals
+@character.special    ; special characters (e.g. wildcards)
+
+@boolean              ; boolean literals
+@number               ; numeric literals
+@float                ; floating-point number literals
+```
+
+#### Functions
+
+```scheme
+@function         ; function definitions
+@function.builtin ; built-in functions
+@function.call    ; function calls
+@function.macro   ; preprocessor macros
+
+@method           ; method definitions
+@method.call      ; method calls
+
+@constructor      ; constructor calls and definitions
+@parameter        ; parameters of a function
+```
+
+#### Keywords
+
+```scheme
+@keyword             ; various keywords
+@keyword.coroutine   ; keywords related to coroutines (e.g. `go` in Go, `async/await` in Python)
+@keyword.function    ; keywords that define a function (e.g. `func` in Go, `def` in Python)
+@keyword.operator    ; operators that are English words (e.g. `and` / `or`)
+@keyword.return      ; keywords like `return` and `yield`
+
+@conditional         ; keywords related to conditionals (e.g. `if` / `else`)
+@conditional.ternary ; ternary operator (e.g. `?` / `:`)
+
+@repeat              ; keywords related to loops (e.g. `for` / `while`)
+@debug               ; keywords related to debugging
+@label               ; GOTO and other labels (e.g. `label:` in C)
+@include             ; keywords for including modules (e.g. `import` / `from` in Python)
+@exception           ; keywords related to exceptions (e.g. `throw` / `catch`)
+```
+
+#### Types
+
+```scheme
+@type            ; type or class definitions and annotations
+@type.builtin    ; built-in types
+@type.definition ; type definitions (e.g. `typedef` in C)
+@type.qualifier  ; type qualifiers (e.g. `const`)
+
+@storageclass    ; modifiers that affect storage in memory or life-time
+@attribute       ; attribute annotations (e.g. Python decorators)
+@field           ; object and struct fields
+@property        ; similar to `@field`
+```
+
+#### Identifiers
+
+```scheme
+@variable         ; various variable names
+@variable.builtin ; built-in variable names (e.g. `this`)
+
+@constant         ; constant identifiers
+@constant.builtin ; built-in constant values
+@constant.macro   ; constants defined by the preprocessor
+
+@namespace        ; modules or namespaces
+@symbol           ; symbols or atoms
+```
+
+#### Text
+
+Mainly for markup languages.
+
+```scheme
+@text                  ; non-structured text
+@text.strong           ; bold text
+@text.emphasis         ; text with emphasis
+@text.underline        ; underlined text
+@text.strike           ; strikethrough text
+@text.title            ; text that is part of a title
+@text.quote            ; text quotations
+@text.uri              ; URIs (e.g. hyperlinks)
+@text.math             ; math environments (e.g. `$ ... $` in LaTeX)
+@text.environment      ; text environments of markup languages
+@text.environment.name ; text indicating the type of an environment
+@text.reference        ; text references, footnotes, citations, etc.
+
+@text.literal          ; literal or verbatim text (e.g., inline code)
+@text.literal.block    ; literal or verbatim text as a stand-alone block
+                       ; (use priority 90 for blocks with injections)
+
+@text.todo             ; todo notes
+@text.note             ; info notes
+@text.warning          ; warning notes
+@text.danger           ; danger/error notes
+
+@text.diff.add         ; added text (for diff files)
+@text.diff.delete      ; deleted text (for diff files)
+```
+
+#### Tags
+
+Used for XML-like tags.
+
+```scheme
+@tag           ; XML tag names
+@tag.attribute ; XML tag attributes
+@tag.delimiter ; XML tag delimiters
+```
+
+#### Conceal
+
+```scheme
+@conceal ; for captures that are only used for concealing
+```
+
+`@conceal` must be followed by `(#set! conceal "")`.
+
+#### Spell
+
+```scheme
+@spell   ; for defining regions to be spellchecked
+@nospell ; for defining regions that should NOT be spellchecked
+```
+
+The main types of nodes which are spell checked are:
+- Comments
+- Strings; where it makes sense. Strings that have interpolation or are typically used for non text purposes are not spell checked (e.g. bash).
+
+#### Priority
+
+Captures can be assigned a priority to control precedence of highlights via the
+`#set! "priority" <number>` directive (see `:h treesitter-highlight-priority`).
+The default priority for treesitter highlights is `100`; queries should only
+set priorities between `90` and `120`, to avoid conflict with other sources of
+highlighting (such as diagnostics or LSP semantic tokens).
+
+### Locals
+
+Note: pay specific attention to the captures here as they are a bit different to
+those listed in the upstream [Local Variables
+docs](https://tree-sitter.github.io/tree-sitter/syntax-highlighting#local-variables).
+Some of these docs didn't exist when `nvim-treesitter` was created and the
+upstream captures are more limiting than what we have here.
+
+```scheme
+@definition            ; various definitions
+@definition.constant   ; constants
+@definition.function   ; functions
+@definition.method     ; methods
+@definition.var        ; variables
+@definition.parameter  ; parameters
+@definition.macro      ; preprocessor macros
+@definition.type       ; types or classes
+@definition.field      ; fields or properties
+@definition.enum       ; enumerations
+@definition.namespace  ; modules or namespaces
+@definition.import     ; imported names
+@definition.associated ; the associated type of a variable
+
+@scope                 ; scope block
+@reference             ; identifier reference
+```
+
+#### Definition Scope
+
+You can set the scope of a definition by setting the `scope` property on the definition.
+
+For example, a JavaScript function declaration creates a scope. The function name is captured as the definition.
+This means that the function definition would only be available WITHIN the scope of the function, which is not the case.
+The definition can be used in the scope the function was defined in.
+
+```javascript
+function doSomething() {}
+
+doSomething(); // Should point to the declaration as the definition
+```
+
+```query
+(function_declaration
+  ((identifier) @definition.var)
+   (#set! "definition.var.scope" "parent"))
+```
+
+Possible scope values are:
+
+- `parent`: The definition is valid in the containing scope and one more scope above that scope
+- `global`: The definition is valid in the root scope
+- `local`: The definition is valid in the containing scope. This is the default behavior
+
+### Folds
+
+You can define folds for a given language by adding a `folds.scm` query :
+
+```scheme
+@fold ; fold this node
+```
+
+If the `folds.scm` query is not present, this will fall back to the `@scope` captures in the `locals`
+query.
+
+### Injections
+
+Some captures are related to language injection (like markdown code blocks). They are used in `injections.scm`.
+You can directly use the name of the language that you want to inject (e.g. `@html` to inject html).
+
+If you want to dynamically detect the language (e.g. for Markdown blocks) use the `@language` to capture
+the node describing the language and `@content` to describe the injection region.
+
+```scheme
+@{lang}   ; e.g. @html to describe a html region
+
+@language ; dynamic detection of the injection language (i.e. the text of the captured node describes the language)
+@content  ; region for the dynamically detected language
+@combined ; combine all matches of a pattern as one single block of content
+```
+
+### Indents
+
+```scheme
+@indent.begin       ; indent children when matching this node
+@indent.end         ; marks the end of indented block
+@indent.align       ; behaves like python aligned/hanging indent
+@indent.dedent      ; dedent children when matching this node
+@indent.branch      ; dedent itself when matching this node
+@indent.ignore      ; do not indent in this node
+@indent.auto        ; behaves like 'autoindent' buffer option
+@indent.zero        ; sets this node at position 0 (no indent)
+```
+
+[Matrix channel]: https://matrix.to/#/#nvim-treesitter:matrix.org

bundle/nvim-treesitter-0.9.1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

bundle/nvim-treesitter-0.9.1/Makefile

@@ -0,0 +1,7 @@
+# https://github.com/luarocks/luarocks/wiki/Creating-a-Makefile-that-plays-nice-with-LuaRocks
+build: 
+	echo "Do nothing"
+
+install:
+	mkdir -p $(INST_LUADIR)
+	cp -r autoload plugin queries lua $(INST_LUADIR)

bundle/nvim-treesitter-0.9.1/README.md

@@ -0,0 +1,721 @@
+<div align="center">
+  <h1>nvim-treesitter</h1>
+  <p>
+    <a href="https://matrix.to/#/#nvim-treesitter:matrix.org">
+      <img alt="Matrix Chat" src="https://img.shields.io/matrix/nvim-treesitter:matrix.org" />
+    </a>
+    <a href="https://github.com/nvim-treesitter/nvim-treesitter/actions?query=workflow%3A%22Linting+and+style+checking%22+branch%3Amaster">
+      <img alt="Linting and Style" src="https://github.com/nvim-treesitter/nvim-treesitter/workflows/Linting%20and%20style%20checking/badge.svg" />
+    </a>
+    <a href="https://github.com/nvim-treesitter/nvim-treesitter/actions?query=workflow%3A%22Check+loading+of+syntax+files%22+branch%3Amaster">
+      <img alt="Syntax files" src="https://github.com/nvim-treesitter/nvim-treesitter/workflows/Check%20loading%20of%20syntax%20files/badge.svg" />
+    </a>
+  </p>
+</div>
+
+<div align="center">
+  <p>
+    <img src="assets/logo.png" align="center" alt="Logo" />
+  </p>
+  <p>
+    <a href="https://github.com/tree-sitter/tree-sitter">Treesitter</a>
+    configurations and abstraction layer for
+    <a href="https://github.com/neovim/neovim/">Neovim</a>.
+  </p>
+  <p>
+    <i>
+      Logo by <a href="https://github.com/steelsojka">@steelsojka</a>
+    </i>
+  </p>
+</div>
+
+The goal of `nvim-treesitter` is both to provide a simple and easy way to use the interface for [tree-sitter](https://github.com/tree-sitter/tree-sitter) in Neovim and to provide some basic functionality such as highlighting based on it:
+
+![example-cpp](https://user-images.githubusercontent.com/2361214/202753610-e923bf4e-e88f-494b-bb1e-d22a7688446f.png)
+
+Traditional highlighting (left) vs Treesitter-based highlighting (right).
+More examples can be found in [our gallery](https://github.com/nvim-treesitter/nvim-treesitter/wiki/Gallery).
+
+**Warning: Treesitter and nvim-treesitter highlighting are an experimental feature of Neovim.
+Please consider the experience with this plug-in as experimental until Tree-Sitter support in Neovim is stable!
+We recommend using the nightly builds of Neovim if possible.
+You can find the current roadmap [here](https://github.com/nvim-treesitter/nvim-treesitter/projects/1).
+The roadmap and all features of this plugin are open to change, and any suggestion will be highly appreciated!**
+
+Nvim-treesitter is based on three interlocking features: [**language parsers**](#language-parsers), [**queries**](#adding-queries), and [**modules**](#available-modules), where _modules_ provide features – e.g., highlighting – based on _queries_ for syntax objects extracted from a given buffer by _language parsers_.
+Users will generally only need to interact with parsers and modules as explained in the next section.
+For more detailed information on setting these up, see ["Advanced setup"](#advanced-setup).
+
+---
+
+### Table of contents
+
+- [Quickstart](#quickstart)
+- [Supported languages](#supported-languages)
+- [Available modules](#available-modules)
+- [Advanced setup](#advanced-setup)
+- [Extra features](#extra-features)
+- [Troubleshooting](#troubleshooting)
+
+---
+
+# Quickstart
+
+## Requirements
+
+- [Latest](https://github.com/neovim/neovim/releases/tag/stable) Neovim release ([nightly](https://github.com/neovim/neovim#install-from-source) recommended)
+- `tar` and `curl` in your path (or alternatively `git`)
+- A C compiler in your path and libstdc++ installed ([Windows users please read this!](https://github.com/nvim-treesitter/nvim-treesitter/wiki/Windows-support)).
+
+## Installation
+
+You can install `nvim-treesitter` with your favorite package manager (or using the native `package` feature of vim, see `:h packages`).
+
+**NOTE: This plugin is only guaranteed to work with specific versions of language parsers** (as specified in the `lockfile.json`). **When upgrading the plugin, you must make sure that all installed parsers are updated to the latest version** via `:TSUpdate`.
+It is strongly recommended to automate this; e.g., if you are using [vim-plug](https://github.com/junegunn/vim-plug), put this in your `init.vim` file:
+
+```vim
+Plug 'nvim-treesitter/nvim-treesitter', {'do': ':TSUpdate'}
+```
+
+For other plugin managers such as `packer.nvim`, see this [Installation page from the wiki](https://github.com/nvim-treesitter/nvim-treesitter/wiki/Installation) (Note that this page is community maintained).
+
+## Language parsers
+
+Treesitter uses a different _parser_ for every language, which needs to be generated via `tree-sitter-cli` from a `grammar.js` file, then compiled to a `.so` library that needs to be placed in neovim's `runtimepath` (typically under `parser/{language}.so`).
+To simplify this, `nvim-treesitter` provides commands to automate this process.
+If the language is already [supported by `nvim-treesitter`](#supported-languages), you can install it with
+
+```vim
+:TSInstall <language_to_install>
+```
+
+This command supports tab expansion.
+You can also get a list of all available languages and their installation status with `:TSInstallInfo`.
+Parsers not on this list can be added manually by following the steps described under ["Adding parsers"](#adding-parsers) below.
+
+To make sure a parser is at the latest compatible version (as specified in `nvim-treesitter`'s `lockfile.json`), use `:TSUpdate {language}`. To update all parsers unconditionally, use `:TSUpdate all` or just `:TSUpdate`.
+
+## Modules
+
+Each module provides a distinct tree-sitter-based feature such as [highlighting](#highlight), [indentation](#indentation), or [folding](#folding); see [`:h nvim-treesitter-modules`](doc/nvim-treesitter.txt) or ["Available modules"](#available-modules) below for a list of modules and their options.
+
+Following examples assume that you are configuring neovim with lua. If you are using vimscript, see `:h lua-heredoc`.
+All modules are disabled by default and need to be activated explicitly in your `init.lua`, e.g., via
+
+```lua
+require'nvim-treesitter.configs'.setup {
+  -- A list of parser names, or "all" (the five listed parsers should always be installed)
+  ensure_installed = { "c", "lua", "vim", "vimdoc", "query" },
+
+  -- Install parsers synchronously (only applied to `ensure_installed`)
+  sync_install = false,
+
+  -- Automatically install missing parsers when entering buffer
+  -- Recommendation: set to false if you don't have `tree-sitter` CLI installed locally
+  auto_install = true,
+
+  -- List of parsers to ignore installing (for "all")
+  ignore_install = { "javascript" },
+
+  ---- If you need to change the installation directory of the parsers (see -> Advanced Setup)
+  -- parser_install_dir = "/some/path/to/store/parsers", -- Remember to run vim.opt.runtimepath:append("/some/path/to/store/parsers")!
+
+  highlight = {
+    enable = true,
+
+    -- NOTE: these are the names of the parsers and not the filetype. (for example if you want to
+    -- disable highlighting for the `tex` filetype, you need to include `latex` in this list as this is
+    -- the name of the parser)
+    -- list of language that will be disabled
+    disable = { "c", "rust" },
+    -- Or use a function for more flexibility, e.g. to disable slow treesitter highlight for large files
+    disable = function(lang, buf)
+        local max_filesize = 100 * 1024 -- 100 KB
+        local ok, stats = pcall(vim.loop.fs_stat, vim.api.nvim_buf_get_name(buf))
+        if ok and stats and stats.size > max_filesize then
+            return true
+        end
+    end,
+
+    -- Setting this to true will run `:h syntax` and tree-sitter at the same time.
+    -- Set this to `true` if you depend on 'syntax' being enabled (like for indentation).
+    -- Using this option may slow down your editor, and you may see some duplicate highlights.
+    -- Instead of true it can also be a list of languages
+    additional_vim_regex_highlighting = false,
+  },
+}
+```
+
+Each module can also be enabled or disabled interactively through the following commands:
+
+```vim
+:TSBufEnable {module} " enable module on current buffer
+:TSBufDisable {module} " disable module on current buffer
+:TSEnable {module} [{ft}] " enable module on every buffer. If filetype is specified, enable only for this filetype.
+:TSDisable {module} [{ft}] " disable module on every buffer. If filetype is specified, disable only for this filetype.
+:TSModuleInfo [{module}] " list information about modules state for each filetype
+```
+
+Check [`:h nvim-treesitter-commands`](doc/nvim-treesitter.txt) for a list of all available commands.
+It may be necessary to reload the buffer (e.g., via `:e`) after enabling a module interactively.
+
+# Supported languages
+
+For `nvim-treesitter` to support a specific feature for a specific language requires both a parser for that language and an appropriate language-specific query file for that feature.
+
+The following is a list of languages for which a parser can be installed through `:TSInstall`; a checked box means that `nvim-treesitter` also contains queries at least for the `highlight` module.
+
+Experimental parsers are parsers that have a maintainer but are not stable enough for
+daily use yet.
+
+We are looking for maintainers to add more parsers and to write query files for their languages. Check our [tracking issue](https://github.com/nvim-treesitter/nvim-treesitter/issues/2282) for open language requests.
+
+<!--This section of the README is automatically updated by a CI job-->
+<!--parserinfo-->
+- [x] [ada](https://github.com/briot/tree-sitter-ada) (maintained by @briot)
+- [x] [agda](https://github.com/AusCyberman/tree-sitter-agda) (maintained by @Decodetalkers)
+- [x] [arduino](https://github.com/ObserverOfTime/tree-sitter-arduino) (maintained by @ObserverOfTime)
+- [x] [astro](https://github.com/virchau13/tree-sitter-astro) (maintained by @virchau13)
+- [ ] [awk](https://github.com/Beaglefoot/tree-sitter-awk)
+- [x] [bash](https://github.com/tree-sitter/tree-sitter-bash) (maintained by @TravonteD)
+- [x] [bass](https://github.com/amaanq/tree-sitter-bass) (maintained by @amaanq)
+- [x] [beancount](https://github.com/polarmutex/tree-sitter-beancount) (maintained by @polarmutex)
+- [x] [bibtex](https://github.com/latex-lsp/tree-sitter-bibtex) (maintained by @theHamsta, @clason)
+- [x] [bicep](https://github.com/amaanq/tree-sitter-bicep) (maintained by @amaanq)
+- [x] [blueprint](https://gitlab.com/gabmus/tree-sitter-blueprint.git) (experimental, maintained by @gabmus)
+- [x] [c](https://github.com/tree-sitter/tree-sitter-c) (maintained by @amaanq)
+- [x] [c_sharp](https://github.com/tree-sitter/tree-sitter-c-sharp) (maintained by @Luxed)
+- [x] [cairo](https://github.com/amaanq/tree-sitter-cairo) (maintained by @amaanq)
+- [x] [capnp](https://github.com/amaanq/tree-sitter-capnp) (maintained by @amaanq)
+- [x] [chatito](https://github.com/ObserverOfTime/tree-sitter-chatito) (maintained by @ObserverOfTime)
+- [x] [clojure](https://github.com/sogaiu/tree-sitter-clojure) (maintained by @sogaiu)
+- [x] [cmake](https://github.com/uyha/tree-sitter-cmake) (maintained by @uyha)
+- [x] [comment](https://github.com/stsewd/tree-sitter-comment) (maintained by @stsewd)
+- [x] [commonlisp](https://github.com/theHamsta/tree-sitter-commonlisp) (maintained by @theHamsta)
+- [x] [cooklang](https://github.com/addcninblue/tree-sitter-cooklang) (maintained by @addcninblue)
+- [x] [corn](https://github.com/jakestanger/tree-sitter-corn) (maintained by @jakestanger)
+- [x] [cpon](https://github.com/amaanq/tree-sitter-cpon) (maintained by @amaanq)
+- [x] [cpp](https://github.com/tree-sitter/tree-sitter-cpp) (maintained by @theHamsta)
+- [x] [css](https://github.com/tree-sitter/tree-sitter-css) (maintained by @TravonteD)
+- [x] [cuda](https://github.com/theHamsta/tree-sitter-cuda) (maintained by @theHamsta)
+- [x] [cue](https://github.com/eonpatapon/tree-sitter-cue) (maintained by @amaanq)
+- [x] [d](https://github.com/CyberShadow/tree-sitter-d) (experimental, maintained by @nawordar)
+- [x] [dart](https://github.com/UserNobody14/tree-sitter-dart) (maintained by @akinsho)
+- [x] [devicetree](https://github.com/joelspadin/tree-sitter-devicetree) (maintained by @jedrzejboczar)
+- [x] [dhall](https://github.com/jbellerb/tree-sitter-dhall) (maintained by @amaanq)
+- [x] [diff](https://github.com/the-mikedavis/tree-sitter-diff) (maintained by @gbprod)
+- [x] [dockerfile](https://github.com/camdencheek/tree-sitter-dockerfile) (maintained by @camdencheek)
+- [x] [dot](https://github.com/rydesun/tree-sitter-dot) (maintained by @rydesun)
+- [x] [ebnf](https://github.com/RubixDev/ebnf) (experimental, maintained by @RubixDev)
+- [x] [eex](https://github.com/connorlay/tree-sitter-eex) (maintained by @connorlay)
+- [x] [elixir](https://github.com/elixir-lang/tree-sitter-elixir) (maintained by @connorlay)
+- [x] [elm](https://github.com/elm-tooling/tree-sitter-elm) (maintained by @zweimach)
+- [x] [elsa](https://github.com/glapa-grossklag/tree-sitter-elsa) (maintained by @glapa-grossklag, @amaanq)
+- [x] [elvish](https://github.com/elves/tree-sitter-elvish) (maintained by @elves)
+- [ ] [embedded_template](https://github.com/tree-sitter/tree-sitter-embedded-template)
+- [x] [erlang](https://github.com/WhatsApp/tree-sitter-erlang) (maintained by @filmor)
+- [x] [fennel](https://github.com/travonted/tree-sitter-fennel) (maintained by @TravonteD)
+- [x] [firrtl](https://github.com/amaanq/tree-sitter-firrtl) (maintained by @amaanq)
+- [x] [fish](https://github.com/ram02z/tree-sitter-fish) (maintained by @ram02z)
+- [x] [foam](https://github.com/FoamScience/tree-sitter-foam) (experimental, maintained by @FoamScience)
+- [x] [fortran](https://github.com/stadelmanma/tree-sitter-fortran) (maintained by @amaanq)
+- [x] [fsh](https://github.com/mgramigna/tree-sitter-fsh) (maintained by @mgramigna)
+- [x] [func](https://github.com/amaanq/tree-sitter-func) (maintained by @amaanq)
+- [x] [fusion](https://gitlab.com/jirgn/tree-sitter-fusion.git) (maintained by @jirgn)
+- [x] [Godot (gdscript)](https://github.com/PrestonKnopp/tree-sitter-gdscript) (maintained by @PrestonKnopp)
+- [x] [git_config](https://github.com/the-mikedavis/tree-sitter-git-config) (maintained by @amaanq)
+- [x] [git_rebase](https://github.com/the-mikedavis/tree-sitter-git-rebase) (maintained by @gbprod)
+- [x] [gitattributes](https://github.com/ObserverOfTime/tree-sitter-gitattributes) (maintained by @ObserverOfTime)
+- [x] [gitcommit](https://github.com/gbprod/tree-sitter-gitcommit) (maintained by @gbprod)
+- [x] [gitignore](https://github.com/shunsambongi/tree-sitter-gitignore) (maintained by @theHamsta)
+- [x] [gleam](https://github.com/gleam-lang/tree-sitter-gleam) (maintained by @amaanq)
+- [x] [Glimmer and Ember](https://github.com/alexlafroscia/tree-sitter-glimmer) (maintained by @NullVoxPopuli)
+- [x] [glsl](https://github.com/theHamsta/tree-sitter-glsl) (maintained by @theHamsta)
+- [x] [go](https://github.com/tree-sitter/tree-sitter-go) (maintained by @theHamsta, @WinWisely268)
+- [x] [Godot Resources (gdresource)](https://github.com/PrestonKnopp/tree-sitter-godot-resource) (maintained by @pierpo)
+- [x] [gomod](https://github.com/camdencheek/tree-sitter-go-mod) (maintained by @camdencheek)
+- [x] [gosum](https://github.com/amaanq/tree-sitter-go-sum) (maintained by @amaanq)
+- [x] [gowork](https://github.com/omertuc/tree-sitter-go-work) (maintained by @omertuc)
+- [x] [graphql](https://github.com/bkegley/tree-sitter-graphql) (maintained by @bkegley)
+- [x] [groovy](https://github.com/Decodetalkers/tree-sitter-groovy) (maintained by @Decodetalkers)
+- [ ] [hack](https://github.com/slackhq/tree-sitter-hack)
+- [x] [hare](https://github.com/amaanq/tree-sitter-hare) (maintained by @amaanq)
+- [ ] [haskell](https://github.com/tree-sitter/tree-sitter-haskell)
+- [x] [haskell_persistent](https://github.com/MercuryTechnologies/tree-sitter-haskell-persistent) (maintained by @lykahb)
+- [x] [hcl](https://github.com/MichaHoffmann/tree-sitter-hcl) (maintained by @MichaHoffmann)
+- [x] [heex](https://github.com/connorlay/tree-sitter-heex) (maintained by @connorlay)
+- [x] [hjson](https://github.com/winston0410/tree-sitter-hjson) (maintained by @winston0410)
+- [x] [hlsl](https://github.com/theHamsta/tree-sitter-hlsl) (maintained by @theHamsta)
+- [x] [hocon](https://github.com/antosha417/tree-sitter-hocon) (maintained by @antosha417)
+- [x] [hoon](https://github.com/urbit-pilled/tree-sitter-hoon) (experimental, maintained by @urbit-pilled)
+- [x] [html](https://github.com/tree-sitter/tree-sitter-html) (maintained by @TravonteD)
+- [x] [htmldjango](https://github.com/interdependence/tree-sitter-htmldjango) (experimental, maintained by @ObserverOfTime)
+- [x] [http](https://github.com/rest-nvim/tree-sitter-http) (maintained by @amaanq)
+- [x] [hurl](https://github.com/pfeiferj/tree-sitter-hurl) (maintained by @pfeiferj)
+- [x] [ini](https://github.com/justinmk/tree-sitter-ini) (experimental, maintained by @theHamsta)
+- [x] [ispc](https://github.com/fab4100/tree-sitter-ispc) (maintained by @fab4100)
+- [x] [janet_simple](https://github.com/sogaiu/tree-sitter-janet-simple) (maintained by @sogaiu)
+- [x] [java](https://github.com/tree-sitter/tree-sitter-java) (maintained by @p00f)
+- [x] [javascript](https://github.com/tree-sitter/tree-sitter-javascript) (maintained by @steelsojka)
+- [x] [jq](https://github.com/flurie/tree-sitter-jq) (maintained by @ObserverOfTime)
+- [x] [jsdoc](https://github.com/tree-sitter/tree-sitter-jsdoc) (maintained by @steelsojka)
+- [x] [json](https://github.com/tree-sitter/tree-sitter-json) (maintained by @steelsojka)
+- [x] [json5](https://github.com/Joakker/tree-sitter-json5) (maintained by @Joakker)
+- [x] [JSON with comments](https://gitlab.com/WhyNotHugo/tree-sitter-jsonc.git) (maintained by @WhyNotHugo)
+- [x] [jsonnet](https://github.com/sourcegraph/tree-sitter-jsonnet) (maintained by @nawordar)
+- [x] [julia](https://github.com/tree-sitter/tree-sitter-julia) (maintained by @theHamsta)
+- [x] [kdl](https://github.com/amaanq/tree-sitter-kdl) (maintained by @amaanq)
+- [x] [kotlin](https://github.com/fwcd/tree-sitter-kotlin) (maintained by @SalBakraa)
+- [x] [lalrpop](https://github.com/traxys/tree-sitter-lalrpop) (maintained by @traxys)
+- [x] [latex](https://github.com/latex-lsp/tree-sitter-latex) (maintained by @theHamsta, @clason)
+- [x] [ledger](https://github.com/cbarrete/tree-sitter-ledger) (maintained by @cbarrete)
+- [x] [llvm](https://github.com/benwilliamgraham/tree-sitter-llvm) (maintained by @benwilliamgraham)
+- [x] [lua](https://github.com/MunifTanjim/tree-sitter-lua) (maintained by @muniftanjim)
+- [x] [luadoc](https://github.com/amaanq/tree-sitter-luadoc) (maintained by @amaanq)
+- [x] [lua patterns](https://github.com/amaanq/tree-sitter-luap) (maintained by @amaanq)
+- [x] [luau](https://github.com/amaanq/tree-sitter-luau) (maintained by @amaanq)
+- [x] [m68k](https://github.com/grahambates/tree-sitter-m68k) (maintained by @grahambates)
+- [x] [make](https://github.com/alemuller/tree-sitter-make) (maintained by @lewis6991)
+- [x] [markdown (basic highlighting)](https://github.com/MDeiml/tree-sitter-markdown) (experimental, maintained by @MDeiml)
+- [x] [markdown_inline (needed for full highlighting)](https://github.com/MDeiml/tree-sitter-markdown) (experimental, maintained by @MDeiml)
+- [x] [matlab](https://github.com/acristoffers/tree-sitter-matlab) (maintained by @acristoffers)
+- [x] [menhir](https://github.com/Kerl13/tree-sitter-menhir) (maintained by @Kerl13)
+- [ ] [mermaid](https://github.com/monaqa/tree-sitter-mermaid) (experimental)
+- [x] [meson](https://github.com/Decodetalkers/tree-sitter-meson) (maintained by @Decodetalkers)
+- [x] [mlir](https://github.com/artagnon/tree-sitter-mlir) (experimental, maintained by @artagnon)
+- [ ] [nickel](https://github.com/nickel-lang/tree-sitter-nickel)
+- [x] [ninja](https://github.com/alemuller/tree-sitter-ninja) (maintained by @alemuller)
+- [x] [nix](https://github.com/cstrahan/tree-sitter-nix) (maintained by @leo60228)
+- [x] [norg](https://github.com/nvim-neorg/tree-sitter-norg) (maintained by @JoeyGrajciar, @vhyrro)
+- [x] [objc](https://github.com/amaanq/tree-sitter-objc) (maintained by @amaanq)
+- [x] [ocaml](https://github.com/tree-sitter/tree-sitter-ocaml) (maintained by @undu)
+- [x] [ocaml_interface](https://github.com/tree-sitter/tree-sitter-ocaml) (maintained by @undu)
+- [x] [ocamllex](https://github.com/atom-ocaml/tree-sitter-ocamllex) (maintained by @undu)
+- [x] [odin](https://github.com/amaanq/tree-sitter-odin) (maintained by @amaanq)
+- [ ] [org](https://github.com/milisims/tree-sitter-org)
+- [x] [pascal](https://github.com/Isopod/tree-sitter-pascal.git) (maintained by @Isopod)
+- [x] [passwd](https://github.com/ath3/tree-sitter-passwd) (maintained by @amaanq)
+- [x] [pem](https://github.com/ObserverOfTime/tree-sitter-pem) (maintained by @ObserverOfTime)
+- [x] [perl](https://github.com/ganezdragon/tree-sitter-perl) (maintained by @lcrownover)
+- [x] [php](https://github.com/tree-sitter/tree-sitter-php) (maintained by @tk-shirasaka)
+- [x] [phpdoc](https://github.com/claytonrcarter/tree-sitter-phpdoc) (experimental, maintained by @mikehaertl)
+- [x] [pioasm](https://github.com/leo60228/tree-sitter-pioasm) (maintained by @leo60228)
+- [x] [po](https://github.com/erasin/tree-sitter-po) (maintained by @amaanq)
+- [x] [Path of Exile item filter](https://github.com/ObserverOfTime/tree-sitter-poe-filter) (experimental, maintained by @ObserverOfTime)
+- [x] [pony](https://github.com/amaanq/tree-sitter-pony) (maintained by @amaanq, @mfelsche)
+- [x] [prisma](https://github.com/victorhqc/tree-sitter-prisma) (maintained by @elianiva)
+- [x] [promql](https://github.com/MichaHoffmann/tree-sitter-promql) (maintained by @MichaHoffmann)
+- [x] [proto](https://github.com/treywood/tree-sitter-proto) (maintained by @treywood)
+- [x] [prql](https://github.com/PRQL/tree-sitter-prql) (maintained by @matthias-Q)
+- [x] [pug](https://github.com/zealot128/tree-sitter-pug) (experimental, maintained by @zealot128)
+- [x] [puppet](https://github.com/amaanq/tree-sitter-puppet) (maintained by @amaanq)
+- [x] [python](https://github.com/tree-sitter/tree-sitter-python) (maintained by @stsewd, @theHamsta)
+- [x] [ql](https://github.com/tree-sitter/tree-sitter-ql) (maintained by @pwntester)
+- [x] [qmldir](https://github.com/Decodetalkers/tree-sitter-qmldir) (maintained by @amaanq)
+- [x] [qmljs](https://github.com/yuja/tree-sitter-qmljs) (maintained by @Decodetalkers)
+- [x] [Tree-Sitter query language](https://github.com/nvim-treesitter/tree-sitter-query) (maintained by @steelsojka)
+- [x] [r](https://github.com/r-lib/tree-sitter-r) (maintained by @echasnovski)
+- [ ] [racket](https://github.com/6cdh/tree-sitter-racket)
+- [x] [rasi](https://github.com/Fymyte/tree-sitter-rasi) (maintained by @Fymyte)
+- [x] [regex](https://github.com/tree-sitter/tree-sitter-regex) (maintained by @theHamsta)
+- [x] [rego](https://github.com/FallenAngel97/tree-sitter-rego) (maintained by @FallenAngel97)
+- [x] [pip requirements](https://github.com/ObserverOfTime/tree-sitter-requirements) (maintained by @ObserverOfTime)
+- [x] [rnoweb](https://github.com/bamonroe/tree-sitter-rnoweb) (maintained by @bamonroe)
+- [x] [robot](https://github.com/Hubro/tree-sitter-robot) (experimental, maintained by @ema2159)
+- [x] [ron](https://github.com/amaanq/tree-sitter-ron) (maintained by @amaanq)
+- [x] [rst](https://github.com/stsewd/tree-sitter-rst) (maintained by @stsewd)
+- [x] [ruby](https://github.com/tree-sitter/tree-sitter-ruby) (maintained by @TravonteD)
+- [x] [rust](https://github.com/tree-sitter/tree-sitter-rust) (maintained by @amaanq)
+- [x] [scala](https://github.com/tree-sitter/tree-sitter-scala) (maintained by @stevanmilic)
+- [x] [scfg](https://git.sr.ht/~rockorager/tree-sitter-scfg) (maintained by @WhyNotHugo)
+- [ ] [scheme](https://github.com/6cdh/tree-sitter-scheme)
+- [x] [scss](https://github.com/serenadeai/tree-sitter-scss) (maintained by @elianiva)
+- [x] [slint](https://github.com/jrmoulton/tree-sitter-slint) (experimental, maintained by @jrmoulton)
+- [x] [smali](https://git.sr.ht/~yotam/tree-sitter-smali) (maintained by @amaanq)
+- [x] [smithy](https://github.com/indoorvivants/tree-sitter-smithy) (maintained by @amaanq, @keynmol)
+- [x] [solidity](https://github.com/JoranHonig/tree-sitter-solidity) (maintained by @amaanq)
+- [x] [sparql](https://github.com/BonaBeavis/tree-sitter-sparql) (maintained by @BonaBeavis)
+- [x] [sql](https://github.com/derekstride/tree-sitter-sql) (maintained by @derekstride)
+- [x] [squirrel](https://github.com/amaanq/tree-sitter-squirrel) (maintained by @amaanq)
+- [x] [starlark](https://github.com/amaanq/tree-sitter-starlark) (maintained by @amaanq)
+- [x] [supercollider](https://github.com/madskjeldgaard/tree-sitter-supercollider) (maintained by @madskjeldgaard)
+- [x] [surface](https://github.com/connorlay/tree-sitter-surface) (maintained by @connorlay)
+- [x] [svelte](https://github.com/Himujjal/tree-sitter-svelte) (maintained by @elianiva)
+- [x] [swift](https://github.com/alex-pinkus/tree-sitter-swift) (maintained by @alex-pinkus)
+- [x] [sxhkdrc](https://github.com/RaafatTurki/tree-sitter-sxhkdrc) (maintained by @RaafatTurki)
+- [x] [systemtap](https://github.com/ok-ryoko/tree-sitter-systemtap) (maintained by @ok-ryoko)
+- [x] [t32](https://gitlab.com/xasc/tree-sitter-t32.git) (maintained by @xasc)
+- [x] [tablegen](https://github.com/amaanq/tree-sitter-tablegen) (maintained by @amaanq)
+- [x] [teal](https://github.com/euclidianAce/tree-sitter-teal) (maintained by @euclidianAce)
+- [x] [terraform](https://github.com/MichaHoffmann/tree-sitter-hcl) (maintained by @MichaHoffmann)
+- [x] [thrift](https://github.com/duskmoon314/tree-sitter-thrift) (maintained by @amaanq, @duskmoon314)
+- [x] [tiger](https://github.com/ambroisie/tree-sitter-tiger) (maintained by @ambroisie)
+- [x] [tlaplus](https://github.com/tlaplus-community/tree-sitter-tlaplus) (maintained by @ahelwer, @susliko)
+- [x] [todotxt](https://github.com/arnarg/tree-sitter-todotxt.git) (experimental, maintained by @arnarg)
+- [x] [toml](https://github.com/ikatyang/tree-sitter-toml) (maintained by @tk-shirasaka)
+- [x] [tsx](https://github.com/tree-sitter/tree-sitter-typescript) (maintained by @steelsojka)
+- [x] [turtle](https://github.com/BonaBeavis/tree-sitter-turtle) (maintained by @BonaBeavis)
+- [x] [twig](https://github.com/gbprod/tree-sitter-twig) (maintained by @gbprod)
+- [x] [typescript](https://github.com/tree-sitter/tree-sitter-typescript) (maintained by @steelsojka)
+- [x] [ungrammar](https://github.com/Philipp-M/tree-sitter-ungrammar) (maintained by @Philipp-M, @amaanq)
+- [x] [usd](https://github.com/ColinKennedy/tree-sitter-usd) (maintained by @ColinKennedy)
+- [x] [uxn tal](https://github.com/amaanq/tree-sitter-uxntal) (maintained by @amaanq)
+- [x] [v](https://github.com/v-analyzer/v-analyzer) (maintained by @kkharji, @amaanq)
+- [x] [vala](https://github.com/vala-lang/tree-sitter-vala) (maintained by @Prince781)
+- [x] [verilog](https://github.com/tree-sitter/tree-sitter-verilog) (maintained by @zegervdv)
+- [x] [vhs](https://github.com/charmbracelet/tree-sitter-vhs) (maintained by @caarlos0)
+- [x] [vim](https://github.com/neovim/tree-sitter-vim) (maintained by @clason)
+- [x] [vimdoc](https://github.com/neovim/tree-sitter-vimdoc) (maintained by @clason)
+- [x] [vue](https://github.com/ikatyang/tree-sitter-vue) (maintained by @WhyNotHugo)
+- [x] [wgsl](https://github.com/szebniok/tree-sitter-wgsl) (maintained by @szebniok)
+- [x] [wgsl_bevy](https://github.com/theHamsta/tree-sitter-wgsl-bevy) (maintained by @theHamsta)
+- [x] [wing](https://github.com/winglang/wing) (experimental, maintained by @gshpychka)
+- [x] [yaml](https://github.com/ikatyang/tree-sitter-yaml) (maintained by @stsewd)
+- [x] [yang](https://github.com/Hubro/tree-sitter-yang) (maintained by @Hubro)
+- [x] [yuck](https://github.com/Philipp-M/tree-sitter-yuck) (maintained by @Philipp-M, @amaanq)
+- [x] [zig](https://github.com/maxxnino/tree-sitter-zig) (maintained by @maxxnino)
+<!--parserinfo-->
+
+For related information on the supported languages, including related plugins, see [this wiki page](https://github.com/nvim-treesitter/nvim-treesitter/wiki/Supported-Languages-Information).
+
+# Available modules
+
+Modules provide the top-level features of `nvim-treesitter`.
+The following is a list of modules included in `nvim-treesitter` and their configuration via `init.lua` (where multiple modules can be combined in a single call to `setup`).
+Note that not all modules work for all languages (depending on the queries available for them).
+Additional modules can be provided as [external plugins](https://github.com/nvim-treesitter/nvim-treesitter/wiki/Extra-modules-and-plugins).
+
+#### Highlight
+
+Consistent syntax highlighting.
+
+```lua
+require'nvim-treesitter.configs'.setup {
+  highlight = {
+    enable = true,
+    -- Setting this to true will run `:h syntax` and tree-sitter at the same time.
+    -- Set this to `true` if you depend on 'syntax' being enabled (like for indentation).
+    -- Using this option may slow down your editor, and you may see some duplicate highlights.
+    -- Instead of true it can also be a list of languages
+    additional_vim_regex_highlighting = false,
+  },
+}
+```
+
+To customize the syntax highlighting of a capture, simply define or link a highlight group of the same name:
+
+```lua
+-- Highlight the @foo.bar capture group with the "Identifier" highlight group
+vim.api.nvim_set_hl(0, "@foo.bar", { link = "Identifier" })
+```
+
+For a language-specific highlight, append the name of the language:
+
+```lua
+-- Highlight @foo.bar as "Identifier" only in Lua files
+vim.api.nvim_set_hl(0, "@foo.bar.lua", { link = "Identifier" })
+```
+
+See `:h treesitter-highlight-groups` for details.
+
+#### Incremental selection
+
+Incremental selection based on the named nodes from the grammar.
+
+```lua
+require'nvim-treesitter.configs'.setup {
+  incremental_selection = {
+    enable = true,
+    keymaps = {
+      init_selection = "gnn", -- set to `false` to disable one of the mappings
+      node_incremental = "grn",
+      scope_incremental = "grc",
+      node_decremental = "grm",
+    },
+  },
+}
+```
+
+#### Indentation
+
+Indentation based on treesitter for the `=` operator.
+**NOTE: This is an experimental feature**.
+
+```lua
+require'nvim-treesitter.configs'.setup {
+  indent = {
+    enable = true
+  }
+}
+```
+
+#### Folding
+
+Tree-sitter based folding. _(Technically not a module because it's per windows and not per buffer.)_
+
+```vim
+set foldmethod=expr
+set foldexpr=nvim_treesitter#foldexpr()
+set nofoldenable                     " Disable folding at startup.
+```
+
+This will respect your `foldminlines` and `foldnestmax` settings.
+
+# Advanced setup
+
+## Changing the parser install directory
+
+If you want to install the parsers to a custom directory you can specify this
+directory with `parser_install_dir` option in that is passed to `setup`.
+`nvim-treesitter` will then install the parser files into this directory.
+
+This directory must be writeable and must be explicitly added to the
+`runtimepath`. For example:
+
+```lua
+  vim.opt.runtimepath:append("/some/path/to/store/parsers")
+
+  require'nvim-treesitter.configs'.setup {
+    parser_install_dir = "/some/path/to/store/parsers",
+
+    ...
+
+  }
+```
+
+If this option is not included in the setup options, or is explicitly set to
+`nil` then the default install directories will be used. If this value is set
+the default directories will be ignored.
+
+Bear in mind that any parser installed into a parser folder on the runtime path
+will still be considered installed. (For example if
+"~/.local/share/nvim/site/parser/c.so" exists then the "c" parser will be
+considered installed, even though it is not in `parser_install_dir`)
+
+The default paths are:
+
+1. first the package folder. Where `nvim-treesitter` is installed.
+2. second the site directory. This is the "site" subdirectory of `stdpath("data")`.
+
+## Adding parsers
+
+If you have a parser that is not on the list of supported languages (either as a repository on Github or in a local directory), you can add it manually for use by `nvim-treesitter` as follows:
+
+1. Clone the repository or [create a new project](https://tree-sitter.github.io/tree-sitter/creating-parsers#project-setup) in, say, `~/projects/tree-sitter-zimbu`. Make sure that the `tree-sitter-cli` executable is installed and in your path; see <https://tree-sitter.github.io/tree-sitter/creating-parsers#installation> for installation instructions.
+2. Run `tree-sitter generate` in this directory (followed by `tree-sitter test` for good measure).
+3. Add the following snippet to your `init.lua`:
+
+```lua
+local parser_config = require "nvim-treesitter.parsers".get_parser_configs()
+parser_config.zimbu = {
+  install_info = {
+    url = "~/projects/tree-sitter-zimbu", -- local path or git repo
+    files = {"src/parser.c"}, -- note that some parsers also require src/scanner.c or src/scanner.cc
+    -- optional entries:
+    branch = "main", -- default branch in case of git repo if different from master
+    generate_requires_npm = false, -- if stand-alone parser without npm dependencies
+    requires_generate_from_grammar = false, -- if folder contains pre-generated src/parser.c
+  },
+  filetype = "zu", -- if filetype does not match the parser name
+}
+```
+
+If you wish to set a specific parser for a filetype, you should use `vim.treesitter.language.register()`:
+
+```lua
+vim.treesitter.language.register('python', 'someft')  -- the someft filetype will use the python parser and queries.
+```
+
+Note this requires Nvim v0.9.
+
+4. Start `nvim` and `:TSInstall zimbu`.
+
+You can also skip step 2 and use `:TSInstallFromGrammar zimbu` to install directly from a `grammar.js` in the top-level directory specified by `url`.
+Once the parser is installed, you can update it (from the latest revision of the `main` branch if `url` is a Github repository) with `:TSUpdate zimbu`.
+
+Note that neither `:TSInstall` nor `:TSInstallFromGrammar` copy query files from the grammar repository.
+If you want your installed grammar to be useful, you must manually [add query files](#adding-queries) to your local nvim-treesitter installation.
+Note also that module functionality is only triggered if your language's filetype is correctly identified.
+If Neovim does not detect your language's filetype by default, you can use [Neovim's `vim.filetype.add()`](<https://neovim.io/doc/user/lua.html#vim.filetype.add()>) to add a custom detection rule.
+
+If you use a git repository for your parser and want to use a specific version, you can set the `revision` key
+in the `install_info` table for you parser config.
+
+## Adding queries
+
+Queries are what `nvim-treesitter` uses to extract information from the syntax tree;
+they are located in the `queries/{language}/*` runtime directories (see `:h rtp`),
+like the `queries` folder of this plugin, e.g. `queries/{language}/{locals,highlights,textobjects}.scm`.
+Other modules may require additional queries such as `folding.scm`. You can find a
+list of all supported capture names in [CONTRIBUTING.md](https://github.com/nvim-treesitter/nvim-treesitter/blob/master/CONTRIBUTING.md#parser-configurations).
+
+All queries found in the runtime directories will be combined.
+By convention, if you want to write a query, use the `queries/` directory,
+but if you want to extend a query use the `after/queries/` directory.
+
+If you want to completely override a query, you can use `:h set_query()`.
+For example, to override the `injections` queries from `c` with your own:
+
+```lua
+require("vim.treesitter.query").set_query("c", "injections", "(comment) @comment")
+```
+
+Note: when using `set_query`, all queries in the runtime directories will be ignored.
+
+## Adding modules
+
+If you wish you write your own module, you need to support
+
+- tree-sitter language detection support;
+- attaching and detaching to buffers;
+- all nvim-treesitter commands.
+
+At the top level, you can use the `define_modules` function to define one or more modules or module groups:
+
+```lua
+require'nvim-treesitter'.define_modules {
+  my_cool_plugin = {
+    attach = function(bufnr, lang)
+      -- Do cool stuff here
+    end,
+    detach = function(bufnr)
+      -- Undo cool stuff here
+    end,
+    is_supported = function(lang)
+      -- Check if the language is supported
+    end
+  }
+}
+```
+
+with the following properties:
+
+- `module_path` specifies a require path (string) that exports a module with an `attach` and `detach` function. This is not required if the functions are on this definition.
+- `enable` determines if the module is enabled by default. This is usually overridden by the user.
+- `disable` takes a list of languages that this module is disabled for. This is usually overridden by the user.
+- `is_supported` takes a function that takes a language and determines if this module supports that language.
+- `attach` takes a function that attaches to a buffer. This is required if `module_path` is not provided.
+- `detach` takes a function that detaches from a buffer. This is required if `module_path` is not provided.
+
+# Extra features
+
+### Statusline indicator
+
+```vim
+echo nvim_treesitter#statusline(90)  " 90 can be any length
+module->expression_statement->call->identifier
+```
+
+### Utilities
+
+You can get some utility functions with
+
+```lua
+local ts_utils = require 'nvim-treesitter.ts_utils'
+```
+
+Check [`:h nvim-treesitter-utils`](doc/nvim-treesitter.txt) for more information.
+
+# Troubleshooting
+
+Before doing anything, make sure you have the latest version of this plugin and run `:checkhealth nvim-treesitter`.
+It can also help to update the parsers via `:TSUpdate`.
+
+#### Feature `X` does not work for `{language}`...
+
+First, check the `health#nvim_treesitter#check` and the `health#treesitter#check` sections of `:checkhealth` for any warning.
+If there is one, it's highly likely that this is the cause of the problem.
+
+Next check the `## Parser/Features` subsection of the `health#nvim_treesitter#check` section of `:checkhealth` to ensure the desired module is enabled for your language.
+If not, you might be missing query files; see [Adding queries](#adding-queries).
+
+Finally, ensure Neovim is correctly identifying your language's filetype using the `:echo &filetype` command while one of your language's files is open in Neovim.
+If not, add a short Vimscript file to nvim-treesitter's `ftdetect` runtime directory following [Neovim's documentation](https://neovim.io/doc/user/filetype.html#new-filetype) on filetype detection.
+You can also quickly & temporarily set the filetype for a single buffer with the `:set filetype=langname` command to test whether it fixes the problem.
+
+If everything is okay, then it might be an actual error.
+In that case, feel free to [open an issue here](https://github.com/nvim-treesitter/nvim-treesitter/issues/new/choose).
+
+#### I get `module 'vim.treesitter.query' not found`
+
+Make sure you have the latest version of Neovim.
+
+#### I get `Error detected while processing .../plugin/nvim-treesitter.vim` every time I open Neovim
+
+This is probably due to a change in a parser's grammar or its queries.
+Try updating the parser that you suspect has changed (`:TSUpdate {language}`) or all of them (`:TSUpdate`).
+If the error persists after updating all parsers,
+please [open an issue](https://github.com/nvim-treesitter/nvim-treesitter/issues/new/choose).
+
+#### I get `query error: invalid node type at position`
+
+This could be due a query file outside this plugin using outdated nodes,
+or due to an outdated parser.
+
+- Make sure you have the parsers up to date with `:TSUpdate`
+- Make sure you don't have more than one `parser` runtime directory.
+  You can execute this command `:echo nvim_get_runtime_file('parser', v:true)` to find all runtime directories.
+  If you get more than one path, remove the ones that are outside this plugin (`nvim-treesitter` directory),
+  so the correct version of the parser is used.
+
+#### I experience weird highlighting issues similar to [#78](https://github.com/nvim-treesitter/nvim-treesitter/issues/78)
+
+This is a well known issue, which arises when the tree and the buffer have gotten out of sync.
+As this is an upstream issue, we don't have any definite fix.
+To get around this, you can force reparsing the buffer with
+
+```vim
+:write | edit | TSBufEnable highlight
+```
+
+This will save, restore and enable highlighting for the current buffer.
+
+#### I experience bugs when using `nvim-treesitter`'s `foldexpr` similar to [#194](https://github.com/nvim-treesitter/nvim-treesitter/issues/194)
+
+This might happen, and is known to happen, with `vim-clap`.
+To avoid these kind of errors, please use `setlocal` instead of `set` for the respective filetypes.
+
+#### I run into errors like `module 'nvim-treesitter.configs' not found` at startup
+
+This is because of `rtp` management in `nvim`, adding `packadd
+nvim-treesitter` should fix the issue.
+
+#### I want to use Git instead of curl for downloading the parsers
+
+In your Lua config:
+
+```lua
+require("nvim-treesitter.install").prefer_git = true
+```
+
+#### I want to use a HTTP proxy for downloading the parsers
+
+You can either configure curl to use additional CLI arguments in your Lua config:
+
+```lua
+require("nvim-treesitter.install").command_extra_args = {
+    curl = { "--proxy", "<proxy url>" },
+}
+```
+
+or you can configure git via `.gitconfig` and use git instead of curl
+
+```lua
+require("nvim-treesitter.install").prefer_git = true
+```
+
+#### I want to use a mirror instead of "https://github.com/"
+
+In your Lua config:
+
+```lua
+for _, config in pairs(require("nvim-treesitter.parsers").get_parser_configs()) do
+  config.install_info.url = config.install_info.url:gsub("https://github.com/", "something else")
+end
+
+require'nvim-treesitter.configs'.setup {
+    --
+    --
+}
+```

bundle/nvim-treesitter-0.9.1/autoload/nvim_treesitter.vim

@@ -0,0 +1,27 @@
+function! nvim_treesitter#statusline(...) abort
+  return luaeval("require'nvim-treesitter.statusline'.statusline(_A)", get(a:, 1, {}))
+endfunction
+
+function! nvim_treesitter#foldexpr() abort
+	return luaeval(printf('require"nvim-treesitter.fold".get_fold_indic(%d)', v:lnum))
+endfunction
+
+function! nvim_treesitter#installable_parsers(arglead, cmdline, cursorpos) abort
+  return join(luaeval("require'nvim-treesitter.parsers'.available_parsers()") + ['all'], "\n")
+endfunction
+
+function! nvim_treesitter#installed_parsers(arglead, cmdline, cursorpos) abort
+  return join(luaeval("require'nvim-treesitter.info'.installed_parsers()") + ['all'], "\n")
+endfunction
+
+function! nvim_treesitter#available_modules(arglead, cmdline, cursorpos) abort
+  return join(luaeval("require'nvim-treesitter.configs'.available_modules()"), "\n")
+endfunction
+
+function! nvim_treesitter#available_query_groups(arglead, cmdline, cursorpos) abort
+  return join(luaeval("require'nvim-treesitter.query'.available_query_groups()"), "\n")
+endfunction
+
+function! nvim_treesitter#indent() abort
+	return luaeval(printf('require"nvim-treesitter.indent".get_indent(%d)', v:lnum))
+endfunction

bundle/nvim-treesitter-0.9.1/doc/nvim-treesitter.txt

@@ -0,0 +1,590 @@
+*nvim-treesitter*  Treesitter configurations and abstraction layer for Neovim.
+
+Minimum version of neovim: nightly
+
+Authors:
+  Kiyan Yazdani <yazdani.kiyan@protonmail.com>
+  Thomas Vigouroux <tomvig38@gmail.com>
+  Stephan Seitz <stephan.seitz@fau.de>
+  Steven Sojka <Steven.Sojka@tdameritrade.com>
+  Santos Gallegos <stsewd@protonmail.com>
+  https://github.com/nvim-treesitter/nvim-treesitter/graphs/contributors
+
+                                       Type |gO| to see the table of contents.
+
+==============================================================================
+INTRODUCTION                                           *nvim-treesitter-intro*
+
+nvim-treesitter wraps the Neovim treesitter API to provide functionalities
+such as highlighting and incremental selection, and a command to easily
+install parsers.
+
+==============================================================================
+QUICK START                                       *nvim-treesitter-quickstart*
+
+Install the parser for your language
+
+>
+  :TSInstall {language}
+<
+
+To get a list of supported languages
+
+>
+  :TSInstallInfo
+<
+
+By default, everything is disabled.
+To enable supported features, put this in your `init.lua` file:
+
+>
+  require'nvim-treesitter.configs'.setup {
+    -- A directory to install the parsers into.
+    -- If this is excluded or nil parsers are installed
+    -- to either the package dir, or the "site" dir.
+    -- If a custom path is used (not nil) it must be added to the runtimepath.
+    parser_install_dir = "/some/path/to/store/parsers",
+
+    -- A list of parser names, or "all"
+    ensure_installed = { "c", "lua", "rust" },
+
+    -- Install parsers synchronously (only applied to `ensure_installed`)
+    sync_install = false,
+
+    -- Automatically install missing parsers when entering buffer
+    auto_install = false,
+
+    -- List of parsers to ignore installing (for "all")
+    ignore_install = { "javascript" },
+
+    highlight = {
+      -- `false` will disable the whole extension
+      enable = true,
+
+      -- list of language that will be disabled
+      disable = { "c", "rust" },
+
+      -- Setting this to true will run `:h syntax` and tree-sitter at the same time.
+      -- Set this to `true` if you depend on 'syntax' being enabled (like for indentation).
+      -- Using this option may slow down your editor, and you may see some duplicate highlights.
+      -- Instead of true it can also be a list of languages
+      additional_vim_regex_highlighting = false,
+    },
+  }
+  vim.opt.runtimepath:append("/some/path/to/store/parsers")
+<
+
+See |nvim-treesitter-modules| for a list of all available modules and its options.
+
+==============================================================================
+MODULES                                              *nvim-treesitter-modules*
+
+|nvim-treesitter| provides several functionalities via modules (and submodules),
+each module makes use of the query files defined for each language,
+
+All modules are disabled by default, and some provide default keymaps.
+Each module corresponds to an entry in the dictionary passed to the
+`nvim-treesitter.configs.setup` function, this should be in your `init.lua` file.
+
+>
+  require'nvim-treesitter.configs'.setup {
+    -- Modules and its options go here
+    highlight = { enable = true },
+    incremental_selection = { enable = true },
+    textobjects = { enable = true },
+  }
+<
+
+All modules share some common options, like `enable` and `disable`.
+When `enable` is `true` this will enable the module for all supported languages,
+if you want to disable the module for some languages you can pass a list to the `disable` option.
+
+>
+  require'nvim-treesitter.configs'.setup {
+    highlight = {
+      enable = true,
+      disable = { "cpp", "lua" },
+    },
+  }
+<
+
+For more fine-grained control, `disable` can also take a function and
+whenever it returns `true`, the module is disabled for that buffer.
+The function is called once when a module starts in a buffer and receives the
+language and buffer number as arguments:
+
+>
+  require'nvim-treesitter.configs'.setup {
+    highlight = {
+      enable = true,
+      disable = function(lang, bufnr) -- Disable in large C++ buffers
+        return lang == "cpp" and vim.api.nvim_buf_line_count(bufnr) > 50000
+      end,
+    },
+  }
+<
+
+Options that define or accept a keymap use the same format you use to define
+keymaps in Neovim, so you can write keymaps as  `gd`, `<space>a`, `<leader>a`
+`<C-a>` (control + a), `<A-n>` (alt + n), `<CR>` (enter), etc.
+
+External plugins can provide their own modules with their own options,
+those can also be configured using the `nvim-treesitter.configs.setup`
+function.
+
+------------------------------------------------------------------------------
+HIGHLIGHT                                      *nvim-treesitter-highlight-mod*
+
+Consistent syntax highlighting.
+
+Query files: `highlights.scm`.
+Supported options:
+
+- enable: `true` or `false`.
+- disable: list of languages.
+- additional_vim_regex_highlighting: `true` or `false`, or a list of languages.
+  Set this to `true` if you depend on 'syntax' being enabled
+  (like for indentation). Using this option may slow down your editor,
+  and you may see some duplicate highlights.
+  Defaults to `false`.
+
+>
+  require'nvim-treesitter.configs'.setup {
+    highlight = {
+      enable = true,
+      custom_captures = {
+        -- Highlight the @foo.bar capture group with the "Identifier" highlight group.
+        ["foo.bar"] = "Identifier",
+      },
+      -- Setting this to true or a list of languages will run `:h syntax` and tree-sitter at the same time.
+      additional_vim_regex_highlighting = false,
+    },
+  }
+<
+
+You can also set custom highlight captures
+>
+  lua <<EOF
+    require"nvim-treesitter.highlight".set_custom_captures {
+      -- Highlight the @foo.bar capture group with the "Identifier" highlight group.
+      ["foo.bar"] = "Identifier",
+    }
+  EOF
+<
+Note: The api is not stable yet.
+
+------------------------------------------------------------------------------
+INCREMENTAL SELECTION              *nvim-treesitter-incremental-selection-mod*
+
+Incremental selection based on the named nodes from the grammar.
+
+Query files: `locals.scm`.
+Supported options:
+- enable: `true` or `false`.
+- disable: list of languages.
+- keymaps:
+  - init_selection: in normal mode, start incremental selection.
+    Defaults to `gnn`.
+  - node_incremental: in visual mode, increment to the upper named parent.
+    Defaults to `grn`.
+  - scope_incremental: in visual mode, increment to the upper scope
+    (as defined in `locals.scm`). Defaults to `grc`.
+  - node_decremental: in visual mode, decrement to the previous named node.
+    Defaults to `grm`.
+
+>
+  require'nvim-treesitter.configs'.setup {
+    incremental_selection = {
+      enable = true,
+      keymaps = {
+        init_selection = "gnn",
+        node_incremental = "grn",
+        scope_incremental = "grc",
+        node_decremental = "grm",
+      },
+    },
+  }
+<
+
+------------------------------------------------------------------------------
+INDENTATION                                  *nvim-treesitter-indentation-mod*
+
+Indentation based on treesitter for the |=| operator.
+NOTE: this is an experimental feature.
+
+Query files: `indents.scm`.
+Supported options:
+- enable: `true` or `false`.
+- disable: list of languages.
+>
+  require'nvim-treesitter.configs'.setup {
+    indent = {
+      enable = true
+    },
+  }
+
+`@indent`				    *nvim-treesitter-indentation-queries*
+Queries can use the following captures: `@indent.begin` and `@indent.dedent`,
+`@indent.branch`, `@indent.end` or `@indent.align`. An `@indent.ignore` capture tells
+treesitter to ignore indentation and a `@indent.zero` capture sets
+the indentation to 0.
+
+`@indent.begin`			    *nvim-treesitter-indentation-indent.begin*
+The `@indent.begin` specifies that the next line should be indented.  Multiple
+indents on the same line get collapsed. Eg.
+
+>
+  (
+   (if_statement)
+   (ERROR "else") @indent.begin
+  )
+<
+Indent can also have `indent.immediate` set using a `#set!` directive, which
+permits the next line to indent even when the block intended to be indented
+has no content yet, improving interactive typing.
+
+eg for python:
+>
+ ((if_statement) @indent.begin
+   (#set! indent.immediate 1))
+<
+
+Will allow:
+>
+  if True:<CR>
+      # Auto indent to here
+
+`@indent.end`				*nvim-treesitter-indentation-indent.end*
+An `@indent.end` capture is used to specify that the indented region ends and
+any text subsequent to the capture should be dedented.  
+
+`@indent.branch`		    *nvim-treesitter-indentation-indent.branch*
+An `@indent.branch` capture is used to specify that a dedented region starts
+at the line including the captured nodes.
+
+`@indent.dedent`		    *nvim-treesitter-indentation-indent.dedent*
+A `@indent.dedent` capture specifies dedenting starting on the next line.
+>
+`@indent.align`		    *nvim-treesitter-indentation-aligned_indent.align*
+Aligned indent blocks may be specified with the `@indent.align` capture.
+This permits
+
+>
+  foo(a,
+      b,
+      c)
+<
+As well as
+>
+  foo(
+    a,
+    b,
+    c)
+<
+and finally
+>
+  foo(
+    a,
+    b,
+    c
+  )
+<
+To specify the delimiters to use `indent.open_delimiter` and
+`indent.close_delimiter` should be used.  Eg.
+>
+ ((argument_list) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+<
+
+For some languages the last line of an `indent.align` block must not be
+the same indent as the natural next line.
+
+For example in python:
+
+>
+  if (a > b and
+      c < d):
+      pass
+
+Is not correct, whereas
+>
+  if (a > b and
+	c < d):
+      pass
+
+Would be correctly indented.  This behavior may be chosen using
+`indent.avoid_last_matching_next`.  Eg.
+
+>
+ (if_statement
+  condition: (parenthesized_expression) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")")
+  (#set! indent.avoid_last_matching_next 1)
+ )
+<
+Could be used to specify that the last line of an `@indent.align` capture
+should be additionally indented to avoid clashing with the indent of the first
+line of the block inside an if.
+
+==============================================================================
+COMMANDS                                            *nvim-treesitter-commands*
+
+								  *:TSInstall*
+:TSInstall {language} ...~
+
+Install one or more treesitter parsers.
+You can use |:TSInstall| `all` to install all parsers. Use |:TSInstall!| to
+force the reinstallation of already installed parsers.
+							      *:TSInstallSync*
+:TSInstallSync {language} ...~
+
+Perform the |:TSInstall| operation synchronously.
+
+							      *:TSInstallInfo*
+:TSInstallInfo~
+
+List information about currently installed parsers
+
+								   *:TSUpdate*
+:TSUpdate {language} ...~
+
+Update the installed parser for one more {language} or all installed parsers
+if {language} is omitted. The specified parser is installed if it is not already
+installed.
+
+							       *:TSUpdateSync*
+:TSUpdateSync {language} ...~
+
+Perform the |:TSUpdate| operation synchronously.
+
+								*:TSUninstall*
+:TSUninstall {language} ...~
+
+Deletes the parser for one or more {language}. You can use 'all' for language
+to uninstall all parsers.
+
+								*:TSBufEnable*
+:TSBufEnable {module}~
+
+Enable {module} on the current buffer.
+A list of modules can be found at |:TSModuleInfo|
+
+							       *:TSBufDisable*
+:TSBufDisable {module}~
+
+Disable {module} on the current buffer.
+A list of modules can be found at |:TSModuleInfo|
+
+								*:TSBufToggle*
+:TSBufToggle {module}~
+
+Toggle (enable if disabled, disable if enabled) {module} on the current
+buffer.
+A list of modules can be found at |:TSModuleInfo|
+
+								*:TSEnable*
+:TSEnable {module} [{language}]~
+
+Enable {module} for the session.
+If {language} is specified, enable module for the session only for this
+particular language.
+A list of modules can be found at |:TSModuleInfo|
+A list of languages can be found at |:TSInstallInfo|
+
+							       *:TSDisable*
+:TSDisable {module} [{language}]~
+
+Disable {module} for the session.
+If {language} is specified, disable module for the session only for this
+particular language.
+A list of modules can be found at |:TSModuleInfo|
+A list of languages can be found at |:TSInstallInfo|
+
+								*:TSToggle*
+:TSToggle {module} [{language}]~
+
+Toggle (enable if disabled, disable if enabled) {module} for the session.
+If {language} is specified, toggle module for the session only for this
+particular language.
+A list of modules can be found at |:TSModuleInfo|
+A list of languages can be found at |:TSInstallInfo|
+
+							       *:TSModuleInfo*
+:TSModuleInfo [{module}]~
+
+List the state for the given module or all modules for the current session in
+a new buffer.
+
+These highlight groups are used by default:
+>
+    highlight default TSModuleInfoGood guifg=LightGreen gui=bold
+    highlight default TSModuleInfoBad  guifg=Crimson
+    highlight default link TSModuleInfoHeader    Type
+    highlight default link TSModuleInfoNamespace Statement
+    highlight default link TSModuleInfoParser    Identifier
+<
+
+								*:TSEditQuery*
+:TSEditQuery {query-group} [{lang}]~
+
+Edit the query file for a {query-group} (e.g. highlights, locals) for given
+{lang}. If there are multiple files, the user is prompted to select one of them.
+If no such file exists, a buffer for a new file in the user's config directory
+is created. If {lang} is not specified, the language of the current buffer
+is used.
+
+						       *:TSEditQueryUserAfter*
+:TSEditQueryUserAfter {query-group} [{lang}]~
+
+Same as |:TSEditQuery| but edits a file in the `after` directory of the
+user's config directory. Useful to add custom extensions for the queries
+provided by a plugin.
+
+==============================================================================
+UTILS                                                  *nvim-treesitter-utils*
+
+Nvim treesitter has some wrapper functions that you can retrieve with:
+>
+    local ts_utils = require 'nvim-treesitter.ts_utils'
+<
+Methods
+						 *ts_utils.get_node_at_cursor*
+get_node_at_cursor(winnr)~
+
+`winnr` will be 0 if nil.
+Returns the node under the cursor.
+
+							  *ts_utils.is_parent*
+is_parent(dest, source)~
+
+Determines whether `dest` is a parent of `source`.
+Returns a boolean.
+
+						 *ts_utils.get_named_children*
+get_named_children(node)~
+
+Returns a table of named children of `node`.
+
+						      *ts_utils.get_next_node*
+get_next_node(node, allow_switch_parent, allow_next_parent)~
+
+Returns the next node within the same parent.
+If no node is found, returns `nil`.
+If `allow_switch_parent` is true, it will allow switching parent
+when the node is the last node.
+If `allow_next_parent` is true, it will allow next parent if
+the node is the last node and the next parent doesn't have children.
+
+						  *ts_utils.get_previous_node*
+get_previous_node(node, allow_switch_parents, allow_prev_parent)~
+
+Returns the previous node within the same parent.
+`allow_switch_parent` and `allow_prev_parent` follow the same rule
+as |ts_utils.get_next_node| but if the node is the first node.
+
+							  *ts_utils.goto_node*
+goto_node(node, goto_end, avoid_set_jump)~
+
+Sets cursor to the position of `node` in the current windows.
+If `goto_end` is truthy, the cursor is set to the end the node range.
+Setting `avoid_set_jump` to `true`, avoids setting the current cursor position
+to the jump list.
+
+							 *ts_utils.swap_nodes*
+swap_nodes(node_or_range1, node_or_range2, bufnr, cursor_to_second)~
+
+Swaps the nodes or ranges.
+set `cursor_to_second`  to true to move the cursor to the second node
+
+						*ts_utils.memoize_by_buf_tick*
+memoize_by_buf_tick(fn, options)~
+
+Caches the return value for a function and returns the cache value if the tick
+of the buffer has not changed from the previous.
+
+		`fn`: a function that takes any arguments
+		and returns a value to store.
+		`options?`: <table>
+                 - `bufnr`: a function/value that extracts the bufnr from the given arguments.
+                 - `key`: a function/value that extracts the cache key from the given arguments.
+		`returns`: a function to call with bufnr as argument to
+		retrieve the value from the cache
+
+						  *ts_utils.node_to_lsp_range*
+node_to_lsp_range(node)~
+
+Get an lsp formatted range from a node range
+
+							*ts_utils.node_length*
+node_length(node)~
+
+Get the byte length of node range
+
+						   *ts_utils.update_selection*
+update_selection(buf, node)~
+
+Set the selection to the node range
+
+						    *ts_utils.highlight_range*
+highlight_range(range, buf, hl_namespace, hl_group)~
+
+Set a highlight that spans the given range
+
+						     *ts_utils.highlight_node*
+highlight_node(node, buf, hl_namespace, hl_group)~
+
+Set a highlight that spans the given node's range
+
+==============================================================================
+FUNCTIONS                                          *nvim-treesitter-functions*
+
+						*nvim_treesitter#statusline()*
+nvim_treesitter#statusline(opts)~
+
+Returns a string describing the current position in the file. This
+could be used as a statusline indicator.
+Default options (lua syntax):
+>
+  {
+    indicator_size = 100,
+    type_patterns = {'class', 'function', 'method'},
+    transform_fn = function(line, _node) return line:gsub('%s*[%[%(%{]*%s*$', '') end,
+    separator = ' -> ',
+    allow_duplicates = false
+  }
+<
+- `indicator_size` - How long should the string be. If longer, it is cut from
+  the beginning.
+- `type_patterns` - Which node type patterns to match.
+- `transform_fn` - Function used to transform the single item in line. By
+  default it removes opening brackets and spaces from end. Takes two arguments:
+  the text of the line in question, and the corresponding treesitter node.
+- `separator` - Separator between nodes.
+- `allow_duplicates` - Whether or not to remove duplicate components.
+
+						  *nvim_treesitter#foldexpr()*
+nvim_treesitter#foldexpr()~
+
+Functions to be used to determine the fold level at a given line number.
+To use it: >
+  set foldmethod=expr
+  set foldexpr=nvim_treesitter#foldexpr()
+<
+
+This will respect your 'foldminlines' and 'foldnestmax' settings.
+
+Note: This is highly experimental, and folding can break on some types of
+      edits. If you encounter such breakage, hitting `zx` should fix folding.
+      In any case, feel free to open an issue with the reproducing steps.
+
+==============================================================================
+PERFORMANCE                                      *nvim-treesitter-performance*
+
+`nvim-treesitter` checks the 'runtimepath' on startup in order to discover
+available parsers and queries and index them. As a consequence, a very long
+'runtimepath' might result in delayed startup times.
+
+
+vim:tw=78:ts=8:expandtab:noet:ft=help:norl:

bundle/nvim-treesitter-0.9.1/lockfile.json

@@ -0,0 +1,608 @@
+{
+  "ada": {
+    "revision": "ba7951a8f3fb08f9ea923625153e7670c89f30b4"
+  },
+  "agda": {
+    "revision": "80ea622cf952a0059e168e5c92a798b2f1925652"
+  },
+  "arduino": {
+    "revision": "d988e6a803203cc2bbfd2a8a84edffc73d2922b4"
+  },
+  "astro": {
+    "revision": "e122a8fcd07e808a7b873bfadc2667834067daf1"
+  },
+  "awk": {
+    "revision": "244426241376b08d9531616290d657106ec8f7ff"
+  },
+  "bash": {
+    "revision": "1b0321ee85701d5036c334a6f04761cdc672e64c"
+  },
+  "bass": {
+    "revision": "27f110dfe79620993f5493ffa0d0f2fe12d250ed"
+  },
+  "beancount": {
+    "revision": "358e5ecbb87109eef7fd596ea518a4ff74cb9b31"
+  },
+  "bibtex": {
+    "revision": "ccfd77db0ed799b6c22c214fe9d2937f47bc8b34"
+  },
+  "bicep": {
+    "revision": "3604d8c961ab129d2bfc6dfca56419c236ccdb83"
+  },
+  "blueprint": {
+    "revision": "7f1a5df44861291d6951b6b2146a9fef4c226e14"
+  },
+  "c": {
+    "revision": "93ef1785bbf854cf964e6e53d6e1e6885a4d8ebc"
+  },
+  "c_sharp": {
+    "revision": "1648e21b4f087963abf0101ee5221bb413107b07"
+  },
+  "cairo": {
+    "revision": "6216c6ee5e9fc0649c4bd7b1aedd884a55bdd9ef"
+  },
+  "capnp": {
+    "revision": "dc28c9f4212809eab74d10996086297853eb34e5"
+  },
+  "chatito": {
+    "revision": "c80c219da2086696202cec8fc2501c02f4819a3f"
+  },
+  "clojure": {
+    "revision": "6e41628e9d18b19caea1cb1d72aae4ccff5bdfe9"
+  },
+  "cmake": {
+    "revision": "3dfc596025431b21e839d392c171f6f97c2a4258"
+  },
+  "comment": {
+    "revision": "c9a7e2df7cac2dfb730f766a4f343308f84ff346"
+  },
+  "commonlisp": {
+    "revision": "338db38330f0d25cba8e2c6428240ebc5e020264"
+  },
+  "cooklang": {
+    "revision": "5e113412aadb78955c27010daa4dbe1d202013cf"
+  },
+  "corn": {
+    "revision": "604d73c38d4c28ca68e9e441ffd405d68cb63051"
+  },
+  "cpon": {
+    "revision": "f4b3cbc8b0bd4e13035d39940fef09f1392e8739"
+  },
+  "cpp": {
+    "revision": "77cecd88d28032bf4f54fd4ee68efb53a6c8c9a5"
+  },
+  "css": {
+    "revision": "5f2c94b897601b4029fedcce7db4c6d76ce8a128"
+  },
+  "cuda": {
+    "revision": "d4285d0396a409c91bcd5a7fd362cf13cc6f8600"
+  },
+  "cue": {
+    "revision": "0deecf48944aa54bb73e5383ba8acfbf9f2c44b4"
+  },
+  "d": {
+    "revision": "c2fbf21bd3aa45495fe13247e040ad5815250032"
+  },
+  "dart": {
+    "revision": "e398400a0b785af3cf571f5a57eccab242f0cdf9"
+  },
+  "devicetree": {
+    "revision": "d2cc332aeb814ea40e1e34ed6b9446324b32612a"
+  },
+  "dhall": {
+    "revision": "affb6ee38d629c9296749767ab832d69bb0d9ea8"
+  },
+  "diff": {
+    "revision": "c165725c28e69b36c5799ff0e458713a844f1aaf"
+  },
+  "dockerfile": {
+    "revision": "c0a9d694d9bf8ab79a919f5f9c7bc9c169caf321"
+  },
+  "dot": {
+    "revision": "9ab85550c896d8b294d9b9ca1e30698736f08cea"
+  },
+  "ebnf": {
+    "revision": "8e635b0b723c620774dfb8abf382a7f531894b40"
+  },
+  "eex": {
+    "revision": "f742f2fe327463335e8671a87c0b9b396905d1d1"
+  },
+  "elixir": {
+    "revision": "a2861e88a730287a60c11ea9299c033c7d076e30"
+  },
+  "elm": {
+    "revision": "b075803c445191af3cf7dbfdc84efef5f5bbc0f5"
+  },
+  "elsa": {
+    "revision": "0a66b2b3f3c1915e67ad2ef9f7dbd2a84820d9d7"
+  },
+  "elvish": {
+    "revision": "5e7210d945425b77f82cbaebc5af4dd3e1ad40f5"
+  },
+  "embedded_template": {
+    "revision": "203f7bd3c1bbfbd98fc19add4b8fcb213c059205"
+  },
+  "erlang": {
+    "revision": "7aa24fe8616072fc1a659f72d5b60bd8c01fb5cc"
+  },
+  "fennel": {
+    "revision": "517195970428aacca60891b050aa53eabf4ba78d"
+  },
+  "firrtl": {
+    "revision": "2b5adae629c8cba528c7b1e4aa67a8ae28934ea5"
+  },
+  "fish": {
+    "revision": "f9176908c9eb2e11eb684d79e1d00f3b29bd65c9"
+  },
+  "foam": {
+    "revision": "09e03445f49290450589c5d293610ab39434e3e4"
+  },
+  "fortran": {
+    "revision": "6828cf3629addb1706bdbbd33491e95f12b7042c"
+  },
+  "fsh": {
+    "revision": "fa3347712f7a59ed02ccf508284554689c6cde28"
+  },
+  "func": {
+    "revision": "0834e35ecf8b23fbf9ad15b088af6a897e19d4a8"
+  },
+  "fusion": {
+    "revision": "19db2f47ba4c3a0f6238d4ae0e2abfca16e61dd6"
+  },
+  "gdscript": {
+    "revision": "03f20b94707a21bed90bb95101684bc4036139ce"
+  },
+  "git_config": {
+    "revision": "a01b498b25003d97a5f93b0da0e6f28307454347"
+  },
+  "git_rebase": {
+    "revision": "d8a4207ebbc47bd78bacdf48f883db58283f9fd8"
+  },
+  "gitattributes": {
+    "revision": "2339ffe87a88d0b7838c015592c8269eb0063140"
+  },
+  "gitcommit": {
+    "revision": "6856a5fd0ffeff17d83325a8ce4e57811010eff1"
+  },
+  "gitignore": {
+    "revision": "f4685bf11ac466dd278449bcfe5fd014e94aa504"
+  },
+  "gleam": {
+    "revision": "8302c98ed78128b22f946fadefaf4af5ba5d5850"
+  },
+  "glimmer": {
+    "revision": "d3031a8294bf331600d5046b1d14e690a0d8ba0c"
+  },
+  "glsl": {
+    "revision": "00ffe2099374613d2f313ace4a9dda44370b458b"
+  },
+  "go": {
+    "revision": "bbaa67a180cfe0c943e50c55130918be8efb20bd"
+  },
+  "godot_resource": {
+    "revision": "b6ef0768711086a86b3297056f9ffb5cc1d77b4a"
+  },
+  "gomod": {
+    "revision": "f41a27386f1cfa1271122db5f0ff59b910520007"
+  },
+  "gosum": {
+    "revision": "e2ac513b2240c7ff1069ae33b2df29ce90777c11"
+  },
+  "gowork": {
+    "revision": "949a8a470559543857a62102c84700d291fc984c"
+  },
+  "graphql": {
+    "revision": "5e66e961eee421786bdda8495ed1db045e06b5fe"
+  },
+  "groovy": {
+    "revision": "76e02db5866dd2b096512103ed4d8f630cc32980"
+  },
+  "hack": {
+    "revision": "2887d3927c5fadebfd71c604922d0c59748e9901"
+  },
+  "hare": {
+    "revision": "3d4af179414525a35dd069ba0208c9b71093d8b3"
+  },
+  "haskell": {
+    "revision": "99706824b92f162d4e0f47c7e930bbccb367276e"
+  },
+  "haskell_persistent": {
+    "revision": "58a6ccfd56d9f1de8fb9f77e6c42151f8f0d0f3d"
+  },
+  "hcl": {
+    "revision": "b5539065432c08e4118eb3ee7c94902fdda85708"
+  },
+  "heex": {
+    "revision": "9bf4ae444a8779839ecbca3b6b896dee426b10ae"
+  },
+  "hjson": {
+    "revision": "02fa3b79b3ff9a296066da6277adfc3f26cbc9e0"
+  },
+  "hlsl": {
+    "revision": "95361dde7ad4025fbec5dc4e5cdde0ea8ed64172"
+  },
+  "hocon": {
+    "revision": "c390f10519ae69fdb03b3e5764f5592fb6924bcc"
+  },
+  "hoon": {
+    "revision": "900a272271cc2fb78f24aa7b5a1e21ed36bb1d39"
+  },
+  "html": {
+    "revision": "e5d7d7decbbdec5a4c90bbc69436b3828f5646e7"
+  },
+  "htmldjango": {
+    "revision": "717e83aefd328735beeeb671f3f95b2624e70c57"
+  },
+  "http": {
+    "revision": "6824a247d1326079aab4fa9f9164e9319678081d"
+  },
+  "hurl": {
+    "revision": "0eca909c8338364992e04c4862ac6afc5342cbb8"
+  },
+  "ini": {
+    "revision": "7f11a02fb8891482068e0fe419965d7bade81a68"
+  },
+  "ispc": {
+    "revision": "cc57a931eb782474324910e19ca253aa0d5fe38a"
+  },
+  "janet_simple": {
+    "revision": "bd9cbaf1ea8b942dfd58e68df10c9a378ab3d2b6"
+  },
+  "java": {
+    "revision": "e8d1bc4043c1d2326f7ce3aa7b8833c7b18d0560"
+  },
+  "javascript": {
+    "revision": "f772967f7b7bc7c28f845be2420a38472b16a8ee"
+  },
+  "jq": {
+    "revision": "13990f530e8e6709b7978503da9bc8701d366791"
+  },
+  "jsdoc": {
+    "revision": "189a6a4829beb9cdbe837260653b4a3dfb0cc3db"
+  },
+  "json": {
+    "revision": "ca3f8919800e3c1ad4508de3bfd7b0b860ce434f"
+  },
+  "json5": {
+    "revision": "5dd5cdc418d9659682556b6adca2dd9ace0ac6d2"
+  },
+  "jsonc": {
+    "revision": "02b01653c8a1c198ae7287d566efa86a135b30d5"
+  },
+  "jsonnet": {
+    "revision": "26d9699842a429731844c93cbcb485519bb2c526"
+  },
+  "julia": {
+    "revision": "ab0f70c0a919d38b41822305a8ca80e527c94e4f"
+  },
+  "kdl": {
+    "revision": "e180e05132c4cb229a8ba679b298790ef1eca77c"
+  },
+  "kotlin": {
+    "revision": "06a2f6e71c7fcac34addcbf2a4667adad1b9c5a7"
+  },
+  "lalrpop": {
+    "revision": "b7431e4b64183a5d0d094895a4cd5daf51ed3103"
+  },
+  "latex": {
+    "revision": "2ae2021d7b224fb6aa57b760e0d146059f943bb8"
+  },
+  "ledger": {
+    "revision": "8a841fb20ce683bfbb3469e6ba67f2851cfdf94a"
+  },
+  "llvm": {
+    "revision": "d47c95d78ef0e7495a74d214dd6fcddf6e402dfc"
+  },
+  "lua": {
+    "revision": "7268c1cea5df56ac0c779cd37d6631d4e6f41d4f"
+  },
+  "luadoc": {
+    "revision": "8981072676ec8bd74def6134be4f883655f7c082"
+  },
+  "luap": {
+    "revision": "31461ae9bd0866cb5117cfe5de71189854fd0f3e"
+  },
+  "luau": {
+    "revision": "6953cd4fa5967c9aa3c769b4e4c7e69c904b9fa9"
+  },
+  "m68k": {
+    "revision": "d097b123f19c6eaba2bf181c05420d88b9fc489d"
+  },
+  "make": {
+    "revision": "a4b9187417d6be349ee5fd4b6e77b4172c6827dd"
+  },
+  "markdown": {
+    "revision": "aaf76797aa8ecd9a5e78e0ec3681941de6c945ee"
+  },
+  "markdown_inline": {
+    "revision": "aaf76797aa8ecd9a5e78e0ec3681941de6c945ee"
+  },
+  "matlab": {
+    "revision": "c8723b33970deda54257e640779714fb181d4d5f"
+  },
+  "menhir": {
+    "revision": "be8866a6bcc2b563ab0de895af69daeffa88fe70"
+  },
+  "mermaid": {
+    "revision": "e26a5f8898a8174f02b4cc9a9050eb3ccfb799f3"
+  },
+  "meson": {
+    "revision": "3d6dfbdb2432603bc84ca7dc009bb39ed9a8a7b1"
+  },
+  "mlir": {
+    "revision": "e2053f7c8856d91bc36c87604f697784845cee69"
+  },
+  "nickel": {
+    "revision": "e1d9337864d209898a08c26b8cd4c2dd14c15148"
+  },
+  "ninja": {
+    "revision": "0a95cfdc0745b6ae82f60d3a339b37f19b7b9267"
+  },
+  "nix": {
+    "revision": "66e3e9ce9180ae08fc57372061006ef83f0abde7"
+  },
+  "norg": {
+    "revision": "1a305093569632de50f9a316ff843dcda25b4ef5"
+  },
+  "objc": {
+    "revision": "97e022ec4a908108283bad23d42eee39ad204db6"
+  },
+  "ocaml": {
+    "revision": "694c57718fd85d514f8b81176038e7a4cfabcaaf"
+  },
+  "ocaml_interface": {
+    "revision": "694c57718fd85d514f8b81176038e7a4cfabcaaf"
+  },
+  "ocamllex": {
+    "revision": "4b9898ccbf198602bb0dec9cd67cc1d2c0a4fad2"
+  },
+  "odin": {
+    "revision": "d165dbee27617dab2653e38737d96ede1030d14f"
+  },
+  "org": {
+    "revision": "64cfbc213f5a83da17632c95382a5a0a2f3357c1"
+  },
+  "pascal": {
+    "revision": "9e995404ddff8319631d72d4b46552e737206912"
+  },
+  "passwd": {
+    "revision": "20239395eacdc2e0923a7e5683ad3605aee7b716"
+  },
+  "pem": {
+    "revision": "e01767921df18142055d97407595329d7629e643"
+  },
+  "perl": {
+    "revision": "79e88f64681660f3961939bf764d8f3b4bbb0d27"
+  },
+  "php": {
+    "revision": "d76de26b8218df208949f46b31e0c422020eda3a"
+  },
+  "phpdoc": {
+    "revision": "915a527d5aafa81b31acf67fab31b0ac6b6319c0"
+  },
+  "pioasm": {
+    "revision": "924aadaf5dea2a6074d72027b064f939acf32e20"
+  },
+  "po": {
+    "revision": "d6aed225290bc71a15ab6f06305cb11419360c56"
+  },
+  "poe_filter": {
+    "revision": "d7b43b51f92fb19efe8af45c2246087c611c8f63"
+  },
+  "pony": {
+    "revision": "16f930b250433cfcd4fb4144df92bb98ad344c20"
+  },
+  "prisma": {
+    "revision": "eca2596a355b1a9952b4f80f8f9caed300a272b5"
+  },
+  "promql": {
+    "revision": "ed9a12f6ae4e75d4622adef8fb1b1e4d0ac0a759"
+  },
+  "proto": {
+    "revision": "e9f6b43f6844bd2189b50a422d4e2094313f6aa3"
+  },
+  "prql": {
+    "revision": "09e158cd3650581c0af4c49c2e5b10c4834c8646"
+  },
+  "pug": {
+    "revision": "a7ff31a38908df9b9f34828d21d6ca5e12413e18"
+  },
+  "puppet": {
+    "revision": "9ce9a5f7d64528572aaa8d59459ba869e634086b"
+  },
+  "python": {
+    "revision": "5af00f64af6bbf822f208243cce5cf75396fb6f5"
+  },
+  "ql": {
+    "revision": "bd087020f0d8c183080ca615d38de0ec827aeeaf"
+  },
+  "qmldir": {
+    "revision": "6b2b5e41734bd6f07ea4c36ac20fb6f14061c841"
+  },
+  "qmljs": {
+    "revision": "35ead5b9955cdb29bcf709d622fa960ff33992b6"
+  },
+  "query": {
+    "revision": "3a9808b22742d5bd906ef5d1a562f2f1ae57406d"
+  },
+  "r": {
+    "revision": "c55f8b4dfaa32c80ddef6c0ac0e79b05cb0cbf57"
+  },
+  "racket": {
+    "revision": "7dc4fb60390218b09bc351062eeede7dcdbb4d9f"
+  },
+  "rasi": {
+    "revision": "371dac6bcce0df5566c1cfebde69d90ecbeefd2d"
+  },
+  "regex": {
+    "revision": "2354482d7e2e8f8ff33c1ef6c8aa5690410fbc96"
+  },
+  "rego": {
+    "revision": "b2667c975f07b33be3ceb83bea5cfbad88095866"
+  },
+  "requirements": {
+    "revision": "56ddb4dad2ea0761d20c0995a0de2990caa350b5"
+  },
+  "rnoweb": {
+    "revision": "502c1126dc6777f09af5bef16e72a42f75bd081e"
+  },
+  "robot": {
+    "revision": "5e50f2517580290cd1b9689664815e3b09d986b8"
+  },
+  "ron": {
+    "revision": "ce6086b2c9e8e71065b8129d6c2289c5f66d1879"
+  },
+  "rst": {
+    "revision": "2ca8c123c82ca41f41b66b5d13d403cff0204b78"
+  },
+  "ruby": {
+    "revision": "f257f3f57833d584050336921773738a3fd8ca22"
+  },
+  "rust": {
+    "revision": "0a70e15da977489d954c219af9b50b8a722630ee"
+  },
+  "scala": {
+    "revision": "f14629b4d53f72356ce8f6d4ac8c54d21b4e74dd"
+  },
+  "scfg": {
+    "revision": "6deae0cbb458c849a4d1e2985093e9c9c32d7fd0"
+  },
+  "scheme": {
+    "revision": "af3af6c9356b936f8a515a1e449c32e804c2b1a8"
+  },
+  "scss": {
+    "revision": "c478c6868648eff49eb04a4df90d703dc45b312a"
+  },
+  "slint": {
+    "revision": "00c8a2d3645766f68c0d0460086c0a994e5b0d85"
+  },
+  "smali": {
+    "revision": "72e334b2630f5852825ba5ff9dfd872447175eb5"
+  },
+  "smithy": {
+    "revision": "cf8c7eb9faf7c7049839585eac19c94af231e6a0"
+  },
+  "solidity": {
+    "revision": "168020304759ad5d8b4a88a541a699134e3730c5"
+  },
+  "sparql": {
+    "revision": "05f949d3c1c15e3261473a244d3ce87777374dec"
+  },
+  "sql": {
+    "revision": "3dfa1b1fafac51e3ffc39064eafb26b5111861a2"
+  },
+  "squirrel": {
+    "revision": "e8b5835296f931bcaa1477d3c5a68a0c5c2ba034"
+  },
+  "starlark": {
+    "revision": "504ddd75ecc78fbbce22aa6facd70375d3f8854a"
+  },
+  "supercollider": {
+    "revision": "3b35bd0fded4423c8fb30e9585c7bacbcd0e8095"
+  },
+  "surface": {
+    "revision": "f4586b35ac8548667a9aaa4eae44456c1f43d032"
+  },
+  "svelte": {
+    "revision": "697bb515471871e85ff799ea57a76298a71a9cca"
+  },
+  "swift": {
+    "revision": "29541ac9bbe2090de75d0b1e70360b85bbda1fef"
+  },
+  "sxhkdrc": {
+    "revision": "440d5f913d9465c9c776a1bd92334d32febcf065"
+  },
+  "systemtap": {
+    "revision": "1af543a96d060b1f808982037bfc54cc02218edd"
+  },
+  "t32": {
+    "revision": "6da5e3cbabd376b566d04282005e52ffe67ef74a"
+  },
+  "tablegen": {
+    "revision": "300f6a490e71f895e644ed2deec6920860a2e107"
+  },
+  "teal": {
+    "revision": "33482c92a0dfa694491d34e167a1d2f52b0dccb1"
+  },
+  "terraform": {
+    "revision": "b5539065432c08e4118eb3ee7c94902fdda85708"
+  },
+  "thrift": {
+    "revision": "d4deb1bd9e848f2dbe81103a151d99e8546de480"
+  },
+  "tiger": {
+    "revision": "4a099243ed68a4fc72fdad8ea3ce57ec411ebfe3"
+  },
+  "tlaplus": {
+    "revision": "7ba226cf85280c7917d082940022006e6a3b7b6f"
+  },
+  "todotxt": {
+    "revision": "0207f6a4ab6aeafc4b091914d31d8235049a2578"
+  },
+  "toml": {
+    "revision": "8bd2056818b21860e3d756b5a58c4f6e05fb744e"
+  },
+  "tsx": {
+    "revision": "b1bf4825d9eaa0f3bdeb1e52f099533328acfbdf"
+  },
+  "turtle": {
+    "revision": "085437f5cb117703b7f520dd92161140a684f092"
+  },
+  "twig": {
+    "revision": "779ee5ab1e065dcef7f51f253030dc875445b25f"
+  },
+  "typescript": {
+    "revision": "b1bf4825d9eaa0f3bdeb1e52f099533328acfbdf"
+  },
+  "ungrammar": {
+    "revision": "debd26fed283d80456ebafa33a06957b0c52e451"
+  },
+  "usd": {
+    "revision": "718a6b3e939904e0b4fe7cff6742e96af4781f4b"
+  },
+  "uxntal": {
+    "revision": "4c5ecd6326ebd61f6f9a22a370cbd100e0d601da"
+  },
+  "v": {
+    "revision": "e14fdf6e661b10edccc744102e4ccf0b187aa8ad"
+  },
+  "vala": {
+    "revision": "8f690bfa639f2b83d1fb938ed3dd98a7ba453e8b"
+  },
+  "verilog": {
+    "revision": "902031343056bc0b11f3e47b33f036a9cf59f58d"
+  },
+  "vhs": {
+    "revision": "fec6e981b7795b68262ddf229d73d2aa03a89b9a"
+  },
+  "vim": {
+    "revision": "77e9e96c2ae5cff7343ce3dced263483acf95793"
+  },
+  "vimdoc": {
+    "revision": "c0f85802485afe4d15e65bbf995ae864bb8ed7c4"
+  },
+  "vue": {
+    "revision": "91fe2754796cd8fba5f229505a23fa08f3546c06"
+  },
+  "wgsl": {
+    "revision": "40259f3c77ea856841a4e0c4c807705f3e4a2b65"
+  },
+  "wgsl_bevy": {
+    "revision": "a041228ae64632f59b9bd37346a0dbcb7817f36b"
+  },
+  "wing": {
+    "revision": "9399564d1e32864c6af2d49c0dcd1f76d54443f2"
+  },
+  "yaml": {
+    "revision": "0e36bed171768908f331ff7dff9d956bae016efb"
+  },
+  "yang": {
+    "revision": "2c0e6be8dd4dcb961c345fa35c309ad4f5bd3502"
+  },
+  "yuck": {
+    "revision": "c348825d3f86dec71dee0e1223c6bd73114e3579"
+  },
+  "zig": {
+    "revision": "0d08703e4c3f426ec61695d7617415fff97029bd"
+  }
+}

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter.lua

@@ -0,0 +1,22 @@
+local install = require "nvim-treesitter.install"
+local utils = require "nvim-treesitter.utils"
+local info = require "nvim-treesitter.info"
+local configs = require "nvim-treesitter.configs"
+local statusline = require "nvim-treesitter.statusline"
+
+-- Registers all query predicates
+require "nvim-treesitter.query_predicates"
+
+local M = {}
+
+function M.setup()
+  utils.setup_commands("install", install.commands)
+  utils.setup_commands("info", info.commands)
+  utils.setup_commands("configs", configs.commands)
+  configs.init()
+end
+
+M.define_modules = configs.define_modules
+M.statusline = statusline.statusline
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/caching.lua

@@ -0,0 +1,71 @@
+local api = vim.api
+
+local M = {}
+
+-- Creates a cache table for buffers keyed by a type name.
+-- Cache entries attach to the buffer and cleanup entries
+-- as buffers are detached.
+function M.create_buffer_cache()
+  local cache = {}
+
+  ---@type table<integer, table<string, any>>
+  local items = setmetatable({}, {
+    __index = function(tbl, key)
+      rawset(tbl, key, {})
+      return rawget(tbl, key)
+    end,
+  })
+
+  ---@type table<integer, boolean>
+  local loaded_buffers = {}
+
+  ---@param type_name string
+  ---@param bufnr integer
+  ---@param value any
+  function cache.set(type_name, bufnr, value)
+    if not loaded_buffers[bufnr] then
+      loaded_buffers[bufnr] = true
+      -- Clean up the cache if the buffer is detached
+      -- to avoid memory leaks
+      api.nvim_buf_attach(bufnr, false, {
+        on_detach = function()
+          cache.clear_buffer(bufnr)
+          loaded_buffers[bufnr] = nil
+          return true
+        end,
+        on_reload = function() end, -- this is needed to prevent on_detach being called on buffer reload
+      })
+    end
+
+    items[bufnr][type_name] = value
+  end
+
+  ---@param type_name string
+  ---@param bufnr integer
+  ---@return any
+  function cache.get(type_name, bufnr)
+    return items[bufnr][type_name]
+  end
+
+  ---@param type_name string
+  ---@param bufnr integer
+  ---@return boolean
+  function cache.has(type_name, bufnr)
+    return cache.get(type_name, bufnr) ~= nil
+  end
+
+  ---@param type_name string
+  ---@param bufnr integer
+  function cache.remove(type_name, bufnr)
+    items[bufnr][type_name] = nil
+  end
+
+  ---@param bufnr integer
+  function cache.clear_buffer(bufnr)
+    items[bufnr] = nil
+  end
+
+  return cache
+end
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/compat.lua

@@ -0,0 +1,27 @@
+-- Shim module to address deprecations across nvim versions
+local ts = vim.treesitter
+local tsq = ts.query
+
+local M = {}
+
+function M.get_query_files(lang, query_group, is_included)
+  return (tsq.get_files or tsq.get_query_files)(lang, query_group, is_included)
+end
+
+function M.get_query(lang, query_name)
+  return (tsq.get or tsq.get_query)(lang, query_name)
+end
+
+function M.parse_query(lang, query)
+  return (tsq.parse or tsq.parse_query)(lang, query)
+end
+
+function M.get_range(node, source, metadata)
+  return (ts.get_range or tsq.get_range)(node, source, metadata)
+end
+
+function M.get_node_text(node, bufnr)
+  return (ts.get_node_text or tsq.get_node_text)(node, bufnr)
+end
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/configs.lua

@@ -0,0 +1,616 @@
+local api = vim.api
+
+local queries = require "nvim-treesitter.query"
+local ts = require "nvim-treesitter.compat"
+local parsers = require "nvim-treesitter.parsers"
+local utils = require "nvim-treesitter.utils"
+local caching = require "nvim-treesitter.caching"
+
+local M = {}
+
+---@class TSConfig
+---@field modules {[string]:TSModule}
+---@field sync_install boolean
+---@field ensure_installed string[]|string
+---@field ignore_install string[]
+---@field auto_install boolean
+---@field parser_install_dir string|nil
+
+---@type TSConfig
+local config = {
+  modules = {},
+  sync_install = false,
+  ensure_installed = {},
+  auto_install = false,
+  ignore_install = {},
+  parser_install_dir = nil,
+}
+
+-- List of modules that need to be setup on initialization.
+---@type TSModule[][]
+local queued_modules_defs = {}
+-- Whether we've initialized the plugin yet.
+local is_initialized = false
+
+---@class TSModule
+---@field module_path string
+---@field enable boolean|string[]|function(string): boolean
+---@field disable boolean|string[]|function(string): boolean
+---@field keymaps table<string, string>
+---@field is_supported function(string): boolean
+---@field attach function(string)
+---@field detach function(string)
+---@field enabled_buffers table<integer, boolean>
+---@field additional_vim_regex_highlighting boolean|string[]
+
+---@type {[string]: TSModule}
+local builtin_modules = {
+  highlight = {
+    module_path = "nvim-treesitter.highlight",
+    -- @deprecated: use `highlight.set_custom_captures` instead
+    custom_captures = {},
+    enable = false,
+    is_supported = function(lang)
+      return queries.has_highlights(lang)
+    end,
+    additional_vim_regex_highlighting = false,
+  },
+  incremental_selection = {
+    module_path = "nvim-treesitter.incremental_selection",
+    enable = false,
+    keymaps = {
+      init_selection = "gnn", -- set to `false` to disable one of the mappings
+      node_incremental = "grn",
+      scope_incremental = "grc",
+      node_decremental = "grm",
+    },
+    is_supported = function()
+      return true
+    end,
+  },
+  indent = {
+    module_path = "nvim-treesitter.indent",
+    enable = false,
+    is_supported = queries.has_indents,
+  },
+}
+
+local attached_buffers_by_module = caching.create_buffer_cache()
+
+---Resolves a module by requiring the `module_path` or using the module definition.
+---@param mod_name string
+---@return TSModule|nil
+local function resolve_module(mod_name)
+  local config_mod = M.get_module(mod_name)
+
+  if not config_mod then
+    return
+  end
+
+  if type(config_mod.attach) == "function" and type(config_mod.detach) == "function" then
+    return config_mod
+  elseif type(config_mod.module_path) == "string" then
+    return require(config_mod.module_path)
+  end
+end
+
+---Enables and attaches the module to a buffer for lang.
+---@param mod string path to module
+---@param bufnr integer|nil buffer number, defaults to current buffer
+---@param lang string|nil language, defaults to current language
+local function enable_module(mod, bufnr, lang)
+  local module = M.get_module(mod)
+  if not module then
+    return
+  end
+
+  bufnr = bufnr or api.nvim_get_current_buf()
+  lang = lang or parsers.get_buf_lang(bufnr)
+
+  if not module.enable then
+    if module.enabled_buffers then
+      module.enabled_buffers[bufnr] = true
+    else
+      module.enabled_buffers = { [bufnr] = true }
+    end
+  end
+
+  M.attach_module(mod, bufnr, lang)
+end
+
+---Enables autocomands for the module.
+---After the module is loaded `loaded` will be set to true for the module.
+---@param mod string path to module
+local function enable_mod_conf_autocmd(mod)
+  local config_mod = M.get_module(mod)
+  if not config_mod or config_mod.loaded then
+    return
+  end
+
+  api.nvim_create_autocmd("FileType", {
+    group = api.nvim_create_augroup("NvimTreesitter-" .. mod, {}),
+    callback = function(args)
+      require("nvim-treesitter.configs").reattach_module(mod, args.buf)
+    end,
+    desc = "Reattach module",
+  })
+
+  config_mod.loaded = true
+end
+
+---Enables the module globally and for all current buffers.
+---After enabled, `enable` will be set to true for the module.
+---@param mod string path to module
+local function enable_all(mod)
+  local config_mod = M.get_module(mod)
+  if not config_mod then
+    return
+  end
+
+  enable_mod_conf_autocmd(mod)
+  config_mod.enable = true
+  config_mod.enabled_buffers = nil
+
+  for _, bufnr in pairs(api.nvim_list_bufs()) do
+    enable_module(mod, bufnr)
+  end
+end
+
+---Disables and detaches the module for a buffer.
+---@param mod string path to module
+---@param bufnr integer buffer number, defaults to current buffer
+local function disable_module(mod, bufnr)
+  local module = M.get_module(mod)
+  if not module then
+    return
+  end
+
+  bufnr = bufnr or api.nvim_get_current_buf()
+  if module.enabled_buffers then
+    module.enabled_buffers[bufnr] = false
+  end
+  M.detach_module(mod, bufnr)
+end
+
+---Disables autocomands for the module.
+---After the module is unloaded `loaded` will be set to false for the module.
+---@param mod string path to module
+local function disable_mod_conf_autocmd(mod)
+  local config_mod = M.get_module(mod)
+  if not config_mod or not config_mod.loaded then
+    return
+  end
+  api.nvim_clear_autocmds { event = "FileType", group = "NvimTreesitter-" .. mod }
+  config_mod.loaded = false
+end
+
+---Disables the module globally and for all current buffers.
+---After disabled, `enable` will be set to false for the module.
+---@param mod string path to module
+local function disable_all(mod)
+  local config_mod = M.get_module(mod)
+  if not config_mod then
+    return
+  end
+
+  config_mod.enabled_buffers = nil
+  disable_mod_conf_autocmd(mod)
+  config_mod.enable = false
+
+  for _, bufnr in pairs(api.nvim_list_bufs()) do
+    disable_module(mod, bufnr)
+  end
+end
+
+---Toggles a module for a buffer
+---@param mod string path to module
+---@param bufnr integer buffer number, defaults to current buffer
+---@param lang string language, defaults to current language
+local function toggle_module(mod, bufnr, lang)
+  bufnr = bufnr or api.nvim_get_current_buf()
+  lang = lang or parsers.get_buf_lang(bufnr)
+
+  if attached_buffers_by_module.has(mod, bufnr) then
+    disable_module(mod, bufnr)
+  else
+    enable_module(mod, bufnr, lang)
+  end
+end
+
+-- Toggles the module globally and for all current buffers.
+-- @param mod path to module
+local function toggle_all(mod)
+  local config_mod = M.get_module(mod)
+  if not config_mod then
+    return
+  end
+
+  if config_mod.enable then
+    disable_all(mod)
+  else
+    enable_all(mod)
+  end
+end
+
+---Recurses through all modules including submodules
+---@param accumulator function called for each module
+---@param root {[string]: TSModule}|nil root configuration table to start at
+---@param path string|nil prefix path
+local function recurse_modules(accumulator, root, path)
+  root = root or config.modules
+
+  for name, module in pairs(root) do
+    local new_path = path and (path .. "." .. name) or name
+
+    if M.is_module(module) then
+      accumulator(name, module, new_path, root)
+    elseif type(module) == "table" then
+      recurse_modules(accumulator, module, new_path)
+    end
+  end
+end
+
+-- Shows current configuration of all nvim-treesitter modules
+---@param process_function function used as the `process` parameter
+---       for vim.inspect (https://github.com/kikito/inspect.lua#optionsprocess)
+local function config_info(process_function)
+  process_function = process_function
+    or function(item, path)
+      if path[#path] == vim.inspect.METATABLE then
+        return
+      end
+      if path[#path] == "is_supported" then
+        return
+      end
+      return item
+    end
+  print(vim.inspect(config, { process = process_function }))
+end
+
+---@param query_group string
+---@param lang string
+function M.edit_query_file(query_group, lang)
+  lang = lang or parsers.get_buf_lang()
+  local files = ts.get_query_files(lang, query_group, true)
+  if #files == 0 then
+    utils.notify "No query file found! Creating a new one!"
+    M.edit_query_file_user_after(query_group, lang)
+  elseif #files == 1 then
+    vim.cmd(":edit " .. files[1])
+  else
+    vim.ui.select(files, { prompt = "Select a file:" }, function(file)
+      if file then
+        vim.cmd(":edit " .. file)
+      end
+    end)
+  end
+end
+
+---@param query_group string
+---@param lang string
+function M.edit_query_file_user_after(query_group, lang)
+  lang = lang or parsers.get_buf_lang()
+  local folder = utils.join_path(vim.fn.stdpath "config", "after", "queries", lang)
+  local file = utils.join_path(folder, query_group .. ".scm")
+  if vim.fn.isdirectory(folder) ~= 1 then
+    vim.ui.select({ "Yes", "No" }, { prompt = '"' .. folder .. '" does not exist. Create it?' }, function(choice)
+      if choice == "Yes" then
+        vim.fn.mkdir(folder, "p", "0755")
+        vim.cmd(":edit " .. file)
+      end
+    end)
+  else
+    vim.cmd(":edit " .. file)
+  end
+end
+
+M.commands = {
+  TSBufEnable = {
+    run = enable_module,
+    args = {
+      "-nargs=1",
+      "-complete=custom,nvim_treesitter#available_modules",
+    },
+  },
+  TSBufDisable = {
+    run = disable_module,
+    args = {
+      "-nargs=1",
+      "-complete=custom,nvim_treesitter#available_modules",
+    },
+  },
+  TSBufToggle = {
+    run = toggle_module,
+    args = {
+      "-nargs=1",
+      "-complete=custom,nvim_treesitter#available_modules",
+    },
+  },
+  TSEnable = {
+    run = enable_all,
+    args = {
+      "-nargs=+",
+      "-complete=custom,nvim_treesitter#available_modules",
+    },
+  },
+  TSDisable = {
+    run = disable_all,
+    args = {
+      "-nargs=+",
+      "-complete=custom,nvim_treesitter#available_modules",
+    },
+  },
+  TSToggle = {
+    run = toggle_all,
+    args = {
+      "-nargs=+",
+      "-complete=custom,nvim_treesitter#available_modules",
+    },
+  },
+  TSConfigInfo = {
+    run = config_info,
+    args = {
+      "-nargs=0",
+    },
+  },
+  TSEditQuery = {
+    run = M.edit_query_file,
+    args = {
+      "-nargs=+",
+      "-complete=custom,nvim_treesitter#available_query_groups",
+    },
+  },
+  TSEditQueryUserAfter = {
+    run = M.edit_query_file_user_after,
+    args = {
+      "-nargs=+",
+      "-complete=custom,nvim_treesitter#available_query_groups",
+    },
+  },
+}
+
+---@param mod string module
+---@param lang string the language of the buffer
+---@param bufnr integer the buffer
+function M.is_enabled(mod, lang, bufnr)
+  if not parsers.has_parser(lang) then
+    return false
+  end
+
+  local module_config = M.get_module(mod)
+  if not module_config then
+    return false
+  end
+
+  local buffer_enabled = module_config.enabled_buffers and module_config.enabled_buffers[bufnr]
+  local config_enabled = module_config.enable or buffer_enabled
+  if not config_enabled or not module_config.is_supported(lang) then
+    return false
+  end
+
+  local disable = module_config.disable
+  if type(disable) == "function" then
+    if disable(lang, bufnr) then
+      return false
+    end
+  elseif type(disable) == "table" then
+    -- Otherwise it's a list of languages
+    for _, parser in pairs(disable) do
+      if lang == parser then
+        return false
+      end
+    end
+  end
+
+  return true
+end
+
+---Setup call for users to override module configurations.
+---@param user_data TSConfig module overrides
+function M.setup(user_data)
+  config.modules = vim.tbl_deep_extend("force", config.modules, user_data)
+  config.ignore_install = user_data.ignore_install or {}
+  config.parser_install_dir = user_data.parser_install_dir or nil
+  if config.parser_install_dir then
+    config.parser_install_dir = vim.fn.expand(config.parser_install_dir, ":p")
+  end
+
+  config.auto_install = user_data.auto_install or false
+  if config.auto_install then
+    require("nvim-treesitter.install").setup_auto_install()
+  end
+
+  local ensure_installed = user_data.ensure_installed or {}
+  if #ensure_installed > 0 then
+    if user_data.sync_install then
+      require("nvim-treesitter.install").ensure_installed_sync(ensure_installed)
+    else
+      require("nvim-treesitter.install").ensure_installed(ensure_installed)
+    end
+  end
+
+  config.modules.ensure_installed = nil
+  config.ensure_installed = ensure_installed
+
+  recurse_modules(function(_, _, new_path)
+    local data = utils.get_at_path(config.modules, new_path)
+    if data.enable then
+      enable_all(new_path)
+    end
+  end, config.modules)
+end
+
+-- Defines a table of modules that can be attached/detached to buffers
+-- based on language support. A module consist of the following properties:
+---* @enable Whether the modules is enabled. Can be true or false.
+---* @disable A list of languages to disable the module for. Only relevant if enable is true.
+---* @keymaps A list of user mappings for a given module if relevant.
+---* @is_supported A function which, given a ft, will return true if the ft works on the module.
+---* @module_path A string path to a module file using `require`. The exported module must contain
+---               an `attach` and `detach` function. This path is not required if `attach` and `detach`
+---               functions are provided directly on the module definition.
+---* @attach An attach function that is called for each buffer that the module is enabled for. This is required
+---          if a `module_path` is not specified.
+---* @detach A detach function that is called for each buffer that the module is enabled for. This is required
+---          if a `module_path` is not specified.
+--
+-- Modules are not setup until `init` is invoked by the plugin. This allows modules to be defined in any order
+-- and can be loaded lazily.
+--
+---* @example
+---require"nvim-treesitter".define_modules {
+---  my_cool_module = {
+---    attach = function()
+---      do_some_cool_setup()
+---    end,
+---    detach = function()
+---      do_some_cool_teardown()
+---    end
+---  }
+---}
+---@param mod_defs TSModule[]
+function M.define_modules(mod_defs)
+  if not is_initialized then
+    table.insert(queued_modules_defs, mod_defs)
+    return
+  end
+
+  recurse_modules(function(key, mod, _, group)
+    group[key] = vim.tbl_extend("keep", mod, {
+      enable = false,
+      disable = {},
+      is_supported = function()
+        return true
+      end,
+    })
+  end, mod_defs)
+
+  config.modules = vim.tbl_deep_extend("keep", config.modules, mod_defs)
+
+  for _, mod in ipairs(M.available_modules(mod_defs)) do
+    local module_config = M.get_module(mod)
+    if module_config and module_config.enable then
+      enable_mod_conf_autocmd(mod)
+    end
+  end
+end
+
+---Attaches a module to a buffer
+---@param mod_name string the module name
+---@param bufnr integer the buffer
+---@param lang string the language of the buffer
+function M.attach_module(mod_name, bufnr, lang)
+  bufnr = bufnr or api.nvim_get_current_buf()
+  lang = lang or parsers.get_buf_lang(bufnr)
+  local resolved_mod = resolve_module(mod_name)
+
+  if resolved_mod and not attached_buffers_by_module.has(mod_name, bufnr) and M.is_enabled(mod_name, lang, bufnr) then
+    attached_buffers_by_module.set(mod_name, bufnr, true)
+    resolved_mod.attach(bufnr, lang)
+  end
+end
+
+-- Detaches a module to a buffer
+---@param mod_name string the module name
+---@param bufnr integer the buffer
+function M.detach_module(mod_name, bufnr)
+  local resolved_mod = resolve_module(mod_name)
+  bufnr = bufnr or api.nvim_get_current_buf()
+
+  if resolved_mod and attached_buffers_by_module.has(mod_name, bufnr) then
+    attached_buffers_by_module.remove(mod_name, bufnr)
+    resolved_mod.detach(bufnr)
+  end
+end
+
+-- Same as attach_module, but if the module is already attached, detach it first.
+---@param mod_name string the module name
+---@param bufnr integer the buffer
+---@param lang string the language of the buffer
+function M.reattach_module(mod_name, bufnr, lang)
+  M.detach_module(mod_name, bufnr)
+  M.attach_module(mod_name, bufnr, lang)
+end
+
+-- Gets available modules
+---@param root {[string]:TSModule}|nil table to find modules
+---@return string[] modules list of module paths
+function M.available_modules(root)
+  local modules = {}
+
+  recurse_modules(function(_, _, path)
+    table.insert(modules, path)
+  end, root)
+
+  return modules
+end
+
+---Gets a module config by path
+---@param mod_path string path to the module
+---@return TSModule|nil: the module or nil
+function M.get_module(mod_path)
+  local mod = utils.get_at_path(config.modules, mod_path)
+
+  return M.is_module(mod) and mod or nil
+end
+
+-- Determines whether the provided table is a module.
+-- A module should contain an attach and detach function.
+---@param mod table|nil the module table
+---@return boolean
+function M.is_module(mod)
+  return type(mod) == "table"
+    and ((type(mod.attach) == "function" and type(mod.detach) == "function") or type(mod.module_path) == "string")
+end
+
+-- Initializes built-in modules and any queued modules
+-- registered by plugins or the user.
+function M.init()
+  is_initialized = true
+  M.define_modules(builtin_modules)
+
+  for _, mod_def in ipairs(queued_modules_defs) do
+    M.define_modules(mod_def)
+  end
+end
+
+-- If parser_install_dir is not nil is used or created.
+-- If parser_install_dir is nil try the package dir of the nvim-treesitter
+-- plugin first, followed by the "site" dir from "runtimepath". "site" dir will
+-- be created if it doesn't exist. Using only the package dir won't work when
+-- the plugin is installed with Nix, since the "/nix/store" is read-only.
+---@param folder_name string|nil
+---@return string|nil, string|nil
+function M.get_parser_install_dir(folder_name)
+  folder_name = folder_name or "parser"
+
+  local install_dir = config.parser_install_dir or utils.get_package_path()
+  local parser_dir = utils.join_path(install_dir, folder_name)
+
+  return utils.create_or_reuse_writable_dir(
+    parser_dir,
+    utils.join_space("Could not create parser dir '", parser_dir, "': "),
+    utils.join_space(
+      "Parser dir '",
+      parser_dir,
+      "' should be read/write (see README on how to configure an alternative install location)"
+    )
+  )
+end
+
+function M.get_parser_info_dir()
+  return M.get_parser_install_dir "parser-info"
+end
+
+function M.get_ignored_parser_installs()
+  return config.ignore_install or {}
+end
+
+function M.get_ensure_installed_parsers()
+  if type(config.ensure_installed) == "string" then
+    return { config.ensure_installed }
+  end
+  return config.ensure_installed or {}
+end
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/fold.lua

@@ -0,0 +1,123 @@
+local api = vim.api
+local tsutils = require "nvim-treesitter.ts_utils"
+local query = require "nvim-treesitter.query"
+local parsers = require "nvim-treesitter.parsers"
+
+local M = {}
+
+-- This is cached on buf tick to avoid computing that multiple times
+-- Especially not for every line in the file when `zx` is hit
+local folds_levels = tsutils.memoize_by_buf_tick(function(bufnr)
+  local max_fold_level = api.nvim_win_get_option(0, "foldnestmax")
+  local trim_level = function(level)
+    if level > max_fold_level then
+      return max_fold_level
+    end
+    return level
+  end
+
+  local parser = parsers.get_parser(bufnr)
+
+  if not parser then
+    return {}
+  end
+
+  local matches = query.get_capture_matches_recursively(bufnr, function(lang)
+    if query.has_folds(lang) then
+      return "@fold", "folds"
+    elseif query.has_locals(lang) then
+      return "@scope", "locals"
+    end
+  end)
+
+  -- start..stop is an inclusive range
+
+  ---@type table<number, number>
+  local start_counts = {}
+  ---@type table<number, number>
+  local stop_counts = {}
+
+  local prev_start = -1
+  local prev_stop = -1
+
+  local min_fold_lines = api.nvim_win_get_option(0, "foldminlines")
+
+  for _, match in ipairs(matches) do
+    local start, stop, stop_col ---@type integer, integer, integer
+    if match.metadata and match.metadata.range then
+      start, _, stop, stop_col = unpack(match.metadata.range) ---@type integer, integer, integer, integer
+    else
+      start, _, stop, stop_col = match.node:range() ---@type integer, integer, integer, integer
+    end
+
+    if stop_col == 0 then
+      stop = stop - 1
+    end
+
+    local fold_length = stop - start + 1
+    local should_fold = fold_length > min_fold_lines
+
+    -- Fold only multiline nodes that are not exactly the same as previously met folds
+    -- Checking against just the previously found fold is sufficient if nodes
+    -- are returned in preorder or postorder when traversing tree
+    if should_fold and not (start == prev_start and stop == prev_stop) then
+      start_counts[start] = (start_counts[start] or 0) + 1
+      stop_counts[stop] = (stop_counts[stop] or 0) + 1
+      prev_start = start
+      prev_stop = stop
+    end
+  end
+
+  ---@type string[]
+  local levels = {}
+  local current_level = 0
+
+  -- We now have the list of fold opening and closing, fill the gaps and mark where fold start
+  for lnum = 0, api.nvim_buf_line_count(bufnr) do
+    local prefix = ""
+
+    local last_trimmed_level = trim_level(current_level)
+    current_level = current_level + (start_counts[lnum] or 0)
+    local trimmed_level = trim_level(current_level)
+    current_level = current_level - (stop_counts[lnum] or 0)
+    local next_trimmed_level = trim_level(current_level)
+
+    -- Determine if it's the start/end of a fold
+    -- NB: vim's fold-expr interface does not have a mechanism to indicate that
+    -- two (or more) folds start at this line, so it cannot distinguish between
+    --  ( \n ( \n )) \n (( \n ) \n )
+    -- versus
+    --  ( \n ( \n ) \n ( \n ) \n )
+    -- If it did have such a mechanism, (trimmed_level - last_trimmed_level)
+    -- would be the correct number of starts to pass on.
+    if trimmed_level - last_trimmed_level > 0 then
+      prefix = ">"
+    elseif trimmed_level - next_trimmed_level > 0 then
+      -- Ending marks tend to confuse vim more than it helps, particularly when
+      -- the fold level changes by at least 2; we can uncomment this if
+      -- vim's behavior gets fixed.
+      -- prefix = "<"
+      prefix = ""
+    end
+
+    levels[lnum + 1] = prefix .. tostring(trimmed_level)
+  end
+
+  return levels
+end)
+
+---@param lnum integer
+---@return string
+function M.get_fold_indic(lnum)
+  if not parsers.has_parser() or not lnum then
+    return "0"
+  end
+
+  local buf = api.nvim_get_current_buf()
+
+  local levels = folds_levels(buf) or {}
+
+  return levels[lnum] or "0"
+end
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/health.lua

@@ -0,0 +1,176 @@
+local api = vim.api
+local fn = vim.fn
+
+local queries = require "nvim-treesitter.query"
+local info = require "nvim-treesitter.info"
+local shell = require "nvim-treesitter.shell_command_selectors"
+local install = require "nvim-treesitter.install"
+local utils = require "nvim-treesitter.utils"
+local ts = require "nvim-treesitter.compat"
+
+local health = vim.health or require "health"
+
+-- "report_" prefix has been deprecated, use the recommended replacements if they exist.
+local _start = health.start or health.report_start
+local _ok = health.ok or health.report_ok
+local _warn = health.warn or health.report_warn
+local _error = health.error or health.report_error
+
+local M = {}
+
+local NVIM_TREESITTER_MINIMUM_ABI = 13
+
+local function install_health()
+  _start "Installation"
+
+  if fn.has "nvim-0.8.3" ~= 1 then
+    _error "Nvim-treesitter requires Neovim 0.8.3+"
+  end
+
+  if fn.executable "tree-sitter" == 0 then
+    _warn(
+      "`tree-sitter` executable not found (parser generator, only needed for :TSInstallFromGrammar,"
+        .. " not required for :TSInstall)"
+    )
+  else
+    _ok(
+      "`tree-sitter` found "
+        .. (utils.ts_cli_version() or "(unknown version)")
+        .. " (parser generator, only needed for :TSInstallFromGrammar)"
+    )
+  end
+
+  if fn.executable "node" == 0 then
+    _warn("`node` executable not found (only needed for :TSInstallFromGrammar," .. " not required for :TSInstall)")
+  else
+    local handle = io.popen "node --version"
+    local result = handle:read "*a"
+    handle:close()
+    local version = vim.split(result, "\n")[1]
+    _ok("`node` found " .. version .. " (only needed for :TSInstallFromGrammar)")
+  end
+
+  if fn.executable "git" == 0 then
+    _error("`git` executable not found.", {
+      "Install it with your package manager.",
+      "Check that your `$PATH` is set correctly.",
+    })
+  else
+    _ok "`git` executable found."
+  end
+
+  local cc = shell.select_executable(install.compilers)
+  if not cc then
+    _error("`cc` executable not found.", {
+      "Check that any of "
+        .. vim.inspect(install.compilers)
+        .. " is in your $PATH"
+        .. ' or set the environment variable CC or `require"nvim-treesitter.install".compilers` explicitly!',
+    })
+  else
+    local version = vim.fn.systemlist(cc .. (cc == "cl" and "" or " --version"))[1]
+    _ok(
+      "`"
+        .. cc
+        .. "` executable found. Selected from "
+        .. vim.inspect(install.compilers)
+        .. (version and ("\nVersion: " .. version) or "")
+    )
+  end
+  if vim.treesitter.language_version then
+    if vim.treesitter.language_version >= NVIM_TREESITTER_MINIMUM_ABI then
+      _ok(
+        "Neovim was compiled with tree-sitter runtime ABI version "
+          .. vim.treesitter.language_version
+          .. " (required >="
+          .. NVIM_TREESITTER_MINIMUM_ABI
+          .. "). Parsers must be compatible with runtime ABI."
+      )
+    else
+      _error(
+        "Neovim was compiled with tree-sitter runtime ABI version "
+          .. vim.treesitter.language_version
+          .. ".\n"
+          .. "nvim-treesitter expects at least ABI version "
+          .. NVIM_TREESITTER_MINIMUM_ABI
+          .. "\n"
+          .. "Please make sure that Neovim is linked against are recent tree-sitter runtime when building"
+          .. " or raise an issue at your Neovim packager. Parsers must be compatible with runtime ABI."
+      )
+    end
+  end
+
+  _start("OS Info:\n" .. vim.inspect(vim.loop.os_uname()))
+end
+
+local function query_status(lang, query_group)
+  local ok, err = pcall(queries.get_query, lang, query_group)
+  if not ok then
+    return "x", err
+  elseif not err then
+    return "."
+  else
+    return "✓"
+  end
+end
+
+function M.check()
+  local error_collection = {}
+  -- Installation dependency checks
+  install_health()
+  queries.invalidate_query_cache()
+  -- Parser installation checks
+  local parser_installation = { "Parser/Features" .. string.rep(" ", 9) .. "H L F I J" }
+  for _, parser_name in pairs(info.installed_parsers()) do
+    local installed = #api.nvim_get_runtime_file("parser/" .. parser_name .. ".so", false)
+
+    -- Only append information about installed parsers
+    if installed >= 1 then
+      local multiple_parsers = installed > 1 and "+" or ""
+      local out = "  - " .. parser_name .. multiple_parsers .. string.rep(" ", 20 - (#parser_name + #multiple_parsers))
+      for _, query_group in pairs(queries.built_in_query_groups) do
+        local status, err = query_status(parser_name, query_group)
+        out = out .. status .. " "
+        if err then
+          table.insert(error_collection, { parser_name, query_group, err })
+        end
+      end
+      table.insert(parser_installation, vim.fn.trim(out, " ", 2))
+    end
+  end
+  local legend = [[
+
+  Legend: H[ighlight], L[ocals], F[olds], I[ndents], In[j]ections
+         +) multiple parsers found, only one will be used
+         x) errors found in the query, try to run :TSUpdate {lang}]]
+  table.insert(parser_installation, legend)
+  -- Finally call the report function
+  _start(table.concat(parser_installation, "\n"))
+  if #error_collection > 0 then
+    _start "The following errors have been detected:"
+    for _, p in ipairs(error_collection) do
+      local lang, type, err = unpack(p)
+      local lines = {}
+      table.insert(lines, lang .. "(" .. type .. "): " .. err)
+      local files = ts.get_query_files(lang, type)
+      if #files > 0 then
+        table.insert(lines, lang .. "(" .. type .. ") is concatenated from the following files:")
+        for _, file in ipairs(files) do
+          local fd = io.open(file, "r")
+          if fd then
+            local ok, file_err = pcall(ts.parse_query, lang, fd:read "*a")
+            if ok then
+              table.insert(lines, '|    [OK]:"' .. file .. '"')
+            else
+              table.insert(lines, '| [ERROR]:"' .. file .. '", failed to load: ' .. file_err)
+            end
+            fd:close()
+          end
+        end
+      end
+      _error(table.concat(lines, "\n"))
+    end
+  end
+end
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/highlight.lua

@@ -0,0 +1,49 @@
+local configs = require "nvim-treesitter.configs"
+
+local M = {}
+
+---@param config TSModule
+---@param lang string
+---@return boolean
+local function should_enable_vim_regex(config, lang)
+  local additional_hl = config.additional_vim_regex_highlighting
+  local is_table = type(additional_hl) == "table"
+
+  ---@diagnostic disable-next-line: param-type-mismatch
+  return additional_hl and (not is_table or vim.tbl_contains(additional_hl, lang))
+end
+
+---@param bufnr integer
+---@param lang string
+function M.attach(bufnr, lang)
+  local config = configs.get_module "highlight"
+  vim.treesitter.start(bufnr, lang)
+  if config and should_enable_vim_regex(config, lang) then
+    vim.bo[bufnr].syntax = "ON"
+  end
+end
+
+---@param bufnr integer
+function M.detach(bufnr)
+  vim.treesitter.stop(bufnr)
+end
+
+---@deprecated
+function M.start(...)
+  vim.notify(
+    "`nvim-treesitter.highlight.start` is deprecated: use `nvim-treesitter.highlight.attach` or `vim.treesitter.start`",
+    vim.log.levels.WARN
+  )
+  M.attach(...)
+end
+
+---@deprecated
+function M.stop(...)
+  vim.notify(
+    "`nvim-treesitter.highlight.stop` is deprecated: use `nvim-treesitter.highlight.detach` or `vim.treesitter.stop`",
+    vim.log.levels.WARN
+  )
+  M.detach(...)
+end
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/incremental_selection.lua

@@ -0,0 +1,176 @@
+local api = vim.api
+
+local configs = require "nvim-treesitter.configs"
+local ts_utils = require "nvim-treesitter.ts_utils"
+local locals = require "nvim-treesitter.locals"
+local parsers = require "nvim-treesitter.parsers"
+local queries = require "nvim-treesitter.query"
+
+local M = {}
+
+---@type table<integer, table<TSNode|nil>>
+local selections = {}
+
+function M.init_selection()
+  local buf = api.nvim_get_current_buf()
+  local node = ts_utils.get_node_at_cursor()
+  selections[buf] = { [1] = node }
+  ts_utils.update_selection(buf, node)
+end
+
+-- Get the range of the current visual selection.
+--
+-- The range starts with 1 and the ending is inclusive.
+---@return integer, integer, integer, integer
+local function visual_selection_range()
+  local _, csrow, cscol, _ = unpack(vim.fn.getpos "'<") ---@type integer, integer, integer, integer
+  local _, cerow, cecol, _ = unpack(vim.fn.getpos "'>") ---@type integer, integer, integer, integer
+
+  local start_row, start_col, end_row, end_col ---@type integer, integer, integer, integer
+
+  if csrow < cerow or (csrow == cerow and cscol <= cecol) then
+    start_row = csrow
+    start_col = cscol
+    end_row = cerow
+    end_col = cecol
+  else
+    start_row = cerow
+    start_col = cecol
+    end_row = csrow
+    end_col = cscol
+  end
+
+  return start_row, start_col, end_row, end_col
+end
+
+---@param node TSNode
+---@return boolean
+local function range_matches(node)
+  local csrow, cscol, cerow, cecol = visual_selection_range()
+  local srow, scol, erow, ecol = ts_utils.get_vim_range { node:range() }
+  return srow == csrow and scol == cscol and erow == cerow and ecol == cecol
+end
+
+---@param get_parent fun(node: TSNode): TSNode|nil
+---@return fun():nil
+local function select_incremental(get_parent)
+  return function()
+    local buf = api.nvim_get_current_buf()
+    local nodes = selections[buf]
+
+    local csrow, cscol, cerow, cecol = visual_selection_range()
+    -- Initialize incremental selection with current selection
+    if not nodes or #nodes == 0 or not range_matches(nodes[#nodes]) then
+      local root = parsers.get_parser():parse()[1]:root()
+      local node = root:named_descendant_for_range(csrow - 1, cscol - 1, cerow - 1, cecol)
+      ts_utils.update_selection(buf, node)
+      if nodes and #nodes > 0 then
+        table.insert(selections[buf], node)
+      else
+        selections[buf] = { [1] = node }
+      end
+      return
+    end
+
+    -- Find a node that changes the current selection.
+    local node = nodes[#nodes] ---@type TSNode
+    while true do
+      local parent = get_parent(node)
+      if not parent or parent == node then
+        -- Keep searching in the main tree
+        -- TODO: we should search on the parent tree of the current node.
+        local root = parsers.get_parser():parse()[1]:root()
+        parent = root:named_descendant_for_range(csrow - 1, cscol - 1, cerow - 1, cecol)
+        if not parent or root == node or parent == node then
+          ts_utils.update_selection(buf, node)
+          return
+        end
+      end
+      node = parent
+      local srow, scol, erow, ecol = ts_utils.get_vim_range { node:range() }
+      local same_range = (srow == csrow and scol == cscol and erow == cerow and ecol == cecol)
+      if not same_range then
+        table.insert(selections[buf], node)
+        if node ~= nodes[#nodes] then
+          table.insert(nodes, node)
+        end
+        ts_utils.update_selection(buf, node)
+        return
+      end
+    end
+  end
+end
+
+M.node_incremental = select_incremental(function(node)
+  return node:parent() or node
+end)
+
+M.scope_incremental = select_incremental(function(node)
+  local lang = parsers.get_buf_lang()
+  if queries.has_locals(lang) then
+    return locals.containing_scope(node:parent() or node)
+  else
+    return node
+  end
+end)
+
+function M.node_decremental()
+  local buf = api.nvim_get_current_buf()
+  local nodes = selections[buf]
+  if not nodes or #nodes < 2 then
+    return
+  end
+
+  table.remove(selections[buf])
+  local node = nodes[#nodes] ---@type TSNode
+  ts_utils.update_selection(buf, node)
+end
+
+local FUNCTION_DESCRIPTIONS = {
+  init_selection = "Start selecting nodes with nvim-treesitter",
+  node_incremental = "Increment selection to named node",
+  scope_incremental = "Increment selection to surrounding scope",
+  node_decremental = "Shrink selection to previous named node",
+}
+
+---@param bufnr integer
+function M.attach(bufnr)
+  local config = configs.get_module "incremental_selection"
+  for funcname, mapping in pairs(config.keymaps) do
+    if mapping then
+      ---@type string, string|function
+      local mode, rhs
+      if funcname == "init_selection" then
+        mode = "n"
+        ---@type function
+        rhs = M[funcname]
+      else
+        mode = "x"
+        -- We need to move to command mode to access marks '< (visual area start) and '> (visual area end) which are not
+        -- properly accessible in visual mode.
+        rhs = string.format(":lua require'nvim-treesitter.incremental_selection'.%s()<CR>", funcname)
+      end
+      vim.keymap.set(
+        mode,
+        mapping,
+        rhs,
+        { buffer = bufnr, silent = true, noremap = true, desc = FUNCTION_DESCRIPTIONS[funcname] }
+      )
+    end
+  end
+end
+
+function M.detach(bufnr)
+  local config = configs.get_module "incremental_selection"
+  for f, mapping in pairs(config.keymaps) do
+    if mapping then
+      if f == "init_selection" then
+        vim.keymap.del("n", mapping, { buffer = bufnr })
+      else
+        vim.keymap.del("x", mapping, { buffer = bufnr })
+      end
+    end
+  end
+end
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/indent.lua

@@ -0,0 +1,359 @@
+local ts = vim.treesitter
+local parsers = require "nvim-treesitter.parsers"
+
+local M = {}
+
+M.avoid_force_reparsing = {
+  yaml = true,
+}
+
+M.comment_parsers = {
+  comment = true,
+  jsdoc = true,
+  phpdoc = true,
+}
+
+local function getline(lnum)
+  return vim.api.nvim_buf_get_lines(0, lnum - 1, lnum, false)[1] or ""
+end
+
+---@param root TSNode
+---@param lnum integer
+---@param col? integer
+---@return TSNode
+local function get_first_node_at_line(root, lnum, col)
+  col = col or vim.fn.indent(lnum)
+  return root:descendant_for_range(lnum - 1, col, lnum - 1, col)
+end
+
+---@param root TSNode
+---@param lnum integer
+---@param col? integer
+---@return TSNode
+local function get_last_node_at_line(root, lnum, col)
+  col = col or (#getline(lnum) - 1)
+  return root:descendant_for_range(lnum - 1, col, lnum - 1, col)
+end
+
+---@param node TSNode
+---@return number
+local function node_length(node)
+  local _, _, start_byte = node:start()
+  local _, _, end_byte = node:end_()
+  return end_byte - start_byte
+end
+
+---@param bufnr integer
+---@param node TSNode
+---@param delimiter string
+---@return TSNode|nil child
+---@return boolean|nil is_end
+local function find_delimiter(bufnr, node, delimiter)
+  for child, _ in node:iter_children() do
+    if child:type() == delimiter then
+      local linenr = child:start()
+      local line = vim.api.nvim_buf_get_lines(bufnr, linenr, linenr + 1, false)[1]
+      local end_char = { child:end_() }
+      local trimmed_after_delim
+      local escaped_delimiter = delimiter:gsub("[%-%.%+%[%]%(%)%$%^%%%?%*]", "%%%1")
+      trimmed_after_delim, _ = line:sub(end_char[2] + 1):gsub("[%s" .. escaped_delimiter .. "]*", "")
+      return child, #trimmed_after_delim == 0
+    end
+  end
+end
+
+---Memoize a function using hash_fn to hash the arguments.
+---@generic F: function
+---@param fn F
+---@param hash_fn fun(...): any
+---@return F
+local function memoize(fn, hash_fn)
+  local cache = setmetatable({}, { __mode = "kv" }) ---@type table<any,any>
+
+  return function(...)
+    local key = hash_fn(...)
+    if cache[key] == nil then
+      local v = fn(...) ---@type any
+      cache[key] = v ~= nil and v or vim.NIL
+    end
+
+    local v = cache[key]
+    return v ~= vim.NIL and v or nil
+  end
+end
+
+local get_indents = memoize(function(bufnr, root, lang)
+  local map = {
+    ["indent.auto"] = {},
+    ["indent.begin"] = {},
+    ["indent.end"] = {},
+    ["indent.dedent"] = {},
+    ["indent.branch"] = {},
+    ["indent.ignore"] = {},
+    ["indent.align"] = {},
+    ["indent.zero"] = {},
+  }
+
+  --TODO(clason): remove when dropping Nvim 0.8 compat
+  local query = (ts.query.get or ts.get_query)(lang, "indents")
+  if not query then
+    return map
+  end
+  for id, node, metadata in query:iter_captures(root, bufnr) do
+    if query.captures[id]:sub(1, 1) ~= "_" then
+      map[query.captures[id]][node:id()] = metadata or {}
+    end
+  end
+
+  return map
+end, function(bufnr, root, lang)
+  return tostring(bufnr) .. root:id() .. "_" .. lang
+end)
+
+---@param lnum number (1-indexed)
+function M.get_indent(lnum)
+  local bufnr = vim.api.nvim_get_current_buf()
+  local parser = parsers.get_parser(bufnr)
+  if not parser or not lnum then
+    return -1
+  end
+
+  --TODO(clason): replace when dropping Nvim 0.8 compat
+  local root_lang = parsers.get_buf_lang(bufnr)
+
+  -- some languages like Python will actually have worse results when re-parsing at opened new line
+  if not M.avoid_force_reparsing[root_lang] then
+    -- Reparse in case we got triggered by ":h indentkeys"
+    parser:parse()
+  end
+
+  -- Get language tree with smallest range around node that's not a comment parser
+  local root, lang_tree ---@type TSNode, LanguageTree
+  parser:for_each_tree(function(tstree, tree)
+    if not tstree or M.comment_parsers[tree:lang()] then
+      return
+    end
+    local local_root = tstree:root()
+    if ts.is_in_node_range(local_root, lnum - 1, 0) then
+      if not root or node_length(root) >= node_length(local_root) then
+        root = local_root
+        lang_tree = tree
+      end
+    end
+  end)
+
+  -- Not likely, but just in case...
+  if not root then
+    return 0
+  end
+
+  local q = get_indents(vim.api.nvim_get_current_buf(), root, lang_tree:lang())
+  local is_empty_line = string.match(getline(lnum), "^%s*$") ~= nil
+  local node ---@type TSNode
+  if is_empty_line then
+    local prevlnum = vim.fn.prevnonblank(lnum)
+    local indent = vim.fn.indent(prevlnum)
+    local prevline = vim.trim(getline(prevlnum))
+    -- The final position can be trailing spaces, which should not affect indentation
+    node = get_last_node_at_line(root, prevlnum, indent + #prevline - 1)
+    if node:type():match "comment" then
+      -- The final node we capture of the previous line can be a comment node, which should also be ignored
+      -- Unless the last line is an entire line of comment, ignore the comment range and find the last node again
+      local first_node = get_first_node_at_line(root, prevlnum, indent)
+      local _, scol, _, _ = node:range()
+      if first_node:id() ~= node:id() then
+        -- In case the last captured node is a trailing comment node, re-trim the string
+        prevline = vim.trim(prevline:sub(1, scol - indent))
+        -- Add back indent as indent of prevline was trimmed away
+        local col = indent + #prevline - 1
+        node = get_last_node_at_line(root, prevlnum, col)
+      end
+    end
+    if q["indent.end"][node:id()] then
+      node = get_first_node_at_line(root, lnum)
+    end
+  else
+    node = get_first_node_at_line(root, lnum)
+  end
+
+  local indent_size = vim.fn.shiftwidth()
+  local indent = 0
+  local _, _, root_start = root:start()
+  if root_start ~= 0 then
+    -- injected tree
+    indent = vim.fn.indent(root:start() + 1)
+  end
+
+  -- tracks to ensure multiple indent levels are not applied for same line
+  local is_processed_by_row = {}
+
+  if q["indent.zero"][node:id()] then
+    return 0
+  end
+
+  while node do
+    -- do 'autoindent' if not marked as @indent
+    if
+      not q["indent.begin"][node:id()]
+      and not q["indent.align"][node:id()]
+      and q["indent.auto"][node:id()]
+      and node:start() < lnum - 1
+      and lnum - 1 <= node:end_()
+    then
+      return -1
+    end
+
+    -- Do not indent if we are inside an @ignore block.
+    -- If a node spans from L1,C1 to L2,C2, we know that lines where L1 < line <= L2 would
+    -- have their indentations contained by the node.
+    if
+      not q["indent.begin"][node:id()]
+      and q["indent.ignore"][node:id()]
+      and node:start() < lnum - 1
+      and lnum - 1 <= node:end_()
+    then
+      return 0
+    end
+
+    local srow, _, erow = node:range()
+
+    local is_processed = false
+
+    if
+      not is_processed_by_row[srow]
+      and ((q["indent.branch"][node:id()] and srow == lnum - 1) or (q["indent.dedent"][node:id()] and srow ~= lnum - 1))
+    then
+      indent = indent - indent_size
+      is_processed = true
+    end
+
+    -- do not indent for nodes that starts-and-ends on same line and starts on target line (lnum)
+    local should_process = not is_processed_by_row[srow]
+    local is_in_err = false
+    if should_process then
+      local parent = node:parent()
+      is_in_err = parent and parent:has_error()
+    end
+    if
+      should_process
+      and (
+        q["indent.begin"][node:id()]
+        and (srow ~= erow or is_in_err or q["indent.begin"][node:id()]["indent.immediate"])
+        and (srow ~= lnum - 1 or q["indent.begin"][node:id()]["indent.start_at_same_line"])
+      )
+    then
+      indent = indent + indent_size
+      is_processed = true
+    end
+
+    if is_in_err and not q["indent.align"][node:id()] then
+      -- only when the node is in error, promote the
+      -- first child's aligned indent to the error node
+      -- to work around ((ERROR "X" . (_)) @aligned_indent (#set! "delimeter" "AB"))
+      -- matching for all X, instead set do
+      -- (ERROR "X" @aligned_indent (#set! "delimeter" "AB") . (_))
+      -- and we will fish it out here.
+      for c in node:iter_children() do
+        if q["indent.align"][c:id()] then
+          q["indent.align"][node:id()] = q["indent.align"][c:id()]
+          break
+        end
+      end
+    end
+    -- do not indent for nodes that starts-and-ends on same line and starts on target line (lnum)
+    if should_process and q["indent.align"][node:id()] and (srow ~= erow or is_in_err) and (srow ~= lnum - 1) then
+      local metadata = q["indent.align"][node:id()]
+      local o_delim_node, o_is_last_in_line ---@type TSNode|nil, boolean|nil
+      local c_delim_node, c_is_last_in_line ---@type TSNode|nil, boolean|nil, boolean|nil
+      local indent_is_absolute = false
+      if metadata["indent.open_delimiter"] then
+        o_delim_node, o_is_last_in_line = find_delimiter(bufnr, node, metadata["indent.open_delimiter"])
+      else
+        o_delim_node = node
+      end
+      if metadata["indent.close_delimiter"] then
+        c_delim_node, c_is_last_in_line = find_delimiter(bufnr, node, metadata["indent.close_delimiter"])
+      else
+        c_delim_node = node
+      end
+
+      if o_delim_node then
+        local o_srow, o_scol = o_delim_node:start()
+        local c_srow = nil
+        if c_delim_node then
+          c_srow, _ = c_delim_node:start()
+        end
+        if o_is_last_in_line then
+          -- hanging indent (previous line ended with starting delimiter)
+          -- should be processed like indent
+          if should_process then
+            indent = indent + indent_size * 1
+            if c_is_last_in_line then
+              -- If current line is outside the range of a node marked with `@aligned_indent`
+              -- Then its indent level shouldn't be affected by `@aligned_indent` node
+              if c_srow and c_srow < lnum - 1 then
+                indent = math.max(indent - indent_size, 0)
+              end
+            end
+          end
+        else
+          -- aligned indent
+          if c_is_last_in_line and c_srow and o_srow ~= c_srow and c_srow < lnum - 1 then
+            -- If current line is outside the range of a node marked with `@aligned_indent`
+            -- Then its indent level shouldn't be affected by `@aligned_indent` node
+            indent = math.max(indent - indent_size, 0)
+          else
+            indent = o_scol + (metadata["indent.increment"] or 1)
+            indent_is_absolute = true
+          end
+        end
+        -- deal with the final line
+        local avoid_last_matching_next = false
+        if c_srow and c_srow ~= o_srow and c_srow == lnum - 1 then
+          -- delims end on current line, and are not open and closed same line.
+          -- then this last line may need additional indent to avoid clashes
+          -- with the next. `indent.avoid_last_matching_next` controls this behavior,
+          -- for example this is needed for function parameters.
+          avoid_last_matching_next = metadata["indent.avoid_last_matching_next"] or false
+        end
+        if avoid_last_matching_next then
+          -- last line must be indented more in cases where
+          -- it would be same indent as next line (we determine this as one
+          -- width more than the open indent to avoid confusing with any
+          -- hanging indents)
+          if indent <= vim.fn.indent(o_srow + 1) + indent_size then
+            indent = indent + indent_size * 1
+          else
+            indent = indent
+          end
+        end
+        is_processed = true
+        if indent_is_absolute then
+          -- don't allow further indenting by parent nodes, this is an absolute position
+          return indent
+        end
+      end
+    end
+
+    is_processed_by_row[srow] = is_processed_by_row[srow] or is_processed
+
+    node = node:parent()
+  end
+
+  return indent
+end
+
+---@type table<integer, string>
+local indent_funcs = {}
+
+---@param bufnr integer
+function M.attach(bufnr)
+  indent_funcs[bufnr] = vim.bo.indentexpr
+  vim.bo.indentexpr = "nvim_treesitter#indent()"
+end
+
+function M.detach(bufnr)
+  vim.bo.indentexpr = indent_funcs[bufnr]
+end
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/info.lua

@@ -0,0 +1,190 @@
+local api = vim.api
+local configs = require "nvim-treesitter.configs"
+local parsers = require "nvim-treesitter.parsers"
+
+local M = {}
+
+local function install_info()
+  local max_len = 0
+  for _, ft in pairs(parsers.available_parsers()) do
+    if #ft > max_len then
+      max_len = #ft
+    end
+  end
+
+  local parser_list = parsers.available_parsers()
+  table.sort(parser_list)
+  for _, lang in pairs(parser_list) do
+    local is_installed = #api.nvim_get_runtime_file("parser/" .. lang .. ".so", false) > 0
+    api.nvim_out_write(lang .. string.rep(" ", max_len - #lang + 1))
+    if is_installed then
+      api.nvim_out_write "[✓] installed\n"
+    elseif pcall(vim.treesitter.inspect_lang, lang) then
+      api.nvim_out_write "[✗] not installed (but still loaded. Restart Neovim!)\n"
+    else
+      api.nvim_out_write "[✗] not installed\n"
+    end
+  end
+end
+
+-- Sort a list of modules into namespaces.
+-- {'mod1', 'mod2.sub1', 'mod2.sub2', 'mod3'}
+-- ->
+-- { default = {'mod1', 'mod3'}, mod2 = {'sub1', 'sub2'}}
+---@param modulelist string[]
+---@return table
+local function namespace_modules(modulelist)
+  local modules = {}
+  for _, module in ipairs(modulelist) do
+    if module:find "%." then
+      local namespace, submodule = module:match "^(.*)%.(.*)$"
+      if not modules[namespace] then
+        modules[namespace] = {}
+      end
+      table.insert(modules[namespace], submodule)
+    else
+      if not modules.default then
+        modules.default = {}
+      end
+      table.insert(modules.default, module)
+    end
+  end
+  return modules
+end
+
+---@param list string[]
+---@return integer length
+local function longest_string_length(list)
+  local length = 0
+  for _, value in ipairs(list) do
+    if #value > length then
+      length = #value
+    end
+  end
+  return length
+end
+
+---@param curbuf integer
+---@param origbuf integer
+---@param parserlist string[]
+---@param namespace string
+---@param modulelist string[]
+local function append_module_table(curbuf, origbuf, parserlist, namespace, modulelist)
+  local maxlen_parser = longest_string_length(parserlist)
+  table.sort(modulelist)
+
+  -- header
+  local header = ">> " .. namespace .. string.rep(" ", maxlen_parser - #namespace - 1)
+  for _, module in pairs(modulelist) do
+    header = header .. module .. "  "
+  end
+  api.nvim_buf_set_lines(curbuf, -1, -1, true, { header })
+
+  -- actual table
+  for _, parser in ipairs(parserlist) do
+    local padding = string.rep(" ", maxlen_parser - #parser + 2)
+    local line = parser .. padding
+    local namespace_prefix = (namespace == "default") and "" or namespace .. "."
+    for _, module in pairs(modulelist) do
+      local modlen = #module
+      module = namespace_prefix .. module
+      if configs.is_enabled(module, parser, origbuf) then
+        line = line .. "✓"
+      else
+        line = line .. "✗"
+      end
+      line = line .. string.rep(" ", modlen + 1)
+    end
+    api.nvim_buf_set_lines(curbuf, -1, -1, true, { line })
+  end
+
+  api.nvim_buf_set_lines(curbuf, -1, -1, true, { "" })
+end
+
+local function print_info_modules(parserlist, module)
+  local origbuf = api.nvim_get_current_buf()
+  api.nvim_command "enew"
+  local curbuf = api.nvim_get_current_buf()
+
+  local modules
+  if module then
+    modules = namespace_modules { module }
+  else
+    modules = namespace_modules(configs.available_modules())
+  end
+
+  ---@type string[]
+  local namespaces = {}
+  for k, _ in pairs(modules) do
+    table.insert(namespaces, k)
+  end
+  table.sort(namespaces)
+
+  table.sort(parserlist)
+  for _, namespace in ipairs(namespaces) do
+    append_module_table(curbuf, origbuf, parserlist, namespace, modules[namespace])
+  end
+
+  api.nvim_buf_set_option(curbuf, "modified", false)
+  api.nvim_buf_set_option(curbuf, "buftype", "nofile")
+  vim.cmd [[
+  syntax match TSModuleInfoGood      /✓/
+  syntax match TSModuleInfoBad       /✗/
+  syntax match TSModuleInfoHeader    /^>>.*$/ contains=TSModuleInfoNamespace
+  syntax match TSModuleInfoNamespace /^>> \w*/ contained
+  syntax match TSModuleInfoParser    /^[^> ]*\ze /
+  ]]
+
+  local highlights = {
+    TSModuleInfoGood = { fg = "LightGreen", bold = true, default = true },
+    TSModuleInfoBad = { fg = "Crimson", default = true },
+    TSModuleInfoHeader = { link = "Type", default = true },
+    TSModuleInfoNamespace = { link = "Statement", default = true },
+    TSModuleInfoParser = { link = "Identifier", default = true },
+  }
+  for k, v in pairs(highlights) do
+    api.nvim_set_hl(0, k, v)
+  end
+end
+
+local function module_info(module)
+  if module and not configs.get_module(module) then
+    return
+  end
+
+  local parserlist = parsers.available_parsers()
+  if module then
+    print_info_modules(parserlist, module)
+  else
+    print_info_modules(parserlist)
+  end
+end
+
+---@return string[]
+function M.installed_parsers()
+  local installed = {}
+  for _, p in pairs(parsers.available_parsers()) do
+    if parsers.has_parser(p) then
+      table.insert(installed, p)
+    end
+  end
+  return installed
+end
+
+M.commands = {
+  TSInstallInfo = {
+    run = install_info,
+    args = {
+      "-nargs=0",
+    },
+  },
+  TSModuleInfo = {
+    run = module_info,
+    args = {
+      "-nargs=?",
+      "-complete=custom,nvim_treesitter#available_modules",
+    },
+  },
+}
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/install.lua

@@ -0,0 +1,773 @@
+local api = vim.api
+local fn = vim.fn
+local luv = vim.loop
+
+local utils = require "nvim-treesitter.utils"
+local parsers = require "nvim-treesitter.parsers"
+local info = require "nvim-treesitter.info"
+local configs = require "nvim-treesitter.configs"
+local shell = require "nvim-treesitter.shell_command_selectors"
+
+local M = {}
+
+---@class LockfileInfo
+---@field revision string
+
+---@type table<string, LockfileInfo>
+local lockfile = {}
+
+M.compilers = { vim.fn.getenv "CC", "cc", "gcc", "clang", "cl", "zig" }
+M.prefer_git = fn.has "win32" == 1
+M.command_extra_args = {}
+M.ts_generate_args = nil
+
+local started_commands = 0
+local finished_commands = 0
+local failed_commands = 0
+local complete_std_output = {}
+local complete_error_output = {}
+
+local function reset_progress_counter()
+  if started_commands ~= finished_commands then
+    return
+  end
+  started_commands = 0
+  finished_commands = 0
+  failed_commands = 0
+  complete_std_output = {}
+  complete_error_output = {}
+end
+
+local function get_job_status()
+  return "[nvim-treesitter] ["
+    .. finished_commands
+    .. "/"
+    .. started_commands
+    .. (failed_commands > 0 and ", failed: " .. failed_commands or "")
+    .. "]"
+end
+
+---@param lang string
+---@return function
+local function reattach_if_possible_fn(lang, error_on_fail)
+  return function()
+    for _, buf in ipairs(vim.api.nvim_list_bufs()) do
+      if parsers.get_buf_lang(buf) == lang then
+        vim._ts_remove_language(lang)
+        local ok, err
+        if vim.treesitter.language.add then
+          local ft = vim.bo[buf].filetype
+          ok, err = pcall(vim.treesitter.language.add, lang, { filetype = ft })
+        else
+          ok, err = pcall(vim.treesitter.language.require_language, lang)
+        end
+        if not ok and error_on_fail then
+          vim.notify("Could not load parser for " .. lang .. ": " .. vim.inspect(err))
+        end
+        for _, mod in ipairs(require("nvim-treesitter.configs").available_modules()) do
+          if ok then
+            require("nvim-treesitter.configs").reattach_module(mod, buf, lang)
+          else
+            require("nvim-treesitter.configs").detach_module(mod, buf)
+          end
+        end
+      end
+    end
+  end
+end
+
+---@param lang string
+---@param validate boolean|nil
+---@return InstallInfo
+local function get_parser_install_info(lang, validate)
+  local parser_config = parsers.get_parser_configs()[lang]
+
+  if not parser_config then
+    error('Parser not available for language "' .. lang .. '"')
+  end
+
+  local install_info = parser_config.install_info
+
+  if validate then
+    vim.validate {
+      url = { install_info.url, "string" },
+      files = { install_info.files, "table" },
+    }
+  end
+
+  return install_info
+end
+
+local function load_lockfile()
+  local filename = utils.join_path(utils.get_package_path(), "lockfile.json")
+  lockfile = vim.fn.filereadable(filename) == 1 and vim.fn.json_decode(vim.fn.readfile(filename)) or {}
+end
+
+local function is_ignored_parser(lang)
+  return vim.tbl_contains(configs.get_ignored_parser_installs(), lang)
+end
+
+---@param lang string
+---@return string|nil
+local function get_revision(lang)
+  if #lockfile == 0 then
+    load_lockfile()
+  end
+
+  local install_info = get_parser_install_info(lang)
+  if install_info.revision then
+    return install_info.revision
+  end
+
+  if lockfile[lang] then
+    return lockfile[lang].revision
+  end
+end
+
+---@param lang string
+---@return string|nil
+local function get_installed_revision(lang)
+  local lang_file = utils.join_path(configs.get_parser_info_dir(), lang .. ".revision")
+  if vim.fn.filereadable(lang_file) == 1 then
+    return vim.fn.readfile(lang_file)[1]
+  end
+end
+
+-- Clean path for use in a prefix comparison
+---@param input string
+---@return string
+local function clean_path(input)
+  local pth = vim.fn.fnamemodify(input, ":p")
+  if fn.has "win32" == 1 then
+    pth = pth:gsub("/", "\\")
+  end
+  return pth
+end
+
+-- Checks if parser is installed with nvim-treesitter
+---@param lang string
+---@return boolean
+local function is_installed(lang)
+  local matched_parsers = vim.api.nvim_get_runtime_file("parser/" .. lang .. ".so", true) or {}
+  local install_dir = configs.get_parser_install_dir()
+  if not install_dir then
+    return false
+  end
+  install_dir = clean_path(install_dir)
+  for _, path in ipairs(matched_parsers) do
+    local abspath = clean_path(path)
+    if vim.startswith(abspath, install_dir) then
+      return true
+    end
+  end
+  return false
+end
+
+---@param lang string
+---@return boolean
+local function needs_update(lang)
+  local revision = get_revision(lang)
+  return not revision or revision ~= get_installed_revision(lang)
+end
+
+---@return string[]
+local function outdated_parsers()
+  return vim.tbl_filter(function(lang) ---@param lang string
+    return is_installed(lang) and needs_update(lang)
+  end, info.installed_parsers())
+end
+
+---@param handle userdata
+---@param is_stderr boolean
+local function onread(handle, is_stderr)
+  return function(_, data)
+    if data then
+      if is_stderr then
+        complete_error_output[handle] = (complete_error_output[handle] or "") .. data
+      else
+        complete_std_output[handle] = (complete_std_output[handle] or "") .. data
+      end
+    end
+  end
+end
+
+function M.iter_cmd(cmd_list, i, lang, success_message)
+  if i == 1 then
+    started_commands = started_commands + 1
+  end
+  if i == #cmd_list + 1 then
+    finished_commands = finished_commands + 1
+    return print(get_job_status() .. " " .. success_message)
+  end
+
+  local attr = cmd_list[i]
+  if attr.info then
+    print(get_job_status() .. " " .. attr.info)
+  end
+
+  if attr.opts and attr.opts.args and M.command_extra_args[attr.cmd] then
+    vim.list_extend(attr.opts.args, M.command_extra_args[attr.cmd])
+  end
+
+  if type(attr.cmd) == "function" then
+    local ok, err = pcall(attr.cmd)
+    if ok then
+      M.iter_cmd(cmd_list, i + 1, lang, success_message)
+    else
+      failed_commands = failed_commands + 1
+      finished_commands = finished_commands + 1
+      return api.nvim_err_writeln(
+        (attr.err or ("Failed to execute the following command:\n" .. vim.inspect(attr))) .. "\n" .. vim.inspect(err)
+      )
+    end
+  else
+    local handle
+    local stdout = luv.new_pipe(false)
+    local stderr = luv.new_pipe(false)
+    attr.opts.stdio = { nil, stdout, stderr }
+    ---@type userdata
+    handle = luv.spawn(
+      attr.cmd,
+      attr.opts,
+      vim.schedule_wrap(function(code)
+        if code ~= 0 then
+          stdout:read_stop()
+          stderr:read_stop()
+        end
+        stdout:close()
+        stderr:close()
+        handle:close()
+        if code ~= 0 then
+          failed_commands = failed_commands + 1
+          finished_commands = finished_commands + 1
+          if complete_std_output[handle] and complete_std_output[handle] ~= "" then
+            print(complete_std_output[handle])
+          end
+
+          local err_msg = complete_error_output[handle] or ""
+          api.nvim_err_writeln(
+            "nvim-treesitter["
+              .. lang
+              .. "]: "
+              .. (attr.err or ("Failed to execute the following command:\n" .. vim.inspect(attr)))
+              .. "\n"
+              .. err_msg
+          )
+          return
+        end
+        M.iter_cmd(cmd_list, i + 1, lang, success_message)
+      end)
+    )
+    luv.read_start(stdout, onread(handle, false))
+    luv.read_start(stderr, onread(handle, true))
+  end
+end
+
+---@param cmd Command
+---@return string command
+local function get_command(cmd)
+  local options = ""
+  if cmd.opts and cmd.opts.args then
+    if M.command_extra_args[cmd.cmd] then
+      vim.list_extend(cmd.opts.args, M.command_extra_args[cmd.cmd])
+    end
+    for _, opt in ipairs(cmd.opts.args) do
+      options = string.format("%s %s", options, opt)
+    end
+  end
+
+  local command = string.format("%s %s", cmd.cmd, options)
+  if cmd.opts and cmd.opts.cwd then
+    command = shell.make_directory_change_for_command(cmd.opts.cwd, command)
+  end
+  return command
+end
+
+---@param cmd_list Command[]
+---@return boolean
+local function iter_cmd_sync(cmd_list)
+  for _, cmd in ipairs(cmd_list) do
+    if cmd.info then
+      print(cmd.info)
+    end
+
+    if type(cmd.cmd) == "function" then
+      cmd.cmd()
+    else
+      local ret = vim.fn.system(get_command(cmd))
+      if vim.v.shell_error ~= 0 then
+        print(ret)
+        api.nvim_err_writeln(
+          (cmd.err and cmd.err .. "\n" or "") .. "Failed to execute the following command:\n" .. vim.inspect(cmd)
+        )
+        return false
+      end
+    end
+  end
+
+  return true
+end
+
+---@param cache_folder string
+---@param install_folder string
+---@param lang string
+---@param repo InstallInfo
+---@param with_sync boolean
+---@param generate_from_grammar boolean
+local function run_install(cache_folder, install_folder, lang, repo, with_sync, generate_from_grammar)
+  parsers.reset_cache()
+
+  local path_sep = utils.get_path_sep()
+
+  local project_name = "tree-sitter-" .. lang
+  local maybe_local_path = vim.fn.expand(repo.url)
+  local from_local_path = vim.fn.isdirectory(maybe_local_path) == 1
+  if from_local_path then
+    repo.url = maybe_local_path
+  end
+
+  ---@type string compile_location only needed for typescript installs.
+  local compile_location
+  if from_local_path then
+    compile_location = repo.url
+    if repo.location then
+      compile_location = utils.join_path(compile_location, repo.location)
+    end
+  else
+    local repo_location = project_name
+    if repo.location then
+      repo_location = repo_location .. "/" .. repo.location
+    end
+    repo_location = repo_location:gsub("/", path_sep)
+    compile_location = utils.join_path(cache_folder, repo_location)
+  end
+  local parser_lib_name = utils.join_path(install_folder, lang) .. ".so"
+
+  generate_from_grammar = repo.requires_generate_from_grammar or generate_from_grammar
+
+  if generate_from_grammar and vim.fn.executable "tree-sitter" ~= 1 then
+    api.nvim_err_writeln "tree-sitter CLI not found: `tree-sitter` is not executable!"
+    if repo.requires_generate_from_grammar then
+      api.nvim_err_writeln(
+        "tree-sitter CLI is needed because `"
+          .. lang
+          .. "` is marked that it needs "
+          .. "to be generated from the grammar definitions to be compatible with nvim!"
+      )
+    end
+    return
+  else
+    if not M.ts_generate_args then
+      local ts_cli_version = utils.ts_cli_version()
+      if ts_cli_version and vim.split(ts_cli_version, " ")[1] > "0.20.2" then
+        M.ts_generate_args = { "generate", "--abi", vim.treesitter.language_version }
+      else
+        M.ts_generate_args = { "generate" }
+      end
+    end
+  end
+  if generate_from_grammar and vim.fn.executable "node" ~= 1 then
+    api.nvim_err_writeln "Node JS not found: `node` is not executable!"
+    return
+  end
+  local cc = shell.select_executable(M.compilers)
+  if not cc then
+    api.nvim_err_writeln('No C compiler found! "' .. table.concat(
+      vim.tbl_filter(function(c) ---@param c string
+        return type(c) == "string"
+      end, M.compilers),
+      '", "'
+    ) .. '" are not executable.')
+    return
+  end
+
+  local revision = repo.revision
+  if not revision then
+    revision = get_revision(lang)
+  end
+
+  ---@class Command
+  ---@field cmd string
+  ---@field info string
+  ---@field err string
+  ---@field opts CmdOpts
+
+  ---@class CmdOpts
+  ---@field args string[]
+  ---@field cwd string
+
+  ---@type Command[]
+  local command_list = {}
+  if not from_local_path then
+    vim.list_extend(command_list, { shell.select_install_rm_cmd(cache_folder, project_name) })
+    vim.list_extend(
+      command_list,
+      shell.select_download_commands(repo, project_name, cache_folder, revision, M.prefer_git)
+    )
+  end
+  if generate_from_grammar then
+    if repo.generate_requires_npm then
+      if vim.fn.executable "npm" ~= 1 then
+        api.nvim_err_writeln("`" .. lang .. "` requires NPM to be installed from grammar.js")
+        return
+      end
+      vim.list_extend(command_list, {
+        {
+          cmd = "npm",
+          info = "Installing NPM dependencies of " .. lang .. " parser",
+          err = "Error during `npm install` (required for parser generation of " .. lang .. " with npm dependencies)",
+          opts = {
+            args = { "install" },
+            cwd = compile_location,
+          },
+        },
+      })
+    end
+    vim.list_extend(command_list, {
+      {
+        cmd = vim.fn.exepath "tree-sitter",
+        info = "Generating source files from grammar.js...",
+        err = 'Error during "tree-sitter generate"',
+        opts = {
+          args = M.ts_generate_args,
+          cwd = compile_location,
+        },
+      },
+    })
+  end
+  vim.list_extend(command_list, {
+    shell.select_compile_command(repo, cc, compile_location),
+    shell.select_mv_cmd("parser.so", parser_lib_name, compile_location),
+    {
+      cmd = function()
+        vim.fn.writefile({ revision or "" }, utils.join_path(configs.get_parser_info_dir() or "", lang .. ".revision"))
+      end,
+    },
+    { -- auto-attach modules after installation
+      cmd = reattach_if_possible_fn(lang, true),
+    },
+  })
+  if not from_local_path then
+    vim.list_extend(command_list, { shell.select_install_rm_cmd(cache_folder, project_name) })
+  end
+
+  if with_sync then
+    if iter_cmd_sync(command_list) == true then
+      print("Treesitter parser for " .. lang .. " has been installed")
+    end
+  else
+    M.iter_cmd(command_list, 1, lang, "Treesitter parser for " .. lang .. " has been installed")
+  end
+end
+
+---@param lang string
+---@param ask_reinstall boolean|string
+---@param cache_folder string
+---@param install_folder string
+---@param with_sync boolean
+---@param generate_from_grammar boolean
+local function install_lang(lang, ask_reinstall, cache_folder, install_folder, with_sync, generate_from_grammar)
+  if is_installed(lang) and ask_reinstall ~= "force" then
+    if not ask_reinstall then
+      return
+    end
+
+    local yesno = fn.input(lang .. " parser already available: would you like to reinstall ? y/n: ")
+    print "\n "
+    if not string.match(yesno, "^y.*") then
+      return
+    end
+  end
+
+  local ok, install_info = pcall(get_parser_install_info, lang, true)
+  if not ok then
+    vim.notify("Installation not possible: " .. install_info, vim.log.levels.ERROR)
+    if not parsers.get_parser_configs()[lang] then
+      vim.notify(
+        "See https://github.com/nvim-treesitter/nvim-treesitter/#adding-parsers on how to add a new parser!",
+        vim.log.levels.INFO
+      )
+    end
+    return
+  end
+
+  run_install(cache_folder, install_folder, lang, install_info, with_sync, generate_from_grammar)
+end
+
+---@class InstallOptions
+---@field with_sync boolean
+---@field ask_reinstall boolean|string
+---@field generate_from_grammar boolean
+---@field exclude_configured_parsers boolean
+
+-- Install a parser
+---@param options? InstallOptions
+---@return function
+local function install(options)
+  options = options or {}
+  local with_sync = options.with_sync
+  local ask_reinstall = options.ask_reinstall
+  local generate_from_grammar = options.generate_from_grammar
+  local exclude_configured_parsers = options.exclude_configured_parsers
+
+  return function(...)
+    if fn.executable "git" == 0 then
+      return api.nvim_err_writeln "Git is required on your system to run this command"
+    end
+
+    local cache_folder, err = utils.get_cache_dir()
+    if err then
+      return api.nvim_err_writeln(err)
+    end
+    assert(cache_folder)
+
+    local install_folder
+    install_folder, err = configs.get_parser_install_dir()
+    if err then
+      return api.nvim_err_writeln(err)
+    end
+    assert(install_folder)
+
+    local languages ---@type string[]
+    local ask ---@type boolean|string
+    if ... == "all" then
+      languages = parsers.available_parsers()
+      ask = false
+    else
+      languages = vim.tbl_flatten { ... }
+      ask = ask_reinstall
+    end
+
+    if exclude_configured_parsers then
+      languages = utils.difference(languages, configs.get_ignored_parser_installs())
+    end
+
+    if #languages > 1 then
+      reset_progress_counter()
+    end
+
+    for _, lang in ipairs(languages) do
+      install_lang(lang, ask, cache_folder, install_folder, with_sync, generate_from_grammar)
+    end
+  end
+end
+
+function M.setup_auto_install()
+  vim.api.nvim_create_autocmd("FileType", {
+    pattern = { "*" },
+    callback = function()
+      local lang = parsers.get_buf_lang()
+      if parsers.get_parser_configs()[lang] and not is_installed(lang) and not is_ignored_parser(lang) then
+        install() { lang }
+      end
+    end,
+  })
+end
+
+function M.update(options)
+  options = options or {}
+  return function(...)
+    M.lockfile = {}
+    reset_progress_counter()
+    if ... and ... ~= "all" then
+      ---@type string[]
+      local languages = vim.tbl_flatten { ... }
+      local installed = 0
+      for _, lang in ipairs(languages) do
+        if (not is_installed(lang)) or (needs_update(lang)) then
+          installed = installed + 1
+          install {
+            ask_reinstall = "force",
+            with_sync = options.with_sync,
+          }(lang)
+        end
+      end
+      if installed == 0 then
+        utils.notify "Parsers are up-to-date!"
+      end
+    else
+      local parsers_to_update = outdated_parsers() or info.installed_parsers()
+      if #parsers_to_update == 0 then
+        utils.notify "All parsers are up-to-date!"
+      end
+      for _, lang in pairs(parsers_to_update) do
+        install {
+          ask_reinstall = "force",
+          exclude_configured_parsers = true,
+          with_sync = options.with_sync,
+        }(lang)
+      end
+    end
+  end
+end
+
+function M.uninstall(...)
+  if vim.tbl_contains({ "all" }, ...) then
+    reset_progress_counter()
+    local installed = info.installed_parsers()
+    M.uninstall(installed)
+  elseif ... then
+    local ensure_installed_parsers = configs.get_ensure_installed_parsers()
+    if ensure_installed_parsers == "all" then
+      ensure_installed_parsers = parsers.available_parsers()
+    end
+    ensure_installed_parsers = utils.difference(ensure_installed_parsers, configs.get_ignored_parser_installs())
+
+    ---@type string[]
+    local languages = vim.tbl_flatten { ... }
+    for _, lang in ipairs(languages) do
+      local install_dir, err = configs.get_parser_install_dir()
+      if err then
+        return api.nvim_err_writeln(err)
+      end
+
+      if vim.tbl_contains(ensure_installed_parsers, lang) then
+        vim.notify(
+          "Uninstalling "
+            .. lang
+            .. '. But the parser is still configured in "ensure_installed" setting of nvim-treesitter.'
+            .. " Please consider updating your config!",
+          vim.log.levels.ERROR
+        )
+      end
+
+      local parser_lib = utils.join_path(install_dir, lang) .. ".so"
+      local all_parsers = vim.api.nvim_get_runtime_file("parser/" .. lang .. ".so", true)
+      if vim.fn.filereadable(parser_lib) == 1 then
+        local command_list = {
+          shell.select_rm_file_cmd(parser_lib, "Uninstalling parser for " .. lang),
+          {
+            cmd = function()
+              local all_parsers_after_deletion = vim.api.nvim_get_runtime_file("parser/" .. lang .. ".so", true)
+              if #all_parsers_after_deletion > 0 then
+                vim.notify(
+                  "Tried to uninstall parser for "
+                    .. lang
+                    .. "! But the parser is still installed (not by nvim-treesitter):"
+                    .. table.concat(all_parsers_after_deletion, ", "),
+                  vim.log.levels.ERROR
+                )
+              end
+            end,
+          },
+          { -- auto-reattach or detach modules after uninstallation
+            cmd = reattach_if_possible_fn(lang, false),
+          },
+        }
+        M.iter_cmd(command_list, 1, lang, "Treesitter parser for " .. lang .. " has been uninstalled")
+      elseif #all_parsers > 0 then
+        vim.notify(
+          "Parser for "
+            .. lang
+            .. " is installed! But not by nvim-treesitter! Please manually remove the following files: "
+            .. table.concat(all_parsers, ", "),
+          vim.log.levels.ERROR
+        )
+      end
+    end
+  end
+end
+
+function M.write_lockfile(verbose, skip_langs)
+  local sorted_parsers = {} ---@type Parser[]
+  -- Load previous lockfile
+  load_lockfile()
+  skip_langs = skip_langs or {}
+
+  for k, v in pairs(parsers.get_parser_configs()) do
+    table.insert(sorted_parsers, { name = k, parser = v })
+  end
+
+  ---@param a Parser
+  ---@param b Parser
+  table.sort(sorted_parsers, function(a, b)
+    return a.name < b.name
+  end)
+
+  for _, v in ipairs(sorted_parsers) do
+    if not vim.tbl_contains(skip_langs, v.name) then
+      -- I'm sure this can be done in aync way with iter_cmd
+      local sha ---@type string
+      if v.parser.install_info.branch then
+        sha = vim.split(
+          vim.fn.systemlist(
+            "git ls-remote " .. v.parser.install_info.url .. " | grep refs/heads/" .. v.parser.install_info.branch
+          )[1],
+          "\t"
+        )[1]
+      else
+        sha = vim.split(vim.fn.systemlist("git ls-remote " .. v.parser.install_info.url)[1], "\t")[1]
+      end
+      lockfile[v.name] = { revision = sha }
+      if verbose then
+        print(v.name .. ": " .. sha)
+      end
+    else
+      print("Skipping " .. v.name)
+    end
+  end
+
+  if verbose then
+    print(vim.inspect(lockfile))
+  end
+  vim.fn.writefile(
+    vim.fn.split(vim.fn.json_encode(lockfile), "\n"),
+    utils.join_path(utils.get_package_path(), "lockfile.json")
+  )
+end
+
+M.ensure_installed = install { exclude_configured_parsers = true }
+M.ensure_installed_sync = install { with_sync = true, exclude_configured_parsers = true }
+
+M.commands = {
+  TSInstall = {
+    run = install { ask_reinstall = true },
+    ["run!"] = install { ask_reinstall = "force" },
+    args = {
+      "-nargs=+",
+      "-bang",
+      "-complete=custom,nvim_treesitter#installable_parsers",
+    },
+  },
+  TSInstallFromGrammar = {
+    run = install { generate_from_grammar = true, ask_reinstall = true },
+    ["run!"] = install { generate_from_grammar = true, ask_reinstall = "force" },
+    args = {
+      "-nargs=+",
+      "-bang",
+      "-complete=custom,nvim_treesitter#installable_parsers",
+    },
+  },
+  TSInstallSync = {
+    run = install { with_sync = true, ask_reinstall = true },
+    ["run!"] = install { with_sync = true, ask_reinstall = "force" },
+    args = {
+      "-nargs=+",
+      "-bang",
+      "-complete=custom,nvim_treesitter#installable_parsers",
+    },
+  },
+  TSUpdate = {
+    run = M.update {},
+    args = {
+      "-nargs=*",
+      "-complete=custom,nvim_treesitter#installed_parsers",
+    },
+  },
+  TSUpdateSync = {
+    run = M.update { with_sync = true },
+    args = {
+      "-nargs=*",
+      "-complete=custom,nvim_treesitter#installed_parsers",
+    },
+  },
+  TSUninstall = {
+    run = M.uninstall,
+    args = {
+      "-nargs=+",
+      "-complete=custom,nvim_treesitter#installed_parsers",
+    },
+  },
+}
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/locals.lua

@@ -0,0 +1,364 @@
+-- Functions to handle locals
+-- Locals are a generalization of definition and scopes
+-- its the way nvim-treesitter uses to "understand" the code
+
+local queries = require "nvim-treesitter.query"
+local ts_utils = require "nvim-treesitter.ts_utils"
+local ts = vim.treesitter
+local api = vim.api
+
+local M = {}
+
+function M.collect_locals(bufnr)
+  return queries.collect_group_results(bufnr, "locals")
+end
+
+-- Iterates matches from a locals query file.
+-- @param bufnr the buffer
+-- @param root the root node
+function M.iter_locals(bufnr, root)
+  return queries.iter_group_results(bufnr, "locals", root)
+end
+
+---@param bufnr integer
+---@return any
+function M.get_locals(bufnr)
+  return queries.get_matches(bufnr, "locals")
+end
+
+-- Creates unique id for a node based on text and range
+---@param scope TSNode: the scope node of the definition
+---@param node_text string: the node text to use
+---@return string: a string id
+function M.get_definition_id(scope, node_text)
+  -- Add a valid starting character in case node text doesn't start with a valid one.
+  return table.concat({ "k", node_text or "", scope:range() }, "_")
+end
+
+function M.get_definitions(bufnr)
+  local locals = M.get_locals(bufnr)
+
+  local defs = {}
+
+  for _, loc in ipairs(locals) do
+    if loc.definition then
+      table.insert(defs, loc.definition)
+    end
+  end
+
+  return defs
+end
+
+function M.get_scopes(bufnr)
+  local locals = M.get_locals(bufnr)
+
+  local scopes = {}
+
+  for _, loc in ipairs(locals) do
+    if loc.scope and loc.scope.node then
+      table.insert(scopes, loc.scope.node)
+    end
+  end
+
+  return scopes
+end
+
+function M.get_references(bufnr)
+  local locals = M.get_locals(bufnr)
+
+  local refs = {}
+
+  for _, loc in ipairs(locals) do
+    if loc.reference and loc.reference.node then
+      table.insert(refs, loc.reference.node)
+    end
+  end
+
+  return refs
+end
+
+-- Gets a table with all the scopes containing a node
+-- The order is from most specific to least (bottom up)
+---@param node TSNode
+---@param bufnr integer
+---@return TSNode[]
+function M.get_scope_tree(node, bufnr)
+  local scopes = {} ---@type TSNode[]
+
+  for scope in M.iter_scope_tree(node, bufnr) do
+    table.insert(scopes, scope)
+  end
+
+  return scopes
+end
+
+-- Iterates over a nodes scopes moving from the bottom up
+---@param node TSNode
+---@param bufnr integer
+---@return fun(): TSNode|nil
+function M.iter_scope_tree(node, bufnr)
+  local last_node = node
+  return function()
+    if not last_node then
+      return
+    end
+
+    local scope = M.containing_scope(last_node, bufnr, false) or ts_utils.get_root_for_node(node)
+
+    last_node = scope:parent()
+
+    return scope
+  end
+end
+
+-- Gets a table of all nodes and their 'kinds' from a locals list
+---@param local_def any: the local list result
+---@return table: a list of node entries
+function M.get_local_nodes(local_def)
+  local result = {}
+
+  M.recurse_local_nodes(local_def, function(def, _node, kind)
+    table.insert(result, vim.tbl_extend("keep", { kind = kind }, def))
+  end)
+
+  return result
+end
+
+-- Recurse locals results until a node is found.
+-- The accumulator function is given
+-- * The table of the node
+-- * The node
+-- * The full definition match `@definition.var.something` -> 'var.something'
+-- * The last definition match `@definition.var.something` -> 'something'
+---@param local_def any The locals result
+---@param accumulator function The accumulator function
+---@param full_match? string The full match path to append to
+---@param last_match? string The last match
+function M.recurse_local_nodes(local_def, accumulator, full_match, last_match)
+  if type(local_def) ~= "table" then
+    return
+  end
+
+  if local_def.node then
+    accumulator(local_def, local_def.node, full_match, last_match)
+  else
+    for match_key, def in pairs(local_def) do
+      M.recurse_local_nodes(def, accumulator, full_match and (full_match .. "." .. match_key) or match_key, match_key)
+    end
+  end
+end
+
+-- Get a single dimension table to look definition nodes.
+-- Keys are generated by using the range of the containing scope and the text of the definition node.
+-- This makes looking up a definition for a given scope a simple key lookup.
+--
+-- This is memoized by buffer tick. If the function is called in succession
+-- without the buffer tick changing, then the previous result will be used
+-- since the syntax tree hasn't changed.
+--
+-- Usage lookups require finding the definition of the node, so `find_definition`
+-- is called very frequently, which is why this lookup must be fast as possible.
+--
+---@param bufnr integer: the buffer
+---@return table result: a table for looking up definitions
+M.get_definitions_lookup_table = ts_utils.memoize_by_buf_tick(function(bufnr)
+  local definitions = M.get_definitions(bufnr)
+  local result = {}
+
+  for _, definition in ipairs(definitions) do
+    for _, node_entry in ipairs(M.get_local_nodes(definition)) do
+      local scopes = M.get_definition_scopes(node_entry.node, bufnr, node_entry.scope)
+      -- Always use the highest valid scope
+      local scope = scopes[#scopes]
+      local node_text = ts.get_node_text(node_entry.node, bufnr)
+      local id = M.get_definition_id(scope, node_text)
+
+      result[id] = node_entry
+    end
+  end
+
+  return result
+end)
+
+-- Gets all the scopes of a definition based on the scope type
+-- Scope types can be
+--
+-- "parent": Uses the parent of the containing scope, basically, skipping a scope
+-- "global": Uses the top most scope
+-- "local": Uses the containing scope of the definition. This is the default
+--
+---@param node TSNode: the definition node
+---@param bufnr integer: the buffer
+---@param scope_type string: the scope type
+function M.get_definition_scopes(node, bufnr, scope_type)
+  local scopes = {}
+  local scope_count = 1 ---@type integer|nil
+
+  -- Definition is valid for the containing scope
+  -- and the containing scope of that scope
+  if scope_type == "parent" then
+    scope_count = 2
+    -- Definition is valid in all parent scopes
+  elseif scope_type == "global" then
+    scope_count = nil
+  end
+
+  local i = 0
+  for scope in M.iter_scope_tree(node, bufnr) do
+    table.insert(scopes, scope)
+    i = i + 1
+
+    if scope_count and i >= scope_count then
+      break
+    end
+  end
+
+  return scopes
+end
+
+---@param node TSNode
+---@param bufnr integer
+---@return TSNode node
+---@return TSNode scope
+---@return string|nil kind
+function M.find_definition(node, bufnr)
+  local def_lookup = M.get_definitions_lookup_table(bufnr)
+  local node_text = ts.get_node_text(node, bufnr)
+
+  for scope in M.iter_scope_tree(node, bufnr) do
+    local id = M.get_definition_id(scope, node_text)
+
+    if def_lookup[id] then
+      local entry = def_lookup[id]
+
+      return entry.node, scope, entry.kind
+    end
+  end
+
+  return node, ts_utils.get_root_for_node(node), nil
+end
+
+-- Finds usages of a node in a given scope.
+---@param node TSNode the node to find usages for
+---@param scope_node TSNode the node to look within
+---@return TSNode[]: a list of nodes
+function M.find_usages(node, scope_node, bufnr)
+  bufnr = bufnr or api.nvim_get_current_buf()
+  local node_text = ts.get_node_text(node, bufnr)
+
+  if not node_text or #node_text < 1 then
+    return {}
+  end
+
+  local scope_node = scope_node or ts_utils.get_root_for_node(node)
+  local usages = {}
+
+  for match in M.iter_locals(bufnr, scope_node) do
+    if match.reference and match.reference.node and ts.get_node_text(match.reference.node, bufnr) == node_text then
+      local def_node, _, kind = M.find_definition(match.reference.node, bufnr)
+
+      if kind == nil or def_node == node then
+        table.insert(usages, match.reference.node)
+      end
+    end
+  end
+
+  return usages
+end
+
+---@param node TSNode
+---@param bufnr? integer
+---@param allow_scope? boolean
+---@return TSNode|nil
+function M.containing_scope(node, bufnr, allow_scope)
+  local bufnr = bufnr or api.nvim_get_current_buf()
+  local allow_scope = allow_scope == nil or allow_scope == true
+
+  local scopes = M.get_scopes(bufnr)
+  if not node or not scopes then
+    return
+  end
+
+  local iter_node = node
+
+  while iter_node ~= nil and not vim.tbl_contains(scopes, iter_node) do
+    iter_node = iter_node:parent()
+  end
+
+  return iter_node or (allow_scope and node or nil)
+end
+
+function M.nested_scope(node, cursor_pos)
+  local bufnr = api.nvim_get_current_buf()
+
+  local scopes = M.get_scopes(bufnr)
+  if not node or not scopes then
+    return
+  end
+
+  local row = cursor_pos.row ---@type integer
+  local col = cursor_pos.col ---@type integer
+  local scope = M.containing_scope(node)
+
+  for _, child in ipairs(ts_utils.get_named_children(scope)) do
+    local row_, col_ = child:start()
+    if vim.tbl_contains(scopes, child) and ((row_ + 1 == row and col_ > col) or row_ + 1 > row) then
+      return child
+    end
+  end
+end
+
+function M.next_scope(node)
+  local bufnr = api.nvim_get_current_buf()
+
+  local scopes = M.get_scopes(bufnr)
+  if not node or not scopes then
+    return
+  end
+
+  local scope = M.containing_scope(node)
+
+  local parent = scope:parent()
+  if not parent then
+    return
+  end
+
+  local is_prev = true
+  for _, child in ipairs(ts_utils.get_named_children(parent)) do
+    if child == scope then
+      is_prev = false
+    elseif not is_prev and vim.tbl_contains(scopes, child) then
+      return child
+    end
+  end
+end
+
+---@param node TSNode
+---@return TSNode|nil
+function M.previous_scope(node)
+  local bufnr = api.nvim_get_current_buf()
+
+  local scopes = M.get_scopes(bufnr)
+  if not node or not scopes then
+    return
+  end
+
+  local scope = M.containing_scope(node)
+
+  local parent = scope:parent()
+  if not parent then
+    return
+  end
+
+  local is_prev = true
+  local children = ts_utils.get_named_children(parent)
+  for i = #children, 1, -1 do
+    if children[i] == scope then
+      is_prev = false
+    elseif not is_prev and vim.tbl_contains(scopes, children[i]) then
+      return children[i]
+    end
+  end
+end
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/query.lua

@@ -0,0 +1,453 @@
+local api = vim.api
+local ts = require "nvim-treesitter.compat"
+local tsrange = require "nvim-treesitter.tsrange"
+local utils = require "nvim-treesitter.utils"
+local parsers = require "nvim-treesitter.parsers"
+local caching = require "nvim-treesitter.caching"
+
+local M = {}
+
+local EMPTY_ITER = function() end
+
+M.built_in_query_groups = { "highlights", "locals", "folds", "indents", "injections" }
+
+-- Creates a function that checks whether a given query exists
+-- for a specific language.
+---@param query string
+---@return fun(string): boolean
+local function get_query_guard(query)
+  return function(lang)
+    return M.has_query_files(lang, query)
+  end
+end
+
+for _, query in ipairs(M.built_in_query_groups) do
+  M["has_" .. query] = get_query_guard(query)
+end
+
+---@return string[]
+function M.available_query_groups()
+  local query_files = api.nvim_get_runtime_file("queries/*/*.scm", true)
+  local groups = {}
+  for _, f in ipairs(query_files) do
+    groups[vim.fn.fnamemodify(f, ":t:r")] = true
+  end
+  local list = {}
+  for k, _ in pairs(groups) do
+    table.insert(list, k)
+  end
+  return list
+end
+
+do
+  local query_cache = caching.create_buffer_cache()
+
+  local function update_cached_matches(bufnr, changed_tick, query_group)
+    query_cache.set(query_group, bufnr, {
+      tick = changed_tick,
+      cache = M.collect_group_results(bufnr, query_group) or {},
+    })
+  end
+
+  ---@param bufnr integer
+  ---@param query_group string
+  ---@return any
+  function M.get_matches(bufnr, query_group)
+    bufnr = bufnr or api.nvim_get_current_buf()
+    local cached_local = query_cache.get(query_group, bufnr)
+    if not cached_local or api.nvim_buf_get_changedtick(bufnr) > cached_local.tick then
+      update_cached_matches(bufnr, api.nvim_buf_get_changedtick(bufnr), query_group)
+    end
+
+    return query_cache.get(query_group, bufnr).cache
+  end
+end
+
+---@param lang string
+---@param query_name string
+---@return string[]
+local function runtime_queries(lang, query_name)
+  return api.nvim_get_runtime_file(string.format("queries/%s/%s.scm", lang, query_name), true) or {}
+end
+
+---@type table<string, table<string, boolean>>
+local query_files_cache = {}
+
+---@param lang string
+---@param query_name string
+---@return boolean
+function M.has_query_files(lang, query_name)
+  if not query_files_cache[lang] then
+    query_files_cache[lang] = {}
+  end
+  if query_files_cache[lang][query_name] == nil then
+    local files = runtime_queries(lang, query_name)
+    query_files_cache[lang][query_name] = files and #files > 0
+  end
+  return query_files_cache[lang][query_name]
+end
+
+do
+  local mt = {}
+  mt.__index = function(tbl, key)
+    if rawget(tbl, key) == nil then
+      rawset(tbl, key, {})
+    end
+    return rawget(tbl, key)
+  end
+
+  -- cache will auto set the table for each lang if it is nil
+  ---@type table<string, table<string, Query>>
+  local cache = setmetatable({}, mt)
+
+  -- Same as `vim.treesitter.query` except will return cached values
+  ---@param lang string
+  ---@param query_name string
+  function M.get_query(lang, query_name)
+    if cache[lang][query_name] == nil then
+      cache[lang][query_name] = ts.get_query(lang, query_name)
+    end
+
+    return cache[lang][query_name]
+  end
+
+  -- Invalidates the query file cache.
+  --
+  -- If lang and query_name is both present, will reload for only the lang and query_name.
+  -- If only lang is present, will reload all query_names for that lang
+  -- If none are present, will reload everything
+  ---@param lang? string
+  ---@param query_name? string
+  function M.invalidate_query_cache(lang, query_name)
+    if lang and query_name then
+      cache[lang][query_name] = nil
+      if query_files_cache[lang] then
+        query_files_cache[lang][query_name] = nil
+      end
+    elseif lang and not query_name then
+      query_files_cache[lang] = nil
+      for query_name0, _ in pairs(cache[lang]) do
+        M.invalidate_query_cache(lang, query_name0)
+      end
+    elseif not lang and not query_name then
+      query_files_cache = {}
+      for lang0, _ in pairs(cache) do
+        for query_name0, _ in pairs(cache[lang0]) do
+          M.invalidate_query_cache(lang0, query_name0)
+        end
+      end
+    else
+      error "Cannot have query_name by itself!"
+    end
+  end
+end
+
+-- This function is meant for an autocommand and not to be used. Only use if file is a query file.
+---@param fname string
+function M.invalidate_query_file(fname)
+  local fnamemodify = vim.fn.fnamemodify
+  M.invalidate_query_cache(fnamemodify(fname, ":p:h:t"), fnamemodify(fname, ":t:r"))
+end
+
+---@class QueryInfo
+---@field root TSNode
+---@field source integer
+---@field start integer
+---@field stop integer
+
+---@param bufnr integer
+---@param query_name string
+---@param root TSNode
+---@param root_lang string|nil
+---@return Query|nil, QueryInfo|nil
+local function prepare_query(bufnr, query_name, root, root_lang)
+  local buf_lang = parsers.get_buf_lang(bufnr)
+
+  if not buf_lang then
+    return
+  end
+
+  local parser = parsers.get_parser(bufnr, buf_lang)
+  if not parser then
+    return
+  end
+
+  if not root then
+    local first_tree = parser:trees()[1]
+
+    if first_tree then
+      root = first_tree:root()
+    end
+  end
+
+  if not root then
+    return
+  end
+
+  local range = { root:range() }
+
+  if not root_lang then
+    local lang_tree = parser:language_for_range(range)
+
+    if lang_tree then
+      root_lang = lang_tree:lang()
+    end
+  end
+
+  if not root_lang then
+    return
+  end
+
+  local query = M.get_query(root_lang, query_name)
+  if not query then
+    return
+  end
+
+  return query,
+    {
+      root = root,
+      source = bufnr,
+      start = range[1],
+      -- The end row is exclusive so we need to add 1 to it.
+      stop = range[3] + 1,
+    }
+end
+
+-- Given a path (i.e. a List(String)) this functions inserts value at path
+---@param object any
+---@param path string[]
+---@param value any
+function M.insert_to_path(object, path, value)
+  local curr_obj = object
+
+  for index = 1, (#path - 1) do
+    if curr_obj[path[index]] == nil then
+      curr_obj[path[index]] = {}
+    end
+
+    curr_obj = curr_obj[path[index]]
+  end
+
+  curr_obj[path[#path]] = value
+end
+
+---@param query Query
+---@param bufnr integer
+---@param start_row integer
+---@param end_row integer
+function M.iter_prepared_matches(query, qnode, bufnr, start_row, end_row)
+  -- A function that splits  a string on '.'
+  ---@param to_split string
+  ---@return string[]
+  local function split(to_split)
+    local t = {}
+    for str in string.gmatch(to_split, "([^.]+)") do
+      table.insert(t, str)
+    end
+
+    return t
+  end
+
+  local matches = query:iter_matches(qnode, bufnr, start_row, end_row)
+
+  local function iterator()
+    local pattern, match, metadata = matches()
+    if pattern ~= nil then
+      local prepared_match = {}
+
+      -- Extract capture names from each match
+      for id, node in pairs(match) do
+        local name = query.captures[id] -- name of the capture in the query
+        if name ~= nil then
+          local path = split(name .. ".node")
+          M.insert_to_path(prepared_match, path, node)
+          local metadata_path = split(name .. ".metadata")
+          M.insert_to_path(prepared_match, metadata_path, metadata[id])
+        end
+      end
+
+      -- Add some predicates for testing
+      ---@type string[][] ( TODO: make pred type so this can be pred[])
+      local preds = query.info.patterns[pattern]
+      if preds then
+        for _, pred in pairs(preds) do
+          -- functions
+          if pred[1] == "set!" and type(pred[2]) == "string" then
+            M.insert_to_path(prepared_match, split(pred[2]), pred[3])
+          end
+          if pred[1] == "make-range!" and type(pred[2]) == "string" and #pred == 4 then
+            M.insert_to_path(
+              prepared_match,
+              split(pred[2] .. ".node"),
+              tsrange.TSRange.from_nodes(bufnr, match[pred[3]], match[pred[4]])
+            )
+          end
+        end
+      end
+
+      return prepared_match
+    end
+  end
+  return iterator
+end
+
+-- Return all nodes corresponding to a specific capture path (like @definition.var, @reference.type)
+-- Works like M.get_references or M.get_scopes except you can choose the capture
+-- Can also be a nested capture like @definition.function to get all nodes defining a function.
+--
+---@param bufnr integer the buffer
+---@param captures string|string[]
+---@param query_group string the name of query group (highlights or injections for example)
+---@param root TSNode|nil node from where to start the search
+---@param lang string|nil the language from where to get the captures.
+---              Root nodes can have several languages.
+---@return table|nil
+function M.get_capture_matches(bufnr, captures, query_group, root, lang)
+  if type(captures) == "string" then
+    captures = { captures }
+  end
+  local strip_captures = {} ---@type string[]
+  for i, capture in ipairs(captures) do
+    if capture:sub(1, 1) ~= "@" then
+      error 'Captures must start with "@"'
+      return
+    end
+    -- Remove leading "@".
+    strip_captures[i] = capture:sub(2)
+  end
+
+  local matches = {}
+  for match in M.iter_group_results(bufnr, query_group, root, lang) do
+    for _, capture in ipairs(strip_captures) do
+      local insert = utils.get_at_path(match, capture)
+      if insert then
+        table.insert(matches, insert)
+      end
+    end
+  end
+  return matches
+end
+
+function M.iter_captures(bufnr, query_name, root, lang)
+  local query, params = prepare_query(bufnr, query_name, root, lang)
+  if not query then
+    return EMPTY_ITER
+  end
+  assert(params)
+
+  local iter = query:iter_captures(params.root, params.source, params.start, params.stop)
+
+  local function wrapped_iter()
+    local id, node, metadata = iter()
+    if not id then
+      return
+    end
+
+    local name = query.captures[id]
+    if string.sub(name, 1, 1) == "_" then
+      return wrapped_iter()
+    end
+
+    return name, node, metadata
+  end
+
+  return wrapped_iter
+end
+
+---@param bufnr integer
+---@param capture_string string
+---@param query_group string
+---@param filter_predicate fun(match: table): boolean
+---@param scoring_function fun(match: table): number
+---@param root TSNode
+---@return table|unknown
+function M.find_best_match(bufnr, capture_string, query_group, filter_predicate, scoring_function, root)
+  if string.sub(capture_string, 1, 1) == "@" then
+    --remove leading "@"
+    capture_string = string.sub(capture_string, 2)
+  end
+
+  local best ---@type table|nil
+  local best_score ---@type number
+
+  for maybe_match in M.iter_group_results(bufnr, query_group, root) do
+    local match = utils.get_at_path(maybe_match, capture_string)
+
+    if match and filter_predicate(match) then
+      local current_score = scoring_function(match)
+      if not best then
+        best = match
+        best_score = current_score
+      end
+      if current_score > best_score then
+        best = match
+        best_score = current_score
+      end
+    end
+  end
+  return best
+end
+
+---Iterates matches from a query file.
+---@param bufnr integer the buffer
+---@param query_group string the query file to use
+---@param root TSNode the root node
+---@param root_lang? string the root node lang, if known
+function M.iter_group_results(bufnr, query_group, root, root_lang)
+  local query, params = prepare_query(bufnr, query_group, root, root_lang)
+  if not query then
+    return EMPTY_ITER
+  end
+  assert(params)
+
+  return M.iter_prepared_matches(query, params.root, params.source, params.start, params.stop)
+end
+
+function M.collect_group_results(bufnr, query_group, root, lang)
+  local matches = {}
+
+  for prepared_match in M.iter_group_results(bufnr, query_group, root, lang) do
+    table.insert(matches, prepared_match)
+  end
+
+  return matches
+end
+
+---@alias CaptureResFn function(string, LanguageTree, LanguageTree): string, string
+
+-- Same as get_capture_matches except this will recursively get matches for every language in the tree.
+---@param bufnr integer The buffer
+---@param capture_or_fn string|CaptureResFn The capture to get. If a function is provided then that
+---                       function will be used to resolve both the capture and query argument.
+---                       The function can return `nil` to ignore that tree.
+---@param query_type string? The query to get the capture from. This is ignored if a function is provided
+---                    for the capture argument.
+---@return table[]
+function M.get_capture_matches_recursively(bufnr, capture_or_fn, query_type)
+  ---@type CaptureResFn
+  local type_fn
+  if type(capture_or_fn) == "function" then
+    type_fn = capture_or_fn
+  else
+    type_fn = function(_, _, _)
+      return capture_or_fn, query_type
+    end
+  end
+  local parser = parsers.get_parser(bufnr)
+  local matches = {}
+
+  if parser then
+    parser:for_each_tree(function(tree, lang_tree)
+      local lang = lang_tree:lang()
+      local capture, type_ = type_fn(lang, tree, lang_tree)
+
+      if capture then
+        vim.list_extend(matches, M.get_capture_matches(bufnr, capture, type_, tree:root(), lang) or {})
+      end
+    end)
+  end
+
+  return matches
+end
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/query_predicates.lua

@@ -0,0 +1,281 @@
+local query = require "vim.treesitter.query"
+
+local html_script_type_languages = {
+  ["importmap"] = "json",
+  ["module"] = "javascript",
+  ["application/ecmascript"] = "javascript",
+  ["text/ecmascript"] = "javascript",
+}
+
+local non_filetype_match_injection_language_aliases = {
+  ex = "elixir",
+  pl = "perl",
+  sh = "bash",
+  uxn = "uxntal",
+  ts = "typescript",
+}
+
+local function get_parser_from_markdown_info_string(injection_alias)
+  local match = vim.filetype.match { filename = "a." .. injection_alias }
+  return match or non_filetype_match_injection_language_aliases[injection_alias] or injection_alias
+end
+
+local function error(str)
+  vim.api.nvim_err_writeln(str)
+end
+
+local function valid_args(name, pred, count, strict_count)
+  local arg_count = #pred - 1
+
+  if strict_count then
+    if arg_count ~= count then
+      error(string.format("%s must have exactly %d arguments", name, count))
+      return false
+    end
+  elseif arg_count < count then
+    error(string.format("%s must have at least %d arguments", name, count))
+    return false
+  end
+
+  return true
+end
+
+---@param match (TSNode|nil)[]
+---@param _pattern string
+---@param _bufnr integer
+---@param pred string[]
+---@return boolean|nil
+query.add_predicate("nth?", function(match, _pattern, _bufnr, pred)
+  if not valid_args("nth?", pred, 2, true) then
+    return
+  end
+
+  local node = match[pred[2]] ---@type TSNode
+  local n = tonumber(pred[3])
+  if node and node:parent() and node:parent():named_child_count() > n then
+    return node:parent():named_child(n) == node
+  end
+
+  return false
+end, true)
+
+---@param match (TSNode|nil)[]
+---@param _pattern string
+---@param _bufnr integer
+---@param pred string[]
+---@return boolean|nil
+local function has_ancestor(match, _pattern, _bufnr, pred)
+  if not valid_args(pred[1], pred, 2) then
+    return
+  end
+
+  local node = match[pred[2]]
+  local ancestor_types = { unpack(pred, 3) }
+  if not node then
+    return true
+  end
+
+  local just_direct_parent = pred[1]:find("has-parent", 1, true)
+
+  node = node:parent()
+  while node do
+    if vim.tbl_contains(ancestor_types, node:type()) then
+      return true
+    end
+    if just_direct_parent then
+      node = nil
+    else
+      node = node:parent()
+    end
+  end
+  return false
+end
+
+query.add_predicate("has-ancestor?", has_ancestor, true)
+
+query.add_predicate("has-parent?", has_ancestor, true)
+
+---@param match (TSNode|nil)[]
+---@param _pattern string
+---@param bufnr integer
+---@param pred string[]
+---@return boolean|nil
+query.add_predicate("is?", function(match, _pattern, bufnr, pred)
+  if not valid_args("is?", pred, 2) then
+    return
+  end
+
+  -- Avoid circular dependencies
+  local locals = require "nvim-treesitter.locals"
+  local node = match[pred[2]]
+  local types = { unpack(pred, 3) }
+
+  if not node then
+    return true
+  end
+
+  local _, _, kind = locals.find_definition(node, bufnr)
+
+  return vim.tbl_contains(types, kind)
+end, true)
+
+---@param match (TSNode|nil)[]
+---@param _pattern string
+---@param _bufnr integer
+---@param pred string[]
+---@return boolean|nil
+query.add_predicate("has-type?", function(match, _pattern, _bufnr, pred)
+  if not valid_args(pred[1], pred, 2) then
+    return
+  end
+
+  local node = match[pred[2]]
+  local types = { unpack(pred, 3) }
+
+  if not node then
+    return true
+  end
+
+  return vim.tbl_contains(types, node:type())
+end, true)
+
+---@param match (TSNode|nil)[]
+---@param _ string
+---@param bufnr integer
+---@param pred string[]
+---@return boolean|nil
+query.add_directive("set-lang-from-mimetype!", function(match, _, bufnr, pred, metadata)
+  local capture_id = pred[2]
+  local node = match[capture_id]
+  if not node then
+    return
+  end
+  local type_attr_value = vim.treesitter.get_node_text(node, bufnr)
+  local configured = html_script_type_languages[type_attr_value]
+  if configured then
+    metadata.language = configured
+  else
+    local parts = vim.split(type_attr_value, "/", {})
+    metadata.language = parts[#parts]
+  end
+end, true)
+
+---@param match (TSNode|nil)[]
+---@param _ string
+---@param bufnr integer
+---@param pred string[]
+---@return boolean|nil
+query.add_directive("set-lang-from-info-string!", function(match, _, bufnr, pred, metadata)
+  local capture_id = pred[2]
+  local node = match[capture_id]
+  if not node then
+    return
+  end
+  local injection_alias = vim.treesitter.get_node_text(node, bufnr)
+  metadata.language = get_parser_from_markdown_info_string(injection_alias)
+end, true)
+
+-- Just avoid some annoying warnings for this directive
+query.add_directive("make-range!", function() end, true)
+
+---@param match (TSNode|nil)[]
+---@param _ string
+---@param bufnr integer
+---@param pred string[]
+---@param metadata table
+---@return boolean|nil
+query.add_directive("downcase!", function(match, _, bufnr, pred, metadata)
+  local text, key, value ---@type string|string[], string, string|integer
+
+  if #pred == 3 then
+    -- (#downcase! @capture "key")
+    key = pred[3]
+    value = metadata[pred[2]][key]
+  else
+    -- (#downcase! "key")
+    key = pred[2]
+    value = metadata[key]
+  end
+
+  if type(value) == "string" then
+    text = value
+  else
+    local node = match[value]
+    text = vim.treesitter.get_node_text(node, bufnr) or ""
+  end
+
+  if #pred == 3 then
+    metadata[pred[2]][key] = string.lower(text)
+  else
+    metadata[key] = string.lower(text)
+  end
+end, true)
+
+---@param match (TSNode|nil)[]
+---@param _pattern string
+---@param _bufnr integer
+---@param pred string[]
+---@param metadata table
+---@return boolean|nil
+query.add_directive("exclude_children!", function(match, _pattern, _bufnr, pred, metadata)
+  local capture_id = pred[2]
+  local node = match[capture_id]
+  local start_row, start_col, end_row, end_col = node:range()
+  local ranges = {}
+  for i = 0, node:named_child_count() - 1 do
+    local child = node:named_child(i) ---@type TSNode
+    local child_start_row, child_start_col, child_end_row, child_end_col = child:range()
+    if child_start_row > start_row or child_start_col > start_col then
+      table.insert(ranges, {
+        start_row,
+        start_col,
+        child_start_row,
+        child_start_col,
+      })
+    end
+    start_row = child_end_row
+    start_col = child_end_col
+  end
+  if end_row > start_row or end_col > start_col then
+    table.insert(ranges, { start_row, start_col, end_row, end_col })
+  end
+  metadata.content = ranges
+end, true)
+
+-- Trim blank lines from end of the region
+-- Arguments are the captures to trim.
+---@param match (TSNode|nil)[]
+---@param _ string
+---@param bufnr integer
+---@param pred string[]
+---@param metadata table
+query.add_directive("trim!", function(match, _, bufnr, pred, metadata)
+  for _, id in ipairs { select(2, unpack(pred)) } do
+    local node = match[id]
+    local start_row, start_col, end_row, end_col = node:range()
+
+    -- Don't trim if region ends in middle of a line
+    if end_col ~= 0 then
+      return
+    end
+
+    while true do
+      -- As we only care when end_col == 0, always inspect one line above end_row.
+      local end_line = vim.api.nvim_buf_get_lines(bufnr, end_row - 1, end_row, true)[1]
+
+      if end_line ~= "" then
+        break
+      end
+
+      end_row = end_row - 1
+    end
+
+    -- If this produces an invalid range, we just skip it.
+    if start_row < end_row or (start_row == end_row and start_col <= end_col) then
+      if not metadata[id] then
+        metadata[id] = {}
+      end
+      metadata[id].range = { start_row, start_col, end_row, end_col }
+    end
+  end
+end, true)

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/shell_command_selectors.lua

@@ -0,0 +1,335 @@
+local fn = vim.fn
+local utils = require "nvim-treesitter.utils"
+
+-- Convert path for cmd.exe on Windows.
+-- This is needed when vim.opt.shellslash is in use.
+---@param p string
+---@return string
+local function cmdpath(p)
+  if vim.opt.shellslash:get() then
+    local r = p:gsub("/", "\\")
+    return r
+  else
+    return p
+  end
+end
+
+local M = {}
+
+-- Returns the mkdir command based on the OS
+---@param directory string
+---@param cwd string
+---@param info_msg string
+---@return table
+function M.select_mkdir_cmd(directory, cwd, info_msg)
+  if fn.has "win32" == 1 then
+    return {
+      cmd = "cmd",
+      opts = {
+        args = { "/C", "mkdir", cmdpath(directory) },
+        cwd = cwd,
+      },
+      info = info_msg,
+      err = "Could not create " .. directory,
+    }
+  else
+    return {
+      cmd = "mkdir",
+      opts = {
+        args = { directory },
+        cwd = cwd,
+      },
+      info = info_msg,
+      err = "Could not create " .. directory,
+    }
+  end
+end
+
+-- Returns the remove command based on the OS
+---@param file string
+---@param info_msg string
+---@return table
+function M.select_rm_file_cmd(file, info_msg)
+  if fn.has "win32" == 1 then
+    return {
+      cmd = "cmd",
+      opts = {
+        args = { "/C", "if", "exist", cmdpath(file), "del", cmdpath(file) },
+      },
+      info = info_msg,
+      err = "Could not delete " .. file,
+    }
+  else
+    return {
+      cmd = "rm",
+      opts = {
+        args = { file },
+      },
+      info = info_msg,
+      err = "Could not delete " .. file,
+    }
+  end
+end
+
+---@param executables string[]
+---@return string|nil
+function M.select_executable(executables)
+  return vim.tbl_filter(function(c) ---@param c string
+    return c ~= vim.NIL and fn.executable(c) == 1
+  end, executables)[1]
+end
+
+-- Returns the compiler arguments based on the compiler and OS
+---@param repo InstallInfo
+---@param compiler string
+---@return string[]
+function M.select_compiler_args(repo, compiler)
+  if string.match(compiler, "cl$") or string.match(compiler, "cl.exe$") then
+    return {
+      "/Fe:",
+      "parser.so",
+      "/Isrc",
+      repo.files,
+      "-Os",
+      "/LD",
+    }
+  elseif string.match(compiler, "zig$") or string.match(compiler, "zig.exe$") then
+    return {
+      "c++",
+      "-o",
+      "parser.so",
+      repo.files,
+      "-lc",
+      "-Isrc",
+      "-shared",
+      "-Os",
+    }
+  else
+    local args = {
+      "-o",
+      "parser.so",
+      "-I./src",
+      repo.files,
+      "-Os",
+    }
+    if fn.has "mac" == 1 then
+      table.insert(args, "-bundle")
+    else
+      table.insert(args, "-shared")
+    end
+    if
+      #vim.tbl_filter(function(file) ---@param file string
+        local ext = vim.fn.fnamemodify(file, ":e")
+        return ext == "cc" or ext == "cpp" or ext == "cxx"
+      end, repo.files) > 0
+    then
+      table.insert(args, "-lstdc++")
+    end
+    if fn.has "win32" == 0 then
+      table.insert(args, "-fPIC")
+    end
+    return args
+  end
+end
+
+-- Returns the compile command based on the OS and user options
+---@param repo InstallInfo
+---@param cc string
+---@param compile_location string
+---@return Command
+function M.select_compile_command(repo, cc, compile_location)
+  local make = M.select_executable { "gmake", "make" }
+  if
+    string.match(cc, "cl$")
+    or string.match(cc, "cl.exe$")
+    or not repo.use_makefile
+    or fn.has "win32" == 1
+    or not make
+  then
+    return {
+      cmd = cc,
+      info = "Compiling...",
+      err = "Error during compilation",
+      opts = {
+        args = vim.tbl_flatten(M.select_compiler_args(repo, cc)),
+        cwd = compile_location,
+      },
+    }
+  else
+    return {
+      cmd = make,
+      info = "Compiling...",
+      err = "Error during compilation",
+      opts = {
+        args = {
+          "--makefile=" .. utils.join_path(utils.get_package_path(), "scripts", "compile_parsers.makefile"),
+          "CC=" .. cc,
+          "CXX_STANDARD=" .. (repo.cxx_standard or "c++14"),
+        },
+        cwd = compile_location,
+      },
+    }
+  end
+end
+
+-- Returns the remove command based on the OS
+---@param cache_folder string
+---@param project_name string
+---@return Command
+function M.select_install_rm_cmd(cache_folder, project_name)
+  if fn.has "win32" == 1 then
+    local dir = cache_folder .. "\\" .. project_name
+    return {
+      cmd = "cmd",
+      opts = {
+        args = { "/C", "if", "exist", cmdpath(dir), "rmdir", "/s", "/q", cmdpath(dir) },
+      },
+    }
+  else
+    return {
+      cmd = "rm",
+      opts = {
+        args = { "-rf", cache_folder .. "/" .. project_name },
+      },
+    }
+  end
+end
+
+-- Returns the move command based on the OS
+---@param from string
+---@param to string
+---@param cwd string
+---@return Command
+function M.select_mv_cmd(from, to, cwd)
+  if fn.has "win32" == 1 then
+    return {
+      cmd = "cmd",
+      opts = {
+        args = { "/C", "move", "/Y", cmdpath(from), cmdpath(to) },
+        cwd = cwd,
+      },
+    }
+  else
+    return {
+      cmd = "mv",
+      opts = {
+        args = { "-f", from, to },
+        cwd = cwd,
+      },
+    }
+  end
+end
+
+---@param repo InstallInfo
+---@param project_name string
+---@param cache_folder string
+---@param revision string|nil
+---@param prefer_git boolean
+---@return table
+function M.select_download_commands(repo, project_name, cache_folder, revision, prefer_git)
+  local can_use_tar = vim.fn.executable "tar" == 1 and vim.fn.executable "curl" == 1
+  local is_github = repo.url:find("github.com", 1, true)
+  local is_gitlab = repo.url:find("gitlab.com", 1, true)
+
+  revision = revision or repo.branch or "master"
+
+  if can_use_tar and (is_github or is_gitlab) and not prefer_git then
+    local path_sep = utils.get_path_sep()
+    local url = repo.url:gsub(".git$", "")
+
+    local folder_rev = revision
+    if is_github and revision:match "^v%d" then
+      folder_rev = revision:sub(2)
+    end
+
+    return {
+      M.select_install_rm_cmd(cache_folder, project_name .. "-tmp"),
+      {
+        cmd = "curl",
+        info = "Downloading " .. project_name .. "...",
+        err = "Error during download, please verify your internet connection",
+        opts = {
+          args = {
+            "--silent",
+            "-L", -- follow redirects
+            is_github and url .. "/archive/" .. revision .. ".tar.gz"
+              or url .. "/-/archive/" .. revision .. "/" .. project_name .. "-" .. revision .. ".tar.gz",
+            "--output",
+            project_name .. ".tar.gz",
+          },
+          cwd = cache_folder,
+        },
+      },
+      M.select_mkdir_cmd(project_name .. "-tmp", cache_folder, "Creating temporary directory"),
+      {
+        cmd = "tar",
+        info = "Extracting " .. project_name .. "...",
+        err = "Error during tarball extraction.",
+        opts = {
+          args = {
+            "-xvzf",
+            project_name .. ".tar.gz",
+            "-C",
+            project_name .. "-tmp",
+          },
+          cwd = cache_folder,
+        },
+      },
+      M.select_rm_file_cmd(cache_folder .. path_sep .. project_name .. ".tar.gz"),
+      M.select_mv_cmd(
+        utils.join_path(project_name .. "-tmp", url:match "[^/]-$" .. "-" .. folder_rev),
+        project_name,
+        cache_folder
+      ),
+      M.select_install_rm_cmd(cache_folder, project_name .. "-tmp"),
+    }
+  else
+    local git_folder = utils.join_path(cache_folder, project_name)
+    local clone_error = "Error during download, please verify your internet connection"
+
+    return {
+      {
+        cmd = "git",
+        info = "Downloading " .. project_name .. "...",
+        err = clone_error,
+        opts = {
+          args = {
+            "clone",
+            repo.url,
+            project_name,
+          },
+          cwd = cache_folder,
+        },
+      },
+      {
+        cmd = "git",
+        info = "Checking out locked revision",
+        err = "Error while checking out revision",
+        opts = {
+          args = {
+            "checkout",
+            revision,
+          },
+          cwd = git_folder,
+        },
+      },
+    }
+  end
+end
+
+---@param dir string
+---@param command string
+---@return string command
+function M.make_directory_change_for_command(dir, command)
+  if fn.has "win32" == 1 then
+    if string.find(vim.o.shell, "cmd") ~= nil then
+      return string.format("pushd %s & %s & popd", cmdpath(dir), command)
+    else
+      return string.format("pushd %s ; %s ; popd", cmdpath(dir), command)
+    end
+  else
+    return string.format("cd %s;\n %s", dir, command)
+  end
+end
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/statusline.lua

@@ -0,0 +1,53 @@
+local parsers = require "nvim-treesitter.parsers"
+local ts_utils = require "nvim-treesitter.ts_utils"
+
+local M = {}
+
+-- Trim spaces and opening brackets from end
+local transform_line = function(line)
+  return line:gsub("%s*[%[%(%{]*%s*$", "")
+end
+
+function M.statusline(opts)
+  if not parsers.has_parser() then
+    return
+  end
+  local options = opts or {}
+  if type(opts) == "number" then
+    options = { indicator_size = opts }
+  end
+  local bufnr = options.bufnr or 0
+  local indicator_size = options.indicator_size or 100
+  local type_patterns = options.type_patterns or { "class", "function", "method" }
+  local transform_fn = options.transform_fn or transform_line
+  local separator = options.separator or " -> "
+  local allow_duplicates = options.allow_duplicates or false
+
+  local current_node = ts_utils.get_node_at_cursor()
+  if not current_node then
+    return ""
+  end
+
+  local lines = {}
+  local expr = current_node
+
+  while expr do
+    local line = ts_utils._get_line_for_node(expr, type_patterns, transform_fn, bufnr)
+    if line ~= "" then
+      if allow_duplicates or not vim.tbl_contains(lines, line) then
+        table.insert(lines, 1, line)
+      end
+    end
+    expr = expr:parent()
+  end
+
+  local text = table.concat(lines, separator)
+  local text_len = #text
+  if text_len > indicator_size then
+    return "..." .. text:sub(text_len - indicator_size, text_len)
+  end
+
+  return text
+end
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/ts_utils.lua

@@ -0,0 +1,467 @@
+local api = vim.api
+
+local parsers = require "nvim-treesitter.parsers"
+local utils = require "nvim-treesitter.utils"
+local ts = vim.treesitter
+
+local M = {}
+
+local function get_node_text(node, bufnr)
+  bufnr = bufnr or api.nvim_get_current_buf()
+  if not node then
+    return {}
+  end
+
+  -- We have to remember that end_col is end-exclusive
+  local start_row, start_col, end_row, end_col = ts.get_node_range(node)
+
+  if start_row ~= end_row then
+    local lines = api.nvim_buf_get_lines(bufnr, start_row, end_row + 1, false)
+    if next(lines) == nil then
+      return {}
+    end
+    lines[1] = string.sub(lines[1], start_col + 1)
+    -- end_row might be just after the last line. In this case the last line is not truncated.
+    if #lines == end_row - start_row + 1 then
+      lines[#lines] = string.sub(lines[#lines], 1, end_col)
+    end
+    return lines
+  else
+    local line = api.nvim_buf_get_lines(bufnr, start_row, start_row + 1, false)[1]
+    -- If line is nil then the line is empty
+    return line and { string.sub(line, start_col + 1, end_col) } or {}
+  end
+end
+
+---@private
+---@param node TSNode
+---@param type_patterns string[]
+---@param transform_fn fun(line: string): string
+---@param bufnr integer
+---@return string
+function M._get_line_for_node(node, type_patterns, transform_fn, bufnr)
+  local node_type = node:type()
+  local is_valid = false
+  for _, rgx in ipairs(type_patterns) do
+    if node_type:find(rgx) then
+      is_valid = true
+      break
+    end
+  end
+  if not is_valid then
+    return ""
+  end
+  local line = transform_fn(vim.trim(get_node_text(node, bufnr)[1] or ""), node)
+  -- Escape % to avoid statusline to evaluate content as expression
+  return line:gsub("%%", "%%%%")
+end
+
+-- Gets the actual text content of a node
+-- @deprecated Use vim.treesitter.query.get_node_text
+-- @param node the node to get the text from
+-- @param bufnr the buffer containing the node
+-- @return list of lines of text of the node
+function M.get_node_text(node, bufnr)
+  vim.notify_once(
+    "nvim-treesitter.ts_utils.get_node_text is deprecated: use vim.treesitter.query.get_node_text",
+    vim.log.levels.WARN
+  )
+  return get_node_text(node, bufnr)
+end
+
+-- Determines whether a node is the parent of another
+-- @param dest the possible parent
+-- @param source the possible child node
+function M.is_parent(dest, source)
+  if not (dest and source) then
+    return false
+  end
+
+  local current = source
+  while current ~= nil do
+    if current == dest then
+      return true
+    end
+
+    current = current:parent()
+  end
+
+  return false
+end
+
+-- Get next node with same parent
+---@param node                  TSNode
+---@param allow_switch_parents? boolean allow switching parents if last node
+---@param allow_next_parent?    boolean allow next parent if last node and next parent without children
+function M.get_next_node(node, allow_switch_parents, allow_next_parent)
+  local destination_node ---@type TSNode
+  local parent = node:parent()
+
+  if not parent then
+    return
+  end
+  local found_pos = 0
+  for i = 0, parent:named_child_count() - 1, 1 do
+    if parent:named_child(i) == node then
+      found_pos = i
+      break
+    end
+  end
+  if parent:named_child_count() > found_pos + 1 then
+    destination_node = parent:named_child(found_pos + 1)
+  elseif allow_switch_parents then
+    local next_node = M.get_next_node(node:parent())
+    if next_node and next_node:named_child_count() > 0 then
+      destination_node = next_node:named_child(0)
+    elseif next_node and allow_next_parent then
+      destination_node = next_node
+    end
+  end
+
+  return destination_node
+end
+
+-- Get previous node with same parent
+---@param node                   TSNode
+---@param allow_switch_parents?  boolean allow switching parents if first node
+---@param allow_previous_parent? boolean allow previous parent if first node and previous parent without children
+function M.get_previous_node(node, allow_switch_parents, allow_previous_parent)
+  local destination_node ---@type TSNode
+  local parent = node:parent()
+  if not parent then
+    return
+  end
+
+  local found_pos = 0
+  for i = 0, parent:named_child_count() - 1, 1 do
+    if parent:named_child(i) == node then
+      found_pos = i
+      break
+    end
+  end
+  if 0 < found_pos then
+    destination_node = parent:named_child(found_pos - 1)
+  elseif allow_switch_parents then
+    local previous_node = M.get_previous_node(node:parent())
+    if previous_node and previous_node:named_child_count() > 0 then
+      destination_node = previous_node:named_child(previous_node:named_child_count() - 1)
+    elseif previous_node and allow_previous_parent then
+      destination_node = previous_node
+    end
+  end
+  return destination_node
+end
+
+function M.get_named_children(node)
+  local nodes = {} ---@type TSNode[]
+  for i = 0, node:named_child_count() - 1, 1 do
+    nodes[i + 1] = node:named_child(i)
+  end
+  return nodes
+end
+
+function M.get_node_at_cursor(winnr, ignore_injected_langs)
+  winnr = winnr or 0
+  local cursor = api.nvim_win_get_cursor(winnr)
+  local cursor_range = { cursor[1] - 1, cursor[2] }
+
+  local buf = vim.api.nvim_win_get_buf(winnr)
+  local root_lang_tree = parsers.get_parser(buf)
+  if not root_lang_tree then
+    return
+  end
+
+  local root ---@type TSNode|nil
+  if ignore_injected_langs then
+    for _, tree in ipairs(root_lang_tree:trees()) do
+      local tree_root = tree:root()
+      if tree_root and ts.is_in_node_range(tree_root, cursor_range[1], cursor_range[2]) then
+        root = tree_root
+        break
+      end
+    end
+  else
+    root = M.get_root_for_position(cursor_range[1], cursor_range[2], root_lang_tree)
+  end
+
+  if not root then
+    return
+  end
+
+  return root:named_descendant_for_range(cursor_range[1], cursor_range[2], cursor_range[1], cursor_range[2])
+end
+
+function M.get_root_for_position(line, col, root_lang_tree)
+  if not root_lang_tree then
+    if not parsers.has_parser() then
+      return
+    end
+
+    root_lang_tree = parsers.get_parser()
+  end
+
+  local lang_tree = root_lang_tree:language_for_range { line, col, line, col }
+
+  for _, tree in ipairs(lang_tree:trees()) do
+    local root = tree:root()
+
+    if root and ts.is_in_node_range(root, line, col) then
+      return root, tree, lang_tree
+    end
+  end
+
+  -- This isn't a likely scenario, since the position must belong to a tree somewhere.
+  return nil, nil, lang_tree
+end
+
+---comment
+---@param node TSNode
+---@return TSNode result
+function M.get_root_for_node(node)
+  local parent = node
+  local result = node
+
+  while parent ~= nil do
+    result = parent
+    parent = result:parent()
+  end
+
+  return result
+end
+
+function M.highlight_node(node, buf, hl_namespace, hl_group)
+  if not node then
+    return
+  end
+  M.highlight_range({ node:range() }, buf, hl_namespace, hl_group)
+end
+
+-- Get a compatible vim range (1 index based) from a TS node range.
+--
+-- TS nodes start with 0 and the end col is ending exclusive.
+-- They also treat a EOF/EOL char as a char ending in the first
+-- col of the next row.
+---comment
+---@param range integer[]
+---@param buf integer|nil
+---@return integer, integer, integer, integer
+function M.get_vim_range(range, buf)
+  ---@type integer, integer, integer, integer
+  local srow, scol, erow, ecol = unpack(range)
+  srow = srow + 1
+  scol = scol + 1
+  erow = erow + 1
+
+  if ecol == 0 then
+    -- Use the value of the last col of the previous row instead.
+    erow = erow - 1
+    if not buf or buf == 0 then
+      ecol = vim.fn.col { erow, "$" } - 1
+    else
+      ecol = #api.nvim_buf_get_lines(buf, erow - 1, erow, false)[1]
+    end
+    ecol = math.max(ecol, 1)
+  end
+  return srow, scol, erow, ecol
+end
+
+function M.highlight_range(range, buf, hl_namespace, hl_group)
+  ---@type integer, integer, integer, integer
+  local start_row, start_col, end_row, end_col = unpack(range)
+  ---@diagnostic disable-next-line: missing-parameter
+  vim.highlight.range(buf, hl_namespace, hl_group, { start_row, start_col }, { end_row, end_col })
+end
+
+-- Set visual selection to node
+-- @param selection_mode One of "charwise" (default) or "v", "linewise" or "V",
+--   "blockwise" or "<C-v>" (as a string with 5 characters or a single character)
+function M.update_selection(buf, node, selection_mode)
+  local start_row, start_col, end_row, end_col = M.get_vim_range({ ts.get_node_range(node) }, buf)
+
+  local v_table = { charwise = "v", linewise = "V", blockwise = "<C-v>" }
+  selection_mode = selection_mode or "charwise"
+
+  -- Normalise selection_mode
+  if vim.tbl_contains(vim.tbl_keys(v_table), selection_mode) then
+    selection_mode = v_table[selection_mode]
+  end
+
+  -- enter visual mode if normal or operator-pending (no) mode
+  -- Why? According to https://learnvimscriptthehardway.stevelosh.com/chapters/15.html
+  --   If your operator-pending mapping ends with some text visually selected, Vim will operate on that text.
+  --   Otherwise, Vim will operate on the text between the original cursor position and the new position.
+  local mode = api.nvim_get_mode()
+  if mode.mode ~= selection_mode then
+    -- Call to `nvim_replace_termcodes()` is needed for sending appropriate command to enter blockwise mode
+    selection_mode = vim.api.nvim_replace_termcodes(selection_mode, true, true, true)
+    api.nvim_cmd({ cmd = "normal", bang = true, args = { selection_mode } }, {})
+  end
+
+  api.nvim_win_set_cursor(0, { start_row, start_col - 1 })
+  vim.cmd "normal! o"
+  api.nvim_win_set_cursor(0, { end_row, end_col - 1 })
+end
+
+-- Byte length of node range
+---@param node TSNode
+---@return number
+function M.node_length(node)
+  local _, _, start_byte = node:start()
+  local _, _, end_byte = node:end_()
+  return end_byte - start_byte
+end
+
+---@deprecated Use `vim.treesitter.is_in_node_range()` instead
+function M.is_in_node_range(node, line, col)
+  vim.notify_once(
+    "nvim-treesitter.ts_utils.is_in_node_range is deprecated: use vim.treesitter.is_in_node_range",
+    vim.log.levels.WARN
+  )
+  return ts.is_in_node_range(node, line, col)
+end
+
+---@deprecated Use `vim.treesitter.get_node_range()` instead
+function M.get_node_range(node_or_range)
+  vim.notify_once(
+    "nvim-treesitter.ts_utils.get_node_range is deprecated: use vim.treesitter.get_node_range",
+    vim.log.levels.WARN
+  )
+  return ts.get_node_range(node_or_range)
+end
+
+---@param node TSNode
+---@return table
+function M.node_to_lsp_range(node)
+  local start_line, start_col, end_line, end_col = ts.get_node_range(node)
+  local rtn = {}
+  rtn.start = { line = start_line, character = start_col }
+  rtn["end"] = { line = end_line, character = end_col }
+  return rtn
+end
+
+-- Memoizes a function based on the buffer tick of the provided bufnr.
+-- The cache entry is cleared when the buffer is detached to avoid memory leaks.
+-- The options argument is a table with two optional values:
+--  - bufnr: extracts a bufnr from the given arguments.
+--  - key: extracts the cache key from the given arguments.
+---@param fn function the fn to memoize, taking the buffer as first argument
+---@param options? {bufnr: integer?, key: string|fun(...): string?} the memoization options
+---@return function: a memoized function
+function M.memoize_by_buf_tick(fn, options)
+  options = options or {}
+
+  ---@type table<string, {result: any, last_tick: integer}>
+  local cache = setmetatable({}, { __mode = "kv" })
+  local bufnr_fn = utils.to_func(options.bufnr or utils.identity)
+  local key_fn = utils.to_func(options.key or utils.identity)
+
+  return function(...)
+    local bufnr = bufnr_fn(...)
+    local key = key_fn(...)
+    local tick = api.nvim_buf_get_changedtick(bufnr)
+
+    if cache[key] then
+      if cache[key].last_tick == tick then
+        return cache[key].result
+      end
+    else
+      local function detach_handler()
+        cache[key] = nil
+      end
+
+      -- Clean up logic only!
+      api.nvim_buf_attach(bufnr, false, {
+        on_detach = detach_handler,
+        on_reload = detach_handler,
+      })
+    end
+
+    cache[key] = {
+      result = fn(...),
+      last_tick = tick,
+    }
+
+    return cache[key].result
+  end
+end
+
+function M.swap_nodes(node_or_range1, node_or_range2, bufnr, cursor_to_second)
+  if not node_or_range1 or not node_or_range2 then
+    return
+  end
+  local range1 = M.node_to_lsp_range(node_or_range1)
+  local range2 = M.node_to_lsp_range(node_or_range2)
+
+  local text1 = get_node_text(node_or_range1, bufnr)
+  local text2 = get_node_text(node_or_range2, bufnr)
+
+  local edit1 = { range = range1, newText = table.concat(text2, "\n") }
+  local edit2 = { range = range2, newText = table.concat(text1, "\n") }
+  vim.lsp.util.apply_text_edits({ edit1, edit2 }, bufnr, "utf-8")
+
+  if cursor_to_second then
+    utils.set_jump()
+
+    local char_delta = 0
+    local line_delta = 0
+    if
+      range1["end"].line < range2.start.line
+      or (range1["end"].line == range2.start.line and range1["end"].character <= range2.start.character)
+    then
+      line_delta = #text2 - #text1
+    end
+
+    if range1["end"].line == range2.start.line and range1["end"].character <= range2.start.character then
+      if line_delta ~= 0 then
+        --- why?
+        --correction_after_line_change =  -range2.start.character
+        --text_now_before_range2 = #(text2[#text2])
+        --space_between_ranges = range2.start.character - range1["end"].character
+        --char_delta = correction_after_line_change + text_now_before_range2 + space_between_ranges
+        --- Equivalent to:
+        char_delta = #text2[#text2] - range1["end"].character
+
+        -- add range1.start.character if last line of range1 (now text2) does not start at 0
+        if range1.start.line == range2.start.line + line_delta then
+          char_delta = char_delta + range1.start.character
+        end
+      else
+        char_delta = #text2[#text2] - #text1[#text1]
+      end
+    end
+
+    api.nvim_win_set_cursor(
+      api.nvim_get_current_win(),
+      { range2.start.line + 1 + line_delta, range2.start.character + char_delta }
+    )
+  end
+end
+
+function M.goto_node(node, goto_end, avoid_set_jump)
+  if not node then
+    return
+  end
+  if not avoid_set_jump then
+    utils.set_jump()
+  end
+  local range = { M.get_vim_range { node:range() } }
+  ---@type table<number>
+  local position
+  if not goto_end then
+    position = { range[1], range[2] }
+  else
+    position = { range[3], range[4] }
+  end
+
+  -- Enter visual mode if we are in operator pending mode
+  -- If we don't do this, it will miss the last character.
+  local mode = vim.api.nvim_get_mode()
+  if mode.mode == "no" then
+    vim.cmd "normal! v"
+  end
+
+  -- Position is 1, 0 indexed.
+  api.nvim_win_set_cursor(0, { position[1], position[2] - 1 })
+end
+
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/tsrange.lua

@@ -0,0 +1,154 @@
+local M = {}
+local TSRange = {}
+TSRange.__index = TSRange
+
+local api = vim.api
+local ts_utils = require "nvim-treesitter.ts_utils"
+local parsers = require "nvim-treesitter.parsers"
+
+local function get_byte_offset(buf, row, col)
+  return api.nvim_buf_get_offset(buf, row) + vim.fn.byteidx(api.nvim_buf_get_lines(buf, row, row + 1, false)[1], col)
+end
+
+function TSRange.new(buf, start_row, start_col, end_row, end_col)
+  return setmetatable({
+    start_pos = { start_row, start_col, get_byte_offset(buf, start_row, start_col) },
+    end_pos = { end_row, end_col, get_byte_offset(buf, end_row, end_col) },
+    buf = buf,
+    [1] = start_row,
+    [2] = start_col,
+    [3] = end_row,
+    [4] = end_col,
+  }, TSRange)
+end
+
+function TSRange.from_nodes(buf, start_node, end_node)
+  TSRange.__index = TSRange
+  local start_pos = start_node and { start_node:start() } or { end_node:start() }
+  local end_pos = end_node and { end_node:end_() } or { start_node:end_() }
+  return setmetatable({
+    start_pos = { start_pos[1], start_pos[2], start_pos[3] },
+    end_pos = { end_pos[1], end_pos[2], end_pos[3] },
+    buf = buf,
+    [1] = start_pos[1],
+    [2] = start_pos[2],
+    [3] = end_pos[1],
+    [4] = end_pos[2],
+  }, TSRange)
+end
+
+function TSRange.from_table(buf, range)
+  return setmetatable({
+    start_pos = { range[1], range[2], get_byte_offset(buf, range[1], range[2]) },
+    end_pos = { range[3], range[4], get_byte_offset(buf, range[3], range[4]) },
+    buf = buf,
+    [1] = range[1],
+    [2] = range[2],
+    [3] = range[3],
+    [4] = range[4],
+  }, TSRange)
+end
+
+function TSRange:parent()
+  local root_lang_tree = parsers.get_parser(self.buf)
+  local root = ts_utils.get_root_for_position(self[1], self[2], root_lang_tree)
+
+  return root
+      and root:named_descendant_for_range(self.start_pos[1], self.start_pos[2], self.end_pos[1], self.end_pos[2])
+    or nil
+end
+
+function TSRange:field() end
+
+function TSRange:child_count()
+  return #self:collect_children()
+end
+
+function TSRange:named_child_count()
+  return #self:collect_children(function(c)
+    return c:named()
+  end)
+end
+
+function TSRange:iter_children()
+  local raw_iterator = self:parent().iter_children()
+  return function()
+    while true do
+      local node = raw_iterator()
+      if not node then
+        return
+      end
+      local _, _, start_byte = node:start()
+      local _, _, end_byte = node:end_()
+      if start_byte >= self.start_pos[3] and end_byte <= self.end_pos[3] then
+        return node
+      end
+    end
+  end
+end
+
+function TSRange:collect_children(filter_fun)
+  local children = {}
+  for _, c in self:iter_children() do
+    if not filter_fun or filter_fun(c) then
+      table.insert(children, c)
+    end
+  end
+  return children
+end
+
+function TSRange:child(index)
+  return self:collect_children()[index + 1]
+end
+
+function TSRange:named_child(index)
+  return self:collect_children(function(c)
+    return c.named()
+  end)[index + 1]
+end
+
+function TSRange:start()
+  return unpack(self.start_pos)
+end
+
+function TSRange:end_()
+  return unpack(self.end_pos)
+end
+
+function TSRange:range()
+  return self.start_pos[1], self.start_pos[2], self.end_pos[1], self.end_pos[2]
+end
+
+function TSRange:type()
+  return "nvim-treesitter-range"
+end
+
+function TSRange:symbol()
+  return -1
+end
+
+function TSRange:named()
+  return false
+end
+
+function TSRange:missing()
+  return false
+end
+
+function TSRange:has_error()
+  return #self:collect_children(function(c)
+    return c:has_error()
+  end) > 0 and true or false
+end
+
+function TSRange:sexpr()
+  return table.concat(
+    vim.tbl_map(function(c)
+      return c:sexpr()
+    end, self:collect_children()),
+    " "
+  )
+end
+
+M.TSRange = TSRange
+return M

bundle/nvim-treesitter-0.9.1/lua/nvim-treesitter/utils.lua

@@ -0,0 +1,237 @@
+local api = vim.api
+local fn = vim.fn
+local luv = vim.loop
+
+local M = {}
+
+-- Wrapper around vim.notify with common options set.
+---@param msg string
+---@param log_level number|nil
+---@param opts table|nil
+function M.notify(msg, log_level, opts)
+  local default_opts = { title = "nvim-treesitter" }
+  vim.notify(msg, log_level, vim.tbl_extend("force", default_opts, opts or {}))
+end
+
+-- Returns the system-specific path separator.
+---@return string
+function M.get_path_sep()
+  return (fn.has "win32" == 1 and not vim.opt.shellslash:get()) and "\\" or "/"
+end
+
+-- Returns a function that joins the given arguments with separator. Arguments
+-- can't be nil. Example:
+--
+--[[
+  print(M.generate_join(" ")("foo", "bar"))
+--]]
+--prints "foo bar"
+---@param separator string
+---@return fun(...: string): string
+function M.generate_join(separator)
+  return function(...)
+    return table.concat({ ... }, separator)
+  end
+end
+
+M.join_path = M.generate_join(M.get_path_sep())
+
+M.join_space = M.generate_join " "
+
+---@class Command
+---@field run function
+---@field f_args string
+---@field args string
+
+-- Define user defined vim command which calls nvim-treesitter module function
+--     - If module name is 'mod', it should be defined in hierarchy 'nvim-treesitter.mod'
+--     - A table with name 'commands' should be defined in 'mod' which needs to be passed as
+--       the commands param of this function
+--
+---@param mod string  Name of the module that resides in the hierarchy - nvim-treesitter.module
+---@param commands table<string, Command>  Command list for the module
+---         - {command_name} Name of the vim user defined command, Keys:
+---             - {run}: (function) callback function that needs to be executed
+---             - {f_args}: (string, default <f-args>)
+---                 - type of arguments that needs to be passed to the vim command
+---             - {args}: (string, optional)
+---                 - vim command attributes
+---
+---* @example
+---  If module is nvim-treesitter.custom_mod
+---  <pre>
+---  M.commands = {
+---      custom_command = {
+---          run = M.module_function,
+---          f_args = "<f-args>",
+---          args = {
+---              "-range"
+---          }
+---      }
+---  }
+---
+---  utils.setup_commands("custom_mod", require("nvim-treesitter.custom_mod").commands)
+---  </pre>
+---
+---  Will generate command :
+---  <pre>
+---  command! -range custom_command \
+---      lua require'nvim-treesitter.custom_mod'.commands.custom_command['run<bang>'](<f-args>)
+---  </pre>
+function M.setup_commands(mod, commands)
+  for command_name, def in pairs(commands) do
+    local f_args = def.f_args or "<f-args>"
+    local call_fn =
+      string.format("lua require'nvim-treesitter.%s'.commands.%s['run<bang>'](%s)", mod, command_name, f_args)
+    local parts = vim.tbl_flatten {
+      "command!",
+      "-bar",
+      def.args,
+      command_name,
+      call_fn,
+    }
+    api.nvim_command(table.concat(parts, " "))
+  end
+end
+
+---@param dir string
+---@param create_err string
+---@param writeable_err string
+---@return string|nil, string|nil
+function M.create_or_reuse_writable_dir(dir, create_err, writeable_err)
+  create_err = create_err or M.join_space("Could not create dir '", dir, "': ")
+  writeable_err = writeable_err or M.join_space("Invalid rights, '", dir, "' should be read/write")
+  -- Try creating and using parser_dir if it doesn't exist
+  if not luv.fs_stat(dir) then
+    local ok, error = pcall(vim.fn.mkdir, dir, "p", "0755")
+    if not ok then
+      return nil, M.join_space(create_err, error)
+    end
+
+    return dir
+  end
+
+  -- parser_dir exists, use it if it's read/write
+  if luv.fs_access(dir, "RW") then
+    return dir
+  end
+
+  -- parser_dir exists but isn't read/write, give up
+  return nil, M.join_space(writeable_err, dir, "'")
+end
+
+function M.get_package_path()
+  -- Path to this source file, removing the leading '@'
+  local source = string.sub(debug.getinfo(1, "S").source, 2)
+
+  -- Path to the package root
+  return fn.fnamemodify(source, ":p:h:h:h")
+end
+
+function M.get_cache_dir()
+  local cache_dir = fn.stdpath "data"
+
+  if luv.fs_access(cache_dir, "RW") then
+    return cache_dir
+  elseif luv.fs_access("/tmp", "RW") then
+    return "/tmp"
+  end
+
+  return nil, M.join_space("Invalid cache rights,", fn.stdpath "data", "or /tmp should be read/write")
+end
+
+-- Returns $XDG_DATA_HOME/nvim/site, but could use any directory that is in
+-- runtimepath
+function M.get_site_dir()
+  return M.join_path(fn.stdpath "data", "site")
+end
+
+-- Gets a property at path
+---@param tbl table the table to access
+---@param path string the '.' separated path
+---@return table|nil result the value at path or nil
+function M.get_at_path(tbl, path)
+  if path == "" then
+    return tbl
+  end
+
+  local segments = vim.split(path, ".", true)
+  ---@type table[]|table
+  local result = tbl
+
+  for _, segment in ipairs(segments) do
+    if type(result) == "table" then
+      ---@type table
+      -- TODO: figure out the actual type of tbl
+      result = result[segment]
+    end
+  end
+
+  return result
+end
+
+function M.set_jump()
+  vim.cmd "normal! m'"
+end
+
+-- Filters a list based on the given predicate
+---@param tbl any[] The list to filter
+---@param predicate fun(v:any, i:number):boolean The predicate to filter with
+function M.filter(tbl, predicate)
+  local result = {}
+
+  for i, v in ipairs(tbl) do
+    if predicate(v, i) then
+      table.insert(result, v)
+    end
+  end
+
+  return result
+end
+
+-- Returns a list of all values from the first list
+-- that are not present in the second list.
+---@param tbl1 any[] The first table
+---@param tbl2 any[] The second table
+---@return table
+function M.difference(tbl1, tbl2)
+  return M.filter(tbl1, function(v)
+    return not vim.tbl_contains(tbl2, v)
+  end)
+end
+
+function M.identity(a)
+  return a
+end
+
+-- Returns a function returning the given value
+---@param a any
+---@return fun():any
+function M.constant(a)
+  return function()
+    return a
+  end
+end
+
+-- Returns a function that returns the given value if it is a function,
+-- otherwise returns a function that returns the given value.
+---@param a any
+---@return fun(...):any
+function M.to_func(a)
+  return type(a) == "function" and a or M.constant(a)
+end
+
+---@return string|nil
+function M.ts_cli_version()
+  if fn.executable "tree-sitter" == 1 then
+    local handle = io.popen "tree-sitter -V"
+    if not handle then
+      return
+    end
+    local result = handle:read "*a"
+    handle:close()
+    return vim.split(result, "\n")[1]:match "[^tree%psitter ].*"
+  end
+end
+
+return M

bundle/nvim-treesitter-0.9.1/nvim-treesitter-scm-1.rockspec

@@ -0,0 +1,36 @@
+local MODREV, SPECREV = 'scm', '-1'
+rockspec_format = '3.0'
+package = 'nvim-treesitter'
+version = MODREV .. SPECREV
+
+description = {
+  summary = 'Nvim Treesitter configurations and abstraction layer',
+  labels = { 'neovim' },
+  homepage = 'https://github.com/nvim-treesitter/nvim-treesitter',
+  license = 'Apache-2.0',
+}
+
+dependencies = {
+  'lua >= 5.1',
+}
+
+source = {
+  url = 'git://github.com/nvim-treesitter/nvim-treesitter',
+}
+
+build = {
+  type = 'make',
+  install_variables = {
+    INST_PREFIX='$(PREFIX)',
+    INST_BINDIR='$(BINDIR)',
+    INST_LIBDIR='$(LIBDIR)',
+    INST_LUADIR='$(LUADIR)',
+    INST_CONFDIR='$(CONFDIR)',
+  },
+  copy_directories = {
+    'autoload',
+    'doc',
+    'plugin',
+    'queries'
+  }
+}

bundle/nvim-treesitter-0.9.1/parser-info/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

bundle/nvim-treesitter-0.9.1/parser/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

bundle/nvim-treesitter-0.9.1/plugin/nvim-treesitter.lua

@@ -0,0 +1,34 @@
+-- Last Change: 2022 Apr 16
+
+if vim.g.loaded_nvim_treesitter then
+  return
+end
+vim.g.loaded_nvim_treesitter = true
+
+-- setup modules
+require("nvim-treesitter").setup()
+
+local api = vim.api
+
+-- define autocommands
+local augroup = api.nvim_create_augroup("NvimTreesitter", {})
+
+api.nvim_create_autocmd("Filetype", {
+  pattern = "query",
+  group = augroup,
+  callback = function()
+    api.nvim_clear_autocmds {
+      group = augroup,
+      event = "BufWritePost",
+    }
+    api.nvim_create_autocmd("BufWritePost", {
+      group = augroup,
+      buffer = 0,
+      callback = function(opts)
+        require("nvim-treesitter.query").invalidate_query_file(opts.file)
+      end,
+      desc = "Invalidate query file",
+    })
+  end,
+  desc = "Reload query",
+})

bundle/nvim-treesitter-0.9.1/queries/ada/folds.scm

@@ -0,0 +1,14 @@
+;; Support for folding in Ada
+;;    za     toggles folding a package, subprogram, if statement or loop
+
+[
+   (package_declaration)
+   (generic_package_declaration)
+   (package_body)
+   (subprogram_body)
+   (block_statement)
+   (if_statement)
+   (loop_statement)
+   (gnatprep_declarative_if_statement)
+   (gnatprep_if_statement)
+] @fold

bundle/nvim-treesitter-0.9.1/queries/ada/highlights.scm

@@ -0,0 +1,196 @@
+;; highlight queries.
+;; See the syntax at https://tree-sitter.github.io/tree-sitter/using-parsers#pattern-matching-with-queries
+;; See also https://github.com/nvim-treesitter/nvim-treesitter/blob/master/CONTRIBUTING.md#parser-configurations
+;; for a list of recommended @ tags, though not all of them have matching
+;; highlights in neovim.
+
+[
+   "abort"
+   "abs"
+   "abstract"
+   "accept"
+   "access"
+   "all"
+   "array"
+   "at"
+   "begin"
+   "declare"
+   "delay"
+   "delta"
+   "digits"
+   "do"
+   "end"
+   "entry"
+   "exit"
+   "generic"
+   "interface"
+   "is"
+   "limited"
+   "null"
+   "of"
+   "others"
+   "out"
+   "pragma"
+   "private"
+   "range"
+   "synchronized"
+   "tagged"
+   "task"
+   "terminate"
+   "until"
+   "when"
+] @keyword
+[
+   "aliased"
+   "constant"
+   "renames"
+] @storageclass
+[
+   "mod"
+   "new"
+   "protected"
+   "record"
+   "subtype"
+   "type"
+] @keyword.type
+[
+   "with"
+   "use"
+] @include
+[
+   "body"
+   "function"
+   "overriding"
+   "procedure"
+   "package"
+   "separate"
+] @keyword.function
+[
+   "and"
+   "in"
+   "not"
+   "or"
+   "xor"
+] @keyword.operator
+[
+   "while"
+   "loop"
+   "for"
+   "parallel"
+   "reverse"
+   "some"
+] @repeat
+[
+   "return"
+] @keyword.return
+[
+   "case"
+   "if"
+   "else"
+   "then"
+   "elsif"
+   "select"
+] @conditional
+[
+   "exception"
+   "raise"
+] @exception
+(comment) @comment @spell
+(string_literal) @string
+(character_literal) @string
+(numeric_literal) @number
+
+;; Highlight the name of subprograms
+(procedure_specification name: (_) @function)
+(function_specification name: (_) @function)
+(package_declaration name: (_) @function)
+(package_body name: (_) @function)
+(generic_instantiation name: (_) @function)
+(entry_declaration . (identifier) @function)
+
+;; Some keywords should take different categories depending on the context
+(use_clause "use"  @include "type" @include)
+(with_clause "private" @include)
+(with_clause "limited" @include)
+(use_clause (_) @namespace)
+(with_clause (_) @namespace)
+
+(loop_statement "end" @keyword.repeat)
+(if_statement "end" @conditional)
+(loop_parameter_specification "in" @keyword.repeat)
+(loop_parameter_specification "in" @keyword.repeat)
+(iterator_specification ["in" "of"] @keyword.repeat)
+(range_attribute_designator "range" @keyword.repeat)
+
+(raise_statement "with" @exception)
+
+(gnatprep_declarative_if_statement)  @preproc
+(gnatprep_if_statement)              @preproc
+(gnatprep_identifier)                @preproc
+
+(subprogram_declaration "is" @keyword.function "abstract"  @keyword.function)
+(aspect_specification "with" @keyword.function)
+
+(full_type_declaration "is" @keyword.type)
+(subtype_declaration "is" @keyword.type)
+(record_definition "end" @keyword.type)
+(full_type_declaration (_ "access" @keyword.type))
+(array_type_definition "array" @keyword.type "of" @keyword.type)
+(access_to_object_definition "access" @keyword.type)
+(access_to_object_definition "access" @keyword.type
+   [
+      (general_access_modifier "constant" @keyword.type)
+      (general_access_modifier "all" @keyword.type)
+   ]
+)
+(range_constraint "range" @keyword.type)
+(signed_integer_type_definition "range" @keyword.type)
+(index_subtype_definition "range" @keyword.type)
+(record_type_definition "abstract" @keyword.type)
+(record_type_definition "tagged" @keyword.type)
+(record_type_definition "limited" @keyword.type)
+(record_type_definition (record_definition "null" @keyword.type))
+(private_type_declaration "is" @keyword.type "private" @keyword.type)
+(private_type_declaration "tagged" @keyword.type)
+(private_type_declaration "limited" @keyword.type)
+(task_type_declaration "task" @keyword.type "is" @keyword.type)
+
+;; Gray the body of expression functions
+(expression_function_declaration
+   (function_specification)
+   "is"
+   (_) @attribute
+)
+(subprogram_declaration (aspect_specification) @attribute)
+
+;; Highlight full subprogram specifications
+;(subprogram_body
+;    [
+;       (procedure_specification)
+;       (function_specification)
+;    ] @function.spec
+;)
+
+((comment) @comment.documentation
+  . [
+      (entry_declaration)
+      (subprogram_declaration)
+      (parameter_specification)
+    ])
+
+(compilation_unit 
+  . (comment) @comment.documentation)
+
+(component_list
+  (component_declaration)
+    . (comment) @comment.documentation)
+
+(enumeration_type_definition 
+  (identifier)
+  . (comment) @comment.documentation)
+
+;; Highlight errors in red. This is not very useful in practice, as text will
+;; be highlighted as user types, and the error could be elsewhere in the code.
+;; This also requires defining    :hi @error guifg=Red    for instance.
+(ERROR) @error
+

bundle/nvim-treesitter-0.9.1/queries/ada/locals.scm

@@ -0,0 +1,33 @@
+;;  Better highlighting by referencing to the definition, for variable
+;;  references. However, this is not yet supported by neovim
+;;  See https://tree-sitter.github.io/tree-sitter/syntax-highlighting#local-variables
+
+(compilation) @scope
+(package_declaration) @scope
+(package_body) @scope
+(subprogram_declaration) @scope
+(subprogram_body) @scope
+(block_statement) @scope
+
+(with_clause (identifier) @definition.import)
+(procedure_specification name: (_) @definition.function)
+(function_specification name: (_) @definition.function)
+(package_declaration name: (_) @definition.var)
+(package_body name: (_) @definition.var)
+(generic_instantiation . name: (_) @definition.var)
+(component_declaration . (identifier) @definition.var)
+(exception_declaration . (identifier) @definition.var)
+(formal_object_declaration . (identifier) @definition.var)
+(object_declaration . (identifier) @definition.var)
+(parameter_specification . (identifier) @definition.var)
+(full_type_declaration . (identifier) @definition.type)
+(private_type_declaration . (identifier) @definition.type)
+(private_extension_declaration . (identifier) @definition.type)
+(incomplete_type_declaration . (identifier) @definition.type)
+(protected_type_declaration . (identifier) @definition.type)
+(formal_complete_type_declaration . (identifier) @definition.type)
+(formal_incomplete_type_declaration . (identifier) @definition.type)
+(task_type_declaration . (identifier) @definition.type)
+(subtype_declaration . (identifier) @definition.type)
+
+(identifier) @reference

bundle/nvim-treesitter-0.9.1/queries/agda/folds.scm

@@ -0,0 +1,4 @@
+[
+ (record)
+ (module)
+] @fold

bundle/nvim-treesitter-0.9.1/queries/agda/highlights.scm

@@ -0,0 +1,82 @@
+
+;; Constants
+(integer) @number
+
+;; Variables and Symbols
+
+(typed_binding (atom (qid) @variable))
+(untyped_binding) @variable
+(typed_binding (expr) @type)
+
+(id) @function
+(bid) @function
+
+(function_name (atom (qid) @function))
+(field_name) @function
+
+
+[(data_name) (record_name)] @constructor
+
+; Set
+(SetN) @type.builtin
+
+(expr . (atom) @function)
+
+((atom) @boolean
+  (#any-of? @boolean "true" "false" "True" "False"))
+
+;; Imports and Module Declarations
+
+"import"  @include
+
+(module_name) @namespace
+
+;; Pragmas and comments
+
+(pragma) @preproc
+
+(comment) @comment
+
+;; Keywords
+[
+  "where"
+  "data"
+  "rewrite"
+  "postulate"
+  "public"
+  "private"
+  "tactic"
+  "Prop"
+  "quote"
+  "renaming"
+  "open"
+  "in"
+  "hiding"
+  "constructor"
+  "abstract"
+  "let"
+  "field"
+  "mutual"
+  "module"
+  "infix"
+  "infixl"
+  "infixr"
+  "record"
+	(ARROW)
+]
+@keyword
+
+;;;(expr 
+;;;	f_name: (atom) @function)
+;; Brackets
+
+[
+  "("
+  ")"
+  "{"
+  "}"]
+@punctuation.bracket
+
+[
+  "="
+] @operator

bundle/nvim-treesitter-0.9.1/queries/arduino/folds.scm

@@ -0,0 +1 @@
+; inherits: cpp

bundle/nvim-treesitter-0.9.1/queries/arduino/highlights.scm

@@ -0,0 +1,111 @@
+; inherits: cpp
+
+((identifier) @function.builtin
+ (#any-of? @function.builtin
+           ; Digital I/O
+           "digitalRead"
+           "digitalWrite"
+           "pinMode"
+           ; Analog I/O
+           "analogRead"
+           "analogReference"
+           "analogWrite"
+           ; Zero, Due & MKR Family
+           "analogReadResolution"
+           "analogWriteResolution"
+           ; Advanced I/O
+           "noTone"
+           "pulseIn"
+           "pulseInLong"
+           "shiftIn"
+           "shiftOut"
+           "tone"
+           ; Time
+           "delay"
+           "delayMicroseconds"
+           "micros"
+           "millis"
+           ; Math
+           "abs"
+           "constrain"
+           "map"
+           "max"
+           "min"
+           "pow"
+           "sq"
+           "sqrt"
+           ; Trigonometry
+           "cos"
+           "sin"
+           "tan"
+           ; Characters
+           "isAlpha"
+           "isAlphaNumeric"
+           "isAscii"
+           "isControl"
+           "isDigit"
+           "isGraph"
+           "isHexadecimalDigit"
+           "isLowerCase"
+           "isPrintable"
+           "isPunct"
+           "isSpace"
+           "isUpperCase"
+           "isWhitespace"
+           ; Random Numbers
+           "random"
+           "randomSeed"
+           ; Bits and Bytes
+           "bit"
+           "bitClear"
+           "bitRead"
+           "bitSet"
+           "bitWrite"
+           "highByte"
+           "lowByte"
+           ; External Interrupts
+           "attachInterrupt"
+           "detachInterrupt"
+           ; Interrupts
+           "interrupts"
+           "noInterrupts"
+           ))
+
+((identifier) @type.builtin
+ (#any-of? @type.builtin
+           "Serial"
+           "SPI"
+           "Stream"
+           "Wire"
+           "Keyboard"
+           "Mouse"
+           "String"
+           ))
+
+((identifier) @constant.builtin
+ (#any-of? @constant.builtin
+           "HIGH"
+           "LOW"
+           "INPUT"
+           "OUTPUT"
+           "INPUT_PULLUP"
+           "LED_BUILTIN"
+           ))
+
+(function_definition
+  (function_declarator
+    declarator: (identifier) @function.builtin)
+  (#any-of? @function.builtin "loop" "setup"))
+
+(call_expression
+  function: (primitive_type) @function.builtin)
+
+(call_expression
+  function: (identifier) @constructor
+  (#any-of? @constructor "SPISettings" "String"))
+
+(declaration
+  (type_identifier) @type.builtin
+  (function_declarator
+    declarator: (identifier) @constructor)
+  (#eq? @type.builtin "SPISettings"))

bundle/nvim-treesitter-0.9.1/queries/arduino/indents.scm

@@ -0,0 +1 @@
+; inherits: cpp

bundle/nvim-treesitter-0.9.1/queries/arduino/injections.scm

@@ -0,0 +1,6 @@
+((preproc_def (preproc_arg) @arduino)
+  (#lua-match? @arduino "\n"))
+(preproc_function_def (preproc_arg) @arduino)
+(preproc_call (preproc_arg) @arduino)
+
+(comment) @comment

bundle/nvim-treesitter-0.9.1/queries/arduino/locals.scm

@@ -0,0 +1 @@
+; inherits: cpp

bundle/nvim-treesitter-0.9.1/queries/astro/folds.scm

@@ -0,0 +1 @@
+; inherits: html

bundle/nvim-treesitter-0.9.1/queries/astro/highlights.scm

@@ -0,0 +1,5 @@
+; inherits: html
+
+[ "---" ] @punctuation.delimiter
+
+[ "{" "}" ] @punctuation.special

bundle/nvim-treesitter-0.9.1/queries/astro/indents.scm

@@ -0,0 +1 @@
+; inherits: html

bundle/nvim-treesitter-0.9.1/queries/astro/injections.scm

@@ -0,0 +1,19 @@
+; inherits: html
+
+((frontmatter
+    (raw_text) @typescript))
+
+((interpolation
+    (raw_text) @tsx))
+
+((script_element
+    (raw_text) @typescript))
+
+((style_element
+   (start_tag
+     (attribute
+       (attribute_name) @_lang_attr
+       (quoted_attribute_value (attribute_value) @_lang_value)))
+   (raw_text) @scss)
+ (#eq? @_lang_attr "lang")
+ (#eq? @_lang_value "scss"))

bundle/nvim-treesitter-0.9.1/queries/astro/locals.scm

@@ -0,0 +1 @@
+; inherits: html

bundle/nvim-treesitter-0.9.1/queries/awk/highlights.scm

@@ -0,0 +1,195 @@
+; adapted from https://github.com/Beaglefoot/tree-sitter-awk
+
+[
+  (identifier)
+  (field_ref)
+] @variable
+(field_ref (_) @variable)
+
+; https://www.gnu.org/software/gawk/manual/html_node/Auto_002dset.html
+((identifier) @constant.builtin
+ (#any-of? @constant.builtin
+           "ARGC"
+           "ARGV"
+           "ARGIND"
+           "ENVIRON"
+           "ERRNO"
+           "FILENAME"
+           "FNR"
+           "NF"
+           "FUNCTAB"
+           "NR"
+           "PROCINFO"
+           "RLENGTH"
+           "RSTART"
+           "RT"
+           "SYMTAB"))
+
+; https://www.gnu.org/software/gawk/manual/html_node/User_002dmodified.html
+((identifier) @variable.builtin
+ (#any-of? @variable.builtin
+           "BINMODE"
+           "CONVFMT"
+           "FIELDWIDTHS"
+           "FPAT"
+           "FS"
+           "IGNORECASE"
+           "LINT"
+           "OFMT"
+           "OFS"
+           "ORS"
+           "PREC"
+           "ROUNDMODE"
+           "RS"
+           "SUBSEP"
+           "TEXTDOMAIN"))
+
+(number) @number
+
+(string) @string
+(regex) @string.regex
+(escape_sequence) @string.escape
+
+(comment) @comment @spell
+
+((program . (comment) @preproc)
+  (#lua-match? @preproc "^#!/"))
+
+(ns_qualified_name (namespace) @namespace)
+(ns_qualified_name "::" @punctuation.delimiter)
+
+(func_def name: (_ (identifier) @function) @function)
+(func_call name: (_ (identifier) @function) @function)
+
+(func_def (param_list (identifier) @parameter))
+
+[
+  "print"
+  "printf"
+  "getline"
+] @function.builtin
+
+[
+  (delete_statement)
+  (break_statement)
+  (continue_statement)
+  (next_statement)
+  (nextfile_statement)
+] @keyword
+
+[
+  "func"
+  "function"
+] @keyword.function
+
+[
+  "return"
+  "exit"
+] @keyword.return
+
+[
+  "do"
+  "while"
+  "for"
+  "in"
+] @repeat
+
+[
+  "if"
+  "else"
+  "switch"
+  "case"
+  "default"
+] @conditional
+
+[
+  "@include"
+  "@load"
+] @include
+
+"@namespace" @preproc
+
+[
+ "BEGIN"
+ "END"
+ "BEGINFILE"
+ "ENDFILE"
+] @label
+
+(binary_exp [
+  "^"
+  "**"
+  "*"
+  "/"
+  "%"
+  "+"
+  "-"
+  "<"
+  ">"
+  "<="
+  ">="
+  "=="
+  "!="
+  "~"
+  "!~"
+  "in"
+  "&&"
+  "||"
+] @operator)
+
+(unary_exp [
+  "!"
+  "+"
+  "-"
+] @operator)
+
+(assignment_exp [
+  "="
+  "+="
+  "-="
+  "*="
+  "/="
+  "%="
+  "^="
+] @operator)
+
+(ternary_exp [
+  "?"
+  ":"
+] @conditional.ternary)
+
+(update_exp [
+  "++"
+  "--"
+] @operator)
+
+(redirected_io_statement [
+  ">"
+  ">>"
+] @operator)
+
+(piped_io_statement [
+  "|"
+  "|&"
+] @operator)
+
+(piped_io_exp [
+  "|"
+  "|&"
+] @operator)
+
+(field_ref "$" @punctuation.delimiter)
+
+(regex "/" @punctuation.delimiter)
+(regex_constant "@" @punctuation.delimiter)
+
+[ ";" "," ] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket

bundle/nvim-treesitter-0.9.1/queries/awk/injections.scm

@@ -0,0 +1,2 @@
+(comment) @comment
+(regex) @regex

bundle/nvim-treesitter-0.9.1/queries/bash/folds.scm

@@ -0,0 +1,8 @@
+[
+  (function_definition)
+  (if_statement)
+  (case_statement)
+  (for_statement)
+  (while_statement)
+  (c_style_for_statement)
+] @fold

bundle/nvim-treesitter-0.9.1/queries/bash/highlights.scm

@@ -0,0 +1,148 @@
+(simple_expansion) @none
+(expansion
+  "${" @punctuation.special
+  "}" @punctuation.special) @none
+[
+ "("
+ ")"
+ "(("
+ "))"
+ "{"
+ "}"
+ "["
+ "]"
+ "[["
+ "]]"
+ ] @punctuation.bracket
+
+[
+ ";"
+ ";;"
+ (heredoc_start)
+ ] @punctuation.delimiter
+
+[
+ "$"
+] @punctuation.special
+
+[
+ ">"
+ ">>"
+ "<"
+ "<<"
+ "&"
+ "&&"
+ "|"
+ "||"
+ "="
+ "=~"
+ "=="
+ "!="
+ ] @operator
+
+; Do *not* spell check strings since they typically have some sort of
+; interpolation in them, or, are typically used for things like filenames, URLs,
+; flags and file content.
+[
+ (string)
+ (raw_string)
+ (ansi_c_string)
+ (heredoc_body)
+] @string
+
+(variable_assignment (word) @string)
+
+[
+ "if"
+ "then"
+ "else"
+ "elif"
+ "fi"
+ "case"
+ "in"
+ "esac"
+ ] @conditional
+
+[
+ "for"
+ "do"
+ "done"
+ "select"
+ "until"
+ "while"
+ ] @repeat
+
+[
+ "declare"
+ "export"
+ "local"
+ "readonly"
+ "unset"
+ ] @keyword
+
+"function" @keyword.function
+
+(special_variable_name) @constant
+
+; trap -l
+((word) @constant.builtin
+ (#match? @constant.builtin "^SIG(HUP|INT|QUIT|ILL|TRAP|ABRT|BUS|FPE|KILL|USR[12]|SEGV|PIPE|ALRM|TERM|STKFLT|CHLD|CONT|STOP|TSTP|TT(IN|OU)|URG|XCPU|XFSZ|VTALRM|PROF|WINCH|IO|PWR|SYS|RTMIN([+]([1-9]|1[0-5]))?|RTMAX(-([1-9]|1[0-4]))?)$"))
+
+((word) @boolean
+  (#any-of? @boolean "true" "false"))
+
+(comment) @comment @spell
+(test_operator) @string
+
+(command_substitution
+  [ "$(" ")" ] @punctuation.bracket)
+
+(process_substitution
+  [ "<(" ")" ] @punctuation.bracket)
+
+
+(function_definition
+  name: (word) @function)
+
+(command_name (word) @function.call)
+
+((command_name (word) @function.builtin)
+ (#any-of? @function.builtin
+    "alias" "bg" "bind" "break" "builtin" "caller" "cd"
+    "command" "compgen" "complete" "compopt" "continue"
+    "coproc" "dirs" "disown" "echo" "enable" "eval"
+    "exec" "exit" "fc" "fg" "getopts" "hash" "help"
+    "history" "jobs" "kill" "let" "logout" "mapfile"
+    "popd" "printf" "pushd" "pwd" "read" "readarray"
+    "return" "set" "shift" "shopt" "source" "suspend"
+    "test" "time" "times" "trap" "type" "typeset"
+    "ulimit" "umask" "unalias" "wait"))
+
+(command
+  argument: [
+             (word) @parameter
+             (concatenation (word) @parameter)
+             ])
+
+((word) @number
+  (#lua-match? @number "^[0-9]+$"))
+
+(file_redirect
+  descriptor: (file_descriptor) @operator
+  destination: (word) @parameter)
+
+(expansion
+  [ "${" "}" ] @punctuation.bracket)
+
+(variable_name) @variable
+
+((variable_name) @constant
+ (#lua-match? @constant "^[A-Z][A-Z_0-9]*$"))
+
+(case_item
+  value: (word) @parameter)
+
+(regex) @string.regex
+
+((program . (comment) @preproc)
+  (#lua-match? @preproc "^#!/"))

bundle/nvim-treesitter-0.9.1/queries/bash/injections.scm

@@ -0,0 +1,3 @@
+(comment) @comment
+
+(regex) @regex

bundle/nvim-treesitter-0.9.1/queries/bash/locals.scm

@@ -0,0 +1,13 @@
+; Scopes
+(function_definition) @scope
+
+; Definitions
+(variable_assignment 
+  name: (variable_name) @definition.var)
+
+(function_definition
+  name: (word) @definition.function)
+
+; References
+(variable_name) @reference
+(word) @reference

bundle/nvim-treesitter-0.9.1/queries/bass/folds.scm

@@ -0,0 +1,5 @@
+[
+  (list)
+  (scope)
+  (cons)
+] @fold

bundle/nvim-treesitter-0.9.1/queries/bass/highlights.scm

@@ -0,0 +1,109 @@
+;; Variables
+
+(list (symbol) @variable)
+
+(cons (symbol) @variable)
+
+(scope (symbol) @variable)
+
+(symbind (symbol) @variable)
+
+;; Constants
+
+((symbol) @constant
+  (#lua-match? @constant "^_*[A-Z][A-Z0-9_]*$"))
+
+;; Functions
+
+(list 
+  . (symbol) @function)
+
+;; Namespaces
+
+(symbind
+  (symbol) @namespace
+  . (keyword))
+
+;; Includes
+
+((symbol) @include
+  (#any-of? @include "use" "import" "load"))
+
+;; Keywords
+
+((symbol) @keyword
+  (#any-of? @keyword "do" "doc"))
+
+;; Special Functions
+
+; Keywords construct a symbol
+
+(keyword) @constructor
+
+((list
+  . (symbol) @keyword.function
+  . (symbol) @function
+  (symbol)? @parameter)
+  (#any-of? @keyword.function "def" "defop" "defn" "fn"))
+
+((cons
+  . (symbol) @keyword.function
+  . (symbol) @function
+  (symbol)? @parameter)
+  (#any-of? @keyword.function "def" "defop" "defn" "fn"))
+
+((symbol) @function.builtin
+  (#any-of? @function.builtin "dump" "mkfs" "json" "log" "error" "now" "cons" "wrap" "unwrap" "eval" "make-scope" "bind" "meta" "with-meta" "null?" "ignore?" "boolean?" "number?" "string?" "symbol?" "scope?" "sink?" "source?" "list?" "pair?" "applicative?" "operative?" "combiner?" "path?" "empty?" "thunk?" "+" "*" "quot" "-" "max" "min" "=" ">" ">=" "<" "<=" "list->source" "across" "emit" "next" "reduce-kv" "assoc" "symbol->string" "string->symbol" "str" "substring" "trim" "scope->list" "string->fs-path" "string->cmd-path" "string->dir" "subpath" "path-name" "path-stem" "with-image" "with-dir" "with-args" "with-cmd" "with-stdin" "with-env" "with-insecure" "with-label" "with-port" "with-tls" "with-mount" "thunk-cmd" "thunk-args" "resolve" "start" "addr" "wait" "read" "cache-dir" "binds?" "recall-memo" "store-memo" "mask" "list" "list*" "first" "rest" "length" "second" "third" "map" "map-pairs" "foldr" "foldl" "append" "filter" "conj" "list->scope" "merge" "apply" "id" "always" "vals" "keys" "memo" "succeeds?" "run" "last" "take" "take-all" "insecure!" "from" "cd" "wrap-cmd" "mkfile" "path-base" "not"))
+
+((symbol) @function.macro
+  (#any-of? @function.macro "op" "current-scope" "quote" "let" "provide" "module" "or" "and" "curryfn" "for" "$" "linux"))
+
+;; Conditionals
+
+((symbol) @conditional
+  (#any-of? @conditional "if" "case" "cond" "when"))
+
+;; Repeats
+
+((symbol) @repeat
+  (#any-of? @repeat "each"))
+
+;; Operators
+
+((symbol) @operator (#any-of? @operator "&" "*" "+" "-" "<" "<=" "=" ">" ">="))
+
+;; Punctuation
+
+[ "(" ")" ] @punctuation.bracket
+
+[ "{" "}" ] @punctuation.bracket
+
+[ "[" "]" ] @punctuation.bracket
+
+((symbol) @punctuation.delimiter
+  (#eq? @punctuation.delimiter "->"))
+
+;; Literals
+
+(string) @string
+
+(escape_sequence) @string.escape
+
+(path) @text.uri @string.special
+
+(number) @number
+
+(boolean) @boolean
+
+[
+  (ignore)
+  (null)
+] @constant.builtin
+
+[
+  "^"
+] @character.special
+
+;; Comments
+
+(comment) @comment @spell

bundle/nvim-treesitter-0.9.1/queries/bass/indents.scm

@@ -0,0 +1,22 @@
+[
+  (list)
+  (scope)
+  (cons)
+] @indent.begin
+
+[
+  ")"
+  "}"
+  "]"
+] @indent.end
+
+[ "(" ")" ] @indent.branch
+
+[ "{" "}" ] @indent.branch
+
+[ "[" "]" ] @indent.branch
+
+[
+  (ERROR)
+  (comment)
+] @indent.auto

bundle/nvim-treesitter-0.9.1/queries/bass/injections.scm

@@ -0,0 +1 @@
+(comment) @comment

bundle/nvim-treesitter-0.9.1/queries/bass/locals.scm

@@ -0,0 +1,25 @@
+; Scopes
+
+[
+  (list)
+  (scope)
+  (cons)
+] @scope
+
+; References
+
+(symbol) @reference
+
+; Definitions
+
+((list
+  . (symbol) @_fnkw
+  . (symbol) @definition.function
+  (symbol)? @definition.parameter)
+  (#any-of? @_fnkw "def" "defop" "defn" "fn"))
+
+((cons
+  . (symbol) @_fnkw
+  . (symbol) @definition.function
+  (symbol)? @definition.parameter)
+  (#any-of? @_fnkw "def" "defop" "defn" "fn"))

bundle/nvim-treesitter-0.9.1/queries/beancount/folds.scm

@@ -0,0 +1,4 @@
+[
+    (transaction)
+    (section)
+] @fold

bundle/nvim-treesitter-0.9.1/queries/beancount/highlights.scm

@@ -0,0 +1,24 @@
+(date) @field
+(txn) @attribute
+(account) @type
+(amount) @number
+(incomplete_amount) @number
+(compound_amount) @number
+(amount_tolerance) @number
+(currency) @property
+(key) @label
+(string) @string
+(narration) @string @spell
+(payee) @string @spell
+(tag) @constant
+(link) @constant
+[
+ (minus) (plus) (slash) (asterisk)
+] @operator
+(comment) @comment @spell
+[
+    (balance) (open) (close) (commodity) (pad)
+    (event) (price) (note) (document) (query)
+    (custom) (pushtag) (poptag) (pushmeta)
+    (popmeta) (option) (include) (plugin)
+] @keyword

bundle/nvim-treesitter-0.9.1/queries/bibtex/folds.scm

@@ -0,0 +1,3 @@
+[
+ (entry)
+] @fold

bundle/nvim-treesitter-0.9.1/queries/bibtex/highlights.scm

@@ -0,0 +1,49 @@
+; CREDITS @pfoerster (adapted from https://github.com/latex-lsp/tree-sitter-bibtex)
+
+[
+  (string_type)
+  (preamble_type)
+  (entry_type)
+] @keyword
+
+[
+  (junk)
+  (comment)
+] @comment
+
+[
+  "="
+  "#"
+] @operator
+
+(command) @function.builtin
+
+(number) @number
+
+(field
+  name: (identifier) @field)
+
+(token
+  (identifier) @parameter)
+
+[
+  (brace_word)
+  (quote_word)
+] @string
+
+[
+  (key_brace)
+  (key_paren)
+] @symbol
+
+(string
+  name: (identifier) @constant)
+
+[
+  "{"
+  "}"
+  "("
+  ")"
+] @punctuation.bracket
+
+"," @punctuation.delimiter

bundle/nvim-treesitter-0.9.1/queries/bibtex/indents.scm

@@ -0,0 +1,10 @@
+[
+ (entry)
+] @indent.begin
+
+[
+ "{"
+ "}"
+] @indent.branch
+
+(comment) @indent.ignore

bundle/nvim-treesitter-0.9.1/queries/bicep/folds.scm

@@ -0,0 +1,25 @@
+[
+  (module_declaration)
+  (metadata_declaration)
+  (output_declaration)
+  (parameter_declaration)
+  (resource_declaration)
+  (type_declaration)
+  (variable_declaration)
+
+  (parenthesized_expression)
+
+  (decorators)
+  (array)
+  (object)
+
+  (if_statement)
+  (for_statement)
+
+  (subscript_expression)
+  (ternary_expression)
+
+  (string)
+
+  (comment)
+] @fold

bundle/nvim-treesitter-0.9.1/queries/bicep/highlights.scm

@@ -0,0 +1,230 @@
+; Includes
+
+(import_statement
+  "import" @include)
+
+(import_with_statement
+  "import" @include
+  "with" @include)
+
+; Namespaces
+
+(module_declaration
+  (identifier) @namespace)
+
+; Builtins
+
+(primitive_type) @type.builtin
+
+((member_expression
+  object: (identifier) @type.builtin)
+  (#eq? @type.builtin "sys"))
+
+; Functions
+
+(call_expression
+  function: (identifier) @function.call)
+
+; Properties
+
+(object_property
+  (identifier) @property
+  ":" @punctuation.delimiter
+  (_))
+
+(object_property
+  (compatible_identifier) @property
+  ":" @punctuation.delimiter
+  (_))
+
+(property_identifier) @property
+
+; Attributes
+
+(decorator
+  "@" @attribute)
+
+(decorator
+  (call_expression (identifier) @attribute))
+
+(decorator
+  (call_expression
+    (member_expression
+	  object: (identifier) @attribute
+	  property: (property_identifier) @attribute)))
+
+; Types
+
+(type_declaration
+  (identifier) @type)
+
+(type_declaration
+  (identifier)
+  "="
+  (identifier) @type)
+
+(type_declaration
+  (identifier)
+  "="
+  (array_type (identifier) @type))
+
+(type
+  (identifier) @type)
+
+(resource_declaration
+  (identifier) @type)
+
+(resource_expression
+  (identifier) @type)
+
+; Parameters
+
+(parameter_declaration
+  (identifier) @parameter
+  (_))
+
+(call_expression
+  function: (_) 
+  (arguments (identifier) @parameter))
+
+(call_expression
+  function: (_) 
+  (arguments (member_expression object: (identifier) @parameter)))
+
+; Variables
+
+(variable_declaration
+  (identifier) @variable
+  (_))
+
+(metadata_declaration
+  (identifier) @variable
+  (_))
+
+(output_declaration
+  (identifier) @variable
+  (_))
+
+(object_property
+  (_)
+  ":"
+  (identifier) @variable)
+
+(for_statement
+  "for"
+  (for_loop_parameters
+    (loop_variable) @variable
+    (loop_enumerator) @variable))
+
+; Conditionals
+
+"if" @conditional
+
+(ternary_expression
+  "?" @conditional.ternary
+  ":" @conditional.ternary)
+
+; Loops
+
+(for_statement
+  "for" @repeat
+  "in"
+  ":" @punctuation.delimiter)
+
+; Keywords
+
+[
+  "module"
+  "metadata"
+  "output"
+  "param"
+  "resource"
+  "existing"
+  "targetScope"
+  "type"
+  "var"
+] @keyword
+
+; Operators
+
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "||"
+  "&&"
+  "|"
+  "=="
+  "!="
+  "=~"
+  "!~"
+  ">"
+  ">="
+  "<="
+  "<"
+  "??"
+  "="
+  "!"
+] @operator
+
+[
+  "in"
+] @keyword.operator
+
+
+; Literals
+
+(string) @string
+(import_string
+  "'" @string
+  (import_name) @namespace
+  "@" @symbol
+  (import_version) @string.special)
+
+(escape_sequence) @string.escape
+
+(number) @number
+
+(boolean) @boolean
+
+(null) @constant.builtin
+
+; Misc
+
+(compatible_identifier
+  "?" @punctuation.special)
+
+(nullable_return_type) @punctuation.special
+
+["{" "}"] @punctuation.bracket
+
+["[" "]"] @punctuation.bracket
+
+["(" ")"] @punctuation.bracket
+
+[
+  "."
+  "::"
+  "=>"
+] @punctuation.delimiter
+
+
+; Interpolation
+
+(interpolation) @none
+
+(interpolation
+  "${" @punctuation.special
+  "}" @punctuation.special)
+
+(interpolation
+  (identifier) @variable)
+
+; Comments
+
+[
+  (comment)
+  (diagnostic_comment)
+] @comment @spell

bundle/nvim-treesitter-0.9.1/queries/bicep/indents.scm

@@ -0,0 +1,18 @@
+[
+  (array)
+  (object)
+] @indent.begin
+
+"}" @indent.end
+
+[ "{" "}" ] @indent.branch
+
+[ "[" "]" ] @indent.branch
+
+[ "(" ")" ] @indent.branch
+
+[
+  (ERROR)
+  (comment)
+  (diagnostic_comment)
+] @indent.auto

bundle/nvim-treesitter-0.9.1/queries/bicep/injections.scm

@@ -0,0 +1,4 @@
+[
+ (comment)
+ (diagnostic_comment)
+] @comment

bundle/nvim-treesitter-0.9.1/queries/bicep/locals.scm

@@ -0,0 +1,74 @@
+; Scopes
+
+[
+  (infrastructure)
+  (call_expression)
+
+  (lambda_expression)
+  (subscript_expression)
+
+  (if_statement)
+  (for_statement)
+
+  (array)
+  (object)
+  (interpolation)
+] @scope
+
+; References
+
+(property_identifier) @reference
+
+(call_expression
+  (identifier) @reference)
+
+(object_property
+  (_)
+  ":"
+  (identifier) @reference)
+
+(resource_expression
+  (identifier) @reference)
+
+; Definitions
+
+(type) @definition.associated
+
+(object_property
+  (identifier) @definition.field
+  (_))
+
+(object_property
+  (compatible_identifier) @definition.field
+  (_))
+
+(import_name) @definition.import
+
+(module_declaration
+  (identifier) @definition.namespace)
+
+(parameter_declaration
+  (identifier) @definition.parameter
+  (_))
+
+(type_declaration
+  (identifier) @definition.type
+  (_))
+
+(variable_declaration
+  (identifier) @definition.var
+  (_))
+
+(metadata_declaration
+  (identifier) @definition.var
+  (_))
+
+(output_declaration
+  (identifier) @definition.var
+  (_))
+
+(for_statement
+  "for"
+  (for_loop_parameters
+    (loop_variable) @definition.var
+    (loop_enumerator) @definition.var))

bundle/nvim-treesitter-0.9.1/queries/blueprint/highlights.scm

@@ -0,0 +1,57 @@
+(object_id) @variable
+
+(string) @string
+(escape_sequence) @string.escape
+
+(comment) @comment
+
+(constant) @constant.builtin
+
+(boolean) @boolean
+
+(using) @include
+
+(template) @keyword
+
+(decorator) @attribute
+
+(property_definition (property_name) @property)
+
+(object) @type
+
+(signal_binding (signal_name) @function.builtin)
+(signal_binding (function (identifier)) @function)
+(signal_binding "swapped" @keyword)
+
+(styles_list "styles" @function.macro)
+(layout_definition "layout" @function.macro)
+
+(gettext_string "_" @function.builtin)
+
+(menu_definition "menu" @keyword)
+(menu_section "section" @keyword)
+(menu_item "item" @function.macro)
+
+(template_definition (template_name_qualifier) @type.qualifier)
+
+(import_statement (gobject_library) @namespace)
+
+(import_statement (version_number) @float)
+
+(float) @float
+(number) @number
+
+[
+  ";"
+  "."
+  ","
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket

bundle/nvim-treesitter-0.9.1/queries/c/folds.scm

@@ -0,0 +1,20 @@
+[
+ (for_statement)
+ (if_statement)
+ (while_statement)
+ (switch_statement)
+ (case_statement)
+ (function_definition)
+ (struct_specifier)
+ (enum_specifier)
+ (comment)
+ (preproc_if)
+ (preproc_elif)
+ (preproc_else)
+ (preproc_ifdef)
+ (initializer_list)
+ (gnu_asm_expression)
+] @fold
+
+(compound_statement
+  (compound_statement) @fold)

bundle/nvim-treesitter-0.9.1/queries/c/highlights.scm

@@ -0,0 +1,263 @@
+; Lower priority to prefer @parameter when identifier appears in parameter_declaration.
+((identifier) @variable (#set! "priority" 95))
+(preproc_def (preproc_arg) @variable)
+
+[
+  "default"
+  "enum"
+  "struct"
+  "typedef"
+  "union"
+  "goto"
+  "asm"
+  "__asm__"
+] @keyword
+
+[
+  "sizeof"
+  "offsetof"
+] @keyword.operator
+(alignof_expression . _ @keyword.operator)
+
+"return" @keyword.return
+
+[
+  "while"
+  "for"
+  "do"
+  "continue"
+  "break"
+] @repeat
+
+[
+ "if"
+ "else"
+ "case"
+ "switch"
+] @conditional
+
+[
+  "#if"
+  "#ifdef"
+  "#ifndef"
+  "#else"
+  "#elif"
+  "#endif"
+  "#elifdef"
+  "#elifndef"
+  (preproc_directive)
+] @preproc
+
+"#define" @define
+
+"#include" @include
+
+[ ";" ":" "," "::" ] @punctuation.delimiter
+
+"..." @punctuation.special
+
+[ "(" ")" "[" "]" "{" "}"] @punctuation.bracket
+
+[
+  "="
+
+  "-"
+  "*"
+  "/"
+  "+"
+  "%"
+
+  "~"
+  "|"
+  "&"
+  "^"
+  "<<"
+  ">>"
+
+  "->"
+  "."
+
+  "<"
+  "<="
+  ">="
+  ">"
+  "=="
+  "!="
+
+  "!"
+  "&&"
+  "||"
+
+  "-="
+  "+="
+  "*="
+  "/="
+  "%="
+  "|="
+  "&="
+  "^="
+  ">>="
+  "<<="
+  "--"
+  "++"
+] @operator
+
+;; Make sure the comma operator is given a highlight group after the comma
+;; punctuator so the operator is highlighted properly.
+(comma_expression [ "," ] @operator)
+
+[
+  (true)
+  (false)
+] @boolean
+
+(conditional_expression [ "?" ":" ] @conditional.ternary)
+
+(string_literal) @string
+(system_lib_string) @string
+(escape_sequence) @string.escape
+
+(null) @constant.builtin
+(number_literal) @number
+(char_literal) @character
+
+((preproc_arg) @function.macro (#set! "priority" 90))
+(preproc_defined) @function.macro
+
+(((field_expression
+     (field_identifier) @property)) @_parent
+ (#not-has-parent? @_parent template_method function_declarator call_expression))
+
+(field_designator) @property
+(((field_identifier) @property)
+ (#has-ancestor? @property field_declaration)
+ (#not-has-ancestor? @property function_declarator))
+
+(statement_identifier) @label
+
+[
+ (type_identifier)
+ (type_descriptor)
+] @type
+
+(storage_class_specifier) @storageclass
+
+[
+  (type_qualifier)
+  (gnu_asm_qualifier)
+  "__extension__"
+] @type.qualifier
+
+(linkage_specification
+  "extern" @storageclass)
+
+(type_definition
+  declarator: (type_identifier) @type.definition)
+
+(primitive_type) @type.builtin
+
+(sized_type_specifier _ @type.builtin type: _?)
+
+((identifier) @constant
+ (#lua-match? @constant "^[A-Z][A-Z0-9_]+$"))
+(preproc_def (preproc_arg) @constant
+  (#lua-match? @constant "^[A-Z][A-Z0-9_]+$"))
+(enumerator
+  name: (identifier) @constant)
+(case_statement
+  value: (identifier) @constant)
+
+((identifier) @constant.builtin
+  (#any-of? @constant.builtin
+    "stderr" "stdin" "stdout"
+    "__FILE__" "__LINE__" "__DATE__" "__TIME__"
+    "__STDC__" "__STDC_VERSION__" "__STDC_HOSTED__"
+    "__cplusplus" "__OBJC__" "__ASSEMBLER__"
+    "__BASE_FILE__" "__FILE_NAME__" "__INCLUDE_LEVEL__"
+    "__TIMESTAMP__" "__clang__" "__clang_major__"
+    "__clang_minor__" "__clang_patchlevel__"
+    "__clang_version__" "__clang_literal_encoding__"
+    "__clang_wide_literal_encoding__"
+    "__FUNCTION__" "__func__" "__PRETTY_FUNCTION__"
+    "__VA_ARGS__" "__VA_OPT__"))
+(preproc_def (preproc_arg) @constant.builtin
+  (#any-of? @constant.builtin
+    "stderr" "stdin" "stdout"
+    "__FILE__" "__LINE__" "__DATE__" "__TIME__"
+    "__STDC__" "__STDC_VERSION__" "__STDC_HOSTED__"
+    "__cplusplus" "__OBJC__" "__ASSEMBLER__"
+    "__BASE_FILE__" "__FILE_NAME__" "__INCLUDE_LEVEL__"
+    "__TIMESTAMP__" "__clang__" "__clang_major__"
+    "__clang_minor__" "__clang_patchlevel__"
+    "__clang_version__" "__clang_literal_encoding__"
+    "__clang_wide_literal_encoding__"
+    "__FUNCTION__" "__func__" "__PRETTY_FUNCTION__"
+    "__VA_ARGS__" "__VA_OPT__"))
+
+(attribute_specifier
+  (argument_list (identifier) @variable.builtin))
+((attribute_specifier
+  (argument_list (call_expression
+                   function: (identifier) @variable.builtin))))
+
+((call_expression
+  function: (identifier) @function.builtin)
+  (#lua-match? @function.builtin "^__builtin_"))
+((call_expression
+   function: (identifier) @function.builtin)
+  (#has-ancestor? @function.builtin attribute_specifier))
+
+;; Preproc def / undef
+(preproc_def
+  name: (_) @constant)
+(preproc_call
+  directive: (preproc_directive) @_u
+  argument: (_) @constant
+  (#eq? @_u "#undef"))
+
+(call_expression
+  function: (identifier) @function.call)
+(call_expression
+  function: (field_expression
+    field: (field_identifier) @function.call))
+(function_declarator
+  declarator: (identifier) @function)
+(function_declarator
+  declarator: (parenthesized_declarator
+                (pointer_declarator
+                  declarator: (field_identifier) @function)))
+(preproc_function_def
+  name: (identifier) @function.macro)
+
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$"))
+
+;; Parameters
+(parameter_declaration
+  declarator: (identifier) @parameter)
+
+(parameter_declaration
+  declarator: (array_declarator) @parameter)
+
+(parameter_declaration
+  declarator: (pointer_declarator) @parameter)
+
+(preproc_params (identifier) @parameter)
+
+[
+  "__attribute__"
+  "__declspec"
+  "__based"
+  "__cdecl"
+  "__clrcall"
+  "__stdcall"
+  "__fastcall"
+  "__thiscall"
+  "__vectorcall"
+  (ms_pointer_modifier)
+  (attribute_declaration)
+] @attribute
+
+(ERROR) @error

bundle/nvim-treesitter-0.9.1/queries/c/indents.scm

@@ -0,0 +1,90 @@
+[
+  (compound_statement) 
+  (field_declaration_list)
+  (case_statement)
+  (enumerator_list)
+  (compound_literal_expression)
+  (initializer_list)
+  (init_declarator)
+] @indent.begin
+
+; With current indent logic, if we capture expression_statement with @indent.begin
+; It will be affected by _parent_ node with error subnodes deep down the tree
+; So narrow indent capture to check for error inside expression statement only, 
+(expression_statement
+  (_) @indent.begin
+  ";" @indent.end)
+
+(ERROR
+  "for" "(" @indent.begin ";" ";" ")" @indent.end)
+
+((for_statement
+    body: (_) @_body) @indent.begin
+  (#not-has-type? @_body compound_statement))
+
+(while_statement
+  condition: (_) @indent.begin)
+
+((while_statement
+    body: (_) @_body) @indent.begin
+  (#not-has-type? @_body compound_statement))
+
+(
+  (if_statement)
+  .
+  (ERROR "else" @indent.begin))
+
+(if_statement
+  condition: (_) @indent.begin)
+
+;; Supports if without braces (but not both if-else without braces)
+((if_statement
+  consequence: 
+    (_ ";" @indent.end) @_consequence
+    (#not-has-type? @_consequence compound_statement)
+  alternative:
+    (else_clause 
+      "else" @indent.branch
+      [ 
+        (if_statement (compound_statement) @indent.dedent)? @indent.dedent
+        (compound_statement)? @indent.dedent
+        (_)? @indent.dedent
+      ]
+      )?
+  ) @indent.begin)
+
+(else_clause (_ . "{" @indent.branch))
+
+
+(compound_statement "}" @indent.end)
+
+[
+  ")"
+  "}"
+  (statement_identifier)
+] @indent.branch
+
+[
+  "#define"
+  "#ifdef"
+  "#ifndef"
+  "#elif"
+  "#if"
+  "#else"
+  "#endif"
+] @indent.zero
+
+[
+  (preproc_arg)
+  (string_literal)
+] @indent.ignore
+
+((ERROR (parameter_declaration)) @indent.align
+ (#set! indent.open_delimiter "(")
+ (#set! indent.close_delimiter ")"))
+([(argument_list) (parameter_list)] @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+(comment) @indent.auto
+

bundle/nvim-treesitter-0.9.1/queries/c/injections.scm

@@ -0,0 +1,10 @@
+((preproc_def (preproc_arg) @c)
+  (#lua-match? @c "\n"))
+(preproc_function_def (preproc_arg) @c)
+(preproc_call (preproc_arg) @c)
+
+(comment) @comment
+
+; TODO: add when asm is added
+; (gnu_asm_expression assembly_code: (string_literal) @asm)
+; (gnu_asm_expression assembly_code: (concatenated_string (string_literal) @asm))

bundle/nvim-treesitter-0.9.1/queries/c/locals.scm

@@ -0,0 +1,53 @@
+;; Functions definitions
+(function_declarator
+  declarator: (identifier) @definition.function)
+(preproc_function_def
+  name: (identifier) @definition.macro) @scope
+
+(preproc_def
+  name: (identifier) @definition.macro)
+(pointer_declarator
+  declarator: (identifier) @definition.var)
+(parameter_declaration
+  declarator: (identifier) @definition.parameter)
+(init_declarator
+  declarator: (identifier) @definition.var)
+(array_declarator
+  declarator: (identifier) @definition.var)
+(declaration
+  declarator: (identifier) @definition.var)
+(enum_specifier
+  name: (_) @definition.type
+  (enumerator_list
+    (enumerator name: (identifier) @definition.var)))
+
+;; Type / Struct / Enum
+(field_declaration
+  declarator: (field_identifier) @definition.field)
+(type_definition
+  declarator: (type_identifier) @definition.type)
+(struct_specifier
+  name: (type_identifier) @definition.type)
+
+;; goto
+(labeled_statement (statement_identifier) @definition)
+
+;; References
+(identifier) @reference
+((field_identifier) @reference
+                    (#set! reference.kind "field"))
+((type_identifier) @reference
+                   (#set! reference.kind "type"))
+
+(goto_statement (statement_identifier) @reference)
+
+;; Scope
+[
+ (for_statement)
+ (if_statement)
+ (while_statement)
+ (translation_unit)
+ (function_definition)
+ (compound_statement) ; a block in curly braces
+ (struct_specifier)
+] @scope

bundle/nvim-treesitter-0.9.1/queries/c_sharp/folds.scm

@@ -0,0 +1,15 @@
+body: [
+  (declaration_list)
+  (switch_body)
+  (enum_member_declaration_list)
+] @fold
+
+accessors: [
+  (accessor_list)
+] @fold
+
+initializer: [
+  (initializer_expression)
+] @fold
+
+(block) @fold

bundle/nvim-treesitter-0.9.1/queries/c_sharp/highlights.scm

@@ -0,0 +1,412 @@
+(identifier) @variable
+
+((identifier) @keyword
+  (#eq? @keyword "value")
+  (#has-ancestor? @keyword accessor_declaration))
+
+(method_declaration
+  name: (identifier) @method)
+
+(local_function_statement
+  name: (identifier) @method)
+
+(method_declaration
+  type: (identifier) @type)
+
+(local_function_statement
+  type: (identifier) @type)
+
+(interpolation) @none
+
+(invocation_expression
+  (member_access_expression
+    name: (identifier) @method.call))
+
+(invocation_expression
+  function: (conditional_access_expression
+    (member_binding_expression
+      name: (identifier) @method.call)))
+
+(namespace_declaration
+  name: [(qualified_name) (identifier)] @namespace)
+
+(qualified_name
+  (identifier) @type)
+
+(invocation_expression
+      (identifier) @method.call)
+
+(field_declaration
+  (variable_declaration
+    (variable_declarator
+      (identifier) @field)))
+
+(initializer_expression
+  (assignment_expression
+    left: (identifier) @field))
+
+(parameter_list
+  (parameter
+   name: (identifier) @parameter))
+
+(parameter_list
+  (parameter
+   type: (identifier) @type))
+
+(integer_literal) @number
+(real_literal) @float
+
+(null_literal) @constant.builtin
+(character_literal) @character
+
+[
+ (string_literal)
+ (verbatim_string_literal)
+ (interpolated_string_expression)
+] @string
+
+(boolean_literal) @boolean
+
+[
+ (predefined_type)
+] @type.builtin
+
+(implicit_type) @keyword
+
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$"))
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^///[^/]"))
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^///$"))
+
+(using_directive
+  (identifier) @type)
+
+(using_directive
+  (name_equals (identifier) @type.definition))
+
+(property_declaration
+  name: (identifier) @property)
+
+(property_declaration
+  type: (identifier) @type)
+
+(nullable_type
+  (identifier) @type)
+
+(catch_declaration
+  type: (identifier) @type)
+
+(interface_declaration
+  name: (identifier) @type)
+(class_declaration
+  name: (identifier) @type)
+(record_declaration
+  name: (identifier) @type)
+(enum_declaration
+  name: (identifier) @type)
+(constructor_declaration
+  name: (identifier) @constructor)
+(constructor_initializer [
+  "base" @constructor
+])
+
+(variable_declaration
+  (identifier) @type)
+(object_creation_expression
+  (identifier) @type)
+
+; Generic Types.
+(type_of_expression
+  (generic_name
+    (identifier) @type))
+
+(type_argument_list
+  (generic_name
+    (identifier) @type))
+
+(base_list
+  (generic_name
+    (identifier) @type))
+
+(type_constraint
+  (generic_name
+    (identifier) @type))
+
+(object_creation_expression
+  (generic_name
+   (identifier) @type))
+
+(property_declaration
+  (generic_name
+    (identifier) @type))
+
+(_
+  type: (generic_name
+   (identifier) @type))
+; Generic Method invocation with generic type
+(invocation_expression
+  function: (generic_name
+              . (identifier) @method.call))
+
+(invocation_expression
+  (member_access_expression
+    (generic_name
+      (identifier) @method)))
+
+(base_list
+  (identifier) @type)
+
+(type_argument_list
+ (identifier) @type)
+
+(type_parameter_list
+  (type_parameter) @type)
+
+(type_parameter_constraints_clause
+  target: (identifier) @type)
+
+(attribute
+ name: (identifier) @attribute)
+
+(for_each_statement
+  type: (identifier) @type)
+
+(tuple_element
+  type: (identifier) @type)
+
+(tuple_expression
+  (argument
+    (declaration_expression
+      type: (identifier) @type)))
+
+(as_expression
+  right: (identifier) @type)
+
+(type_of_expression
+  (identifier) @type)
+
+(name_colon
+  (identifier) @parameter)
+
+(warning_directive) @text.warning
+(error_directive) @exception
+
+(define_directive
+  (identifier) @constant) @constant.macro
+(undef_directive
+  (identifier) @constant) @constant.macro
+
+(line_directive) @constant.macro
+(line_directive
+  (preproc_integer_literal) @constant
+  (preproc_string_literal)? @string)
+
+(pragma_directive
+  (identifier) @constant) @constant.macro
+(pragma_directive
+  (preproc_string_literal) @string) @constant.macro
+
+[
+ (nullable_directive)
+ (region_directive)
+ (endregion_directive)
+] @constant.macro
+
+[
+ "if"
+ "else"
+ "switch"
+ "break"
+ "case"
+ (if_directive)
+ (elif_directive)
+ (else_directive)
+ (endif_directive)
+] @conditional
+
+(if_directive
+  (identifier) @constant)
+(elif_directive
+  (identifier) @constant)
+
+[
+ "while"
+ "for"
+ "do"
+ "continue"
+ "goto"
+ "foreach"
+] @repeat
+
+[
+ "try"
+ "catch"
+ "throw"
+ "finally"
+] @exception
+
+[
+ "+"
+ "?"
+ ":"
+ "++"
+ "-"
+ "--"
+ "&"
+ "&&"
+ "|"
+ "||"
+ "!"
+ "!="
+ "=="
+ "*"
+ "/"
+ "%"
+ "<"
+ "<="
+ ">"
+ ">="
+ "="
+ "-="
+ "+="
+ "*="
+ "/="
+ "%="
+ "^"
+ "^="
+ "&="
+ "|="
+ "~"
+ ">>"
+ ">>>"
+ "<<"
+ "<<="
+ ">>="
+ ">>>="
+ "=>"
+] @operator
+
+[
+ ";"
+ "."
+ ","
+ ":"
+] @punctuation.delimiter
+
+(conditional_expression ["?" ":"] @conditional.ternary)
+
+[
+ "["
+ "]"
+ "{"
+ "}"
+ "("
+ ")"
+] @punctuation.bracket
+
+(type_argument_list ["<" ">"] @punctuation.bracket)
+
+[
+ (this_expression)
+ (base_expression)
+] @variable.builtin
+
+[
+ "using"
+ "as"
+] @include
+
+(alias_qualified_name
+  (identifier "global") @include)
+
+[
+ "with"
+ "new"
+ "typeof"
+ "sizeof"
+ "is"
+ "and"
+ "or"
+ "not"
+ "stackalloc"
+ "in"
+ "out"
+ "ref"
+] @keyword.operator
+
+[
+ "lock"
+ "params"
+ "operator"
+ "default"
+ "implicit"
+ "explicit"
+ "override"
+ "class"
+ "delegate"
+ "enum"
+ "interface"
+ "namespace"
+ "struct"
+ "get"
+ "set"
+ "init"
+ "where"
+ "record"
+ "event"
+ "add"
+ "remove"
+ "checked"
+ "unchecked"
+ "fixed"
+] @keyword
+
+[
+  "async"
+  "await"
+] @keyword.coroutine
+
+[
+ "const"
+ "extern"
+ "readonly"
+ "static"
+ "volatile"
+ "required"
+] @storageclass
+
+[
+ "abstract"
+ "private"
+ "protected"
+ "internal"
+ "public"
+ "partial"
+ "sealed"
+ "virtual"
+] @type.qualifier
+
+(parameter_modifier) @operator
+
+(query_expression
+  (_ [
+    "from"
+    "orderby"
+    "select"
+    "group"
+    "by"
+    "ascending"
+    "descending"
+    "equals"
+    "let"
+  ] @keyword))
+
+[
+  "return"
+  "yield"
+] @keyword.return

bundle/nvim-treesitter-0.9.1/queries/c_sharp/injections.scm

@@ -0,0 +1 @@
+(comment) @comment

bundle/nvim-treesitter-0.9.1/queries/c_sharp/locals.scm

@@ -0,0 +1,41 @@
+;; Definitions
+(variable_declarator
+  . (identifier) @definition.var)
+
+(variable_declarator
+  (tuple_pattern
+    (identifier) @definition.var))
+
+(declaration_expression
+  name: (identifier) @definition.var)
+
+(for_each_statement
+  left: (identifier) @definition.var)
+
+(for_each_statement
+  left: (tuple_pattern
+    (identifier) @definition.var))
+
+(parameter
+  (identifier) @definition.parameter)
+
+(method_declaration
+  name: (identifier) @definition.method)
+
+(local_function_statement
+  name: (identifier) @definition.method)
+
+(property_declaration
+  name: (identifier) @definition)
+
+(type_parameter
+  (identifier) @definition.type)
+
+(class_declaration
+  name: (identifier) @definition)
+
+;; References
+(identifier) @reference
+
+;; Scope
+(block) @scope

bundle/nvim-treesitter-0.9.1/queries/cairo/folds.scm

@@ -0,0 +1,31 @@
+[
+  (mod_item)
+  (struct_item)
+  (trait_item)
+  (enum_item)
+  (impl_item)
+  (type_item)
+
+  (use_declaration)
+  (let_declaration)
+  (namespace_definition)
+
+  (arguments)
+  (implicit_arguments)
+  (tuple_type)
+
+  (import_statement)
+  (attribute_statement)
+  (with_statement)
+  (if_statement)
+
+  (function_definition)
+  (struct_definition)
+  (loop_expression)
+  (if_expression)
+  (match_expression)
+  (call_expression)
+  (tuple_expression)
+
+  (attribute_item)
+] @fold

bundle/nvim-treesitter-0.9.1/queries/cairo/highlights.scm

@@ -0,0 +1,338 @@
+; Preproc
+
+[
+  "%builtins"
+  "%lang"
+] @preproc
+
+; Includes
+
+(import_statement [ "from" "import" ] @include module_name: (dotted_name (identifier) @namespace . ))
+
+[
+  "as"
+  "use"
+  "mod"
+] @include
+
+; Variables
+
+(identifier) @variable
+
+; Namespaces
+
+(namespace_definition (identifier) @namespace)
+
+(mod_item
+  name: (identifier) @namespace)
+
+(use_list (self) @namespace)
+
+(scoped_use_list (self) @namespace)
+
+(scoped_identifier
+  path: (identifier) @namespace)
+
+(scoped_identifier
+ (scoped_identifier
+  name: (identifier) @namespace))
+
+(scoped_type_identifier
+  path: (identifier) @namespace)
+
+((scoped_identifier
+  path: (identifier) @type)
+ (#lua-match? @type "^[A-Z]"))
+
+((scoped_identifier
+    name: (identifier) @type)
+ (#lua-match? @type "^[A-Z]"))
+
+((scoped_identifier
+    name: (identifier) @constant)
+ (#lua-match? @constant "^[A-Z][A-Z%d_]*$"))
+
+((scoped_identifier
+  path: (identifier) @type
+  name: (identifier) @constant)
+  (#lua-match? @type "^[A-Z]")
+  (#lua-match? @constant "^[A-Z]"))
+
+((scoped_type_identifier
+  path: (identifier) @type
+  name: (type_identifier) @constant)
+  (#lua-match? @type "^[A-Z]")
+  (#lua-match? @constant "^[A-Z]"))
+
+(scoped_use_list
+  path: (identifier) @namespace)
+
+(scoped_use_list
+  path: (scoped_identifier
+          (identifier) @namespace))
+
+(use_list (scoped_identifier (identifier) @namespace . (_)))
+
+(use_list (identifier) @type (#lua-match? @type "^[A-Z]"))
+
+(use_as_clause alias: (identifier) @type (#lua-match? @type "^[A-Z]"))
+
+; Keywords
+
+[
+  ; 0.x
+  "using"
+  "namespace"
+  "struct"
+  "let"
+  "const"
+  "local"
+  "rel"
+  "abs"
+  "dw"
+  "alloc_locals"
+  (inst_ret)
+  "with_attr"
+  "with"
+  "call"
+  "nondet"
+
+  ; 1.0
+  "type"
+  "impl"
+  "implicits"
+  "of"
+  "ref"
+  "mut"
+  "trait"
+  "enum"
+] @keyword
+
+[
+  "func"
+  "fn"
+  "end"
+] @keyword.function
+
+"return" @keyword.return
+
+[
+  "cast"
+  "new"
+  "and"
+] @keyword.operator
+
+[
+  "tempvar"
+  "extern"
+] @storageclass
+
+[
+  "if"
+  "else"
+  "match"
+] @conditional
+
+[
+  "loop"
+] @repeat
+
+[
+  "assert"
+  "static_assert"
+  "nopanic"
+] @exception
+
+; Fields
+
+(implicit_arguments (typed_identifier (identifier) @field))
+
+(member_expression "." (identifier) @field)
+
+(call_expression (assignment_expression left: (identifier) @field))
+
+(tuple_expression (assignment_expression left: (identifier) @field))
+
+(field_identifier) @field
+
+(shorthand_field_initializer (identifier) @field)
+
+; Parameters
+
+(arguments (typed_identifier (identifier) @parameter))
+
+(call_expression (tuple_expression (assignment_expression left: (identifier) @parameter)))
+
+(return_type (tuple_type (named_type . (identifier) @parameter)))
+
+(parameter (identifier) @parameter)
+
+; Builtins
+
+(builtin_directive (identifier) @variable.builtin)
+(lang_directive (identifier) @variable.builtin)
+
+[
+  "ap"
+  "fp"
+  (self)
+] @variable.builtin
+
+; Functions
+
+(function_definition "func" (identifier) @function)
+(function_definition "fn" (identifier) @function)
+(function_signature "fn" (identifier) @function)
+(extern_function_statement (identifier) @function)
+
+(call_expression
+  function: (identifier) @function.call)
+
+(call_expression
+  function: (scoped_identifier
+              (identifier) @function.call .))
+
+(call_expression
+  function: (field_expression
+    field: (field_identifier) @function.call))
+
+[
+  "jmp"
+] @function.builtin
+
+; Types
+
+(struct_definition . (identifier) @type (typed_identifier (identifier) @field)?)
+
+(named_type (identifier) @type .)
+
+[
+  (builtin_type)
+  (primitive_type)
+] @type.builtin
+
+((identifier) @type
+  (#lua-match? @type "^[A-Z][a-zA-Z0-9_]*$"))
+
+(type_identifier) @type
+
+; Constants
+
+((identifier) @constant
+  (#lua-match? @constant "^[A-Z_][A-Z0-9_]*$"))
+
+(enum_variant
+  name: (identifier) @constant)
+
+(call_expression
+  function: (scoped_identifier
+    "::"
+    name: (identifier) @constant)
+  (#lua-match? @constant "^[A-Z]"))
+
+((match_arm
+   pattern: (match_pattern (identifier) @constant))
+ (#lua-match? @constant "^[A-Z]"))
+
+((match_arm
+   pattern: (match_pattern
+     (scoped_identifier
+       name: (identifier) @constant)))
+ (#lua-match? @constant "^[A-Z]"))
+
+((identifier) @constant.builtin
+ (#any-of? @constant.builtin "Some" "None" "Ok" "Err"))
+
+; Constructors
+
+(unary_expression "new" (call_expression . (identifier) @constructor))
+
+((call_expression . (identifier) @constructor)
+  (#lua-match? @constructor "^%u"))
+
+; Attributes
+
+(decorator "@" @attribute (identifier) @attribute)
+
+(attribute_item (identifier) @function.macro)
+
+(attribute_item (scoped_identifier (identifier) @function.macro .))
+
+; Labels
+
+(label . (identifier) @label)
+
+(inst_jmp_to_label "jmp" . (identifier) @label)
+
+(inst_jnz_to_label "jmp" . (identifier) @label)
+
+; Operators
+
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "**"
+  "=="
+  "!="
+  "&"
+  "="
+  "++"
+  "+="
+  "@"
+  "!"
+  "~"
+  ".."
+  "&&"
+  "||"
+  "^"
+  "<"
+  "<="
+  ">"
+  ">="
+  "<<"
+  ">>"
+  "%"
+  "-="
+  "*="
+  "/="
+  "%="
+  "&="
+  "|="
+  "^="
+  "<<="
+  ">>="
+  "?"
+] @operator
+
+; Literals
+
+(number) @number
+
+(boolean) @boolean
+
+[
+  (string)
+  (short_string)
+] @string
+
+; Punctuation
+
+(attribute_item "#" @punctuation.special)
+
+[ "." "," ":" ";" "->" "=>" "::" ] @punctuation.delimiter
+
+[ "{" "}" "(" ")" "[" "]" "%{" "%}" ] @punctuation.bracket
+
+(type_parameters [ "<" ">" ] @punctuation.bracket)
+
+(type_arguments [ "<" ">" ] @punctuation.bracket)
+
+; Comment
+
+(comment) @comment @spell
+
+; Errors
+
+(ERROR) @error

bundle/nvim-treesitter-0.9.1/queries/cairo/indents.scm

@@ -0,0 +1,45 @@
+[
+  (mod_item)
+  (struct_item)
+  (enum_item)
+  (impl_item)
+  (struct_expression)
+  (match_expression)
+  (tuple_expression)
+  (match_arm)
+  (match_block)
+  (call_expression)
+  (assignment_expression)
+  (arguments)
+  (block)
+  (use_list)
+  (field_declaration_list)
+  (enum_variant_list)
+  (tuple_pattern)
+] @indent.begin
+
+(import_statement "(") @indent.begin
+
+(block "}" @indent.end)
+(enum_item
+  body: (enum_variant_list "}" @indent.end))
+(match_expression
+  body: (match_block "}" @indent.end))
+(mod_item
+  body: (declaration_list "}" @indent.end))
+(struct_item
+  body: (field_declaration_list "}" @indent.end))
+(trait_item
+  body: (declaration_list "}" @indent.end))
+
+[
+  ")"
+  "]"
+  "}"
+] @indent.branch
+
+[
+  (comment)
+  (string)
+  (short_string)
+] @indent.ignore