diff --git a/pack/ant/start/nvim-treesitter/.editorconfig b/pack/ant/start/nvim-treesitter/.editorconfig
new file mode 100644
index 0000000..00ea231
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.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
diff --git a/pack/ant/start/nvim-treesitter/.github/FUNDING.yml b/pack/ant/start/nvim-treesitter/.github/FUNDING.yml
new file mode 100644
index 0000000..b2844b2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.github/FUNDING.yml
@@ -0,0 +1,2 @@
+open_collective: "nvim-treesitter"
+github: "nvim-treesitter"
diff --git a/pack/ant/start/nvim-treesitter/.github/ISSUE_TEMPLATE/bug_report.yml b/pack/ant/start/nvim-treesitter/.github/ISSUE_TEMPLATE/bug_report.yml
new file mode 100644
index 0000000..f68dd24
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.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.
diff --git a/pack/ant/start/nvim-treesitter/.github/ISSUE_TEMPLATE/feature_request.md b/pack/ant/start/nvim-treesitter/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 0000000..d883b8f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.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.
diff --git a/pack/ant/start/nvim-treesitter/.github/ISSUE_TEMPLATE/highlighting_issue.yml b/pack/ant/start/nvim-treesitter/.github/ISSUE_TEMPLATE/highlighting_issue.yml
new file mode 100644
index 0000000..a429b5e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.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 `:InspectTree` 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 `:Inspect` 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 `:InspectTree` (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
+        `:Inspect`.
+    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.
diff --git a/pack/ant/start/nvim-treesitter/.github/workflows/lint.yml b/pack/ant/start/nvim-treesitter/.github/workflows/lint.yml
new file mode 100644
index 0000000..cd0e519
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.github/workflows/lint.yml
@@ -0,0 +1,51 @@
+name: Linting and style checking
+
+on:
+  pull_request:
+    branches:
+      - "master"
+
+jobs:
+  luacheck:
+    name: Luacheck
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - 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@v4
+      - name: Lint with stylua
+        uses: JohnnyMorganz/stylua-action@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          version: latest
+          args: --check .
+
+  format-queries:
+    name: Lint queries
+    runs-on: ubuntu-latest
+    env:
+      NVIM_TAG: stable
+    steps:
+      - uses: actions/checkout@v4
+      - name: Prepare
+        run: |
+          bash ./scripts/ci-install.sh
+
+      - name: Lint
+        run: |
+          nvim --headless -c "TSInstallSync query" -c "q"
+          nvim -l scripts/format-queries.lua
+          git diff --exit-code
diff --git a/pack/ant/start/nvim-treesitter/.github/workflows/release.yml b/pack/ant/start/nvim-treesitter/.github/workflows/release.yml
new file mode 100644
index 0000000..11f3ffc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.github/workflows/release.yml
@@ -0,0 +1,24 @@
+name: "release"
+on:
+  push:
+    tags: # Will upload to luarocks.org
+      - "*"
+  pull_request: # Will test a local install without uploading to luarocks.org
+   paths:
+    - 'contrib/*.rockspec'
+    - .github/workflows/release.yml
+  
+jobs:
+  luarocks-upload:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: nvim-neorocks/luarocks-tag-release@v5
+        env:
+          LUAROCKS_API_KEY: ${{ secrets.LUAROCKS_API_KEY }}
+        with:
+          name: nvim-treesitter
+          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.
+          template: contrib/nvim-treesitter-luarocks.template
diff --git a/pack/ant/start/nvim-treesitter/.github/workflows/test-queries.yml b/pack/ant/start/nvim-treesitter/.github/workflows/test-queries.yml
new file mode 100644
index 0000000..bc4a18d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.github/workflows/test-queries.yml
@@ -0,0 +1,88 @@
+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-latest, macos-14]
+        cc: [gcc, clang]
+        nvim_tag: [stable]
+        exclude:
+          - os: ubuntu-latest
+            cc: clang
+            nvim_tag: stable
+
+          - os: macos-14
+            cc: gcc
+            nvim_tag: stable
+
+          - os: windows-latest
+            cc: clang
+            nvim_tag: stable
+
+        include:
+          - os: windows-latest
+            cc: cl
+            nvim_tag: nightly
+
+          - os: ubuntu-latest
+            cc: gcc
+            nvim_tag: nightly
+
+    name: Parser compilation
+    runs-on: ${{ matrix.os }}
+    env:
+      CC: ${{ matrix.cc }}
+      NVIM: ${{ matrix.os == 'windows-latest' && 'nvim-win64\\bin\\nvim.exe' || 'nvim' }}
+      ALLOWED_INSTALLATION_FAILURES: ${{ matrix.os == 'windows-latest' && 'rnoweb' }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: tree-sitter/setup-action/cli@v1
+      - uses: ilammy/msvc-dev-cmd@v1
+
+      - name: Install and prepare Neovim
+        env:
+          NVIM_TAG: ${{ matrix.nvim_tag }}
+        run: |
+          bash ./scripts/ci-install.sh
+
+      - name: Setup Parsers Cache
+        id: parsers-cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ./parser/
+            ~/AppData/Local/nvim/pack/nvim-treesitter/start/nvim-treesitter/parser/
+          key: parsers-${{ join(matrix.*, '-') }}-${{ hashFiles(
+            './lockfile.json',
+            './lua/nvim-treesitter/install.lua',
+            './lua/nvim-treesitter/parsers.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: runner.os == 'Windows'
+        run: cp -r ~/AppData/Local/nvim/pack/nvim-treesitter/start/nvim-treesitter/parser/* parser
+
+      - name: Check query files
+        run: $NVIM -l scripts/check-queries.lua
diff --git a/pack/ant/start/nvim-treesitter/.github/workflows/tests.yml b/pack/ant/start/nvim-treesitter/.github/workflows/tests.yml
new file mode 100644
index 0000000..5c775ed
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.github/workflows/tests.yml
@@ -0,0 +1,64 @@
+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@v4
+      - uses: tree-sitter/setup-action/cli@v1
+
+      - 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
+        run: |
+          bash ./scripts/ci-install.sh
+
+      - name: Setup Parsers Cache
+        id: parsers-cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ./parser/
+            ~/AppData/Local/nvim/pack/nvim-treesitter/start/nvim-treesitter/parser/
+          key: parsers-${{ join(matrix.*, '-') }}-${{ hashFiles(
+            './lockfile.json',
+            './lua/nvim-treesitter/install.lua',
+            './lua/nvim-treesitter/parsers.lua',
+            './lua/nvim-treesitter/shell_selectors.lua') }}
+
+      - name: Compile parsers Unix like
+        run: |
+          nvim --headless -c "TSInstallSync all" -c "q"
+
+      - name: Tests
+        run: PATH=/usr/local/bin:$PATH ./scripts/run_tests.sh
diff --git a/pack/ant/start/nvim-treesitter/.github/workflows/update-lockfile.yml b/pack/ant/start/nvim-treesitter/.github/workflows/update-lockfile.yml
new file mode 100644
index 0000000..70d6287
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.github/workflows/update-lockfile.yml
@@ -0,0 +1,58 @@
+name: Update lockfile
+
+on:
+  schedule:
+    - cron: "30 6 * * *"
+  workflow_dispatch:
+
+jobs:
+  update-lockfile:
+    name: Update lockfile
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: master
+
+      - uses: actions/create-github-app-token@v1
+        id: app-token
+        with:
+          app-id: ${{ vars.TOKEN_ID }}
+          private-key: ${{ secrets.TOKEN_PRIVATE_KEY }}
+
+      - name: Prepare
+        env:
+          NVIM_TAG: stable
+        run: |
+          wget https://github.com/josephburnett/jd/releases/download/v1.7.1/jd-amd64-linux
+          mv jd-amd64-linux /tmp/jd
+          chmod +x /tmp/jd
+          bash scripts/ci-install.sh
+
+      - name: Update parsers
+        env:
+          SKIP_LOCKFILE_UPDATE_FOR_LANGS: "djot"
+        run: |
+          cp lockfile.json /tmp/old_lockfile.json
+          nvim -l scripts/write-lockfile.lua
+          # Pretty print
+          cp lockfile.json /tmp/lockfile.json
+          cat /tmp/lockfile.json | jq --sort-keys > 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
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v7
+        with:
+          token: ${{ steps.app-token.outputs.token }}
+          sign-commits: true
+          commit-message: "bot(lockfile): update ${{ env.UPDATED_PARSERS }}"
+          title: "Update lockfile.json: ${{ env.UPDATED_PARSERS }}"
+          body: "[beep boop](https://github.com/peter-evans/create-pull-request)"
+          branch: update-lockfile-pr
+          base: ${{ github.head_ref }}
+
+      - name: Enable Pull Request Automerge
+        env:
+          GH_TOKEN: ${{ steps.app-token.outputs.token }}
+        run: gh pr merge --rebase --auto update-lockfile-pr
diff --git a/pack/ant/start/nvim-treesitter/.github/workflows/update-readme.yml b/pack/ant/start/nvim-treesitter/.github/workflows/update-readme.yml
new file mode 100644
index 0000000..a3fa018
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.github/workflows/update-readme.yml
@@ -0,0 +1,46 @@
+name: Update README
+
+on:
+  push:
+    branches:
+      - master
+  workflow_dispatch:
+
+jobs:
+  update-readme:
+    name: Update README
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/create-github-app-token@v1
+        id: app-token
+        with:
+          app-id: ${{ vars.TOKEN_ID }}
+          private-key: ${{ secrets.TOKEN_PRIVATE_KEY }}
+
+      - name: Prepare
+        env:
+          NVIM_TAG: stable
+        run: |
+          bash ./scripts/ci-install.sh
+
+      - name: Check README
+        run: |
+          nvim -l scripts/update-readme.lua || echo 'Needs update'
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v7
+        with:
+          token: ${{ steps.app-token.outputs.token }}
+          sign-commits: true
+          commit-message: "bot(readme): update"
+          title: Update README
+          body: "[beep boop](https://github.com/peter-evans/create-pull-request)"
+          branch: update-readme-pr
+          base: ${{ github.head_ref }}
+
+      - name: Enable Pull Request Automerge
+        env:
+          GH_TOKEN: ${{ steps.app-token.outputs.token }}
+        run: gh pr merge --rebase --auto update-readme-pr
diff --git a/pack/ant/start/nvim-treesitter/.gitignore b/pack/ant/start/nvim-treesitter/.gitignore
new file mode 100644
index 0000000..0ac164c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.gitignore
@@ -0,0 +1,7 @@
+doc/tags
+.luacheckcache
+/tags
+nvim.appimage
+nvim-linux64*
+nvim-macos*
+nvim-win64*
diff --git a/pack/ant/start/nvim-treesitter/.luacheckrc b/pack/ant/start/nvim-treesitter/.luacheckrc
new file mode 100644
index 0000000..b0ee19d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.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",
+}
diff --git a/pack/ant/start/nvim-treesitter/.luarc.json b/pack/ant/start/nvim-treesitter/.luarc.json
new file mode 100644
index 0000000..8dc0605
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.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": [ "_*" ]
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/.stylua.toml b/pack/ant/start/nvim-treesitter/.stylua.toml
new file mode 100644
index 0000000..ecb6dca
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.stylua.toml
@@ -0,0 +1,6 @@
+column_width = 120
+line_endings = "Unix"
+indent_type = "Spaces"
+indent_width = 2
+quote_style = "AutoPreferDouble"
+call_parentheses = "None"
diff --git a/pack/ant/start/nvim-treesitter/.styluaignore b/pack/ant/start/nvim-treesitter/.styluaignore
new file mode 100644
index 0000000..2b6c4c6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/.styluaignore
@@ -0,0 +1 @@
+tests/indent/lua/
diff --git a/pack/ant/start/nvim-treesitter/CONTRIBUTING.md b/pack/ant/start/nvim-treesitter/CONTRIBUTING.md
new file mode 100644
index 0000000..23321f0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/CONTRIBUTING.md
@@ -0,0 +1,401 @@
+# 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.
+
+#### Inheriting languages
+
+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).
+
+#### Formatting
+
+All queries are expected to follow a standard format, with every node on a single line and indented by two spaces for each level of nesting. You can automatically format the bundled queries by running the provided formatter `./scripts/format-queries.lua` on a single file (ending in `.scm`) or directory to format.
+
+Should you need to preserve a specific format for a node, you can exempt it (and all contained nodes) by placing before it
+```query
+; format-ignore
+```
+
+### 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 color scheme needs to define (or link) these captures as highlight groups.
+
+#### Identifiers
+
+```query
+@variable                    ; various variable names
+@variable.builtin            ; built-in variable names (e.g. `this`)
+@variable.parameter          ; parameters of a function
+@variable.parameter.builtin  ; special parameters (e.g. `_`, `it`)
+@variable.member             ; object and struct fields
+
+@constant          ; constant identifiers
+@constant.builtin  ; built-in constant values
+@constant.macro    ; constants defined by the preprocessor
+
+@module            ; modules or namespaces
+@module.builtin    ; built-in modules or namespaces
+@label             ; GOTO and other labels (e.g. `label:` in C), including heredoc labels
+```
+
+#### Literals
+
+```query
+@string                 ; string literals
+@string.documentation   ; string documenting code (e.g. Python docstrings)
+@string.regexp          ; regular expressions
+@string.escape          ; escape sequences
+@string.special         ; other special strings (e.g. dates)
+@string.special.symbol  ; symbols or atoms
+@string.special.url     ; URIs (e.g. hyperlinks)
+@string.special.path    ; filenames
+
+@character              ; character literals
+@character.special      ; special characters (e.g. wildcards)
+
+@boolean                ; boolean literals
+@number                 ; numeric literals
+@number.float           ; floating-point number literals
+```
+
+#### Types
+
+```query
+@type             ; type or class definitions and annotations
+@type.builtin     ; built-in types
+@type.definition  ; identifiers in type definitions (e.g. `typedef <type> <identifier>` in C)
+
+@attribute          ; attribute annotations (e.g. Python decorators, Rust lifetimes)
+@attribute.builtin  ; builtin annotations (e.g. `@property` in Python)
+@property           ; the key in key/value pairs
+```
+
+#### Functions
+
+```query
+@function             ; function definitions
+@function.builtin     ; built-in functions
+@function.call        ; function calls
+@function.macro       ; preprocessor macros
+
+@function.method      ; method definitions
+@function.method.call ; method calls
+
+@constructor          ; constructor calls and definitions
+@operator             ; symbolic operators (e.g. `+` / `*`)
+```
+
+#### Keywords
+
+```query
+@keyword                   ; keywords not fitting into specific categories
+@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.import            ; keywords for including or exporting modules (e.g. `import` / `from` in Python)
+@keyword.type              ; keywords describing namespaces and composite types (e.g. `struct`, `enum`)
+@keyword.modifier          ; keywords modifying other constructs (e.g. `const`, `static`, `public`)
+@keyword.repeat            ; keywords related to loops (e.g. `for` / `while`)
+@keyword.return            ; keywords like `return` and `yield`
+@keyword.debug             ; keywords related to debugging
+@keyword.exception         ; keywords related to exceptions (e.g. `throw` / `catch`)
+
+@keyword.conditional         ; keywords related to conditionals (e.g. `if` / `else`)
+@keyword.conditional.ternary ; ternary operator (e.g. `?` / `:`)
+
+@keyword.directive         ; various preprocessor directives & shebangs
+@keyword.directive.define  ; preprocessor definition directives
+```
+
+#### Punctuation
+
+```query
+@punctuation.delimiter ; delimiters (e.g. `;` / `.` / `,`)
+@punctuation.bracket   ; brackets (e.g. `()` / `{}` / `[]`)
+@punctuation.special   ; special symbols (e.g. `{}` in string interpolation)
+```
+
+#### Comments
+
+```query
+@comment               ; line and block comments
+@comment.documentation ; comments documenting code
+
+@comment.error         ; error-type comments (e.g. `ERROR`, `FIXME`, `DEPRECATED`)
+@comment.warning       ; warning-type comments (e.g. `WARNING`, `FIX`, `HACK`)
+@comment.todo          ; todo-type comments (e.g. `TODO`, `WIP`)
+@comment.note          ; note-type comments (e.g. `NOTE`, `INFO`, `XXX`)
+```
+
+#### Markup
+
+Mainly for markup languages.
+
+```query
+@markup.strong         ; bold text
+@markup.italic         ; italic text
+@markup.strikethrough  ; struck-through text
+@markup.underline      ; underlined text (only for literal underline markup!)
+
+@markup.heading        ; headings, titles (including markers)
+@markup.heading.1      ; top-level heading
+@markup.heading.2      ; section heading
+@markup.heading.3      ; subsection heading
+@markup.heading.4      ; and so on
+@markup.heading.5      ; and so forth
+@markup.heading.6      ; six levels ought to be enough for anybody
+
+@markup.quote          ; block quotes
+@markup.math           ; math environments (e.g. `$ ... $` in LaTeX)
+
+@markup.link           ; text references, footnotes, citations, etc.
+@markup.link.label     ; link, reference descriptions
+@markup.link.url       ; URL-style links
+
+@markup.raw            ; literal or verbatim text (e.g. inline code)
+@markup.raw.block      ; literal or verbatim text as a stand-alone block
+                       ; (use priority 90 for blocks with injections)
+
+@markup.list           ; list markers
+@markup.list.checked   ; checked todo-style list markers
+@markup.list.unchecked ; unchecked todo-style list markers
+```
+
+```query
+@diff.plus       ; added text (for diff files)
+@diff.minus      ; deleted text (for diff files)
+@diff.delta      ; changed text (for diff files)
+```
+
+```query
+@tag           ; XML-style tag names (and similar)
+@tag.builtin   ; builtin tag names (e.g. HTML5 tags)
+@tag.attribute ; XML-style tag attributes
+@tag.delimiter ; XML-style tag delimiters
+```
+
+#### Non-highlighting captures
+
+```query
+@none    ; completely disable the highlight
+@conceal ; captures that are only meant to be concealed
+```
+
+```query
+@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).
+
+#### Predicates
+
+Captures can be restricted according to node contents using [predicates](https://neovim.io/doc/user/treesitter.html#treesitter-predicates). For performance reasons, prefer earlier predicates in this list:
+
+1. `#eq?` (literal match)
+2. `#any-of?` (one of several literal matches)
+3. `#lua-match?` (match against a [Lua pattern](https://neovim.io/doc/user/luaref.html#lua-pattern))
+4. `#match?`/`#vim-match?` (match against a [Vim regular expression](https://neovim.io/doc/user/pattern.html#regexp)
+
+#### Conceal
+
+Captures can be concealed by setting the [`conceal` metadata](https://neovim.io/doc/user/treesitter.html#treesitter-highlight-conceal), e.g..,
+```query
+    (fenced_code_block_delimiter @markup.raw.block (#set! conceal ""))
+```
+The capture should be meaningful to allow proper highlighting when `set conceallevel=0`. If the unconcealed capture should not be highlighted (e.g., because an earlier pattern handles this), you can use `@conceal`.
+
+A conceal can be restricted to part of the capture via the [`#offset!` directive](https://neovim.io/doc/user/treesitter.html#treesitter-directive-offset%21).
+
+#### 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
+
+Locals are used to keep track of definitions and references in local or global
+scopes, see [upstream
+documentation](https://tree-sitter.github.io/tree-sitter/syntax-highlighting#local-variables).
+Note that nvim-treesitter uses more specific subcaptures for definitions and
+**does not use locals for highlighting**.
+
+```query
+@local.definition            ; various definitions
+@local.definition.constant   ; constants
+@local.definition.function   ; functions
+@local.definition.method     ; methods
+@local.definition.var        ; variables
+@local.definition.parameter  ; parameters
+@local.definition.macro      ; preprocessor macros
+@local.definition.type       ; types or classes
+@local.definition.field      ; fields or properties
+@local.definition.enum       ; enumerations
+@local.definition.namespace  ; modules or namespaces
+@local.definition.import     ; imported names
+@local.definition.associated ; the associated type of a variable
+
+@local.scope                 ; scope block
+@local.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) @local.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 :
+
+```query
+@fold ; fold this node
+```
+
+If the `folds.scm` query is not present, this will fall back to the `@local.scope` captures in the `locals`
+query.
+
+### Injections
+
+Some captures are related to language injection (like markdown code blocks). They are used in `injections.scm`.
+
+If you want to dynamically detect the language (e.g. for Markdown blocks) use the `@injection.language` to capture
+the node describing the language and `@injection.content` to describe the injection region.
+
+```query
+@injection.language ; dynamic detection of the injection language (i.e. the text of the captured node describes the language)
+@injection.content  ; region for the dynamically detected language
+```
+
+For example, to inject javascript into HTML's `<script>` tag
+
+```html
+<script>someJsCode();</script>
+```
+
+```query
+(script_element
+  (raw_text) @injection.content
+  (#set! injection.language "javascript")) ; set the parser language for @injection.content region to javascript
+```
+
+For regions that don't have a corresponding `@injection.language`, you need to manually set the language 
+through `(#set injection.language "lang_name")`
+
+To combine all matches of a pattern as one single block of content, add `(#set! injection.combined)` to such pattern
+
+### Indents
+
+```query
+@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
diff --git a/pack/ant/start/nvim-treesitter/LICENSE b/pack/ant/start/nvim-treesitter/LICENSE
new file mode 100644
index 0000000..261eeb9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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.
diff --git a/pack/ant/start/nvim-treesitter/Makefile b/pack/ant/start/nvim-treesitter/Makefile
new file mode 100644
index 0000000..338c754
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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 lua/* $(INST_LUADIR)
diff --git a/pack/ant/start/nvim-treesitter/README.md b/pack/ant/start/nvim-treesitter/README.md
new file mode 100644
index 0000000..1205209
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/README.md
@@ -0,0 +1,833 @@
+<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/issues/4767).
+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
+
+- **Neovim 0.9.2** or later  ([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 listed parsers MUST always be installed)
+  ensure_installed = { "c", "lua", "vim", "vimdoc", "query", "markdown", "markdown_inline" },
+
+  -- 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 (or "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/tree-sitter/tree-sitter-agda) (maintained by @Decodetalkers)
+- [x] [angular](https://github.com/dlvandenberg/tree-sitter-angular) (experimental, maintained by @dlvandenberg)
+- [x] [apex](https://github.com/aheber/tree-sitter-sfapex) (maintained by @aheber, @xixiaofinland)
+- [x] [arduino](https://github.com/ObserverOfTime/tree-sitter-arduino) (maintained by @ObserverOfTime)
+- [x] [asm](https://github.com/RubixDev/tree-sitter-asm) (maintained by @RubixDev)
+- [x] [astro](https://github.com/virchau13/tree-sitter-astro) (maintained by @virchau13)
+- [x] [authzed](https://github.com/mleonidas/tree-sitter-authzed) (maintained by @mattpolzin)
+- [ ] [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/vito/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] [bitbake](https://github.com/amaanq/tree-sitter-bitbake) (maintained by @amaanq)
+- [x] [blueprint](https://gitlab.com/gabmus/tree-sitter-blueprint.git) (experimental, maintained by @gabmus)
+- [x] [bp](https://github.com/ambroisie/tree-sitter-bp) (maintained by @ambroisie)
+- [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 @amaanq)
+- [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 @NoahTheDuke)
+- [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] [csv](https://github.com/amaanq/tree-sitter-csv) (maintained by @amaanq)
+- [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/gdamore/tree-sitter-d) (maintained by @amaanq)
+- [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] [disassembly](https://github.com/ColinKennedy/tree-sitter-disassembly) (maintained by @ColinKennedy)
+- [x] [djot](https://github.com/treeman/tree-sitter-djot) (maintained by @NoahTheDuke)
+- [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] [doxygen](https://github.com/amaanq/tree-sitter-doxygen) (maintained by @amaanq)
+- [x] [dtd](https://github.com/tree-sitter-grammars/tree-sitter-xml) (maintained by @ObserverOfTime)
+- [x] [earthfile](https://github.com/glehmann/tree-sitter-earthfile) (maintained by @glehmann)
+- [x] [ebnf](https://github.com/RubixDev/ebnf) (experimental, maintained by @RubixDev)
+- [x] [editorconfig](https://github.com/ValdezFOmar/tree-sitter-editorconfig) (maintained by @ValdezFOmar)
+- [x] [eds](https://github.com/uyha/tree-sitter-eds) (maintained by @uyha)
+- [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] [facility](https://github.com/FacilityApi/tree-sitter-facility) (maintained by @bryankenote)
+- [x] [faust](https://github.com/khiner/tree-sitter-faust) (maintained by @khiner)
+- [x] [fennel](https://github.com/alexmozaidze/tree-sitter-fennel) (maintained by @alexmozaidze)
+- [x] [fidl](https://github.com/google/tree-sitter-fidl) (maintained by @chaopeng)
+- [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] [forth](https://github.com/AlexanderBrevig/tree-sitter-forth) (maintained by @amaanq)
+- [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] [fsharp](https://github.com/ionide/tree-sitter-fsharp) (maintained by @nsidorenco)
+- [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] [GAP system](https://github.com/gap-system/tree-sitter-gap) (maintained by @reiniscirpons)
+- [x] [GAP system test files](https://github.com/gap-system/tree-sitter-gaptst) (maintained by @reiniscirpons)
+- [x] [Godot (gdscript)](https://github.com/PrestonKnopp/tree-sitter-gdscript) (maintained by @PrestonKnopp)
+- [x] [gdshader](https://github.com/GodOfAvacyn/tree-sitter-gdshader) (maintained by @godofavacyn)
+- [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/ember-tooling/tree-sitter-glimmer) (maintained by @NullVoxPopuli)
+- [x] [glimmer_javascript](https://github.com/NullVoxPopuli/tree-sitter-glimmer-javascript) (maintained by @NullVoxPopuli)
+- [x] [glimmer_typescript](https://github.com/NullVoxPopuli/tree-sitter-glimmer-typescript) (maintained by @NullVoxPopuli)
+- [x] [glsl](https://github.com/theHamsta/tree-sitter-glsl) (maintained by @theHamsta)
+- [x] [GN (Generate Ninja)](https://github.com/amaanq/tree-sitter-gn) (maintained by @amaanq)
+- [x] [gnuplot](https://github.com/dpezto/tree-sitter-gnuplot) (maintained by @dpezto)
+- [x] [go](https://github.com/tree-sitter/tree-sitter-go) (maintained by @theHamsta, @WinWisely268)
+- [x] [goctl](https://github.com/chaozwn/tree-sitter-goctl) (maintained by @chaozwn)
+- [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] [gotmpl](https://github.com/ngalaiko/tree-sitter-go-template) (maintained by @qvalentin)
+- [x] [gowork](https://github.com/omertuc/tree-sitter-go-work) (maintained by @omertuc)
+- [x] [gpg](https://github.com/ObserverOfTime/tree-sitter-gpg-config) (maintained by @ObserverOfTime)
+- [x] [graphql](https://github.com/bkegley/tree-sitter-graphql) (maintained by @bkegley)
+- [x] [gren](https://github.com/MaeBrooks/tree-sitter-gren) (maintained by @MaeBrooks)
+- [x] [groovy](https://github.com/murtaza64/tree-sitter-groovy) (maintained by @murtaza64)
+- [x] [gstlaunch](https://github.com/theHamsta/tree-sitter-gstlaunch) (maintained by @theHamsta)
+- [ ] [hack](https://github.com/slackhq/tree-sitter-hack)
+- [x] [hare](https://github.com/amaanq/tree-sitter-hare) (maintained by @amaanq)
+- [x] [haskell](https://github.com/tree-sitter/tree-sitter-haskell) (maintained by @mrcjkb)
+- [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] [helm](https://github.com/ngalaiko/tree-sitter-go-template) (maintained by @qvalentin)
+- [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] [hlsplaylist](https://github.com/Freed-Wu/tree-sitter-hlsplaylist) (maintained by @Freed-Wu)
+- [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, @NTBBloodbath)
+- [x] [hurl](https://github.com/pfeiferj/tree-sitter-hurl) (maintained by @pfeiferj)
+- [x] [hyprlang](https://github.com/luckasRanarison/tree-sitter-hyprlang) (maintained by @luckasRanarison)
+- [x] [idl](https://github.com/cathaysia/tree-sitter-idl) (maintained by @cathaysia)
+- [x] [ini](https://github.com/justinmk/tree-sitter-ini) (experimental, maintained by @theHamsta)
+- [x] [inko](https://github.com/inko-lang/tree-sitter-inko) (maintained by @yorickpeterse)
+- [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] [just](https://github.com/IndianBoy42/tree-sitter-just) (maintained by @Hubro)
+- [x] [kconfig](https://github.com/amaanq/tree-sitter-kconfig) (maintained by @amaanq)
+- [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] [koto](https://github.com/koto-lang/tree-sitter-koto) (maintained by @irh)
+- [x] [kusto](https://github.com/Willem-J-an/tree-sitter-kusto) (maintained by @Willem-J-an)
+- [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] [leo](https://github.com/r001/tree-sitter-leo) (maintained by @r001)
+- [x] [linkerscript](https://github.com/amaanq/tree-sitter-linkerscript) (maintained by @amaanq)
+- [x] [liquid](https://github.com/hankthetank27/tree-sitter-liquid) (maintained by @hankthetank27)
+- [x] [liquidsoap](https://github.com/savonet/tree-sitter-liquidsoap) (maintained by @toots)
+- [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)
+- [x] [muttrc](https://github.com/neomutt/tree-sitter-muttrc) (maintained by @Freed-Wu)
+- [x] [nasm](https://github.com/naclsn/tree-sitter-nasm) (maintained by @ObserverOfTime)
+- [x] [nginx](https://github.com/opa-oz/tree-sitter-nginx) (maintained by @opa-oz)
+- [ ] [nickel](https://github.com/nickel-lang/tree-sitter-nickel)
+- [x] [nim](https://github.com/alaviss/tree-sitter-nim) (maintained by @aMOPel)
+- [x] [nim_format_string](https://github.com/aMOPel/tree-sitter-nim-format-string) (maintained by @aMOPel)
+- [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] [nqc](https://github.com/amaanq/tree-sitter-nqc) (maintained by @amaanq)
+- [x] [objc](https://github.com/amaanq/tree-sitter-objc) (maintained by @amaanq)
+- [x] [objdump](https://github.com/ColinKennedy/tree-sitter-objdump) (maintained by @ColinKennedy)
+- [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) (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/tree-sitter-perl/tree-sitter-perl) (maintained by @RabbiVeesh, @LeoNerd)
+- [x] [php](https://github.com/tree-sitter/tree-sitter-php) (maintained by @tk-shirasaka, @calebdw)
+- [x] [php_only](https://github.com/tree-sitter/tree-sitter-php) (maintained by @tk-shirasaka, @calebdw)
+- [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] [pod](https://github.com/tree-sitter-perl/tree-sitter-pod) (maintained by @RabbiVeesh, @LeoNerd)
+- [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] [powershell](https://github.com/airbus-cert/tree-sitter-powershell) (maintained by @L2jLiga)
+- [x] [printf](https://github.com/ObserverOfTime/tree-sitter-printf) (maintained by @ObserverOfTime)
+- [x] [prisma](https://github.com/victorhqc/tree-sitter-prisma) (maintained by @elianiva)
+- [x] [problog](https://github.com/foxyseta/tree-sitter-prolog) (maintained by @foxyseta)
+- [x] [prolog](https://github.com/foxyseta/tree-sitter-prolog) (maintained by @foxyseta)
+- [x] [promql](https://github.com/MichaHoffmann/tree-sitter-promql) (maintained by @MichaHoffmann)
+- [x] [properties](https://github.com/tree-sitter-grammars/tree-sitter-properties) (maintained by @ObserverOfTime)
+- [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] [psv](https://github.com/amaanq/tree-sitter-csv) (maintained by @amaanq)
+- [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] [purescript](https://github.com/postsolar/tree-sitter-purescript) (maintained by @postsolar)
+- [x] [PyPA manifest](https://github.com/ObserverOfTime/tree-sitter-pymanifest) (maintained by @ObserverOfTime)
+- [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 @ribru17)
+- [ ] [racket](https://github.com/6cdh/tree-sitter-racket)
+- [x] [ralph](https://github.com/alephium/tree-sitter-ralph) (maintained by @tdroxler)
+- [x] [rasi](https://github.com/Fymyte/tree-sitter-rasi) (maintained by @Fymyte)
+- [x] [rbs](https://github.com/joker1007/tree-sitter-rbs) (maintained by @joker1007)
+- [x] [re2c](https://github.com/amaanq/tree-sitter-re2c) (maintained by @amaanq)
+- [x] [readline](https://github.com/ribru17/tree-sitter-readline) (maintained by @ribru17)
+- [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] [rescript](https://github.com/rescript-lang/tree-sitter-rescript) (maintained by @ribru17)
+- [x] [rnoweb](https://github.com/bamonroe/tree-sitter-rnoweb) (maintained by @bamonroe)
+- [x] [robot](https://github.com/Hubro/tree-sitter-robot) (maintained by @Hubro)
+- [x] [robots](https://github.com/opa-oz/tree-sitter-robots-txt) (maintained by @opa-oz)
+- [x] [roc](https://github.com/faldor20/tree-sitter-roc) (maintained by @nat-418)
+- [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://github.com/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] [sflog](https://github.com/aheber/tree-sitter-sfapex) (maintained by @aheber, @xixiaofinland)
+- [x] [slang](https://github.com/theHamsta/tree-sitter-slang) (experimental, maintained by @theHamsta)
+- [x] [slint](https://github.com/slint-ui/tree-sitter-slint) (maintained by @hunger)
+- [x] [smali](https://github.com/tree-sitter-grammars/tree-sitter-smali) (maintained by @amaanq)
+- [x] [smithy](https://github.com/indoorvivants/tree-sitter-smithy) (maintained by @amaanq, @keynmol)
+- [ ] [snakemake](https://github.com/osthomas/tree-sitter-snakemake) (experimental)
+- [x] [solidity](https://github.com/JoranHonig/tree-sitter-solidity) (maintained by @amaanq)
+- [x] [soql](https://github.com/aheber/tree-sitter-sfapex) (maintained by @aheber, @xixiaofinland)
+- [x] [sosl](https://github.com/aheber/tree-sitter-sfapex) (maintained by @aheber, @xixiaofinland)
+- [x] [sourcepawn](https://github.com/nilshelmig/tree-sitter-sourcepawn) (maintained by @Sarrus1)
+- [x] [sparql](https://github.com/GordianDziwis/tree-sitter-sparql) (maintained by @GordianDziwis)
+- [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] [ssh_config](https://github.com/ObserverOfTime/tree-sitter-ssh-config) (maintained by @ObserverOfTime)
+- [x] [starlark](https://github.com/amaanq/tree-sitter-starlark) (maintained by @amaanq)
+- [x] [strace](https://github.com/sigmaSd/tree-sitter-strace) (maintained by @amaanq)
+- [x] [styled](https://github.com/mskelton/tree-sitter-styled) (maintained by @mskelton)
+- [x] [supercollider](https://github.com/madskjeldgaard/tree-sitter-supercollider) (maintained by @madskjeldgaard)
+- [x] [superhtml](https://github.com/kristoff-it/superhtml) (maintained by @rockorager)
+- [x] [surface](https://github.com/connorlay/tree-sitter-surface) (maintained by @connorlay)
+- [x] [svelte](https://github.com/tree-sitter-grammars/tree-sitter-svelte) (maintained by @amaanq)
+- [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] [tact](https://github.com/tact-lang/tree-sitter-tact) (maintained by @novusnota)
+- [x] [tcl](https://github.com/tree-sitter-grammars/tree-sitter-tcl) (maintained by @lewis6991)
+- [x] [teal](https://github.com/euclidianAce/tree-sitter-teal) (maintained by @euclidianAce)
+- [x] [templ](https://github.com/vrischmann/tree-sitter-templ) (maintained by @vrischmann)
+- [x] [terraform](https://github.com/MichaHoffmann/tree-sitter-hcl) (maintained by @MichaHoffmann)
+- [x] [textproto](https://github.com/PorterAtGoogle/tree-sitter-textproto) (maintained by @Porter)
+- [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] [tmux](https://github.com/Freed-Wu/tree-sitter-tmux) (maintained by @Freed-Wu)
+- [x] [todotxt](https://github.com/arnarg/tree-sitter-todotxt) (experimental, maintained by @arnarg)
+- [x] [toml](https://github.com/tree-sitter-grammars/tree-sitter-toml) (maintained by @tk-shirasaka)
+- [x] [tsv](https://github.com/amaanq/tree-sitter-csv) (maintained by @amaanq)
+- [x] [tsx](https://github.com/tree-sitter/tree-sitter-typescript) (maintained by @steelsojka)
+- [x] [turtle](https://github.com/GordianDziwis/tree-sitter-turtle) (maintained by @GordianDziwis)
+- [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] [typespec](https://github.com/happenslol/tree-sitter-typespec) (maintained by @happenslol)
+- [x] [typoscript](https://github.com/Teddytrombone/tree-sitter-typoscript) (maintained by @Teddytrombone)
+- [x] [typst](https://github.com/uben0/tree-sitter-typst) (maintained by @uben0, @RaafatTurki)
+- [x] [udev](https://github.com/ObserverOfTime/tree-sitter-udev) (maintained by @ObserverOfTime)
+- [x] [ungrammar](https://github.com/Philipp-M/tree-sitter-ungrammar) (maintained by @Philipp-M, @amaanq)
+- [x] [unison](https://github.com/kylegoetz/tree-sitter-unison) (maintained by @tapegram)
+- [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/vlang/v-analyzer) (maintained by @kkharji, @amaanq)
+- [x] [vala](https://github.com/vala-lang/tree-sitter-vala) (maintained by @Prince781)
+- [x] [vento](https://github.com/ventojs/tree-sitter-vento) (maintained by @wrapperup, @oscarotero)
+- [x] [verilog](https://github.com/gmlarumbe/tree-sitter-systemverilog) (maintained by @zhangwwpeng)
+- [x] [vhdl](https://github.com/jpt13653903/tree-sitter-vhdl) (maintained by @jpt13653903)
+- [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] [vrl](https://github.com/belltoy/tree-sitter-vrl) (maintained by @belltoy)
+- [x] [vue](https://github.com/tree-sitter-grammars/tree-sitter-vue) (maintained by @WhyNotHugo, @lucario387)
+- [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/tree-sitter-wing) (maintained by @gshpychka, @MarkMcCulloh)
+- [x] [wit](https://github.com/liamwh/tree-sitter-wit) (maintained by @liamwh)
+- [x] [xcompose](https://github.com/ObserverOfTime/tree-sitter-xcompose) (maintained by @ObserverOfTime)
+- [x] [xml](https://github.com/tree-sitter-grammars/tree-sitter-xml) (maintained by @ObserverOfTime)
+- [x] [xresources](https://github.com/ValdezFOmar/tree-sitter-xresources) (maintained by @ValdezFOmar)
+- [x] [yaml](https://github.com/tree-sitter-grammars/tree-sitter-yaml) (maintained by @amaanq)
+- [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] [zathurarc](https://github.com/Freed-Wu/tree-sitter-zathurarc) (maintained by @Freed-Wu)
+- [x] [zig](https://github.com/tree-sitter-grammars/tree-sitter-zig) (maintained by @amaanq)
+- [x] [ziggy](https://github.com/kristoff-it/ziggy) (maintained by @rockorager)
+- [x] [ziggy_schema](https://github.com/kristoff-it/ziggy) (maintained by @rockorager)
+<!--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 (implemented in Neovim itself, see `:h vim.treesitter.foldexpr()`). To enable it for the current window, set
+
+```lua
+vim.wo.foldmethod = 'expr'
+vim.wo.foldexpr = 'v:lua.vim.treesitter.foldexpr()'
+```
+
+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 prepended to the
+`runtimepath`. For example:
+
+```lua
+  -- It MUST be at the beginning of runtimepath. Otherwise the parsers from Neovim itself
+  -- is loaded that may not be compatible with the queries from the 'nvim-treesitter' plugin.
+  vim.opt.runtimepath:prepend("/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).
+
+The first query file on `runtimepath` will be used (see `:h treesitter-query`).
+If you want to make a query on the user config extend other queries instead of
+replacing them, see `:h treesitter-query-modeline-extends`.
+
+If you want to completely override a query, you can use `:h vim.treesitter.query.set()`.
+For example, to override the `injections` queries from `c` with your own:
+
+```lua
+vim.treesitter.query.set("c", "injections", "(comment) @comment")
+```
+
+Note: when using `query.set()`, 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 {
+    --
+    --
+}
+```
+
+#### Using an existing parser for another filetype
+
+For example, to use the `bash` tree-sitter to highlight file with
+`filetype=apkbuild`, use:
+
+```lua
+vim.treesitter.language.register("bash", "apkbuild")
+```
+
+The `bash` tree-sitter must be installed following the usual procedure [as
+described above](#language-parsers).
diff --git a/pack/ant/start/nvim-treesitter/assets/logo.png b/pack/ant/start/nvim-treesitter/assets/logo.png
new file mode 100644
index 0000000..a60e536
Binary files /dev/null and b/pack/ant/start/nvim-treesitter/assets/logo.png differ
diff --git a/pack/ant/start/nvim-treesitter/autoload/nvim_treesitter.vim b/pack/ant/start/nvim-treesitter/autoload/nvim_treesitter.vim
new file mode 100644
index 0000000..9095398
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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
diff --git a/pack/ant/start/nvim-treesitter/contrib/nvim-treesitter-luarocks.template b/pack/ant/start/nvim-treesitter/contrib/nvim-treesitter-luarocks.template
new file mode 100644
index 0000000..8109f5f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/contrib/nvim-treesitter-luarocks.template
@@ -0,0 +1,41 @@
+local git_ref = '$git_ref'
+local modrev = '$modrev'
+local specrev = '-1'
+
+local repo_url = '$repo_url'
+
+rockspec_format = '3.0'
+package = '$package'
+version = modrev .. specrev
+
+description = {
+  summary = 'Nvim Treesitter configurations and abstraction layer',
+  detailed = $detailed_description,
+  labels = { 'neovim' },
+  homepage = 'https://github.com/nvim-treesitter/nvim-treesitter',
+  license = 'Apache-2.0',
+}
+
+dependencies = {
+  'lua >= 5.1',
+}
+
+-- source = file:///.
+
+source = {
+  url = repo_url .. '/archive/' .. git_ref .. '.zip',
+  dir = '$repo_name-' .. '$archive_dir_suffix',
+}
+
+build = {
+  type = 'make',
+  build_pass = false,
+  install_variables = {
+    INST_PREFIX='$(PREFIX)',
+    INST_BINDIR='$(BINDIR)',
+    INST_LIBDIR='$(LIBDIR)',
+    INST_LUADIR='$(LUADIR)',
+    INST_CONFDIR='$(CONFDIR)',
+  },
+  copy_directories = $copy_directories,
+}
diff --git a/pack/ant/start/nvim-treesitter/contrib/nvim-treesitter-scm-1.rockspec b/pack/ant/start/nvim-treesitter/contrib/nvim-treesitter-scm-1.rockspec
new file mode 100644
index 0000000..a901c5b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/contrib/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'
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/doc/nvim-treesitter.txt b/pack/ant/start/nvim-treesitter/doc/nvim-treesitter.txt
new file mode 100644
index 0000000..f7a91b8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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:
diff --git a/pack/ant/start/nvim-treesitter/lockfile.json b/pack/ant/start/nvim-treesitter/lockfile.json
new file mode 100644
index 0000000..627e8e6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/lockfile.json
@@ -0,0 +1,905 @@
+{
+  "ada": {
+    "revision": "e8e2515465cc2d7c444498e68bdb9f1d86767f95"
+  },
+  "agda": {
+    "revision": "6516cfec35479d62c0ad3c8e7e546a9774b489fd"
+  },
+  "angular": {
+    "revision": "745d3c65c2294aca1110b6b6ad6805124be605c9"
+  },
+  "apex": {
+    "revision": "46d4a12e4e90b10a575b7b16ea3b6ead50322074"
+  },
+  "arduino": {
+    "revision": "415ebc8f75eb02a748faa03f5af199f08ced120f"
+  },
+  "asm": {
+    "revision": "55b2b913f1e71136027d6fce8212e760c64f3532"
+  },
+  "astro": {
+    "revision": "4be180759ec13651f72bacee65fa477c64222a1a"
+  },
+  "authzed": {
+    "revision": "1dec7e1af96c56924e3322cd85fdce15d0a31d00"
+  },
+  "awk": {
+    "revision": "553fdc4afb3b603332c3f4baf50c711506f4e797"
+  },
+  "bash": {
+    "revision": "597a5ed6ed4d932fd44697feec988f977081ae59"
+  },
+  "bass": {
+    "revision": "28dc7059722be090d04cd751aed915b2fee2f89a"
+  },
+  "beancount": {
+    "revision": "01c0da29e0fc7130420a09d939ecc524e09b6ba6"
+  },
+  "bibtex": {
+    "revision": "ccfd77db0ed799b6c22c214fe9d2937f47bc8b34"
+  },
+  "bicep": {
+    "revision": "0092c7d1bd6bb22ce0a6f78497d50ea2b87f19c0"
+  },
+  "bitbake": {
+    "revision": "a5d04fdb5a69a02b8fa8eb5525a60dfb5309b73b"
+  },
+  "blueprint": {
+    "revision": "60ba73739c6083c693d86a1a7cf039c07eb4ed59"
+  },
+  "bp": {
+    "revision": "4e60cf3c2e613625c06f6f85540b3631e2d06cd3"
+  },
+  "c": {
+    "revision": "79284a14a0d7e4495b095b38acdd8a27acbe870e"
+  },
+  "c_sharp": {
+    "revision": "3a85187e0a9e8db01dec6b3eb2f4e7cdfecc9d88"
+  },
+  "cairo": {
+    "revision": "6238f609bea233040fe927858156dee5515a0745"
+  },
+  "capnp": {
+    "revision": "7b0883c03e5edd34ef7bcf703194204299d7099f"
+  },
+  "chatito": {
+    "revision": "a461f20dedb43905febb12c1635bc7d2e43e96f0"
+  },
+  "clojure": {
+    "revision": "f4236d4da8aa92bc105d9c118746474c608e6af7"
+  },
+  "cmake": {
+    "revision": "e409ae33f00e04cde30f2bcffb979caf1a33562a"
+  },
+  "comment": {
+    "revision": "3555706cef8b98d3e4c7379d7260548ff03ad363"
+  },
+  "commonlisp": {
+    "revision": "bf2a65b1c119898a1a17389e07f2a399c05cdc0c"
+  },
+  "cooklang": {
+    "revision": "4ebe237c1cf64cf3826fc249e9ec0988fe07e58e"
+  },
+  "corn": {
+    "revision": "464654742cbfd3a3de560aba120998f1d5dfa844"
+  },
+  "cpon": {
+    "revision": "594289eadfec719198e560f9d7fd243c4db678d5"
+  },
+  "cpp": {
+    "revision": "16bf9d2c451957aee976c982c2c668b1c0d12014"
+  },
+  "css": {
+    "revision": "ccc4e2c4b30ddabc4b41c577ad0550b3cac4a74a"
+  },
+  "csv": {
+    "revision": "7eb7297823605392d2bbcc4c09b1cd18d6fa9529"
+  },
+  "cuda": {
+    "revision": "635e8aa3747823a0c4e9660c07cef76fe8d3ef93"
+  },
+  "cue": {
+    "revision": "8a5f273bfa281c66354da562f2307c2d394b6c81"
+  },
+  "d": {
+    "revision": "45e5f1e9d6de2c68591bc8e5ec662cf18e950b4a"
+  },
+  "dart": {
+    "revision": "9ac03bb2154316624fb4c41fe0f372a5f1597b43"
+  },
+  "devicetree": {
+    "revision": "16c9cb959675bc9bc4f4e5bebe473d511a12a06d"
+  },
+  "dhall": {
+    "revision": "affb6ee38d629c9296749767ab832d69bb0d9ea8"
+  },
+  "diff": {
+    "revision": "63439b5e6e35750aff1e53d9eecc663d369c54bc"
+  },
+  "disassembly": {
+    "revision": "0229c0211dba909c5d45129ac784a3f4d49c243a"
+  },
+  "djot": {
+    "revision": "886601b67d1f4690173a4925c214343c30704d32"
+  },
+  "dockerfile": {
+    "revision": "087daa20438a6cc01fa5e6fe6906d77c869d19fe"
+  },
+  "dot": {
+    "revision": "9ab85550c896d8b294d9b9ca1e30698736f08cea"
+  },
+  "doxygen": {
+    "revision": "ccd998f378c3f9345ea4eeb223f56d7b84d16687"
+  },
+  "dtd": {
+    "revision": "cd1316e476ec40da6ce1fb5749c9d7e6b4f1090c"
+  },
+  "earthfile": {
+    "revision": "1d637f2002bb8b22d4c08d26ad2bfbc22916f3ce"
+  },
+  "ebnf": {
+    "revision": "8e635b0b723c620774dfb8abf382a7f531894b40"
+  },
+  "editorconfig": {
+    "revision": "777f774d6381f1bb84adffa02a4e476fb61486ae"
+  },
+  "eds": {
+    "revision": "26d529e6cfecde391a03c21d1474eb51e0285805"
+  },
+  "eex": {
+    "revision": "f742f2fe327463335e8671a87c0b9b396905d1d1"
+  },
+  "elixir": {
+    "revision": "2ac7a0f81f0731d83068b2872c4a8fee39263a85"
+  },
+  "elm": {
+    "revision": "27f502ed0a1cbd3c5912d284cc7934ee0d4cdddc"
+  },
+  "elsa": {
+    "revision": "0a66b2b3f3c1915e67ad2ef9f7dbd2a84820d9d7"
+  },
+  "elvish": {
+    "revision": "5e7210d945425b77f82cbaebc5af4dd3e1ad40f5"
+  },
+  "embedded_template": {
+    "revision": "7e319b065c5864bac2fb68f7e14a338b919e8bb3"
+  },
+  "erlang": {
+    "revision": "4095e9993acc89cb311ab1be8614c21b1cf768a4"
+  },
+  "facility": {
+    "revision": "2d037f2f2bf668737f72e6be6eda4b7918b68d86"
+  },
+  "faust": {
+    "revision": "f3b9274514b5f9bf6b0dd4a01c30f9cc15c58bc4"
+  },
+  "fennel": {
+    "revision": "cfbfa478dc2dbef267ee94ae4323d9c886f45e94"
+  },
+  "fidl": {
+    "revision": "0a8910f293268e27ff554357c229ba172b0eaed2"
+  },
+  "firrtl": {
+    "revision": "8503d3a0fe0f9e427863cb0055699ff2d29ae5f5"
+  },
+  "fish": {
+    "revision": "a78aef9abc395c600c38a037ac779afc7e3cc9e0"
+  },
+  "foam": {
+    "revision": "04664b40c0dadb7ef37028acf3422c63271d377b"
+  },
+  "forth": {
+    "revision": "90189238385cf636b9ee99ce548b9e5b5e569d48"
+  },
+  "fortran": {
+    "revision": "4a593dda9cbc050a6686187249f8350ceea292ce"
+  },
+  "fsh": {
+    "revision": "fad2e175099a45efbc98f000cc196d3674cc45e0"
+  },
+  "fsharp": {
+    "revision": "971da5ff0266bfe4a6ecfb94616548032d6d1ba0"
+  },
+  "func": {
+    "revision": "f780ca55e65e7d7360d0229331763e16c452fc98"
+  },
+  "fusion": {
+    "revision": "19db2f47ba4c3a0f6238d4ae0e2abfca16e61dd6"
+  },
+  "gap": {
+    "revision": "141b063335e85299bde3f61b4888d02d674a1abc"
+  },
+  "gaptst": {
+    "revision": "e0723dc6136309b3d5904dad2c73ef71267428c1"
+  },
+  "gdscript": {
+    "revision": "1f1e782fe2600f50ae57b53876505b8282388d77"
+  },
+  "gdshader": {
+    "revision": "ffd9f958df13cae04593781d7d2562295a872455"
+  },
+  "git_config": {
+    "revision": "9c2a1b7894e6d9eedfe99805b829b4ecd871375e"
+  },
+  "git_rebase": {
+    "revision": "bff4b66b44b020d918d67e2828eada1974a966aa"
+  },
+  "gitattributes": {
+    "revision": "41940e199ba5763abea1d21b4f717014b45f01ea"
+  },
+  "gitcommit": {
+    "revision": "db0e0c4fb9095fdc42a7af34019c0616c071e9eb"
+  },
+  "gitignore": {
+    "revision": "f4685bf11ac466dd278449bcfe5fd014e94aa504"
+  },
+  "gleam": {
+    "revision": "57c9951b290c8084d7c60b0aee7a2b30986ea031"
+  },
+  "glimmer": {
+    "revision": "da605af8c5999b43e6839b575eae5e6cafabb06f"
+  },
+  "glimmer_javascript": {
+    "revision": "7e8ea8cf39fc360cb97bd253442cd48e4f7a9ce3"
+  },
+  "glimmer_typescript": {
+    "revision": "4006128790efb58ca82a4492d8ef0983b260fc6a"
+  },
+  "glsl": {
+    "revision": "66aec57f7119c7e8e40665b723cd7af5594f15ee"
+  },
+  "gn": {
+    "revision": "bc06955bc1e3c9ff8e9b2b2a55b38b94da923c05"
+  },
+  "gnuplot": {
+    "revision": "3c895f5d9c0b3a3c7e02383766b462c21913c000"
+  },
+  "go": {
+    "revision": "df2ce2e206d2810bf010d73055055bfcff1b55aa"
+  },
+  "goctl": {
+    "revision": "49c43532689fe1f53e8b9e009d0521cab02c432b"
+  },
+  "godot_resource": {
+    "revision": "2ffb90de47417018651fc3b970e5f6b67214dc9d"
+  },
+  "gomod": {
+    "revision": "3b01edce2b9ea6766ca19328d1850e456fde3103"
+  },
+  "gosum": {
+    "revision": "e2ac513b2240c7ff1069ae33b2df29ce90777c11"
+  },
+  "gotmpl": {
+    "revision": "ca52fbfc98366c585b84f4cb3745df49f33cd140"
+  },
+  "gowork": {
+    "revision": "949a8a470559543857a62102c84700d291fc984c"
+  },
+  "gpg": {
+    "revision": "f99323fb8f3f10b6c69db0c2f6d0a14bd7330675"
+  },
+  "graphql": {
+    "revision": "5e66e961eee421786bdda8495ed1db045e06b5fe"
+  },
+  "gren": {
+    "revision": "c06e272341363c5d8e19ac34bc7c56258a37e71b"
+  },
+  "groovy": {
+    "revision": "0d8884514fe10c4fa47527d9a0284d207f38ddea"
+  },
+  "gstlaunch": {
+    "revision": "549aef253fd38a53995cda1bf55c501174372bf7"
+  },
+  "hack": {
+    "revision": "fca1e294f6dce8ec5659233a6a21f5bd0ed5b4f2"
+  },
+  "hare": {
+    "revision": "4af5d82cf9ec39f67cb1db5b7a9269d337406592"
+  },
+  "haskell": {
+    "revision": "70ea0757986ea58a0d39ddfcd9d791beadeb0f43"
+  },
+  "haskell_persistent": {
+    "revision": "577259b4068b2c281c9ebf94c109bd50a74d5857"
+  },
+  "hcl": {
+    "revision": "9e3ec9848f28d26845ba300fd73c740459b83e9b"
+  },
+  "heex": {
+    "revision": "6dd0303acf7138dd2b9b432a229e16539581c701"
+  },
+  "helm": {
+    "revision": "ca52fbfc98366c585b84f4cb3745df49f33cd140"
+  },
+  "hjson": {
+    "revision": "02fa3b79b3ff9a296066da6277adfc3f26cbc9e0"
+  },
+  "hlsl": {
+    "revision": "b309425a7ab4456605cfe78774b80f7e275ca87d"
+  },
+  "hlsplaylist": {
+    "revision": "3bfda9271e3adb08d35f47a2102fe957009e1c55"
+  },
+  "hocon": {
+    "revision": "c390f10519ae69fdb03b3e5764f5592fb6924bcc"
+  },
+  "hoon": {
+    "revision": "a24c5a39d1d7e993a8bee913c8e8b6a652ca5ae8"
+  },
+  "html": {
+    "revision": "c30792dee70aaa1910e66a39557a841b6e4386d5"
+  },
+  "htmldjango": {
+    "revision": "ea71012d3fe14dd0b69f36be4f96bdfe9155ebae"
+  },
+  "http": {
+    "revision": "231f1b1bafd12e46c8ed8c21dbbdd940d9f15e94"
+  },
+  "hurl": {
+    "revision": "ff07a42d9ec95443b5c1b57ed793414bf7b79be5"
+  },
+  "hyprlang": {
+    "revision": "6858695eba0e63b9e0fceef081d291eb352abce8"
+  },
+  "idl": {
+    "revision": "5573b295410201ed22771776b34d636900eba368"
+  },
+  "ini": {
+    "revision": "962568c9efa71d25720ab42c5d36e222626ef3a6"
+  },
+  "inko": {
+    "revision": "6f9c072d023c3886aabcd8012274461b35d2d0a9"
+  },
+  "ispc": {
+    "revision": "9b2f9aec2106b94b4e099fe75e73ebd8ae707c04"
+  },
+  "janet_simple": {
+    "revision": "12bfab7db8a5f5b1d774ef84b5831acd34936071"
+  },
+  "java": {
+    "revision": "b864ed97b9675e86de7c15a70c12e4c1ca85fbf9"
+  },
+  "javascript": {
+    "revision": "c4ce9dc8e7e98ea25757ea26bfe9a022043ccd77"
+  },
+  "jq": {
+    "revision": "13990f530e8e6709b7978503da9bc8701d366791"
+  },
+  "jsdoc": {
+    "revision": "b2237872e528b8372ed008068f717db66c16a725"
+  },
+  "json": {
+    "revision": "f2503f1c437fe24560876557868ac94c9cfd3216"
+  },
+  "json5": {
+    "revision": "ab0ba8229d639ec4f3fa5f674c9133477f4b77bd"
+  },
+  "jsonc": {
+    "revision": "02b01653c8a1c198ae7287d566efa86a135b30d5"
+  },
+  "jsonnet": {
+    "revision": "ddd075f1939aed8147b7aa67f042eda3fce22790"
+  },
+  "julia": {
+    "revision": "19f62656dc7f2ff3756a8ef3dcf9ab1c01a9eb58"
+  },
+  "just": {
+    "revision": "6aee3d2f5b3a47286bae0916daaa6c7a217f6fa4"
+  },
+  "kconfig": {
+    "revision": "486fea71f61ad9f3fd4072a118402e97fe88d26c"
+  },
+  "kdl": {
+    "revision": "b37e3d58e5c5cf8d739b315d6114e02d42e66664"
+  },
+  "kotlin": {
+    "revision": "76f53c48d29e8588934fb55b0240d7bdfe00bfe5"
+  },
+  "koto": {
+    "revision": "cbf637e5163065934c827d254b293f4d2f08f523"
+  },
+  "kusto": {
+    "revision": "8353a1296607d6ba33db7c7e312226e5fc83e8ce"
+  },
+  "lalrpop": {
+    "revision": "194c25539f435de415ee0551a5f07058833da915"
+  },
+  "latex": {
+    "revision": "87e4059f01bed363230dc349f794ce4cc580e862"
+  },
+  "ledger": {
+    "revision": "a2eff7fee59ee6adfc4a3646e2f41ba3b340a97d"
+  },
+  "leo": {
+    "revision": "6ca11a96fc2cab51217e0cf4a2f9ed3ea63e28fb"
+  },
+  "linkerscript": {
+    "revision": "f99011a3554213b654985a4b0a65b3b032ec4621"
+  },
+  "liquid": {
+    "revision": "23ac814111e2b4b4b083e2c92219af2d5b74d13d"
+  },
+  "liquidsoap": {
+    "revision": "14feafa91630afb1ab9988cf9b738b7ea29f3f89"
+  },
+  "llvm": {
+    "revision": "c14cb839003348692158b845db9edda201374548"
+  },
+  "lua": {
+    "revision": "34e60e7f45fc313463c68090d88d742a55d1bd7a"
+  },
+  "luadoc": {
+    "revision": "873612aadd3f684dd4e631bdf42ea8990c57634e"
+  },
+  "luap": {
+    "revision": "c134aaec6acf4fa95fe4aa0dc9aba3eacdbbe55a"
+  },
+  "luau": {
+    "revision": "fbadc96272f718dba267628ba7b0e694c368cef3"
+  },
+  "m68k": {
+    "revision": "e128454c2210c0e0c10b68fe45ddb8fee80182a3"
+  },
+  "make": {
+    "revision": "a4b9187417d6be349ee5fd4b6e77b4172c6827dd"
+  },
+  "markdown": {
+    "revision": "5cdc549ab8f461aff876c5be9741027189299cec"
+  },
+  "markdown_inline": {
+    "revision": "5cdc549ab8f461aff876c5be9741027189299cec"
+  },
+  "matlab": {
+    "revision": "306c43ab28b7b8a4976e40ff0a7c26b019ad52df"
+  },
+  "menhir": {
+    "revision": "be8866a6bcc2b563ab0de895af69daeffa88fe70"
+  },
+  "mermaid": {
+    "revision": "90ae195b31933ceb9d079abfa8a3ad0a36fee4cc"
+  },
+  "meson": {
+    "revision": "c5fffb8edd39f22644084ab3f73a924a75721ee3"
+  },
+  "mlir": {
+    "revision": "0238b7fb6a630f77b3fc8b8a48285ef6ed45cbcc"
+  },
+  "muttrc": {
+    "revision": "173b0ab53a9c07962c9777189c4c70e90f1c1837"
+  },
+  "nasm": {
+    "revision": "570f3d7be01fffc751237f4cfcf52d04e20532d1"
+  },
+  "nginx": {
+    "revision": "281d184b8240b2b22670b8907b57b6d6842db6f3"
+  },
+  "nickel": {
+    "revision": "ddaa2bc22355effd97c0d6b09ff5962705c6368d"
+  },
+  "nim": {
+    "revision": "897e5d346f0b59ed62b517cfb0f1a845ad8f0ab7"
+  },
+  "nim_format_string": {
+    "revision": "d45f75022d147cda056e98bfba68222c9c8eca3a"
+  },
+  "ninja": {
+    "revision": "0a95cfdc0745b6ae82f60d3a339b37f19b7b9267"
+  },
+  "nix": {
+    "revision": "456b14a2fa6315abc7e02fcffaf4a1f35d4955d3"
+  },
+  "norg": {
+    "revision": "d89d95af13d409f30a6c7676387bde311ec4a2c8"
+  },
+  "nqc": {
+    "revision": "14e6da1627aaef21d2b2aa0c37d04269766dcc1d"
+  },
+  "objc": {
+    "revision": "62e61b6f5c0289c376d61a8c91faf6435cde9012"
+  },
+  "objdump": {
+    "revision": "28d3b2e25a0b1881d1b47ed1924ca276c7003d45"
+  },
+  "ocaml": {
+    "revision": "5f7a97e9757d8afe6c0b0b5dd8734cf59f35456e"
+  },
+  "ocaml_interface": {
+    "revision": "5f7a97e9757d8afe6c0b0b5dd8734cf59f35456e"
+  },
+  "ocamllex": {
+    "revision": "4b9898ccbf198602bb0dec9cd67cc1d2c0a4fad2"
+  },
+  "odin": {
+    "revision": "3fee7964bbfb2554deef12c224344f3870d15375"
+  },
+  "org": {
+    "revision": "64cfbc213f5a83da17632c95382a5a0a2f3357c1"
+  },
+  "pascal": {
+    "revision": "d0ebabefaea9ac3f6fc3004cf08cd121b66da9e4"
+  },
+  "passwd": {
+    "revision": "20239395eacdc2e0923a7e5683ad3605aee7b716"
+  },
+  "pem": {
+    "revision": "217ff2af3f2db15a79ab7e3d21ea1e0c17e71a1a"
+  },
+  "perl": {
+    "revision": "76ab9a52b9dd2a1758aae3da8286519d995037e9"
+  },
+  "php": {
+    "revision": "2bce5a6588ad6d53ffe5effaf9708682f0fbfc9b"
+  },
+  "php_only": {
+    "revision": "2bce5a6588ad6d53ffe5effaf9708682f0fbfc9b"
+  },
+  "phpdoc": {
+    "revision": "fe3202e468bc17332bec8969f2b50ff1f1da3a46"
+  },
+  "pioasm": {
+    "revision": "afece58efdb30440bddd151ef1347fa8d6f744a9"
+  },
+  "po": {
+    "revision": "bd860a0f57f697162bf28e576674be9c1500db5e"
+  },
+  "pod": {
+    "revision": "0bf8387987c21bf2f8ed41d2575a8f22b139687f"
+  },
+  "poe_filter": {
+    "revision": "592476d81f95d2451f2ca107dc872224c76fecdf"
+  },
+  "pony": {
+    "revision": "73ff874ae4c9e9b45462673cbc0a1e350e2522a7"
+  },
+  "powershell": {
+    "revision": "ebe2ab2f642eda2072c68c8de02e83973c26f33c"
+  },
+  "printf": {
+    "revision": "0e0aceabbf607ea09e03562f5d8a56f048ddea3d"
+  },
+  "prisma": {
+    "revision": "eca2596a355b1a9952b4f80f8f9caed300a272b5"
+  },
+  "problog": {
+    "revision": "93c69d2f84d8a167c0a3f4a8d51ccefe365a4dc8"
+  },
+  "prolog": {
+    "revision": "93c69d2f84d8a167c0a3f4a8d51ccefe365a4dc8"
+  },
+  "promql": {
+    "revision": "77625d78eebc3ffc44d114a07b2f348dff3061b0"
+  },
+  "properties": {
+    "revision": "9d09f5f200c356c50c4103d36441309fd61b48d1"
+  },
+  "proto": {
+    "revision": "e9f6b43f6844bd2189b50a422d4e2094313f6aa3"
+  },
+  "prql": {
+    "revision": "09e158cd3650581c0af4c49c2e5b10c4834c8646"
+  },
+  "psv": {
+    "revision": "7eb7297823605392d2bbcc4c09b1cd18d6fa9529"
+  },
+  "pug": {
+    "revision": "a7ff31a38908df9b9f34828d21d6ca5e12413e18"
+  },
+  "puppet": {
+    "revision": "584522f32495d648b18a53ccb52d988e60de127d"
+  },
+  "purescript": {
+    "revision": "daf9b3e2be18b0b2996a1281f7783e0d041d8b80"
+  },
+  "pymanifest": {
+    "revision": "be062582956165019d3253794b4d712f66dfeaaa"
+  },
+  "python": {
+    "revision": "7f4b9c2d8039701b0579b7c060a918f8548aa7cd"
+  },
+  "ql": {
+    "revision": "1d3e2ff34f1113fadc0ff174c8a01cd4227af7fd"
+  },
+  "qmldir": {
+    "revision": "6b2b5e41734bd6f07ea4c36ac20fb6f14061c841"
+  },
+  "qmljs": {
+    "revision": "6d4db242185721e1f5ef21fde613ca90c743ec47"
+  },
+  "query": {
+    "revision": "f767fb0ac5e711b6d44c5e0c8d1f349687a86ce0"
+  },
+  "r": {
+    "revision": "2097fa502efa21349d26af0ffee55d773015e481"
+  },
+  "racket": {
+    "revision": "5b211bf93021d1c45f39aa96898be9f794f087e4"
+  },
+  "ralph": {
+    "revision": "f6d81bf7a4599c77388035439cf5801cd461ff77"
+  },
+  "rasi": {
+    "revision": "6c9bbcfdf5f0f553d9ebc01750a3aa247a37b8aa"
+  },
+  "rbs": {
+    "revision": "8d8e65ac3f77fbc9e15b1cdb9f980a3e0ac3ab99"
+  },
+  "re2c": {
+    "revision": "c18a3c2f4b6665e35b7e50d6048ea3cff770c572"
+  },
+  "readline": {
+    "revision": "74addc90fc539d31d413c0c7cf7581997a7fa46e"
+  },
+  "regex": {
+    "revision": "58f4caf9db12db3b38b81c77d274aa73c9e85aca"
+  },
+  "rego": {
+    "revision": "20b5a5958c837bc9f74b231022a68a594a313f6d"
+  },
+  "requirements": {
+    "revision": "5ad9b7581b3334f6ad492847d007f2fac6e6e5f2"
+  },
+  "rescript": {
+    "revision": "4606cd81c4c31d1d02390fee530858323410a74c"
+  },
+  "rnoweb": {
+    "revision": "1a74dc0ed731ad07db39f063e2c5a6fe528cae7f"
+  },
+  "robot": {
+    "revision": "322e4cc65754d2b3fdef4f2f8a71e0762e3d13af"
+  },
+  "robots": {
+    "revision": "8e3a4205b76236bb6dbebdbee5afc262ce38bb62"
+  },
+  "roc": {
+    "revision": "ef46edd0c03ea30a22f7e92bc68628fb7231dc8a"
+  },
+  "ron": {
+    "revision": "78938553b93075e638035f624973083451b29055"
+  },
+  "rst": {
+    "revision": "5120f6e59284cb8b85b450bd2db0bd352635ba9f"
+  },
+  "ruby": {
+    "revision": "83aec5f7d1659aaa79e6f24b406a9cd49b87e8e8"
+  },
+  "rust": {
+    "revision": "2ace7a922a755960f44d73a7bb1efffeb4cc5501"
+  },
+  "scala": {
+    "revision": "a9af6356f8e31f04e870587bca79bc2b15808ff5"
+  },
+  "scfg": {
+    "revision": "a5512800ea0220da4abbae61b8aea8423d1549aa"
+  },
+  "scheme": {
+    "revision": "63e25a4a84142ae7ee0ee01fe3a32c985ca16745"
+  },
+  "scss": {
+    "revision": "c478c6868648eff49eb04a4df90d703dc45b312a"
+  },
+  "sflog": {
+    "revision": "46d4a12e4e90b10a575b7b16ea3b6ead50322074"
+  },
+  "slang": {
+    "revision": "3ed23c04a412a0559162d9cadf96dfff7cb36079"
+  },
+  "slint": {
+    "revision": "4e2765d4cac1f03ada6f635eeb6008d1d0aff5a3"
+  },
+  "smali": {
+    "revision": "fdfa6a1febc43c7467aa7e937b87b607956f2346"
+  },
+  "smithy": {
+    "revision": "fa898ac0885d1da9a253695c3e0e91f5efc587cd"
+  },
+  "snakemake": {
+    "revision": "e909815acdbe37e69440261ebb1091ed52e1dec6"
+  },
+  "solidity": {
+    "revision": "ee5a2d2ba30b487c4bbf613d2ef310a454c09c7c"
+  },
+  "soql": {
+    "revision": "46d4a12e4e90b10a575b7b16ea3b6ead50322074"
+  },
+  "sosl": {
+    "revision": "46d4a12e4e90b10a575b7b16ea3b6ead50322074"
+  },
+  "sourcepawn": {
+    "revision": "6b9bf9cbab91443380d2ca8a2f6c491cc7fac5bf"
+  },
+  "sparql": {
+    "revision": "d853661ca680d8ff7f8d800182d5782b61d0dd58"
+  },
+  "sql": {
+    "revision": "f551a8fa69dc9aea479b93fae34c3ea7be15f931"
+  },
+  "squirrel": {
+    "revision": "072c969749e66f000dba35a33c387650e203e96e"
+  },
+  "ssh_config": {
+    "revision": "77450e8bce8853921512348f83c73c168c71fdfb"
+  },
+  "starlark": {
+    "revision": "018d0e09d9d0f0dd6740a37682b8ee4512e8b2ac"
+  },
+  "strace": {
+    "revision": "d819cdd5dbe455bd3c859193633c8d91c0df7c36"
+  },
+  "styled": {
+    "revision": "764af55fc6b8e5ae177eb272f5c5de6238db23e6"
+  },
+  "supercollider": {
+    "revision": "1a8ee0da9a4f2df5a8a22f4d637ac863623a78a7"
+  },
+  "superhtml": {
+    "revision": "3325bbb2dda260131a8db0cae1f1f557d17ebced"
+  },
+  "surface": {
+    "revision": "f4586b35ac8548667a9aaa4eae44456c1f43d032"
+  },
+  "svelte": {
+    "revision": "ae5199db47757f785e43a14b332118a5474de1a2"
+  },
+  "swift": {
+    "revision": "d351cb321c28f0a3e66242ef2f61b1f890ec4b44"
+  },
+  "sxhkdrc": {
+    "revision": "440d5f913d9465c9c776a1bd92334d32febcf065"
+  },
+  "systemtap": {
+    "revision": "f2b378a9af0b7e1192cff67a5fb45508c927205d"
+  },
+  "t32": {
+    "revision": "0f6a5b1e031c97ebf58d3c76eadb2c6bf1e4f780"
+  },
+  "tablegen": {
+    "revision": "b1170880c61355aaf38fc06f4af7d3c55abdabc4"
+  },
+  "tact": {
+    "revision": "83e264928fa194b7283428527259e88e54205264"
+  },
+  "tcl": {
+    "revision": "cdba4ab96a9896492d0d5219b70300c8783ca4e7"
+  },
+  "teal": {
+    "revision": "485fbdc00d811b01b2090dff4d0469fd1d0350f5"
+  },
+  "templ": {
+    "revision": "4519e3ec9ca92754ca25659bb1fd410d5e0f8d88"
+  },
+  "terraform": {
+    "revision": "9e3ec9848f28d26845ba300fd73c740459b83e9b"
+  },
+  "textproto": {
+    "revision": "568471b80fd8793d37ed01865d8c2208a9fefd1b"
+  },
+  "thrift": {
+    "revision": "68fd0d80943a828d9e6f49c58a74be1e9ca142cf"
+  },
+  "tiger": {
+    "revision": "a7f11d946b44244f71df41d2a78af0665d618dae"
+  },
+  "tlaplus": {
+    "revision": "8a8413f1d08e7ee40b347206d26eac4324db9fd9"
+  },
+  "tmux": {
+    "revision": "0252ecd080016e45e6305ef1a943388f5ae2f4b4"
+  },
+  "todotxt": {
+    "revision": "3937c5cd105ec4127448651a21aef45f52d19609"
+  },
+  "toml": {
+    "revision": "16a30c83ce427385b8d14939c45c137fcfca6c42"
+  },
+  "tsv": {
+    "revision": "7eb7297823605392d2bbcc4c09b1cd18d6fa9529"
+  },
+  "tsx": {
+    "revision": "73c4447796b251295b498227bad028d88dc1918b"
+  },
+  "turtle": {
+    "revision": "7f789ea7ef765080f71a298fc96b7c957fa24422"
+  },
+  "twig": {
+    "revision": "085648e01d1422163a1702a44e72303b4e2a0bd1"
+  },
+  "typescript": {
+    "revision": "73c4447796b251295b498227bad028d88dc1918b"
+  },
+  "typespec": {
+    "revision": "0ee05546d73d8eb64635ed8125de6f35c77759fe"
+  },
+  "typoscript": {
+    "revision": "43b221c0b76e77244efdaa9963e402a17c930fbc"
+  },
+  "typst": {
+    "revision": "8b8b16ef1b40cbecbe3f754b1c1c966b5a0904fe"
+  },
+  "udev": {
+    "revision": "8f58696e79092b4ad6bf197415bbd0970acf15cd"
+  },
+  "ungrammar": {
+    "revision": "debd26fed283d80456ebafa33a06957b0c52e451"
+  },
+  "unison": {
+    "revision": "bc06e1eb100e1c0fab9bd89a9ca55d646ac80fc4"
+  },
+  "usd": {
+    "revision": "4e0875f724d94d0c2ff36f9b8cb0b12f8b20d216"
+  },
+  "uxntal": {
+    "revision": "ad9b638b914095320de85d59c49ab271603af048"
+  },
+  "v": {
+    "revision": "ea538758a1273b59774dc9179cde460d9c73fd89"
+  },
+  "vala": {
+    "revision": "8f690bfa639f2b83d1fb938ed3dd98a7ba453e8b"
+  },
+  "vento": {
+    "revision": "3321077d7446c1b3b017c294fd56ce028ed817fe"
+  },
+  "verilog": {
+    "revision": "0dacb911daa9614a7c7e79a594d4cb9f478e6554"
+  },
+  "vhdl": {
+    "revision": "d6e8301999336b47d663052d43f983c3edeb01dd"
+  },
+  "vhs": {
+    "revision": "09f8fbfe40a3a699b200daca7d92e65fbbe9f9e6"
+  },
+  "vim": {
+    "revision": "f3cd62d8bd043ef20507e84bb6b4b53731ccf3a7"
+  },
+  "vimdoc": {
+    "revision": "59c539286e7487b267bc7808b16833f9e3ad6793"
+  },
+  "vrl": {
+    "revision": "274b3ce63f72aa8ffea18e7fc280d3062d28f0ba"
+  },
+  "vue": {
+    "revision": "22bdfa6c9fc0f5ffa44c6e938ec46869ac8a99ff"
+  },
+  "wgsl": {
+    "revision": "40259f3c77ea856841a4e0c4c807705f3e4a2b65"
+  },
+  "wgsl_bevy": {
+    "revision": "47c1818d245a6156a488c4c4d06e9336714bae9b"
+  },
+  "wing": {
+    "revision": "76e0c25844a66ebc6e866d690fcc5f4e90698947"
+  },
+  "wit": {
+    "revision": "81490b4e74c792369e005f72b0d46fe082d3fed2"
+  },
+  "xcompose": {
+    "revision": "fff3e72242aa110ebba6441946ea4d12d200fa68"
+  },
+  "xml": {
+    "revision": "cd1316e476ec40da6ce1fb5749c9d7e6b4f1090c"
+  },
+  "xresources": {
+    "revision": "630af80f563ede09a652a808277950c36306e3a3"
+  },
+  "yaml": {
+    "revision": "7b03feefd36b5f155465ca736c6304aca983b267"
+  },
+  "yang": {
+    "revision": "2c0e6be8dd4dcb961c345fa35c309ad4f5bd3502"
+  },
+  "yuck": {
+    "revision": "e877f6ade4b77d5ef8787075141053631ba12318"
+  },
+  "zathurarc": {
+    "revision": "0554b4a5d313244b7fc000cbb41c04afae4f4e31"
+  },
+  "zig": {
+    "revision": "eb7d58c2dc4fbeea4745019dee8df013034ae66b"
+  },
+  "ziggy": {
+    "revision": "42b6f5d7320340bc5903c4c29d34065e8517a549"
+  },
+  "ziggy_schema": {
+    "revision": "42b6f5d7320340bc5903c4c29d34065e8517a549"
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter.lua
new file mode 100644
index 0000000..963fe73
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/caching.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/caching.lua
new file mode 100644
index 0000000..7733202
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/compat.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/compat.lua
new file mode 100644
index 0000000..0ad0100
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/compat.lua
@@ -0,0 +1,39 @@
+-- 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
+
+function M.require_language(lang, opts)
+  return (ts.language.add or ts.language.require_language)(lang, opts)
+end
+
+function M.flatten(t)
+  if vim.fn.has "nvim-0.11" == 1 then
+    return vim.iter(t):flatten():totable()
+  else
+    return vim.tbl_flatten(t)
+  end
+end
+
+return M
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/configs.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/configs.lua
new file mode 100644
index 0000000..a3ec30f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/fold.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/fold.lua
new file mode 100644
index 0000000..7595998
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/health.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/health.lua
new file mode 100644
index 0000000..be265f7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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.9.2" ~= 1 then
+    _error "Nvim-treesitter requires Nvim 0.9.2 or newer"
+  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
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/highlight.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/highlight.lua
new file mode 100644
index 0000000..5a3cc2e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/incremental_selection.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/incremental_selection.lua
new file mode 100644
index 0000000..78f0915
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/incremental_selection.lua
@@ -0,0 +1,167 @@
+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 utils = require "nvim-treesitter.utils"
+
+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 "v") ---@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
+      local mode = funcname == "init_selection" and "n" or "x"
+      local rhs = M[funcname] ---@type function
+
+      if not rhs then
+        utils.notify("Unknown keybinding: " .. funcname .. debug.traceback(), vim.log.levels.ERROR)
+      else
+        vim.keymap.set(mode, mapping, rhs, { buffer = bufnr, silent = true, desc = FUNCTION_DESCRIPTIONS[funcname] })
+      end
+    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
+      local mode = f == "init_selection" and "n" or "x"
+      local ok, err = pcall(vim.keymap.del, mode, mapping, { buffer = bufnr })
+      if not ok then
+        utils.notify(string.format('%s "%s" for mode %s', err, mapping, mode), vim.log.levels.ERROR)
+      end
+    end
+  end
+end
+
+return M
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/indent.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/indent.lua
new file mode 100644
index 0000000..19e7ef1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/indent.lua
@@ -0,0 +1,366 @@
+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 lnum integer
+---@return integer
+local function get_indentcols_at_line(lnum)
+  local _, indentcols = getline(lnum):find "^%s*"
+  return indentcols or 0
+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 get_indentcols_at_line(lnum)
+  return root:descendant_for_range(lnum - 1, col, lnum - 1, col + 1)
+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 + 1)
+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 { vim.fn.line "w0" - 1, vim.fn.line "w$" }
+  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 indentcols = get_indentcols_at_line(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, indentcols + #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, indentcols)
+      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 - indentcols))
+        -- Add back indent as indent of prevline was trimmed away
+        local col = indentcols + #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! "delimiter" "AB"))
+      -- matching for all X, instead set do
+      -- (ERROR "X" @aligned_indent (#set! "delimiter" "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
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/info.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/info.lua
new file mode 100644
index 0000000..6e94b35
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/install.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/install.lua
new file mode 100644
index 0000000..cd12dbb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/install.lua
@@ -0,0 +1,781 @@
+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 compat = require "nvim-treesitter.compat"
+
+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(compat.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", "--no-bindings", "--abi", vim.treesitter.language_version }
+      else
+        M.ts_generate_args = { "generate", "--no-bindings" }
+      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
+    install_folder = install_folder and clean_path(install_folder)
+    assert(install_folder)
+
+    local languages ---@type string[]
+    local ask ---@type boolean|string
+    if ... == "all" then
+      languages = parsers.available_parsers()
+      ask = false
+    else
+      languages = compat.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()
+  local function try_install_curr_lang()
+    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
+
+  try_install_curr_lang()
+
+  vim.api.nvim_create_autocmd("FileType", {
+    pattern = { "*" },
+    group = vim.api.nvim_create_augroup("NvimTreesitter-auto_install", { clear = true }),
+    callback = try_install_curr_lang,
+  })
+end
+
+function M.update(options)
+  options = options or {}
+  return function(...)
+    M.lockfile = {}
+    reset_progress_counter()
+    if ... and ... ~= "all" then
+      ---@type string[]
+      local languages = compat.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 = compat.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
+      install_dir = install_dir and clean_path(install_dir)
+
+      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
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/locals.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/locals.lua
new file mode 100644
index 0000000..fed835b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/locals.lua
@@ -0,0 +1,365 @@
+-- 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["local"]["definition"] then
+      table.insert(defs, loc["local"]["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["local"]["scope"] and loc["local"]["scope"].node then
+      table.insert(scopes, loc["local"]["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["local"]["reference"] and loc["local"]["reference"].node then
+      table.insert(refs, loc["local"]["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
+    match = match["local"]
+    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
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/parsers.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/parsers.lua
new file mode 100644
index 0000000..f673130
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/parsers.lua
@@ -0,0 +1,2693 @@
+local api = vim.api
+local ts = vim.treesitter
+
+for ft, lang in pairs {
+  automake = "make",
+  javascriptreact = "javascript",
+  ecma = "javascript",
+  jsx = "javascript",
+  gyp = "python",
+  html_tags = "html",
+  ["typescript.tsx"] = "tsx",
+  ["terraform-vars"] = "terraform",
+  ["html.handlebars"] = "glimmer",
+  systemverilog = "verilog",
+  dosini = "ini",
+  confini = "ini",
+  svg = "xml",
+  xsd = "xml",
+  xslt = "xml",
+  expect = "tcl",
+  mysql = "sql",
+  sbt = "scala",
+  neomuttrc = "muttrc",
+  --- short-hand list from https://github.com/helix-editor/helix/blob/master/languages.toml
+  rs = "rust",
+  ex = "elixir",
+  js = "javascript",
+  ts = "typescript",
+  ["c-sharp"] = "csharp",
+  hs = "haskell",
+  py = "python",
+  erl = "erlang",
+  typ = "typst",
+  pl = "perl",
+  uxn = "uxntal",
+} do
+  ts.language.register(lang, ft)
+end
+
+---@class InstallInfo
+---@field url string
+---@field branch string|nil
+---@field revision string|nil
+---@field files string[]
+---@field generate_requires_npm boolean|nil
+---@field requires_generate_from_grammar boolean|nil
+---@field location string|nil
+---@field use_makefile boolean|nil
+---@field cxx_standard string|nil
+
+---@class ParserInfo
+---@field install_info InstallInfo
+---@field filetype string
+---@field maintainers string[]
+---@field experimental boolean|nil
+---@field readme_name string|nil
+
+---@type ParserInfo[]
+local list = setmetatable({}, {
+  __newindex = function(table, parsername, parserconfig)
+    rawset(table, parsername, parserconfig)
+    if parserconfig.filetype or vim.fn.has "nvim-0.11" == 0 then
+      ts.language.register(parsername, parserconfig.filetype or parsername)
+    end
+  end,
+})
+
+list.ada = {
+  install_info = {
+    url = "https://github.com/briot/tree-sitter-ada",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@briot" },
+}
+
+list.agda = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-agda",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@Decodetalkers" },
+}
+
+list.angular = {
+  install_info = {
+    url = "https://github.com/dlvandenberg/tree-sitter-angular",
+    files = { "src/parser.c", "src/scanner.c" },
+    generate_requires_npm = true,
+  },
+  filetype = "htmlangular",
+  maintainers = { "@dlvandenberg" },
+  experimental = true,
+}
+
+list.apex = {
+  install_info = {
+    url = "https://github.com/aheber/tree-sitter-sfapex",
+    files = { "src/parser.c" },
+    location = "apex",
+  },
+  maintainers = { "@aheber", "@xixiaofinland" },
+}
+
+list.arduino = {
+  install_info = {
+    url = "https://github.com/ObserverOfTime/tree-sitter-arduino",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@ObserverOfTime" },
+}
+
+list.asm = {
+  install_info = {
+    url = "https://github.com/RubixDev/tree-sitter-asm",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@RubixDev" },
+}
+
+list.astro = {
+  install_info = {
+    url = "https://github.com/virchau13/tree-sitter-astro",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@virchau13" },
+}
+
+list.authzed = {
+  install_info = {
+    url = "https://github.com/mleonidas/tree-sitter-authzed",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@mattpolzin" },
+}
+
+list.awk = {
+  install_info = {
+    url = "https://github.com/Beaglefoot/tree-sitter-awk",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+}
+
+list.bash = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-bash",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  filetype = "sh",
+  maintainers = { "@TravonteD" },
+}
+
+list.bass = {
+  install_info = {
+    url = "https://github.com/vito/tree-sitter-bass",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.beancount = {
+  install_info = {
+    url = "https://github.com/polarmutex/tree-sitter-beancount",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@polarmutex" },
+}
+
+list.bibtex = {
+  install_info = {
+    url = "https://github.com/latex-lsp/tree-sitter-bibtex",
+    files = { "src/parser.c" },
+  },
+  filetype = "bib",
+  maintainers = { "@theHamsta", "@clason" },
+}
+
+list.bicep = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-bicep",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.bitbake = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-bitbake",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.blueprint = {
+  install_info = {
+    url = "https://gitlab.com/gabmus/tree-sitter-blueprint.git",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@gabmus" },
+  experimental = true,
+}
+
+list.bp = {
+  install_info = {
+    url = "https://github.com/ambroisie/tree-sitter-bp",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@ambroisie" },
+}
+
+list.c = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-c",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.c_sharp = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-c-sharp",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  filetype = "cs",
+  maintainers = { "@amaanq" },
+}
+
+list.cairo = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-cairo",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.capnp = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-capnp",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.chatito = {
+  install_info = {
+    url = "https://github.com/ObserverOfTime/tree-sitter-chatito",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@ObserverOfTime" },
+}
+
+list.clojure = {
+  install_info = {
+    url = "https://github.com/sogaiu/tree-sitter-clojure",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@NoahTheDuke" },
+}
+
+list.cmake = {
+  install_info = {
+    url = "https://github.com/uyha/tree-sitter-cmake",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@uyha" },
+}
+
+list.comment = {
+  install_info = {
+    url = "https://github.com/stsewd/tree-sitter-comment",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@stsewd" },
+}
+
+list.commonlisp = {
+  install_info = {
+    url = "https://github.com/theHamsta/tree-sitter-commonlisp",
+    files = { "src/parser.c" },
+    generate_requires_npm = true,
+  },
+  filetype = "lisp",
+  maintainers = { "@theHamsta" },
+}
+
+list.cooklang = {
+  install_info = {
+    url = "https://github.com/addcninblue/tree-sitter-cooklang",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@addcninblue" },
+}
+
+list.corn = {
+  install_info = {
+    url = "https://github.com/jakestanger/tree-sitter-corn",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@jakestanger" },
+}
+
+list.cpon = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-cpon",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.cpp = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-cpp",
+    files = { "src/parser.c", "src/scanner.c" },
+    generate_requires_npm = true,
+  },
+  maintainers = { "@theHamsta" },
+}
+
+list.css = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-css",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@TravonteD" },
+}
+
+list.csv = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-csv",
+    files = { "src/parser.c" },
+    location = "csv",
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.cuda = {
+  install_info = {
+    url = "https://github.com/theHamsta/tree-sitter-cuda",
+    files = { "src/parser.c", "src/scanner.c" },
+    generate_requires_npm = true,
+  },
+  maintainers = { "@theHamsta" },
+}
+
+list.cue = {
+  install_info = {
+    url = "https://github.com/eonpatapon/tree-sitter-cue",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.d = {
+  install_info = {
+    url = "https://github.com/gdamore/tree-sitter-d",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.dart = {
+  install_info = {
+    url = "https://github.com/UserNobody14/tree-sitter-dart",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@akinsho" },
+}
+
+list.devicetree = {
+  install_info = {
+    url = "https://github.com/joelspadin/tree-sitter-devicetree",
+    files = { "src/parser.c" },
+  },
+  filetype = "dts",
+  maintainers = { "@jedrzejboczar" },
+}
+
+list.dhall = {
+  install_info = {
+    url = "https://github.com/jbellerb/tree-sitter-dhall",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.diff = {
+  install_info = {
+    url = "https://github.com/the-mikedavis/tree-sitter-diff",
+    files = { "src/parser.c" },
+  },
+  filetype = "gitdiff",
+  maintainers = { "@gbprod" },
+}
+
+list.disassembly = {
+  install_info = {
+    url = "https://github.com/ColinKennedy/tree-sitter-disassembly",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@ColinKennedy" },
+}
+
+list.djot = {
+  install_info = {
+    url = "https://github.com/treeman/tree-sitter-djot",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@NoahTheDuke" },
+}
+
+list.dockerfile = {
+  install_info = {
+    url = "https://github.com/camdencheek/tree-sitter-dockerfile",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@camdencheek" },
+}
+
+list.dot = {
+  install_info = {
+    url = "https://github.com/rydesun/tree-sitter-dot",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@rydesun" },
+}
+
+list.doxygen = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-doxygen",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.dtd = {
+  install_info = {
+    url = "https://github.com/tree-sitter-grammars/tree-sitter-xml",
+    files = { "src/parser.c", "src/scanner.c" },
+    location = "dtd",
+  },
+  maintainers = { "@ObserverOfTime" },
+}
+
+list.earthfile = {
+  install_info = {
+    url = "https://github.com/glehmann/tree-sitter-earthfile",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@glehmann" },
+}
+
+list.ebnf = {
+  install_info = {
+    url = "https://github.com/RubixDev/ebnf",
+    files = { "src/parser.c" },
+    location = "crates/tree-sitter-ebnf",
+  },
+  maintainers = { "@RubixDev" },
+  experimental = true,
+}
+
+list.editorconfig = {
+  install_info = {
+    url = "https://github.com/ValdezFOmar/tree-sitter-editorconfig",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@ValdezFOmar" },
+}
+
+list.eds = {
+  install_info = {
+    url = "https://github.com/uyha/tree-sitter-eds",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@uyha" },
+}
+
+list.eex = {
+  install_info = {
+    url = "https://github.com/connorlay/tree-sitter-eex",
+    files = { "src/parser.c" },
+  },
+  filetype = "eelixir",
+  maintainers = { "@connorlay" },
+}
+
+list.elixir = {
+  install_info = {
+    url = "https://github.com/elixir-lang/tree-sitter-elixir",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@connorlay" },
+}
+
+list.elm = {
+  install_info = {
+    url = "https://github.com/elm-tooling/tree-sitter-elm",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@zweimach" },
+}
+
+list.elsa = {
+  install_info = {
+    url = "https://github.com/glapa-grossklag/tree-sitter-elsa",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@glapa-grossklag", "@amaanq" },
+}
+
+list.elvish = {
+  install_info = {
+    url = "https://github.com/elves/tree-sitter-elvish",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@elves" },
+}
+
+list.embedded_template = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-embedded-template",
+    files = { "src/parser.c" },
+  },
+  filetype = "eruby",
+}
+
+list.erlang = {
+  install_info = {
+    url = "https://github.com/WhatsApp/tree-sitter-erlang",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@filmor" },
+}
+
+list.facility = {
+  install_info = {
+    url = "https://github.com/FacilityApi/tree-sitter-facility",
+    files = { "src/parser.c" },
+  },
+  filetype = "fsd",
+  maintainers = { "@bryankenote" },
+}
+
+list.faust = {
+  install_info = {
+    url = "https://github.com/khiner/tree-sitter-faust",
+    files = { "src/parser.c" },
+  },
+  filetype = "dsp",
+  maintainers = { "@khiner" },
+}
+
+list.fennel = {
+  install_info = {
+    url = "https://github.com/alexmozaidze/tree-sitter-fennel",
+    files = { "src/parser.c", "src/scanner.c" },
+    generate_requires_npm = true,
+  },
+  maintainers = { "@alexmozaidze" },
+}
+
+list.fidl = {
+  install_info = {
+    url = "https://github.com/google/tree-sitter-fidl",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@chaopeng" },
+}
+
+list.firrtl = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-firrtl",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.fish = {
+  install_info = {
+    url = "https://github.com/ram02z/tree-sitter-fish",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@ram02z" },
+}
+
+list.foam = {
+  install_info = {
+    url = "https://github.com/FoamScience/tree-sitter-foam",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@FoamScience" },
+  -- Queries might change over time on the grammar's side
+  -- Otherwise everything runs fine
+  experimental = true,
+}
+
+list.forth = {
+  install_info = {
+    url = "https://github.com/AlexanderBrevig/tree-sitter-forth",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.fortran = {
+  install_info = {
+    url = "https://github.com/stadelmanma/tree-sitter-fortran",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.fsh = {
+  install_info = {
+    url = "https://github.com/mgramigna/tree-sitter-fsh",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@mgramigna" },
+}
+
+list.fsharp = {
+  install_info = {
+    url = "https://github.com/ionide/tree-sitter-fsharp",
+    files = { "src/parser.c", "src/scanner.c" },
+    location = "fsharp",
+  },
+  maintainers = { "@nsidorenco" },
+}
+
+list.func = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-func",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.fusion = {
+  install_info = {
+    url = "https://gitlab.com/jirgn/tree-sitter-fusion.git",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@jirgn" },
+}
+
+list.gap = {
+  install_info = {
+    url = "https://github.com/gap-system/tree-sitter-gap",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@reiniscirpons" },
+  readme_name = "GAP system",
+}
+
+list.gaptst = {
+  install_info = {
+    url = "https://github.com/gap-system/tree-sitter-gaptst",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@reiniscirpons" },
+  readme_name = "GAP system test files",
+}
+
+list.gdscript = {
+  install_info = {
+    url = "https://github.com/PrestonKnopp/tree-sitter-gdscript",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@PrestonKnopp" },
+  readme_name = "Godot (gdscript)",
+}
+
+list.gdshader = {
+  install_info = {
+    url = "https://github.com/GodOfAvacyn/tree-sitter-gdshader",
+    files = { "src/parser.c" },
+  },
+  filetype = "gdshaderinc",
+  maintainers = { "@godofavacyn" },
+}
+
+list.git_rebase = {
+  install_info = {
+    url = "https://github.com/the-mikedavis/tree-sitter-git-rebase",
+    files = { "src/parser.c" },
+  },
+  filetype = "gitrebase",
+  maintainers = { "@gbprod" },
+}
+
+list.gitattributes = {
+  install_info = {
+    url = "https://github.com/ObserverOfTime/tree-sitter-gitattributes",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@ObserverOfTime" },
+}
+
+list.gitcommit = {
+  install_info = {
+    url = "https://github.com/gbprod/tree-sitter-gitcommit",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@gbprod" },
+}
+
+list.git_config = {
+  install_info = {
+    url = "https://github.com/the-mikedavis/tree-sitter-git-config",
+    files = { "src/parser.c" },
+  },
+  filetype = "gitconfig",
+  maintainers = { "@amaanq" },
+  readme_name = "git_config",
+}
+
+list.gitignore = {
+  install_info = {
+    url = "https://github.com/shunsambongi/tree-sitter-gitignore",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@theHamsta" },
+}
+
+list.gleam = {
+  install_info = {
+    url = "https://github.com/gleam-lang/tree-sitter-gleam",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.glimmer = {
+  install_info = {
+    url = "https://github.com/ember-tooling/tree-sitter-glimmer",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  filetype = "handlebars",
+  maintainers = { "@NullVoxPopuli" },
+  readme_name = "Glimmer and Ember",
+}
+
+list.glimmer_javascript = {
+  install_info = {
+    url = "https://github.com/NullVoxPopuli/tree-sitter-glimmer-javascript",
+    files = { "src/parser.c", "src/scanner.c" },
+    generate_requires_npm = true,
+  },
+  filetype = "javascript.glimmer",
+  maintainers = { "@NullVoxPopuli" },
+}
+
+list.glimmer_typescript = {
+  install_info = {
+    url = "https://github.com/NullVoxPopuli/tree-sitter-glimmer-typescript",
+    files = { "src/parser.c", "src/scanner.c" },
+    generate_requires_npm = true,
+  },
+  filetype = "typescript.glimmer",
+  maintainers = { "@NullVoxPopuli" },
+}
+
+list.glsl = {
+  install_info = {
+    url = "https://github.com/theHamsta/tree-sitter-glsl",
+    files = { "src/parser.c" },
+    generate_requires_npm = true,
+  },
+  maintainers = { "@theHamsta" },
+}
+
+list.gn = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-gn",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+  readme_name = "GN (Generate Ninja)",
+}
+
+list.gnuplot = {
+  install_info = {
+    url = "https://github.com/dpezto/tree-sitter-gnuplot",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@dpezto" },
+}
+
+list.go = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-go",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@theHamsta", "@WinWisely268" },
+}
+
+list.goctl = {
+  install_info = {
+    url = "https://github.com/chaozwn/tree-sitter-goctl",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@chaozwn" },
+}
+
+list.godot_resource = {
+  install_info = {
+    url = "https://github.com/PrestonKnopp/tree-sitter-godot-resource",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  filetype = "gdresource",
+  maintainers = { "@pierpo" },
+  readme_name = "Godot Resources (gdresource)",
+}
+
+list.gomod = {
+  install_info = {
+    url = "https://github.com/camdencheek/tree-sitter-go-mod",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@camdencheek" },
+}
+
+list.gosum = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-go-sum",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.gowork = {
+  install_info = {
+    url = "https://github.com/omertuc/tree-sitter-go-work",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@omertuc" },
+}
+
+list.gotmpl = {
+  install_info = {
+    url = "https://github.com/ngalaiko/tree-sitter-go-template",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@qvalentin" },
+}
+
+list.gpg = {
+  install_info = {
+    url = "https://github.com/ObserverOfTime/tree-sitter-gpg-config",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@ObserverOfTime" },
+}
+
+list.gren = {
+  install_info = {
+    files = { "src/parser.c", "src/scanner.c" },
+    url = "https://github.com/MaeBrooks/tree-sitter-gren",
+  },
+  maintainers = { "@MaeBrooks" },
+}
+
+list.groovy = {
+  install_info = {
+    url = "https://github.com/murtaza64/tree-sitter-groovy",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@murtaza64" },
+}
+
+list.graphql = {
+  install_info = {
+    url = "https://github.com/bkegley/tree-sitter-graphql",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@bkegley" },
+}
+
+list.gstlaunch = {
+  install_info = {
+    url = "https://github.com/theHamsta/tree-sitter-gstlaunch",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@theHamsta" },
+}
+
+list.hack = {
+  install_info = {
+    url = "https://github.com/slackhq/tree-sitter-hack",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+}
+
+list.hare = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-hare",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.haskell = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-haskell",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@mrcjkb" },
+}
+
+list.haskell_persistent = {
+  install_info = {
+    url = "https://github.com/MercuryTechnologies/tree-sitter-haskell-persistent",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  filetype = "haskellpersistent",
+  maintainers = { "@lykahb" },
+}
+
+list.hcl = {
+  install_info = {
+    url = "https://github.com/MichaHoffmann/tree-sitter-hcl",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@MichaHoffmann" },
+}
+
+list.heex = {
+  install_info = {
+    url = "https://github.com/connorlay/tree-sitter-heex",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@connorlay" },
+}
+
+list.helm = {
+  install_info = {
+    url = "https://github.com/ngalaiko/tree-sitter-go-template",
+    location = "dialects/helm",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@qvalentin" },
+}
+
+list.hjson = {
+  install_info = {
+    url = "https://github.com/winston0410/tree-sitter-hjson",
+    files = { "src/parser.c" },
+    generate_requires_npm = true,
+  },
+  maintainers = { "@winston0410" },
+}
+
+list.hlsl = {
+  install_info = {
+    url = "https://github.com/theHamsta/tree-sitter-hlsl",
+    files = { "src/parser.c", "src/scanner.c" },
+    generate_requires_npm = true,
+  },
+  maintainers = { "@theHamsta" },
+}
+
+list.hocon = {
+  install_info = {
+    url = "https://github.com/antosha417/tree-sitter-hocon",
+    files = { "src/parser.c" },
+    generate_requires_npm = true,
+  },
+  maintainers = { "@antosha417" },
+}
+
+list.hoon = {
+  install_info = {
+    url = "https://github.com/urbit-pilled/tree-sitter-hoon",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@urbit-pilled" },
+  experimental = true,
+}
+
+list.html = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-html",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@TravonteD" },
+}
+
+list.htmldjango = {
+  install_info = {
+    url = "https://github.com/interdependence/tree-sitter-htmldjango",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@ObserverOfTime" },
+  experimental = true,
+}
+
+list.http = {
+  install_info = {
+    url = "https://github.com/rest-nvim/tree-sitter-http",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq", "@NTBBloodbath" },
+}
+
+list.hurl = {
+  install_info = {
+    url = "https://github.com/pfeiferj/tree-sitter-hurl",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@pfeiferj" },
+}
+
+list.hyprlang = {
+  install_info = {
+    url = "https://github.com/luckasRanarison/tree-sitter-hyprlang",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@luckasRanarison" },
+}
+
+list.idl = {
+  install_info = {
+    url = "https://github.com/cathaysia/tree-sitter-idl",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@cathaysia" },
+}
+
+list.ini = {
+  install_info = {
+    url = "https://github.com/justinmk/tree-sitter-ini",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@theHamsta" },
+  experimental = true,
+}
+
+list.inko = {
+  install_info = {
+    url = "https://github.com/inko-lang/tree-sitter-inko",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@yorickpeterse" },
+}
+
+list.ispc = {
+  install_info = {
+    url = "https://github.com/fab4100/tree-sitter-ispc",
+    files = { "src/parser.c" },
+    generate_requires_npm = true,
+  },
+  maintainers = { "@fab4100" },
+}
+
+list.janet_simple = {
+  install_info = {
+    url = "https://github.com/sogaiu/tree-sitter-janet-simple",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  filetype = "janet",
+  maintainers = { "@sogaiu" },
+}
+
+list.java = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-java",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@p00f" },
+}
+
+list.javascript = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-javascript",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@steelsojka" },
+}
+
+list.jq = {
+  install_info = {
+    url = "https://github.com/flurie/tree-sitter-jq",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@ObserverOfTime" },
+}
+
+list.jsdoc = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-jsdoc",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@steelsojka" },
+}
+
+list.json = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-json",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@steelsojka" },
+}
+
+list.json5 = {
+  install_info = {
+    url = "https://github.com/Joakker/tree-sitter-json5",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@Joakker" },
+}
+
+list.jsonc = {
+  install_info = {
+    url = "https://gitlab.com/WhyNotHugo/tree-sitter-jsonc.git",
+    files = { "src/parser.c" },
+    generate_requires_npm = true,
+  },
+  maintainers = { "@WhyNotHugo" },
+  readme_name = "JSON with comments",
+}
+
+list.jsonnet = {
+  install_info = {
+    url = "https://github.com/sourcegraph/tree-sitter-jsonnet",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@nawordar" },
+}
+
+list.julia = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-julia",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@theHamsta" },
+}
+
+list.just = {
+  install_info = {
+    url = "https://github.com/IndianBoy42/tree-sitter-just",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@Hubro" },
+}
+
+list.kconfig = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-kconfig",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.kdl = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-kdl",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.kotlin = {
+  install_info = {
+    url = "https://github.com/fwcd/tree-sitter-kotlin",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@SalBakraa" },
+}
+
+list.koto = {
+  install_info = {
+    url = "https://github.com/koto-lang/tree-sitter-koto",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@irh" },
+}
+
+list.kusto = {
+  install_info = {
+    url = "https://github.com/Willem-J-an/tree-sitter-kusto",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@Willem-J-an" },
+}
+
+list.lalrpop = {
+  install_info = {
+    url = "https://github.com/traxys/tree-sitter-lalrpop",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@traxys" },
+}
+
+list.latex = {
+  install_info = {
+    url = "https://github.com/latex-lsp/tree-sitter-latex",
+    files = { "src/parser.c", "src/scanner.c" },
+    requires_generate_from_grammar = true,
+  },
+  filetype = "tex",
+  maintainers = { "@theHamsta", "@clason" },
+}
+
+list.ledger = {
+  install_info = {
+    url = "https://github.com/cbarrete/tree-sitter-ledger",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@cbarrete" },
+}
+
+list.leo = {
+  install_info = {
+    url = "https://github.com/r001/tree-sitter-leo",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@r001" },
+}
+
+list.llvm = {
+  install_info = {
+    url = "https://github.com/benwilliamgraham/tree-sitter-llvm",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@benwilliamgraham" },
+}
+
+list.linkerscript = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-linkerscript",
+    files = { "src/parser.c" },
+  },
+  filetype = "ld",
+  maintainers = { "@amaanq" },
+}
+
+list.liquid = {
+  install_info = {
+    url = "https://github.com/hankthetank27/tree-sitter-liquid",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@hankthetank27" },
+}
+
+list.liquidsoap = {
+  install_info = {
+    url = "https://github.com/savonet/tree-sitter-liquidsoap",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@toots" },
+}
+
+list.lua = {
+  install_info = {
+    url = "https://github.com/MunifTanjim/tree-sitter-lua",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@muniftanjim" },
+}
+
+list.luadoc = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-luadoc",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.luap = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-luap",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+  readme_name = "lua patterns",
+}
+
+list.luau = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-luau",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.hlsplaylist = {
+  install_info = {
+    url = "https://github.com/Freed-Wu/tree-sitter-hlsplaylist",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@Freed-Wu" },
+}
+
+list.m68k = {
+  install_info = {
+    url = "https://github.com/grahambates/tree-sitter-m68k",
+    files = { "src/parser.c" },
+  },
+  filetype = "asm68k",
+  maintainers = { "@grahambates" },
+}
+
+list.make = {
+  install_info = {
+    url = "https://github.com/alemuller/tree-sitter-make",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@lewis6991" },
+}
+
+list.markdown = {
+  install_info = {
+    url = "https://github.com/MDeiml/tree-sitter-markdown",
+    location = "tree-sitter-markdown",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@MDeiml" },
+  readme_name = "markdown (basic highlighting)",
+  experimental = true,
+}
+
+list.markdown_inline = {
+  install_info = {
+    url = "https://github.com/MDeiml/tree-sitter-markdown",
+    location = "tree-sitter-markdown-inline",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@MDeiml" },
+  readme_name = "markdown_inline (needed for full highlighting)",
+  experimental = true,
+}
+
+list.matlab = {
+  install_info = {
+    url = "https://github.com/acristoffers/tree-sitter-matlab",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@acristoffers" },
+}
+
+list.menhir = {
+  install_info = {
+    url = "https://github.com/Kerl13/tree-sitter-menhir",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@Kerl13" },
+}
+
+list.mermaid = {
+  install_info = {
+    url = "https://github.com/monaqa/tree-sitter-mermaid",
+    files = { "src/parser.c" },
+  },
+  experimental = true,
+}
+
+list.meson = {
+  install_info = {
+    url = "https://github.com/Decodetalkers/tree-sitter-meson",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@Decodetalkers" },
+}
+
+list.mlir = {
+  install_info = {
+    url = "https://github.com/artagnon/tree-sitter-mlir",
+    files = { "src/parser.c" },
+    requires_generate_from_grammar = true,
+  },
+  experimental = true,
+  maintainers = { "@artagnon" },
+}
+
+list.muttrc = {
+  install_info = {
+    url = "https://github.com/neomutt/tree-sitter-muttrc",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@Freed-Wu" },
+}
+
+list.nasm = {
+  install_info = {
+    url = "https://github.com/naclsn/tree-sitter-nasm",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@ObserverOfTime" },
+}
+
+list.nginx = {
+  install_info = {
+    url = "https://github.com/opa-oz/tree-sitter-nginx",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@opa-oz" },
+}
+
+list.nickel = {
+  install_info = {
+    url = "https://github.com/nickel-lang/tree-sitter-nickel",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+}
+
+list.nim = {
+  install_info = {
+    url = "https://github.com/alaviss/tree-sitter-nim",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@aMOPel" },
+}
+
+list.nim_format_string = {
+  install_info = {
+    url = "https://github.com/aMOPel/tree-sitter-nim-format-string",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@aMOPel" },
+}
+
+list.ninja = {
+  install_info = {
+    url = "https://github.com/alemuller/tree-sitter-ninja",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@alemuller" },
+}
+
+list.nix = {
+  install_info = {
+    url = "https://github.com/cstrahan/tree-sitter-nix",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@leo60228" },
+}
+
+list.norg = {
+  install_info = {
+    url = "https://github.com/nvim-neorg/tree-sitter-norg",
+    files = { "src/parser.c", "src/scanner.cc" },
+    cxx_standard = "c++14",
+    use_makefile = true,
+  },
+  maintainers = { "@JoeyGrajciar", "@vhyrro" },
+}
+
+list.nqc = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-nqc",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.objc = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-objc",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.objdump = {
+  install_info = {
+    url = "https://github.com/ColinKennedy/tree-sitter-objdump",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@ColinKennedy" },
+}
+
+list.ocaml = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-ocaml",
+    files = { "src/parser.c", "src/scanner.c" },
+    location = "grammars/ocaml",
+  },
+  maintainers = { "@undu" },
+}
+
+list.ocaml_interface = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-ocaml",
+    files = { "src/parser.c", "src/scanner.c" },
+    location = "grammars/interface",
+  },
+  filetype = "ocamlinterface",
+  maintainers = { "@undu" },
+}
+
+list.ocamllex = {
+  install_info = {
+    url = "https://github.com/atom-ocaml/tree-sitter-ocamllex",
+    files = { "src/parser.c", "src/scanner.c" },
+    requires_generate_from_grammar = true,
+  },
+  maintainers = { "@undu" },
+}
+
+list.odin = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-odin",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.org = {
+  install_info = {
+    url = "https://github.com/milisims/tree-sitter-org",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+}
+
+list.pascal = {
+  install_info = {
+    url = "https://github.com/Isopod/tree-sitter-pascal",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@Isopod" },
+}
+
+list.passwd = {
+  install_info = {
+    url = "https://github.com/ath3/tree-sitter-passwd",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.pem = {
+  install_info = {
+    url = "https://github.com/ObserverOfTime/tree-sitter-pem",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@ObserverOfTime" },
+}
+
+list.perl = {
+  install_info = {
+    url = "https://github.com/tree-sitter-perl/tree-sitter-perl",
+    files = { "src/parser.c", "src/scanner.c" },
+    branch = "release",
+  },
+  maintainers = { "@RabbiVeesh", "@LeoNerd" },
+}
+
+list.php = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-php",
+    location = "php",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@tk-shirasaka", "@calebdw" },
+}
+
+list.php_only = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-php",
+    location = "php_only",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@tk-shirasaka", "@calebdw" },
+}
+
+-- Parsers for injections
+list.phpdoc = {
+  install_info = {
+    url = "https://github.com/claytonrcarter/tree-sitter-phpdoc",
+    files = { "src/parser.c", "src/scanner.c" },
+    generate_requires_npm = true,
+  },
+  maintainers = { "@mikehaertl" },
+  experimental = true,
+}
+
+list.pioasm = {
+  install_info = {
+    url = "https://github.com/leo60228/tree-sitter-pioasm",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@leo60228" },
+}
+
+list.po = {
+  install_info = {
+    url = "https://github.com/erasin/tree-sitter-po",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.pod = {
+  install_info = {
+    url = "https://github.com/tree-sitter-perl/tree-sitter-pod",
+    files = { "src/parser.c", "src/scanner.c" },
+    branch = "release",
+  },
+  maintainers = { "@RabbiVeesh", "@LeoNerd" },
+}
+
+list.poe_filter = {
+  install_info = {
+    url = "https://github.com/ObserverOfTime/tree-sitter-poe-filter",
+    files = { "src/parser.c" },
+  },
+  filetype = "poefilter",
+  maintainers = { "@ObserverOfTime" },
+  readme_name = "Path of Exile item filter",
+  experimental = true,
+}
+
+list.pony = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-pony",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq", "@mfelsche" },
+}
+
+list.powershell = {
+  install_info = {
+    url = "https://github.com/airbus-cert/tree-sitter-powershell",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  filetype = "ps1",
+  maintainers = { "@L2jLiga" },
+}
+
+list.printf = {
+  install_info = {
+    url = "https://github.com/ObserverOfTime/tree-sitter-printf",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@ObserverOfTime" },
+}
+
+list.prisma = {
+  install_info = {
+    url = "https://github.com/victorhqc/tree-sitter-prisma",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@elianiva" },
+}
+
+list.problog = {
+  install_info = {
+    url = "https://github.com/foxyseta/tree-sitter-prolog",
+    files = { "src/parser.c" },
+    location = "grammars/problog",
+  },
+  maintainers = { "@foxyseta" },
+}
+
+list.prolog = {
+  install_info = {
+    url = "https://github.com/foxyseta/tree-sitter-prolog",
+    files = { "src/parser.c" },
+    location = "grammars/prolog",
+  },
+  maintainers = { "@foxyseta" },
+}
+
+list.promql = {
+  install_info = {
+    url = "https://github.com/MichaHoffmann/tree-sitter-promql",
+    files = { "src/parser.c" },
+    experimental = true,
+  },
+  maintainers = { "@MichaHoffmann" },
+}
+
+list.properties = {
+  install_info = {
+    url = "https://github.com/tree-sitter-grammars/tree-sitter-properties",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  filetype = "jproperties",
+  maintainers = { "@ObserverOfTime" },
+}
+
+list.proto = {
+  install_info = {
+    url = "https://github.com/treywood/tree-sitter-proto",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@treywood" },
+}
+
+list.prql = {
+  install_info = {
+    url = "https://github.com/PRQL/tree-sitter-prql",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@matthias-Q" },
+}
+
+list.psv = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-csv",
+    files = { "src/parser.c" },
+    location = "psv",
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.pug = {
+  install_info = {
+    url = "https://github.com/zealot128/tree-sitter-pug",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@zealot128" },
+  experimental = true,
+}
+
+list.puppet = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-puppet",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.purescript = {
+  install_info = {
+    url = "https://github.com/postsolar/tree-sitter-purescript",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@postsolar" },
+}
+
+list.pymanifest = {
+  install_info = {
+    url = "https://github.com/ObserverOfTime/tree-sitter-pymanifest",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@ObserverOfTime" },
+  readme_name = "PyPA manifest",
+}
+
+list.python = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-python",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@stsewd", "@theHamsta" },
+}
+
+list.ql = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-ql",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@pwntester" },
+}
+
+list.qmldir = {
+  install_info = {
+    url = "https://github.com/Decodetalkers/tree-sitter-qmldir",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.qmljs = {
+  install_info = {
+    url = "https://github.com/yuja/tree-sitter-qmljs",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  filetype = "qml",
+  maintainers = { "@Decodetalkers" },
+}
+
+list.query = {
+  install_info = {
+    url = "https://github.com/nvim-treesitter/tree-sitter-query",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@steelsojka" },
+  readme_name = "Tree-Sitter query language",
+}
+
+list.r = {
+  install_info = {
+    url = "https://github.com/r-lib/tree-sitter-r",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@ribru17" },
+}
+
+list.racket = {
+  install_info = {
+    url = "https://github.com/6cdh/tree-sitter-racket",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+}
+
+list.ralph = {
+  install_info = {
+    url = "https://github.com/alephium/tree-sitter-ralph",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@tdroxler" },
+}
+
+list.rasi = {
+  install_info = {
+    url = "https://github.com/Fymyte/tree-sitter-rasi",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@Fymyte" },
+}
+
+list.rbs = {
+  install_info = {
+    url = "https://github.com/joker1007/tree-sitter-rbs",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@joker1007" },
+}
+
+list.re2c = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-re2c",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.readline = {
+  install_info = {
+    url = "https://github.com/ribru17/tree-sitter-readline",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@ribru17" },
+}
+
+list.regex = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-regex",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@theHamsta" },
+}
+
+list.rego = {
+  install_info = {
+    url = "https://github.com/FallenAngel97/tree-sitter-rego",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@FallenAngel97" },
+}
+
+list.requirements = {
+  install_info = {
+    url = "https://github.com/ObserverOfTime/tree-sitter-requirements",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@ObserverOfTime" },
+  readme_name = "pip requirements",
+}
+
+list.rescript = {
+  install_info = {
+    url = "https://github.com/rescript-lang/tree-sitter-rescript",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@ribru17" },
+}
+
+list.rnoweb = {
+  install_info = {
+    url = "https://github.com/bamonroe/tree-sitter-rnoweb",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@bamonroe" },
+}
+
+list.robot = {
+  install_info = {
+    url = "https://github.com/Hubro/tree-sitter-robot",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@Hubro" },
+}
+
+list.robots = {
+  install_info = {
+    url = "https://github.com/opa-oz/tree-sitter-robots-txt",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@opa-oz" },
+}
+
+list.roc = {
+  install_info = {
+    url = "https://github.com/faldor20/tree-sitter-roc",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@nat-418" },
+}
+
+list.ron = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-ron",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.rst = {
+  install_info = {
+    url = "https://github.com/stsewd/tree-sitter-rst",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@stsewd" },
+}
+
+list.ruby = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-ruby",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@TravonteD" },
+}
+
+list.rust = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-rust",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.scala = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-scala",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@stevanmilic" },
+}
+
+list.scfg = {
+  install_info = {
+    url = "https://github.com/rockorager/tree-sitter-scfg",
+    files = { "src/parser.c" },
+    requires_generate_from_grammar = true,
+  },
+  maintainers = { "@WhyNotHugo" },
+}
+
+list.scheme = {
+  install_info = {
+    url = "https://github.com/6cdh/tree-sitter-scheme",
+    files = { "src/parser.c" },
+  },
+}
+
+list.scss = {
+  install_info = {
+    url = "https://github.com/serenadeai/tree-sitter-scss",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@elianiva" },
+}
+
+list.sflog = {
+  install_info = {
+    url = "https://github.com/aheber/tree-sitter-sfapex",
+    files = { "src/parser.c" },
+    location = "sflog",
+  },
+  maintainers = { "@aheber", "@xixiaofinland" },
+}
+
+list.slang = {
+  install_info = {
+    url = "https://github.com/theHamsta/tree-sitter-slang",
+    files = { "src/parser.c", "src/scanner.c" },
+    generate_requires_npm = true,
+  },
+  filetype = "shaderslang",
+  maintainers = { "@theHamsta" },
+  experimental = true,
+}
+
+list.slint = {
+  install_info = {
+    url = "https://github.com/slint-ui/tree-sitter-slint",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@hunger" },
+}
+
+list.smali = {
+  install_info = {
+    url = "https://github.com/tree-sitter-grammars/tree-sitter-smali",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.snakemake = {
+  install_info = {
+    url = "https://github.com/osthomas/tree-sitter-snakemake",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainer = { "@osthomas" },
+  experimental = true,
+}
+
+list.smithy = {
+  install_info = {
+    url = "https://github.com/indoorvivants/tree-sitter-smithy",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq", "@keynmol" },
+}
+
+list.solidity = {
+  install_info = {
+    url = "https://github.com/JoranHonig/tree-sitter-solidity",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.soql = {
+  install_info = {
+    url = "https://github.com/aheber/tree-sitter-sfapex",
+    files = { "src/parser.c" },
+    location = "soql",
+  },
+  maintainers = { "@aheber", "@xixiaofinland" },
+}
+
+list.sosl = {
+  install_info = {
+    url = "https://github.com/aheber/tree-sitter-sfapex",
+    files = { "src/parser.c" },
+    location = "sosl",
+  },
+  maintainers = { "@aheber", "@xixiaofinland" },
+}
+
+list.sourcepawn = {
+  install_info = {
+    url = "https://github.com/nilshelmig/tree-sitter-sourcepawn",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@Sarrus1" },
+  tier = 3,
+}
+
+list.sparql = {
+  install_info = {
+    url = "https://github.com/GordianDziwis/tree-sitter-sparql",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@GordianDziwis" },
+}
+
+list.sql = {
+  install_info = {
+    url = "https://github.com/derekstride/tree-sitter-sql",
+    files = { "src/parser.c", "src/scanner.c" },
+    branch = "gh-pages",
+  },
+  maintainers = { "@derekstride" },
+}
+
+list.squirrel = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-squirrel",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.ssh_config = {
+  install_info = {
+    url = "https://github.com/ObserverOfTime/tree-sitter-ssh-config",
+    files = { "src/parser.c" },
+  },
+  filetype = "sshconfig",
+  maintainers = { "@ObserverOfTime" },
+}
+
+list.starlark = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-starlark",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  filetype = "bzl",
+  maintainers = { "@amaanq" },
+}
+
+list.strace = {
+  install_info = {
+    url = "https://github.com/sigmaSd/tree-sitter-strace",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.styled = {
+  install_info = {
+    url = "https://github.com/mskelton/tree-sitter-styled",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@mskelton" },
+}
+
+list.supercollider = {
+  install_info = {
+    url = "https://github.com/madskjeldgaard/tree-sitter-supercollider",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@madskjeldgaard" },
+}
+
+list.superhtml = {
+  install_info = {
+    url = "https://github.com/kristoff-it/superhtml",
+    files = {
+      "src/parser.c",
+      "src/scanner.c",
+    },
+    location = "tree-sitter-superhtml",
+  },
+  maintainers = { "@rockorager" },
+}
+
+list.surface = {
+  install_info = {
+    url = "https://github.com/connorlay/tree-sitter-surface",
+    files = { "src/parser.c" },
+  },
+  filetype = "sface",
+  maintainers = { "@connorlay" },
+}
+
+list.svelte = {
+  install_info = {
+    url = "https://github.com/tree-sitter-grammars/tree-sitter-svelte",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.swift = {
+  install_info = {
+    url = "https://github.com/alex-pinkus/tree-sitter-swift",
+    files = { "src/parser.c", "src/scanner.c" },
+    requires_generate_from_grammar = true,
+  },
+  maintainers = { "@alex-pinkus" },
+}
+
+list.sxhkdrc = {
+  install_info = {
+    url = "https://github.com/RaafatTurki/tree-sitter-sxhkdrc",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@RaafatTurki" },
+}
+
+list.systemtap = {
+  install_info = {
+    url = "https://github.com/ok-ryoko/tree-sitter-systemtap",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@ok-ryoko" },
+}
+
+list.t32 = {
+  install_info = {
+    url = "https://gitlab.com/xasc/tree-sitter-t32.git",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  filetype = "trace32",
+  maintainers = { "@xasc" },
+}
+
+list.tablegen = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-tablegen",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.tact = {
+  install_info = {
+    url = "https://github.com/tact-lang/tree-sitter-tact",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@novusnota" },
+}
+
+list.teal = {
+  install_info = {
+    url = "https://github.com/euclidianAce/tree-sitter-teal",
+    files = { "src/parser.c", "src/scanner.c" },
+    requires_generate_from_grammar = true,
+  },
+  maintainers = { "@euclidianAce" },
+}
+
+list.tcl = {
+  install_info = {
+    url = "https://github.com/tree-sitter-grammars/tree-sitter-tcl",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@lewis6991" },
+}
+
+list.terraform = {
+  install_info = {
+    url = "https://github.com/MichaHoffmann/tree-sitter-hcl",
+    files = { "src/parser.c", "src/scanner.c" },
+    location = "dialects/terraform",
+  },
+  maintainers = { "@MichaHoffmann" },
+}
+
+list.textproto = {
+  install_info = {
+    url = "https://github.com/PorterAtGoogle/tree-sitter-textproto",
+    files = { "src/parser.c" },
+  },
+  filetype = "pbtxt",
+  maintainers = { "@Porter" },
+}
+
+list.thrift = {
+  install_info = {
+    url = "https://github.com/duskmoon314/tree-sitter-thrift",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq", "@duskmoon314" },
+}
+
+list.tiger = {
+  install_info = {
+    url = "https://github.com/ambroisie/tree-sitter-tiger",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@ambroisie" },
+}
+
+list.tlaplus = {
+  install_info = {
+    url = "https://github.com/tlaplus-community/tree-sitter-tlaplus",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  filetype = "tla",
+  maintainers = { "@ahelwer", "@susliko" },
+}
+
+list.tmux = {
+  install_info = {
+    url = "https://github.com/Freed-Wu/tree-sitter-tmux",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@Freed-Wu" },
+}
+
+list.todotxt = {
+  install_info = {
+    url = "https://github.com/arnarg/tree-sitter-todotxt",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@arnarg" },
+  experimental = true,
+}
+
+list.toml = {
+  install_info = {
+    url = "https://github.com/tree-sitter-grammars/tree-sitter-toml",
+    files = { "src/parser.c", "src/scanner.c" },
+    generate_requires_npm = true,
+  },
+  maintainers = { "@tk-shirasaka" },
+}
+
+list.tsv = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-csv",
+    files = { "src/parser.c" },
+    location = "tsv",
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.tsx = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-typescript",
+    files = { "src/parser.c", "src/scanner.c" },
+    location = "tsx",
+    generate_requires_npm = true,
+  },
+  filetype = "typescriptreact",
+  maintainers = { "@steelsojka" },
+}
+
+list.turtle = {
+  install_info = {
+    url = "https://github.com/GordianDziwis/tree-sitter-turtle",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@GordianDziwis" },
+}
+
+list.twig = {
+  install_info = {
+    url = "https://github.com/gbprod/tree-sitter-twig",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@gbprod" },
+}
+
+list.typescript = {
+  install_info = {
+    url = "https://github.com/tree-sitter/tree-sitter-typescript",
+    files = { "src/parser.c", "src/scanner.c" },
+    location = "typescript",
+    generate_requires_npm = true,
+  },
+  maintainers = { "@steelsojka" },
+}
+
+list.typespec = {
+  install_info = {
+    url = "https://github.com/happenslol/tree-sitter-typespec",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@happenslol" },
+}
+
+list.typoscript = {
+  install_info = {
+    url = "https://github.com/Teddytrombone/tree-sitter-typoscript",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@Teddytrombone" },
+}
+
+list.typst = {
+  install_info = {
+    url = "https://github.com/uben0/tree-sitter-typst",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@uben0", "@RaafatTurki" },
+}
+
+list.udev = {
+  install_info = {
+    url = "https://github.com/ObserverOfTime/tree-sitter-udev",
+    files = { "src/parser.c" },
+  },
+  filetype = "udevrules",
+  maintainers = { "@ObserverOfTime" },
+}
+
+list.ungrammar = {
+  install_info = {
+    url = "https://github.com/Philipp-M/tree-sitter-ungrammar",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@Philipp-M", "@amaanq" },
+}
+
+list.unison = {
+  install_info = {
+    url = "https://github.com/kylegoetz/tree-sitter-unison",
+    files = { "src/parser.c", "src/scanner.c" },
+    requires_generate_from_grammar = true,
+  },
+  maintainers = { "@tapegram" },
+}
+
+list.usd = {
+  install_info = {
+    url = "https://github.com/ColinKennedy/tree-sitter-usd",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@ColinKennedy" },
+}
+
+list.uxntal = {
+  install_info = {
+    url = "https://github.com/amaanq/tree-sitter-uxntal",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  filetype = "tal",
+  maintainers = { "@amaanq" },
+  readme_name = "uxn tal",
+}
+
+list.v = {
+  install_info = {
+    url = "https://github.com/vlang/v-analyzer",
+    files = { "src/parser.c" },
+    location = "tree_sitter_v",
+  },
+  filetype = "vlang",
+  maintainers = { "@kkharji", "@amaanq" },
+}
+
+list.vala = {
+  install_info = {
+    url = "https://github.com/vala-lang/tree-sitter-vala",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@Prince781" },
+}
+
+list.vento = {
+  install_info = {
+    url = "https://github.com/ventojs/tree-sitter-vento",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  filetype = "vto",
+  maintainers = { "@wrapperup", "@oscarotero" },
+}
+
+list.verilog = {
+  install_info = {
+    url = "https://github.com/gmlarumbe/tree-sitter-systemverilog",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@zhangwwpeng" },
+}
+
+list.vhdl = {
+  install_info = {
+    url = "https://github.com/jpt13653903/tree-sitter-vhdl",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@jpt13653903" },
+}
+
+list.vhs = {
+  install_info = {
+    url = "https://github.com/charmbracelet/tree-sitter-vhs",
+    files = { "src/parser.c" },
+  },
+  filetype = "tape",
+  maintainers = { "@caarlos0" },
+}
+
+list.vim = {
+  install_info = {
+    url = "https://github.com/neovim/tree-sitter-vim",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@clason" },
+}
+
+list.vimdoc = {
+  install_info = {
+    url = "https://github.com/neovim/tree-sitter-vimdoc",
+    files = { "src/parser.c" },
+  },
+  filetype = "help",
+  maintainers = { "@clason" },
+}
+
+list.vrl = {
+  install_info = {
+    url = "https://github.com/belltoy/tree-sitter-vrl",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@belltoy" },
+}
+
+list.vue = {
+  install_info = {
+    url = "https://github.com/tree-sitter-grammars/tree-sitter-vue",
+    files = { "src/parser.c", "src/scanner.c" },
+    branch = "main",
+  },
+  maintainers = { "@WhyNotHugo", "@lucario387" },
+}
+
+list.wgsl = {
+  install_info = {
+    url = "https://github.com/szebniok/tree-sitter-wgsl",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@szebniok" },
+}
+
+list.wgsl_bevy = {
+  install_info = {
+    url = "https://github.com/theHamsta/tree-sitter-wgsl-bevy",
+    files = { "src/parser.c", "src/scanner.c" },
+    generate_requires_npm = true,
+  },
+  maintainers = { "@theHamsta" },
+}
+
+list.wing = {
+  install_info = {
+    url = "https://github.com/winglang/tree-sitter-wing",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@gshpychka", "@MarkMcCulloh" },
+}
+
+list.wit = {
+  install_info = {
+    url = "https://github.com/liamwh/tree-sitter-wit",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@liamwh" },
+}
+
+list.xcompose = {
+  install_info = {
+    url = "https://github.com/ObserverOfTime/tree-sitter-xcompose",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@ObserverOfTime" },
+}
+
+list.xml = {
+  install_info = {
+    url = "https://github.com/tree-sitter-grammars/tree-sitter-xml",
+    files = { "src/parser.c", "src/scanner.c" },
+    location = "xml",
+  },
+  maintainers = { "@ObserverOfTime" },
+}
+
+list.xresources = {
+  install_info = {
+    url = "https://github.com/ValdezFOmar/tree-sitter-xresources",
+    files = { "src/parser.c" },
+  },
+  filetype = "xdefaults",
+  maintainers = { "@ValdezFOmar" },
+}
+
+list.yaml = {
+  install_info = {
+    url = "https://github.com/tree-sitter-grammars/tree-sitter-yaml",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.yang = {
+  install_info = {
+    url = "https://github.com/Hubro/tree-sitter-yang",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@Hubro" },
+}
+
+list.yuck = {
+  install_info = {
+    url = "https://github.com/Philipp-M/tree-sitter-yuck",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@Philipp-M", "@amaanq" },
+}
+
+list.zathurarc = {
+  install_info = {
+    url = "https://github.com/Freed-Wu/tree-sitter-zathurarc",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@Freed-Wu" },
+}
+
+list.zig = {
+  install_info = {
+    url = "https://github.com/tree-sitter-grammars/tree-sitter-zig",
+    files = { "src/parser.c" },
+  },
+  maintainers = { "@amaanq" },
+}
+
+list.ziggy = {
+  install_info = {
+    url = "https://github.com/kristoff-it/ziggy",
+    files = { "src/parser.c" },
+    location = "tree-sitter-ziggy",
+  },
+  maintainers = { "@rockorager" },
+}
+
+list.ziggy_schema = {
+  install_info = {
+    url = "https://github.com/kristoff-it/ziggy",
+    files = { "src/parser.c" },
+    location = "tree-sitter-ziggy-schema",
+  },
+  maintainers = { "@rockorager" },
+}
+
+list.templ = {
+  install_info = {
+    url = "https://github.com/vrischmann/tree-sitter-templ",
+    files = { "src/parser.c", "src/scanner.c" },
+  },
+  maintainers = { "@vrischmann" },
+}
+
+local M = {
+  list = list,
+}
+
+function M.ft_to_lang(ft)
+  local result = ts.language.get_lang(ft)
+  if result then
+    return result
+  else
+    ft = vim.split(ft, ".", { plain = true })[1]
+    return ts.language.get_lang(ft) or ft
+  end
+end
+
+-- Get a list of all available parsers
+---@return string[]
+function M.available_parsers()
+  local parsers = vim.tbl_keys(M.list)
+  table.sort(parsers)
+  if vim.fn.executable "tree-sitter" == 1 and vim.fn.executable "node" == 1 then
+    return parsers
+  else
+    return vim.tbl_filter(function(p) ---@param p string
+      return not M.list[p].install_info.requires_generate_from_grammar
+    end, parsers)
+  end
+end
+
+function M.get_parser_configs()
+  return M.list
+end
+
+local parser_files
+
+function M.reset_cache()
+  parser_files = setmetatable({}, {
+    __index = function(tbl, key)
+      rawset(tbl, key, api.nvim_get_runtime_file("parser/" .. key .. ".*", false))
+      return rawget(tbl, key)
+    end,
+  })
+end
+
+M.reset_cache()
+
+function M.has_parser(lang)
+  lang = lang or M.get_buf_lang(api.nvim_get_current_buf())
+
+  if not lang or #lang == 0 then
+    return false
+  end
+  -- HACK: nvim internal API
+  if vim._ts_has_language(lang) then
+    return true
+  end
+  return #parser_files[lang] > 0
+end
+
+function M.get_parser(bufnr, lang)
+  bufnr = bufnr or api.nvim_get_current_buf()
+  lang = lang or M.get_buf_lang(bufnr)
+
+  if M.has_parser(lang) then
+    return ts.get_parser(bufnr, lang)
+  end
+end
+
+-- @deprecated This is only kept for legacy purposes.
+--             All root nodes should be accounted for.
+function M.get_tree_root(bufnr)
+  bufnr = bufnr or api.nvim_get_current_buf()
+  return M.get_parser(bufnr):parse()[1]:root()
+end
+
+-- Gets the language of a given buffer
+---@param bufnr number? or current buffer
+---@return string
+function M.get_buf_lang(bufnr)
+  bufnr = bufnr or api.nvim_get_current_buf()
+  return M.ft_to_lang(api.nvim_buf_get_option(bufnr, "ft"))
+end
+
+return M
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/query.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/query.lua
new file mode 100644
index 0000000..4aba9f2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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, { all = false })
+
+  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
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/query_predicates.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/query_predicates.lua
new file mode 100644
index 0000000..5caaaa8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/query_predicates.lua
@@ -0,0 +1,241 @@
+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",
+}
+
+-- compatibility shim for breaking change on nightly/0.11
+local opts = vim.fn.has "nvim-0.10" == 1 and { force = true, all = false } or true
+
+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, opts)
+
+---@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, opts)
+
+query.add_predicate("has-parent?", has_ancestor, opts)
+
+---@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, opts)
+
+---@param match (TSNode|nil)[]
+---@param _pattern string
+---@param _bufnr integer
+---@param pred string[]
+---@return boolean|nil
+query.add_predicate("kind-eq?", 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, opts)
+
+---@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["injection.language"] = configured
+  else
+    local parts = vim.split(type_attr_value, "/", {})
+    metadata["injection.language"] = parts[#parts]
+  end
+end, opts)
+
+---@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):lower()
+  metadata["injection.language"] = get_parser_from_markdown_info_string(injection_alias)
+end, opts)
+
+-- Just avoid some annoying warnings for this directive
+query.add_directive("make-range!", function() end, opts)
+
+--- transform node text to lower case (e.g., to make @injection.language case insensitive)
+---
+---@param match (TSNode|nil)[]
+---@param _ string
+---@param bufnr integer
+---@param pred string[]
+---@return boolean|nil
+query.add_directive("downcase!", function(match, _, bufnr, pred, metadata)
+  local id = pred[2]
+  local node = match[id]
+  if not node then
+    return
+  end
+
+  local text = vim.treesitter.get_node_text(node, bufnr, { metadata = metadata[id] }) or ""
+  if not metadata[id] then
+    metadata[id] = {}
+  end
+  metadata[id].text = string.lower(text)
+end, opts)
+
+-- 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, opts)
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/shell_command_selectors.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/shell_command_selectors.lua
new file mode 100644
index 0000000..48f6101
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/shell_command_selectors.lua
@@ -0,0 +1,365 @@
+local fn = vim.fn
+local utils = require "nvim-treesitter.utils"
+local uv = vim.uv or vim.loop
+
+-- 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",
+      "/utf-8",
+      "/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 = require("nvim-treesitter.compat").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",
+            "--show-error",
+            "-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"
+
+    -- Running `git clone` or `git checkout` while running under Git (such as
+    -- editing a `git commit` message) will likely fail to install parsers
+    -- (such as 'gitcommit') and can also corrupt the index file of the current
+    -- Git repository. Check for typical git environment variables and abort if found.
+    for _, k in pairs {
+      "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+      "GIT_CEILING_DIRECTORIES",
+      "GIT_DIR",
+      "GIT_INDEX",
+      "GIT_INDEX_FILE",
+      "GIT_OBJECT_DIRECTORY",
+      "GIT_PREFIX",
+      "GIT_WORK_TREE",
+    } do
+      if uv.os_getenv(k) then
+        vim.api.nvim_err_writeln(
+          string.format(
+            "Cannot install %s with git in an active git session. Exit the session and run ':TSInstall %s' manually",
+            project_name,
+            project_name
+          )
+        )
+        return {}
+      end
+    end
+
+    return {
+      {
+        cmd = "git",
+        info = "Downloading " .. project_name .. "...",
+        err = clone_error,
+        opts = {
+          args = {
+            "clone",
+            repo.url,
+            project_name,
+            "--filter=blob:none",
+          },
+          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
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/statusline.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/statusline.lua
new file mode 100644
index 0000000..68ba41a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/ts_utils.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/ts_utils.lua
new file mode 100644
index 0000000..f2ee7f5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/ts_utils.lua
@@ -0,0 +1,468 @@
+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.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.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 pairs(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 pairs(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") }
+  bufnr = bufnr == 0 and vim.api.nvim_get_current_buf() or bufnr
+  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
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/tsrange.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/tsrange.lua
new file mode 100644
index 0000000..d41585c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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
diff --git a/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/utils.lua b/pack/ant/start/nvim-treesitter/lua/nvim-treesitter/utils.lua
new file mode 100644
index 0000000..d920f4a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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 = require("nvim-treesitter.compat").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
diff --git a/pack/ant/start/nvim-treesitter/parser-info/.gitignore b/pack/ant/start/nvim-treesitter/parser-info/.gitignore
new file mode 100644
index 0000000..d6b7ef3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/parser-info/.gitignore
@@ -0,0 +1,2 @@
+*
+!.gitignore
diff --git a/pack/ant/start/nvim-treesitter/parser/.gitignore b/pack/ant/start/nvim-treesitter/parser/.gitignore
new file mode 100644
index 0000000..d6b7ef3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/parser/.gitignore
@@ -0,0 +1,2 @@
+*
+!.gitignore
diff --git a/pack/ant/start/nvim-treesitter/plugin/nvim-treesitter.lua b/pack/ant/start/nvim-treesitter/plugin/nvim-treesitter.lua
new file mode 100644
index 0000000..4ea3925
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/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",
+})
diff --git a/pack/ant/start/nvim-treesitter/queries/ada/folds.scm b/pack/ant/start/nvim-treesitter/queries/ada/folds.scm
new file mode 100644
index 0000000..8e3defa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ada/folds.scm
@@ -0,0 +1,13 @@
+; 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
diff --git a/pack/ant/start/nvim-treesitter/queries/ada/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ada/highlights.scm
new file mode 100644
index 0000000..0d42b70
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ada/highlights.scm
@@ -0,0 +1,286 @@
+; 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"
+  "body"
+  "declare"
+  "delay"
+  "delta"
+  "digits"
+  "do"
+  "end"
+  "entry"
+  "exit"
+  "generic"
+  "interface"
+  "is"
+  "limited"
+  "mod"
+  "new"
+  "null"
+  "of"
+  "others"
+  "out"
+  "overriding"
+  "package"
+  "pragma"
+  "private"
+  "protected"
+  "range"
+  "separate"
+  "subtype"
+  "synchronized"
+  "tagged"
+  "task"
+  "terminate"
+  "type"
+  "until"
+  "when"
+] @keyword
+
+"record" @keyword.type
+
+[
+  "aliased"
+  "constant"
+  "renames"
+] @keyword.modifier
+
+[
+  "with"
+  "use"
+] @keyword.import
+
+[
+  "function"
+  "procedure"
+] @keyword.function
+
+[
+  "and"
+  "in"
+  "not"
+  "or"
+  "xor"
+] @keyword.operator
+
+[
+  "while"
+  "loop"
+  "for"
+  "parallel"
+  "reverse"
+  "some"
+] @keyword.repeat
+
+"return" @keyword.return
+
+[
+  "case"
+  "if"
+  "else"
+  "then"
+  "elsif"
+  "select"
+] @keyword.conditional
+
+[
+  "exception"
+  "raise"
+] @keyword.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" @keyword.import
+  "type" @keyword.import)
+
+(with_clause
+  "private" @keyword.import)
+
+(with_clause
+  "limited" @keyword.import)
+
+(use_clause
+  (_) @module)
+
+(with_clause
+  (_) @module)
+
+(loop_statement
+  "end" @keyword.repeat)
+
+(if_statement
+  "end" @keyword.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" @keyword.exception)
+
+(gnatprep_declarative_if_statement) @keyword.directive
+
+(gnatprep_if_statement) @keyword.directive
+
+(gnatprep_identifier) @keyword.directive
+
+(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)
diff --git a/pack/ant/start/nvim-treesitter/queries/ada/injections.scm b/pack/ant/start/nvim-treesitter/queries/ada/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ada/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/ada/locals.scm b/pack/ant/start/nvim-treesitter/queries/ada/locals.scm
new file mode 100644
index 0000000..bdfc38b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ada/locals.scm
@@ -0,0 +1,91 @@
+;  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) @local.scope
+
+(package_declaration) @local.scope
+
+(package_body) @local.scope
+
+(subprogram_declaration) @local.scope
+
+(subprogram_body) @local.scope
+
+(block_statement) @local.scope
+
+(with_clause
+  (identifier) @local.definition.import)
+
+(procedure_specification
+  name: (_) @local.definition.function)
+
+(function_specification
+  name: (_) @local.definition.function)
+
+(package_declaration
+  name: (_) @local.definition.var)
+
+(package_body
+  name: (_) @local.definition.var)
+
+(generic_instantiation
+  .
+  name: (_) @local.definition.var)
+
+(component_declaration
+  .
+  (identifier) @local.definition.var)
+
+(exception_declaration
+  .
+  (identifier) @local.definition.var)
+
+(formal_object_declaration
+  .
+  (identifier) @local.definition.var)
+
+(object_declaration
+  .
+  (identifier) @local.definition.var)
+
+(parameter_specification
+  .
+  (identifier) @local.definition.var)
+
+(full_type_declaration
+  .
+  (identifier) @local.definition.type)
+
+(private_type_declaration
+  .
+  (identifier) @local.definition.type)
+
+(private_extension_declaration
+  .
+  (identifier) @local.definition.type)
+
+(incomplete_type_declaration
+  .
+  (identifier) @local.definition.type)
+
+(protected_type_declaration
+  .
+  (identifier) @local.definition.type)
+
+(formal_complete_type_declaration
+  .
+  (identifier) @local.definition.type)
+
+(formal_incomplete_type_declaration
+  .
+  (identifier) @local.definition.type)
+
+(task_type_declaration
+  .
+  (identifier) @local.definition.type)
+
+(subtype_declaration
+  .
+  (identifier) @local.definition.type)
+
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/agda/folds.scm b/pack/ant/start/nvim-treesitter/queries/agda/folds.scm
new file mode 100644
index 0000000..5e1051f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/agda/folds.scm
@@ -0,0 +1,4 @@
+[
+  (record)
+  (module)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/agda/highlights.scm b/pack/ant/start/nvim-treesitter/queries/agda/highlights.scm
new file mode 100644
index 0000000..4626a8c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/agda/highlights.scm
@@ -0,0 +1,87 @@
+; 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" @keyword.import
+
+(module_name) @module
+
+; Pragmas and comments
+(pragma) @keyword.directive
+
+(comment) @comment @spell
+
+; Keywords
+[
+  "where"
+  "data"
+  "rewrite"
+  "postulate"
+  "public"
+  "private"
+  "tactic"
+  "Prop"
+  "quote"
+  "renaming"
+  "open"
+  "in"
+  "hiding"
+  "constructor"
+  "abstract"
+  "let"
+  "field"
+  "mutual"
+  "module"
+  "infix"
+  "infixl"
+  "infixr"
+] @keyword
+
+"record" @keyword.type
+
+;(expr
+;	f_name: (atom) @function)
+; Brackets
+[
+  "("
+  ")"
+  "{"
+  "}"
+] @punctuation.bracket
+
+"=" @operator
diff --git a/pack/ant/start/nvim-treesitter/queries/agda/injections.scm b/pack/ant/start/nvim-treesitter/queries/agda/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/agda/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/angular/folds.scm b/pack/ant/start/nvim-treesitter/queries/angular/folds.scm
new file mode 100644
index 0000000..1f2129c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/angular/folds.scm
@@ -0,0 +1 @@
+; inherits: html
diff --git a/pack/ant/start/nvim-treesitter/queries/angular/highlights.scm b/pack/ant/start/nvim-treesitter/queries/angular/highlights.scm
new file mode 100644
index 0000000..3783933
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/angular/highlights.scm
@@ -0,0 +1,146 @@
+; inherits: html_tags
+
+(identifier) @variable
+
+(pipe_operator) @operator
+
+[
+  (string)
+  (static_member_expression)
+] @string
+
+(number) @number
+
+(pipe_call
+  name: (identifier) @function)
+
+(pipe_call
+  arguments: (pipe_arguments
+    (identifier) @variable.parameter))
+
+(structural_directive
+  "*" @keyword
+  (identifier) @keyword)
+
+(attribute
+  (attribute_name) @variable.member
+  (#lua-match? @variable.member "#.*"))
+
+(binding_name
+  (identifier) @keyword)
+
+(event_binding
+  (binding_name
+    (identifier) @keyword))
+
+(event_binding
+  "\"" @punctuation.delimiter)
+
+(property_binding
+  "\"" @punctuation.delimiter)
+
+(structural_assignment
+  operator: (identifier) @keyword)
+
+(member_expression
+  property: (identifier) @property)
+
+(call_expression
+  function: (identifier) @function)
+
+(call_expression
+  function: ((identifier) @function.builtin
+    (#eq? @function.builtin "$any")))
+
+(pair
+  key: ((identifier) @variable.builtin
+    (#eq? @variable.builtin "$implicit")))
+
+[
+  (control_keyword)
+  (special_keyword)
+] @keyword
+
+((control_keyword) @keyword.repeat
+  (#any-of? @keyword.repeat "for" "empty"))
+
+((control_keyword) @keyword.conditional
+  (#any-of? @keyword.conditional "if" "else" "switch" "case" "default"))
+
+((control_keyword) @keyword.coroutine
+  (#any-of? @keyword.coroutine "defer" "placeholder" "loading"))
+
+((control_keyword) @keyword.exception
+  (#eq? @keyword.exception "error"))
+
+((identifier) @boolean
+  (#any-of? @boolean "true" "false"))
+
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin "this" "$event"))
+
+((identifier) @constant.builtin
+  (#eq? @constant.builtin "null"))
+
+[
+  (ternary_operator)
+  (conditional_operator)
+] @keyword.conditional.ternary
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  "@"
+] @punctuation.bracket
+
+(two_way_binding
+  [
+    "[("
+    ")]"
+  ] @punctuation.bracket)
+
+[
+  "{{"
+  "}}"
+] @punctuation.special
+
+[
+  ";"
+  "."
+  ","
+  "?."
+] @punctuation.delimiter
+
+(nullish_coalescing_expression
+  (coalescing_operator) @operator)
+
+(concatenation_expression
+  "+" @operator)
+
+(icu_clause) @keyword.operator
+
+(icu_category) @keyword.conditional
+
+(binary_expression
+  [
+    "-"
+    "&&"
+    "+"
+    "<"
+    "<="
+    "="
+    "=="
+    "==="
+    "!="
+    "!=="
+    ">"
+    ">="
+    "*"
+    "/"
+    "||"
+    "%"
+  ] @operator)
diff --git a/pack/ant/start/nvim-treesitter/queries/angular/indents.scm b/pack/ant/start/nvim-treesitter/queries/angular/indents.scm
new file mode 100644
index 0000000..2f46aa5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/angular/indents.scm
@@ -0,0 +1,16 @@
+; inherits: html_tags
+
+[
+  (statement_block)
+  (switch_statement)
+] @indent.begin
+
+(statement_block
+  "{" @indent.branch)
+
+(statement_block
+  "}" @indent.end)
+
+"}" @indent.branch
+
+"}" @indent.end
diff --git a/pack/ant/start/nvim-treesitter/queries/angular/injections.scm b/pack/ant/start/nvim-treesitter/queries/angular/injections.scm
new file mode 100644
index 0000000..448e942
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/angular/injections.scm
@@ -0,0 +1 @@
+; inherits: html_tags
diff --git a/pack/ant/start/nvim-treesitter/queries/angular/locals.scm b/pack/ant/start/nvim-treesitter/queries/angular/locals.scm
new file mode 100644
index 0000000..1f2129c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/angular/locals.scm
@@ -0,0 +1 @@
+; inherits: html
diff --git a/pack/ant/start/nvim-treesitter/queries/apex/folds.scm b/pack/ant/start/nvim-treesitter/queries/apex/folds.scm
new file mode 100644
index 0000000..fdfc2a1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/apex/folds.scm
@@ -0,0 +1,6 @@
+[
+  (class_body)
+  (constructor_declaration)
+  (argument_list)
+  (annotation_argument_list)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/apex/highlights.scm b/pack/ant/start/nvim-treesitter/queries/apex/highlights.scm
new file mode 100644
index 0000000..82ce234
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/apex/highlights.scm
@@ -0,0 +1,257 @@
+; inherits: soql
+
+; Apex + SOQL
+[
+  "["
+  "]"
+  "{"
+  "}"
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  ","
+  "."
+  ":"
+  "?"
+  ";"
+] @punctuation.delimiter
+
+; Default general color definition
+(identifier) @variable
+
+(type_identifier) @type
+
+; Methods
+(method_declaration
+  name: (identifier) @function.method)
+
+(method_invocation
+  name: (identifier) @function.method.call)
+
+(super) @function.builtin
+
+; Annotations
+(annotation
+  name: (identifier) @attribute)
+
+; Types
+(interface_declaration
+  name: (identifier) @type)
+
+(class_declaration
+  name: (identifier) @type)
+
+(class_declaration
+  (superclass) @type)
+
+(enum_declaration
+  name: (identifier) @type)
+
+(enum_constant
+  name: (identifier) @constant)
+
+(type_arguments
+  "<" @punctuation.delimiter)
+
+(type_arguments
+  ">" @punctuation.delimiter)
+
+(field_access
+  object: (identifier) @type)
+
+(field_access
+  field: (identifier) @property)
+
+((scoped_identifier
+  scope: (identifier) @type)
+  (#match? @type "^[A-Z]"))
+
+((method_invocation
+  object: (identifier) @type)
+  (#match? @type "^[A-Z]"))
+
+(method_declaration
+  (formal_parameters
+    (formal_parameter
+      name: (identifier) @variable.parameter)))
+
+(constructor_declaration
+  name: (identifier) @constructor)
+
+(dml_type) @function.builtin
+
+(assignment_operator) @operator
+
+(update_operator) @operator
+
+(trigger_declaration
+  name: (identifier) @type
+  object: (identifier) @type
+  (trigger_event) @keyword
+  (","
+    (trigger_event) @keyword)*)
+
+[
+  "@"
+  "="
+  "!="
+  "<="
+  ">="
+] @operator
+
+(binary_expression
+  operator: [
+    ">"
+    "<"
+    "=="
+    "==="
+    "!=="
+    "&&"
+    "||"
+    "+"
+    "-"
+    "*"
+    "/"
+    "&"
+    "|"
+    "^"
+    "%"
+    "<<"
+    ">>"
+    ">>>"
+  ] @operator)
+
+(unary_expression
+  operator: [
+    "+"
+    "-"
+    "!"
+    "~"
+  ]) @operator
+
+"=>" @operator
+
+[
+  (boolean_type)
+  (void_type)
+] @type.builtin
+
+; Fields
+(field_declaration
+  declarator: (variable_declarator
+    name: (identifier) @variable.member))
+
+(field_access
+  field: (identifier) @variable.member)
+
+; Variables
+(variable_declarator
+  (identifier) @property)
+
+(field_declaration
+  (modifiers
+    (modifier
+      [
+        (final)
+        (static)
+      ])
+    (modifier
+      [
+        (final)
+        (static)
+      ]))
+  (variable_declarator
+    name: (identifier) @constant))
+
+((identifier) @constant
+  (#lua-match? @constant "^[A-Z][A-Z0-9_]+$")) ; SCREAM SNAKE CASE
+
+(this) @variable.builtin
+
+; Literals
+[
+  (int)
+  (decimal)
+  (currency_literal)
+] @number
+
+(string_literal) @string
+
+[
+  (line_comment)
+  (block_comment)
+] @comment
+
+(null_literal) @constant.builtin
+
+; ;; Keywords
+[
+  "abstract"
+  "final"
+  "private"
+  "protected"
+  "public"
+  "static"
+] @keyword.modifier
+
+[
+  "if"
+  "else"
+  "switch"
+] @keyword.conditional
+
+[
+  "for"
+  "while"
+  "do"
+  "break"
+] @keyword.repeat
+
+"return" @keyword.return
+
+[
+  "throw"
+  "finally"
+  "try"
+  "catch"
+] @keyword.exception
+
+"new" @keyword.operator
+
+[
+  (abstract)
+  (all_rows_clause)
+  "continue"
+  "extends"
+  (final)
+  "get"
+  (global)
+  "implements"
+  "instanceof"
+  "on"
+  (override)
+  (private)
+  (protected)
+  (public)
+  "set"
+  (static)
+  (testMethod)
+  (webservice)
+  (transient)
+  "trigger"
+  (virtual)
+  "when"
+  (with_sharing)
+  (without_sharing)
+  (inherited_sharing)
+] @keyword
+
+[
+  "interface"
+  "class"
+  "enum"
+] @keyword.type
+
+"System.runAs" @function.builtin
diff --git a/pack/ant/start/nvim-treesitter/queries/apex/injections.scm b/pack/ant/start/nvim-treesitter/queries/apex/injections.scm
new file mode 100644
index 0000000..3cd6aac
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/apex/injections.scm
@@ -0,0 +1,5 @@
+([
+  (line_comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/apex/locals.scm b/pack/ant/start/nvim-treesitter/queries/apex/locals.scm
new file mode 100644
index 0000000..2457752
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/apex/locals.scm
@@ -0,0 +1,70 @@
+; declarations
+(class_declaration) @local.scope
+
+(method_declaration) @local.scope
+
+(constructor_declaration) @local.scope
+
+(enum_declaration) @local.scope
+
+(enhanced_for_statement) @local.scope
+
+; if/else
+(if_statement) @local.scope
+
+(if_statement
+  consequence: (_) @local.scope) ; if body in case there are no braces
+
+(if_statement
+  alternative: (_) @local.scope) ; else body in case there are no braces
+
+; try/catch
+(try_statement) @local.scope ; covers try+catch, individual try and catch are covered by (block)
+
+(catch_clause) @local.scope ; needed because `Exception` variable
+
+; loops
+(for_statement) @local.scope
+
+(for_statement ; "for" body in case there are no braces
+  body: (_) @local.scope)
+
+(do_statement
+  body: (_) @local.scope)
+
+(while_statement
+  body: (_) @local.scope)
+
+; Functions
+(constructor_declaration) @local.scope
+
+(method_declaration) @local.scope
+
+; definitions
+(enum_declaration
+  name: (identifier) @local.definition.enum)
+
+(method_declaration
+  name: (identifier) @local.definition.method)
+
+(local_variable_declaration
+  declarator: (variable_declarator
+    name: (identifier) @local.definition.var))
+
+(enhanced_for_statement
+  name: (identifier) @local.definition.var)
+
+(formal_parameter
+  name: (identifier) @local.definition.parameter)
+
+(catch_formal_parameter
+  name: (identifier) @local.definition.parameter)
+
+(field_declaration
+  declarator: (variable_declarator
+    name: (identifier) @local.definition.field))
+
+; REFERENCES
+(identifier) @local.reference
+
+(type_identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/arduino/folds.scm b/pack/ant/start/nvim-treesitter/queries/arduino/folds.scm
new file mode 100644
index 0000000..b617fdc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/arduino/folds.scm
@@ -0,0 +1 @@
+; inherits: cpp
diff --git a/pack/ant/start/nvim-treesitter/queries/arduino/highlights.scm b/pack/ant/start/nvim-treesitter/queries/arduino/highlights.scm
new file mode 100644
index 0000000..e6bf147
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/arduino/highlights.scm
@@ -0,0 +1,53 @@
+; 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"))
diff --git a/pack/ant/start/nvim-treesitter/queries/arduino/indents.scm b/pack/ant/start/nvim-treesitter/queries/arduino/indents.scm
new file mode 100644
index 0000000..b617fdc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/arduino/indents.scm
@@ -0,0 +1 @@
+; inherits: cpp
diff --git a/pack/ant/start/nvim-treesitter/queries/arduino/injections.scm b/pack/ant/start/nvim-treesitter/queries/arduino/injections.scm
new file mode 100644
index 0000000..b637d9b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/arduino/injections.scm
@@ -0,0 +1,5 @@
+((preproc_arg) @injection.content
+  (#set! injection.language "arduino"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/arduino/locals.scm b/pack/ant/start/nvim-treesitter/queries/arduino/locals.scm
new file mode 100644
index 0000000..b617fdc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/arduino/locals.scm
@@ -0,0 +1 @@
+; inherits: cpp
diff --git a/pack/ant/start/nvim-treesitter/queries/asm/highlights.scm b/pack/ant/start/nvim-treesitter/queries/asm/highlights.scm
new file mode 100644
index 0000000..eccf9c9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/asm/highlights.scm
@@ -0,0 +1,66 @@
+; General
+(label
+  [
+    (ident)
+    (word)
+  ] @label)
+
+(reg) @variable.builtin
+
+(meta
+  kind: (_) @function.builtin)
+
+(instruction
+  kind: (_) @function.builtin)
+
+(const
+  name: (word) @constant)
+
+; Comments
+[
+  (line_comment)
+  (block_comment)
+] @comment @spell
+
+; Literals
+(int) @number
+
+(float) @number.float
+
+(string) @string
+
+; Keywords
+[
+  "byte"
+  "word"
+  "dword"
+  "qword"
+  "ptr"
+  "rel"
+  "label"
+  "const"
+] @keyword
+
+; Operators & Punctuation
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "|"
+  "^"
+  "&"
+] @operator
+
+[
+  "("
+  ")"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ","
+  ":"
+] @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/asm/injections.scm b/pack/ant/start/nvim-treesitter/queries/asm/injections.scm
new file mode 100644
index 0000000..3cd6aac
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/asm/injections.scm
@@ -0,0 +1,5 @@
+([
+  (line_comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/astro/folds.scm b/pack/ant/start/nvim-treesitter/queries/astro/folds.scm
new file mode 100644
index 0000000..1f2129c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/astro/folds.scm
@@ -0,0 +1 @@
+; inherits: html
diff --git a/pack/ant/start/nvim-treesitter/queries/astro/highlights.scm b/pack/ant/start/nvim-treesitter/queries/astro/highlights.scm
new file mode 100644
index 0000000..e4baf53
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/astro/highlights.scm
@@ -0,0 +1,25 @@
+; inherits: html_tags
+
+(doctype) @constant
+
+"<!" @tag.delimiter
+
+"---" @punctuation.delimiter
+
+[
+  "{"
+  "}"
+] @punctuation.special
+
+; custom components get `@type` highlighting
+((start_tag
+  (tag_name) @type)
+  (#lua-match? @type "^[A-Z]"))
+
+((end_tag
+  (tag_name) @type)
+  (#lua-match? @type "^[A-Z]"))
+
+((erroneous_end_tag
+  (erroneous_end_tag_name) @type)
+  (#lua-match? @type "^[A-Z]"))
diff --git a/pack/ant/start/nvim-treesitter/queries/astro/indents.scm b/pack/ant/start/nvim-treesitter/queries/astro/indents.scm
new file mode 100644
index 0000000..1f2129c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/astro/indents.scm
@@ -0,0 +1 @@
+; inherits: html
diff --git a/pack/ant/start/nvim-treesitter/queries/astro/injections.scm b/pack/ant/start/nvim-treesitter/queries/astro/injections.scm
new file mode 100644
index 0000000..d4f15ba
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/astro/injections.scm
@@ -0,0 +1,32 @@
+; inherits: html_tags
+
+(frontmatter
+  (frontmatter_js_block) @injection.content
+  (#set! injection.language "typescript"))
+
+(attribute_interpolation
+  (attribute_js_expr) @injection.content
+  (#set! injection.language "typescript"))
+
+(attribute
+  (attribute_backtick_string) @injection.content
+  (#set! injection.language "typescript"))
+
+(html_interpolation
+  (permissible_text) @injection.content
+  (#set! injection.language "typescript"))
+
+(script_element
+  (raw_text) @injection.content
+  (#set! injection.language "typescript"))
+
+(style_element
+  (start_tag
+    (attribute
+      (attribute_name) @_lang_attr
+      (quoted_attribute_value
+        (attribute_value) @_lang_value)))
+  (raw_text) @injection.content
+  (#eq? @_lang_attr "lang")
+  (#eq? @_lang_value "scss")
+  (#set! injection.language "scss"))
diff --git a/pack/ant/start/nvim-treesitter/queries/astro/locals.scm b/pack/ant/start/nvim-treesitter/queries/astro/locals.scm
new file mode 100644
index 0000000..1f2129c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/astro/locals.scm
@@ -0,0 +1 @@
+; inherits: html
diff --git a/pack/ant/start/nvim-treesitter/queries/authzed/highlights.scm b/pack/ant/start/nvim-treesitter/queries/authzed/highlights.scm
new file mode 100644
index 0000000..fb946ca
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/authzed/highlights.scm
@@ -0,0 +1,60 @@
+(identifier) @function
+
+(block
+  (relation
+    (relation_literal) @function.builtin
+    (identifier) @constant))
+
+(block
+  (permission
+    (permission_literal) @variable.builtin
+    (identifier) @type))
+
+; relations
+(rel_expression
+  (identifier) @property)
+
+(relation
+  (rel_expression
+    (hash_literal)
+    .
+    (identifier) @constant))
+
+; permissions
+(perm_expression
+  (identifier) @property)
+
+(call_expression
+  function: (selector_expression
+    operand: (identifier) @constant
+    field: (field_identifier) @function.method))
+
+(perm_expression
+  (stabby) @operator
+  .
+  (identifier) @function)
+
+; misc
+[
+  (plus_literal)
+  (minus_literal)
+  (amp_literal)
+  (pipe_literal)
+] @operator
+
+[
+  (true)
+  (false)
+] @boolean
+
+(nil) @constant.builtin
+
+[
+  (caveat_literal)
+  (definition_literal)
+] @keyword
+
+[
+  (hash_literal)
+  (comment)
+] @comment
diff --git a/pack/ant/start/nvim-treesitter/queries/authzed/injections.scm b/pack/ant/start/nvim-treesitter/queries/authzed/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/authzed/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/awk/highlights.scm b/pack/ant/start/nvim-treesitter/queries/awk/highlights.scm
new file mode 100644
index 0000000..904cf2a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/awk/highlights.scm
@@ -0,0 +1,199 @@
+; 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.regexp
+
+(escape_sequence) @string.escape
+
+(comment) @comment @spell
+
+((program
+  .
+  (comment) @keyword.directive @nospell)
+  (#lua-match? @keyword.directive "^#!/"))
+
+(ns_qualified_name
+  (namespace) @module)
+
+(ns_qualified_name
+  "::" @punctuation.delimiter)
+
+(func_def
+  name: (_
+    (identifier) @function) @function)
+
+(func_call
+  name: (_
+    (identifier) @function) @function)
+
+(func_def
+  (param_list
+    (identifier) @variable.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"
+] @keyword.repeat
+
+[
+  "if"
+  "else"
+  "switch"
+  "case"
+  "default"
+] @keyword.conditional
+
+[
+  "@include"
+  "@load"
+] @keyword.import
+
+"@namespace" @keyword.directive
+
+[
+  "BEGIN"
+  "END"
+  "BEGINFILE"
+  "ENDFILE"
+] @label
+
+(binary_exp
+  [
+    "^"
+    "**"
+    "*"
+    "/"
+    "%"
+    "+"
+    "-"
+    "<"
+    ">"
+    "<="
+    ">="
+    "=="
+    "!="
+    "~"
+    "!~"
+    "in"
+    "&&"
+    "||"
+  ] @operator)
+
+(unary_exp
+  [
+    "!"
+    "+"
+    "-"
+  ] @operator)
+
+(assignment_exp
+  [
+    "="
+    "+="
+    "-="
+    "*="
+    "/="
+    "%="
+    "^="
+  ] @operator)
+
+(ternary_exp
+  [
+    "?"
+    ":"
+  ] @keyword.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
diff --git a/pack/ant/start/nvim-treesitter/queries/awk/injections.scm b/pack/ant/start/nvim-treesitter/queries/awk/injections.scm
new file mode 100644
index 0000000..3e67da2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/awk/injections.scm
@@ -0,0 +1,17 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((regex) @injection.content
+  (#set! injection.language "regex"))
+
+((print_statement
+  (exp_list
+    .
+    (string) @injection.content))
+  (#set! injection.language "printf"))
+
+((printf_statement
+  (exp_list
+    .
+    (string) @injection.content))
+  (#set! injection.language "printf"))
diff --git a/pack/ant/start/nvim-treesitter/queries/bash/folds.scm b/pack/ant/start/nvim-treesitter/queries/bash/folds.scm
new file mode 100644
index 0000000..766dbe5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bash/folds.scm
@@ -0,0 +1,9 @@
+[
+  (function_definition)
+  (if_statement)
+  (case_statement)
+  (for_statement)
+  (while_statement)
+  (c_style_for_statement)
+  (heredoc_redirect)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/bash/highlights.scm b/pack/ant/start/nvim-treesitter/queries/bash/highlights.scm
new file mode 100644
index 0000000..0e192bb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bash/highlights.scm
@@ -0,0 +1,239 @@
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+  "[["
+  "]]"
+  "(("
+  "))"
+] @punctuation.bracket
+
+[
+  ";"
+  ";;"
+  ";&"
+  ";;&"
+  "&"
+] @punctuation.delimiter
+
+[
+  ">"
+  ">>"
+  "<"
+  "<<"
+  "&&"
+  "|"
+  "|&"
+  "||"
+  "="
+  "+="
+  "=~"
+  "=="
+  "!="
+  "&>"
+  "&>>"
+  "<&"
+  ">&"
+  ">|"
+  "<&-"
+  ">&-"
+  "<<-"
+  "<<<"
+  ".."
+  "!"
+] @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
+
+[
+  (heredoc_start)
+  (heredoc_end)
+] @label
+
+(variable_assignment
+  (word) @string)
+
+(command
+  argument: "$" @string) ; bare dollar
+
+(concatenation
+  (word) @string)
+
+[
+  "if"
+  "then"
+  "else"
+  "elif"
+  "fi"
+  "case"
+  "in"
+  "esac"
+] @keyword.conditional
+
+[
+  "for"
+  "do"
+  "done"
+  "select"
+  "until"
+  "while"
+] @keyword.repeat
+
+[
+  "declare"
+  "typeset"
+  "readonly"
+  "local"
+  "unset"
+  "unsetenv"
+] @keyword
+
+"export" @keyword.import
+
+"function" @keyword.function
+
+(special_variable_name) @constant
+
+; trap -l
+((word) @constant.builtin
+  (#any-of? @constant.builtin
+    "SIGHUP" "SIGINT" "SIGQUIT" "SIGILL" "SIGTRAP" "SIGABRT" "SIGBUS" "SIGFPE" "SIGKILL" "SIGUSR1"
+    "SIGSEGV" "SIGUSR2" "SIGPIPE" "SIGALRM" "SIGTERM" "SIGSTKFLT" "SIGCHLD" "SIGCONT" "SIGSTOP"
+    "SIGTSTP" "SIGTTIN" "SIGTTOU" "SIGURG" "SIGXCPU" "SIGXFSZ" "SIGVTALRM" "SIGPROF" "SIGWINCH"
+    "SIGIO" "SIGPWR" "SIGSYS" "SIGRTMIN" "SIGRTMIN+1" "SIGRTMIN+2" "SIGRTMIN+3" "SIGRTMIN+4"
+    "SIGRTMIN+5" "SIGRTMIN+6" "SIGRTMIN+7" "SIGRTMIN+8" "SIGRTMIN+9" "SIGRTMIN+10" "SIGRTMIN+11"
+    "SIGRTMIN+12" "SIGRTMIN+13" "SIGRTMIN+14" "SIGRTMIN+15" "SIGRTMAX-14" "SIGRTMAX-13"
+    "SIGRTMAX-12" "SIGRTMAX-11" "SIGRTMAX-10" "SIGRTMAX-9" "SIGRTMAX-8" "SIGRTMAX-7" "SIGRTMAX-6"
+    "SIGRTMAX-5" "SIGRTMAX-4" "SIGRTMAX-3" "SIGRTMAX-2" "SIGRTMAX-1" "SIGRTMAX"))
+
+((word) @boolean
+  (#any-of? @boolean "true" "false"))
+
+(comment) @comment @spell
+
+(test_operator) @operator
+
+(command_substitution
+  "$(" @punctuation.special
+  ")" @punctuation.special)
+
+(process_substitution
+  [
+    "<("
+    ">("
+  ] @punctuation.special
+  ")" @punctuation.special)
+
+(arithmetic_expansion
+  [
+    "$(("
+    "(("
+  ] @punctuation.special
+  "))" @punctuation.special)
+
+(arithmetic_expansion
+  "," @punctuation.delimiter)
+
+(ternary_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+(binary_expression
+  operator: _ @operator)
+
+(unary_expression
+  operator: _ @operator)
+
+(postfix_expression
+  operator: _ @operator)
+
+(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) @variable.parameter
+    (concatenation
+      (word) @variable.parameter)
+  ])
+
+(declaration_command
+  (word) @variable.parameter)
+
+(unset_command
+  (word) @variable.parameter)
+
+(number) @number
+
+((word) @number
+  (#lua-match? @number "^[0-9]+$"))
+
+(file_redirect
+  destination: (word) @variable.parameter)
+
+(file_descriptor) @operator
+
+(simple_expansion
+  "$" @punctuation.special) @none
+
+(expansion
+  "${" @punctuation.special
+  "}" @punctuation.special) @none
+
+(expansion
+  operator: _ @punctuation.special)
+
+(expansion
+  "@"
+  .
+  operator: _ @character.special)
+
+((expansion
+  (subscript
+    index: (word) @character.special))
+  (#any-of? @character.special "@" "*"))
+
+"``" @punctuation.special
+
+(variable_name) @variable
+
+((variable_name) @constant
+  (#lua-match? @constant "^[A-Z][A-Z_0-9]*$"))
+
+(case_item
+  value: (word) @variable.parameter)
+
+[
+  (regex)
+  (extglob_pattern)
+] @string.regexp
+
+((program
+  .
+  (comment) @keyword.directive @nospell)
+  (#lua-match? @keyword.directive "^#!/"))
diff --git a/pack/ant/start/nvim-treesitter/queries/bash/injections.scm b/pack/ant/start/nvim-treesitter/queries/bash/injections.scm
new file mode 100644
index 0000000..3286308
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bash/injections.scm
@@ -0,0 +1,79 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((regex) @injection.content
+  (#set! injection.language "regex"))
+
+((heredoc_redirect
+  (heredoc_body) @injection.content
+  (heredoc_end) @injection.language)
+  (#downcase! @injection.language))
+
+; printf 'format'
+((command
+  name: (command_name) @_command
+  .
+  argument: [
+    (string
+      (string_content) @injection.content)
+    (concatenation
+      (string
+        (string_content) @injection.content))
+    (raw_string) @injection.content
+    (concatenation
+      (raw_string) @injection.content)
+  ])
+  (#eq? @_command "printf")
+  (#set! injection.language "printf"))
+
+; printf -v var 'format'
+((command
+  name: (command_name) @_command
+  argument: (word) @_arg
+  .
+  (_)
+  .
+  argument: [
+    (string
+      (string_content) @injection.content)
+    (concatenation
+      (string
+        (string_content) @injection.content))
+    (raw_string) @injection.content
+    (concatenation
+      (raw_string) @injection.content)
+  ])
+  (#eq? @_command "printf")
+  (#eq? @_arg "-v")
+  (#set! injection.language "printf"))
+
+; printf -- 'format'
+((command
+  name: (command_name) @_command
+  argument: (word) @_arg
+  .
+  argument: [
+    (string
+      (string_content) @injection.content)
+    (concatenation
+      (string
+        (string_content) @injection.content))
+    (raw_string) @injection.content
+    (concatenation
+      (raw_string) @injection.content)
+  ])
+  (#eq? @_command "printf")
+  (#eq? @_arg "--")
+  (#set! injection.language "printf"))
+
+((command
+  name: (command_name) @_command
+  .
+  argument: [
+    (string)
+    (raw_string)
+  ] @injection.content)
+  (#eq? @_command "bind")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.include-children)
+  (#set! injection.language "readline"))
diff --git a/pack/ant/start/nvim-treesitter/queries/bash/locals.scm b/pack/ant/start/nvim-treesitter/queries/bash/locals.scm
new file mode 100644
index 0000000..347f51f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bash/locals.scm
@@ -0,0 +1,14 @@
+; Scopes
+(function_definition) @local.scope
+
+; Definitions
+(variable_assignment
+  name: (variable_name) @local.definition.var)
+
+(function_definition
+  name: (word) @local.definition.function)
+
+; References
+(variable_name) @local.reference
+
+(word) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/bass/folds.scm b/pack/ant/start/nvim-treesitter/queries/bass/folds.scm
new file mode 100644
index 0000000..d99e0c1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bass/folds.scm
@@ -0,0 +1,5 @@
+[
+  (list)
+  (scope)
+  (cons)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/bass/highlights.scm b/pack/ant/start/nvim-treesitter/queries/bass/highlights.scm
new file mode 100644
index 0000000..f84993a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bass/highlights.scm
@@ -0,0 +1,126 @@
+; 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) @module
+  .
+  (keyword))
+
+; Includes
+((symbol) @keyword.import
+  (#any-of? @keyword.import "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)? @variable.parameter)
+  (#any-of? @keyword.function "def" "defop" "defn" "fn"))
+
+((cons
+  .
+  (symbol) @keyword.function
+  .
+  (symbol) @function
+  (symbol)? @variable.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) @keyword.conditional
+  (#any-of? @keyword.conditional "if" "case" "cond" "when"))
+
+; Repeats
+((symbol) @keyword.repeat
+  (#any-of? @keyword.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) @string.special.url
+
+(number) @number
+
+(boolean) @boolean
+
+[
+  (ignore)
+  (null)
+] @constant.builtin
+
+"^" @character.special
+
+; Comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/bass/indents.scm b/pack/ant/start/nvim-treesitter/queries/bass/indents.scm
new file mode 100644
index 0000000..27b976f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bass/indents.scm
@@ -0,0 +1,31 @@
+[
+  (list)
+  (scope)
+  (cons)
+] @indent.begin
+
+[
+  ")"
+  "}"
+  "]"
+] @indent.end
+
+[
+  "("
+  ")"
+] @indent.branch
+
+[
+  "{"
+  "}"
+] @indent.branch
+
+[
+  "["
+  "]"
+] @indent.branch
+
+[
+  (ERROR)
+  (comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/bass/injections.scm b/pack/ant/start/nvim-treesitter/queries/bass/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bass/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/bass/locals.scm b/pack/ant/start/nvim-treesitter/queries/bass/locals.scm
new file mode 100644
index 0000000..daed7e5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bass/locals.scm
@@ -0,0 +1,26 @@
+; Scopes
+[
+  (list)
+  (scope)
+  (cons)
+] @local.scope
+
+; References
+(symbol) @local.reference
+
+; Definitions
+((list
+  .
+  (symbol) @_fnkw
+  .
+  (symbol) @local.definition.function
+  (symbol)? @local.definition.parameter)
+  (#any-of? @_fnkw "def" "defop" "defn" "fn"))
+
+((cons
+  .
+  (symbol) @_fnkw
+  .
+  (symbol) @local.definition.function
+  (symbol)? @local.definition.parameter)
+  (#any-of? @_fnkw "def" "defop" "defn" "fn"))
diff --git a/pack/ant/start/nvim-treesitter/queries/beancount/folds.scm b/pack/ant/start/nvim-treesitter/queries/beancount/folds.scm
new file mode 100644
index 0000000..9f1b6cb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/beancount/folds.scm
@@ -0,0 +1,4 @@
+[
+  (transaction)
+  (section)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/beancount/highlights.scm b/pack/ant/start/nvim-treesitter/queries/beancount/highlights.scm
new file mode 100644
index 0000000..1e23d28
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/beancount/highlights.scm
@@ -0,0 +1,57 @@
+(date) @variable.member
+
+(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
diff --git a/pack/ant/start/nvim-treesitter/queries/beancount/injections.scm b/pack/ant/start/nvim-treesitter/queries/beancount/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/beancount/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/bibtex/folds.scm b/pack/ant/start/nvim-treesitter/queries/bibtex/folds.scm
new file mode 100644
index 0000000..321a045
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bibtex/folds.scm
@@ -0,0 +1 @@
+(entry) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/bibtex/highlights.scm b/pack/ant/start/nvim-treesitter/queries/bibtex/highlights.scm
new file mode 100644
index 0000000..a82b371
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bibtex/highlights.scm
@@ -0,0 +1,50 @@
+; CREDITS @pfoerster (adapted from https://github.com/latex-lsp/tree-sitter-bibtex)
+[
+  (string_type)
+  (preamble_type)
+  (entry_type)
+] @keyword
+
+[
+  (junk)
+  (comment)
+] @comment
+
+(comment) @spell
+
+[
+  "="
+  "#"
+] @operator
+
+(command) @function.builtin
+
+(number) @number
+
+(field
+  name: (identifier) @variable.member)
+
+(token
+  (identifier) @variable.parameter)
+
+[
+  (brace_word)
+  (quote_word)
+] @string
+
+[
+  (key_brace)
+  (key_paren)
+] @string.special.symbol
+
+(string
+  name: (identifier) @constant)
+
+[
+  "{"
+  "}"
+  "("
+  ")"
+] @punctuation.bracket
+
+"," @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/bibtex/indents.scm b/pack/ant/start/nvim-treesitter/queries/bibtex/indents.scm
new file mode 100644
index 0000000..764172a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bibtex/indents.scm
@@ -0,0 +1,8 @@
+(entry) @indent.begin
+
+[
+  "{"
+  "}"
+] @indent.branch
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/bibtex/injections.scm b/pack/ant/start/nvim-treesitter/queries/bibtex/injections.scm
new file mode 100644
index 0000000..98ad387
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bibtex/injections.scm
@@ -0,0 +1,2 @@
+((junk) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/bicep/folds.scm b/pack/ant/start/nvim-treesitter/queries/bicep/folds.scm
new file mode 100644
index 0000000..217a86d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bicep/folds.scm
@@ -0,0 +1,19 @@
+[
+  (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
diff --git a/pack/ant/start/nvim-treesitter/queries/bicep/highlights.scm b/pack/ant/start/nvim-treesitter/queries/bicep/highlights.scm
new file mode 100644
index 0000000..35c9d6c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bicep/highlights.scm
@@ -0,0 +1,234 @@
+; Includes
+[
+  "import"
+  "provider"
+  "with"
+  "as"
+  "from"
+] @keyword.import
+
+; Namespaces
+(module_declaration
+  (identifier) @module)
+
+; Builtins
+(primitive_type) @type.builtin
+
+((member_expression
+  object: (identifier) @type.builtin)
+  (#eq? @type.builtin "sys"))
+
+; Functions
+(call_expression
+  function: (identifier) @function.call)
+
+(user_defined_function
+  name: (identifier) @function)
+
+; 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
+  (identifier) @type)
+
+(resource_declaration
+  (identifier) @type)
+
+(resource_expression
+  (identifier) @type)
+
+; Parameters
+(parameter_declaration
+  (identifier) @variable.parameter
+  (_))
+
+(call_expression
+  function: (_)
+  (arguments
+    (identifier) @variable.parameter))
+
+(call_expression
+  function: (_)
+  (arguments
+    (member_expression
+      object: (identifier) @variable.parameter)))
+
+(parameter
+  .
+  (identifier) @variable.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" @keyword.conditional
+
+(ternary_expression
+  "?" @keyword.conditional.ternary
+  ":" @keyword.conditional.ternary)
+
+; Loops
+(for_statement
+  "for" @keyword.repeat
+  "in"
+  ":" @punctuation.delimiter)
+
+; Keywords
+[
+  "module"
+  "metadata"
+  "output"
+  "param"
+  "resource"
+  "existing"
+  "targetScope"
+  "type"
+  "var"
+  "using"
+  "test"
+] @keyword
+
+"func" @keyword.function
+
+"assert" @keyword.exception
+
+; Operators
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "||"
+  "&&"
+  "|"
+  "=="
+  "!="
+  "=~"
+  "!~"
+  ">"
+  ">="
+  "<="
+  "<"
+  "??"
+  "="
+  "!"
+  ".?"
+] @operator
+
+(subscript_expression
+  "?" @operator)
+
+(nullable_type
+  "?" @operator)
+
+"in" @keyword.operator
+
+; Literals
+(string) @string
+
+(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
diff --git a/pack/ant/start/nvim-treesitter/queries/bicep/indents.scm b/pack/ant/start/nvim-treesitter/queries/bicep/indents.scm
new file mode 100644
index 0000000..055e51b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bicep/indents.scm
@@ -0,0 +1,27 @@
+[
+  (array)
+  (object)
+] @indent.begin
+
+"}" @indent.end
+
+[
+  "{"
+  "}"
+] @indent.branch
+
+[
+  "["
+  "]"
+] @indent.branch
+
+[
+  "("
+  ")"
+] @indent.branch
+
+[
+  (ERROR)
+  (comment)
+  (diagnostic_comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/bicep/injections.scm b/pack/ant/start/nvim-treesitter/queries/bicep/injections.scm
new file mode 100644
index 0000000..5c2d4a5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bicep/injections.scm
@@ -0,0 +1,5 @@
+([
+  (comment)
+  (diagnostic_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/bicep/locals.scm b/pack/ant/start/nvim-treesitter/queries/bicep/locals.scm
new file mode 100644
index 0000000..cc9c3c2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bicep/locals.scm
@@ -0,0 +1,73 @@
+; Scopes
+[
+  (infrastructure)
+  (call_expression)
+  (lambda_expression)
+  (subscript_expression)
+  (if_statement)
+  (for_statement)
+  (array)
+  (object)
+  (interpolation)
+] @local.scope
+
+; References
+(property_identifier) @local.reference
+
+(call_expression
+  (identifier) @local.reference)
+
+(object_property
+  (_)
+  ":"
+  (identifier) @local.reference)
+
+(resource_expression
+  (identifier) @local.reference)
+
+; Definitions
+(type) @local.definition.associated
+
+(object_property
+  (identifier) @local.definition.field
+  (_))
+
+(object_property
+  (compatible_identifier) @local.definition.field
+  (_))
+
+(user_defined_function
+  name: (identifier) @local.definition.function)
+
+(module_declaration
+  (identifier) @local.definition.namespace)
+
+(parameter_declaration
+  (identifier) @local.definition.parameter
+  (_))
+
+(parameter
+  .
+  (identifier) @local.definition.parameter)
+
+(type_declaration
+  (identifier) @local.definition.type
+  (_))
+
+(variable_declaration
+  (identifier) @local.definition.var
+  (_))
+
+(metadata_declaration
+  (identifier) @local.definition.var
+  (_))
+
+(output_declaration
+  (identifier) @local.definition.var
+  (_))
+
+(for_statement
+  "for"
+  (for_loop_parameters
+    (loop_variable) @local.definition.var
+    (loop_enumerator) @local.definition.var))
diff --git a/pack/ant/start/nvim-treesitter/queries/bitbake/folds.scm b/pack/ant/start/nvim-treesitter/queries/bitbake/folds.scm
new file mode 100644
index 0000000..85d2263
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bitbake/folds.scm
@@ -0,0 +1,24 @@
+[
+  (function_definition)
+  (anonymous_python_function)
+  (python_function_definition)
+  (while_statement)
+  (for_statement)
+  (if_statement)
+  (with_statement)
+  (try_statement)
+  (import_from_statement)
+  (parameters)
+  (argument_list)
+  (parenthesized_expression)
+  (generator_expression)
+  (list_comprehension)
+  (set_comprehension)
+  (dictionary_comprehension)
+  (tuple)
+  (list)
+  (set)
+  (dictionary)
+  (string)
+  (python_string)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/bitbake/highlights.scm b/pack/ant/start/nvim-treesitter/queries/bitbake/highlights.scm
new file mode 100644
index 0000000..c7316de
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bitbake/highlights.scm
@@ -0,0 +1,406 @@
+; Includes
+[
+  "inherit"
+  "include"
+  "require"
+  "export"
+  "import"
+] @keyword.import
+
+; Keywords
+[
+  "unset"
+  "EXPORT_FUNCTIONS"
+  "python"
+  "assert"
+  "exec"
+  "global"
+  "nonlocal"
+  "pass"
+  "print"
+  "with"
+  "as"
+] @keyword
+
+[
+  "async"
+  "await"
+] @keyword.coroutine
+
+[
+  "return"
+  "yield"
+] @keyword.return
+
+(yield
+  "from" @keyword.return)
+
+(future_import_statement
+  "from" @keyword.import
+  "__future__" @constant.builtin)
+
+(import_from_statement
+  "from" @keyword.import)
+
+"import" @keyword.import
+
+(aliased_import
+  "as" @keyword.import)
+
+[
+  "if"
+  "elif"
+  "else"
+] @keyword.conditional
+
+[
+  "for"
+  "while"
+  "break"
+  "continue"
+] @keyword.repeat
+
+[
+  "try"
+  "except"
+  "except*"
+  "raise"
+  "finally"
+] @keyword.exception
+
+(raise_statement
+  "from" @keyword.exception)
+
+(try_statement
+  (else_clause
+    "else" @keyword.exception))
+
+[
+  "addtask"
+  "deltask"
+  "addhandler"
+  "def"
+  "lambda"
+] @keyword.function
+
+[
+  "before"
+  "after"
+] @keyword.modifier
+
+[
+  "append"
+  "prepend"
+  "remove"
+] @keyword.modifier
+
+; Variables
+[
+  (identifier)
+  (python_identifier)
+] @variable
+
+[
+  "noexec"
+  "OVERRIDES"
+  "$BB_ENV_PASSTHROUGH"
+  "$BB_ENV_PASSTHROUGH_ADDITIONS"
+] @variable.builtin
+
+; Reset highlighting in f-string interpolations
+(interpolation) @none
+
+; Identifier naming conventions
+((python_identifier) @type
+  (#lua-match? @type "^[A-Z].*[a-z]"))
+
+([
+  (identifier)
+  (python_identifier)
+] @constant
+  (#lua-match? @constant "^[A-Z][A-Z_0-9]*$"))
+
+((python_identifier) @constant.builtin
+  (#lua-match? @constant.builtin "^__[a-zA-Z0-9_]*__$"))
+
+((python_identifier) @constant.builtin
+  (#any-of? @constant.builtin
+    ; https://docs.python.org/3/library/constants.html
+    "NotImplemented" "Ellipsis" "quit" "exit" "copyright" "credits" "license"))
+
+((assignment
+  left: (python_identifier) @type.definition
+  (type
+    (python_identifier) @_annotation))
+  (#eq? @_annotation "TypeAlias"))
+
+((assignment
+  left: (python_identifier) @type.definition
+  right: (call
+    function: (python_identifier) @_func))
+  (#any-of? @_func "TypeVar" "NewType"))
+
+; Fields
+(flag) @variable.member
+
+((attribute
+  attribute: (python_identifier) @variable.member)
+  (#lua-match? @variable.member "^[%l_].*$"))
+
+; Functions
+(call
+  function: (python_identifier) @function.call)
+
+(call
+  function: (attribute
+    attribute: (python_identifier) @function.method.call))
+
+((call
+  function: (python_identifier) @constructor)
+  (#lua-match? @constructor "^%u"))
+
+((call
+  function: (attribute
+    attribute: (python_identifier) @constructor))
+  (#lua-match? @constructor "^%u"))
+
+((call
+  function: (python_identifier) @function.builtin)
+  (#any-of? @function.builtin
+    "abs" "all" "any" "ascii" "bin" "bool" "breakpoint" "bytearray" "bytes" "callable" "chr"
+    "classmethod" "compile" "complex" "delattr" "dict" "dir" "divmod" "enumerate" "eval" "exec"
+    "filter" "float" "format" "frozenset" "getattr" "globals" "hasattr" "hash" "help" "hex" "id"
+    "input" "int" "isinstance" "issubclass" "iter" "len" "list" "locals" "map" "max" "memoryview"
+    "min" "next" "object" "oct" "open" "ord" "pow" "print" "property" "range" "repr" "reversed"
+    "round" "set" "setattr" "slice" "sorted" "staticmethod" "str" "sum" "super" "tuple" "type"
+    "vars" "zip" "__import__"))
+
+(python_function_definition
+  name: (python_identifier) @function)
+
+(type
+  (python_identifier) @type)
+
+(type
+  (subscript
+    (python_identifier) @type)) ; type subscript: Tuple[int]
+
+((call
+  function: (python_identifier) @_isinstance
+  arguments: (argument_list
+    (_)
+    (python_identifier) @type))
+  (#eq? @_isinstance "isinstance"))
+
+(anonymous_python_function
+  (identifier) @function)
+
+(function_definition
+  (identifier) @function)
+
+(addtask_statement
+  (identifier) @function)
+
+(deltask_statement
+  (identifier) @function)
+
+(export_functions_statement
+  (identifier) @function)
+
+(addhandler_statement
+  (identifier) @function)
+
+(python_function_definition
+  body: (block
+    .
+    (expression_statement
+      (python_string) @string.documentation @spell)))
+
+; Namespace
+(inherit_path) @module
+
+; Normal parameters
+(parameters
+  (python_identifier) @variable.parameter)
+
+; Lambda parameters
+(lambda_parameters
+  (python_identifier) @variable.parameter)
+
+(lambda_parameters
+  (tuple_pattern
+    (python_identifier) @variable.parameter))
+
+; Default parameters
+(keyword_argument
+  name: (python_identifier) @variable.parameter)
+
+; Naming parameters on call-site
+(default_parameter
+  name: (python_identifier) @variable.parameter)
+
+(typed_parameter
+  (python_identifier) @variable.parameter)
+
+(typed_default_parameter
+  (python_identifier) @variable.parameter)
+
+; Variadic parameters *args, **kwargs
+(parameters
+  (list_splat_pattern
+    ; *args
+    (python_identifier) @variable.parameter))
+
+(parameters
+  (dictionary_splat_pattern
+    ; **kwargs
+    (python_identifier) @variable.parameter))
+
+; Literals
+(none) @constant.builtin
+
+[
+  (true)
+  (false)
+] @boolean
+
+((python_identifier) @variable.builtin
+  (#any-of? @variable.builtin "self" "cls"))
+
+(integer) @number
+
+(float) @number.float
+
+; Operators
+[
+  "?="
+  "??="
+  ":="
+  "=+"
+  ".="
+  "=."
+  "-"
+  "-="
+  ":="
+  "!="
+  "*"
+  "**"
+  "**="
+  "*="
+  "/"
+  "//"
+  "//="
+  "/="
+  "&"
+  "&="
+  "%"
+  "%="
+  "^"
+  "^="
+  "+"
+  "+="
+  "<"
+  "<<"
+  "<<="
+  "<="
+  "<>"
+  "="
+  "=="
+  ">"
+  ">="
+  ">>"
+  ">>="
+  "@"
+  "@="
+  "|"
+  "|="
+  "~"
+  "->"
+] @operator
+
+[
+  "and"
+  "in"
+  "is"
+  "not"
+  "or"
+  "is not"
+  "not in"
+  "del"
+] @keyword.operator
+
+; Literals
+[
+  (string)
+  (python_string)
+  "\""
+] @string
+
+(include_path) @string.special.path
+
+[
+  (escape_sequence)
+  (escape_interpolation)
+] @string.escape
+
+; Punctuation
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ":"
+  "->"
+  ";"
+  "."
+  ","
+  (ellipsis)
+] @punctuation.delimiter
+
+(variable_expansion
+  [
+    "${"
+    "}"
+  ] @punctuation.special)
+
+(inline_python
+  [
+    "${@"
+    "}"
+  ] @punctuation.special)
+
+(interpolation
+  "{" @punctuation.special
+  "}" @punctuation.special)
+
+(type_conversion) @function.macro
+
+([
+  (identifier)
+  (python_identifier)
+] @type.builtin
+  (#any-of? @type.builtin
+    ; https://docs.python.org/3/library/exceptions.html
+    "BaseException" "Exception" "ArithmeticError" "BufferError" "LookupError" "AssertionError"
+    "AttributeError" "EOFError" "FloatingPointError" "GeneratorExit" "ImportError"
+    "ModuleNotFoundError" "IndexError" "KeyError" "KeyboardInterrupt" "MemoryError" "NameError"
+    "NotImplementedError" "OSError" "OverflowError" "RecursionError" "ReferenceError" "RuntimeError"
+    "StopIteration" "StopAsyncIteration" "SyntaxError" "IndentationError" "TabError" "SystemError"
+    "SystemExit" "TypeError" "UnboundLocalError" "UnicodeError" "UnicodeEncodeError"
+    "UnicodeDecodeError" "UnicodeTranslateError" "ValueError" "ZeroDivisionError" "EnvironmentError"
+    "IOError" "WindowsError" "BlockingIOError" "ChildProcessError" "ConnectionError"
+    "BrokenPipeError" "ConnectionAbortedError" "ConnectionRefusedError" "ConnectionResetError"
+    "FileExistsError" "FileNotFoundError" "InterruptedError" "IsADirectoryError"
+    "NotADirectoryError" "PermissionError" "ProcessLookupError" "TimeoutError" "Warning"
+    "UserWarning" "DeprecationWarning" "PendingDeprecationWarning" "SyntaxWarning" "RuntimeWarning"
+    "FutureWarning" "ImportWarning" "UnicodeWarning" "BytesWarning" "ResourceWarning"
+    ; https://docs.python.org/3/library/stdtypes.html
+    "bool" "int" "float" "complex" "list" "tuple" "range" "str" "bytes" "bytearray" "memoryview"
+    "set" "frozenset" "dict" "type" "object"))
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/bitbake/indents.scm b/pack/ant/start/nvim-treesitter/queries/bitbake/indents.scm
new file mode 100644
index 0000000..5f20818
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bitbake/indents.scm
@@ -0,0 +1,172 @@
+[
+  (import_from_statement)
+  (parenthesized_expression)
+  (generator_expression)
+  (list_comprehension)
+  (set_comprehension)
+  (dictionary_comprehension)
+  (tuple_pattern)
+  (list_pattern)
+  (binary_operator)
+  (lambda)
+  (concatenated_string)
+] @indent.begin
+
+((list) @indent.align
+  (#set! indent.open_delimiter "[")
+  (#set! indent.close_delimiter "]"))
+
+((dictionary) @indent.align
+  (#set! indent.open_delimiter "{")
+  (#set! indent.close_delimiter "}"))
+
+((set) @indent.align
+  (#set! indent.open_delimiter "{")
+  (#set! indent.close_delimiter "}"))
+
+((for_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+((if_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+((while_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+((try_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+(ERROR
+  "try"
+  ":" @indent.begin
+  (#set! indent.immediate 1))
+
+((python_function_definition) @indent.begin
+  (#set! indent.immediate 1))
+
+(function_definition) @indent.begin
+
+(anonymous_python_function) @indent.begin
+
+((with_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+(if_statement
+  condition: (parenthesized_expression) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")")
+  (#set! indent.avoid_last_matching_next 1))
+
+(while_statement
+  condition: (parenthesized_expression) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")")
+  (#set! indent.avoid_last_matching_next 1))
+
+(ERROR
+  "(" @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")")
+  .
+  (_))
+
+((argument_list) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+((parameters) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")")
+  (#set! indent.avoid_last_matching_next 1))
+
+((tuple) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+(ERROR
+  "[" @indent.align
+  (#set! indent.open_delimiter "[")
+  (#set! indent.close_delimiter "]")
+  .
+  (_))
+
+(ERROR
+  "{" @indent.align
+  (#set! indent.open_delimiter "{")
+  (#set! indent.close_delimiter "}")
+  .
+  (_))
+
+[
+  (break_statement)
+  (continue_statement)
+] @indent.dedent
+
+(ERROR
+  (_) @indent.branch
+  ":"
+  .
+  (#lua-match? @indent.branch "^else"))
+
+(ERROR
+  (_) @indent.branch @indent.dedent
+  ":"
+  .
+  (#lua-match? @indent.branch "^elif"))
+
+(parenthesized_expression
+  ")" @indent.end)
+
+(generator_expression
+  ")" @indent.end)
+
+(list_comprehension
+  "]" @indent.end)
+
+(set_comprehension
+  "}" @indent.end)
+
+(dictionary_comprehension
+  "}" @indent.end)
+
+(tuple_pattern
+  ")" @indent.end)
+
+(list_pattern
+  "]" @indent.end)
+
+(function_definition
+  "}" @indent.end)
+
+(anonymous_python_function
+  "}" @indent.end)
+
+(return_statement
+  [
+    (_) @indent.end
+    (_
+      [
+        (_)
+        ")"
+        "}"
+        "]"
+      ] @indent.end .)
+    (attribute
+      attribute: (_) @indent.end)
+    (call
+      arguments: (_
+        ")" @indent.end))
+    "return" @indent.end
+  ] .)
+
+[
+  ")"
+  "]"
+  "}"
+  (elif_clause)
+  (else_clause)
+  (except_clause)
+  (finally_clause)
+] @indent.branch
+
+(string) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/bitbake/injections.scm b/pack/ant/start/nvim-treesitter/queries/bitbake/injections.scm
new file mode 100644
index 0000000..35c984a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bitbake/injections.scm
@@ -0,0 +1,15 @@
+(call
+  function: (attribute
+    object: (python_identifier) @_re)
+  arguments: (argument_list
+    (python_string
+      (string_content) @injection.content) @_string)
+  (#eq? @_re "re")
+  (#lua-match? @_string "^r.*")
+  (#set! injection.language "regex"))
+
+((shell_content) @injection.content
+  (#set! injection.language "bash"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/bitbake/locals.scm b/pack/ant/start/nvim-treesitter/queries/bitbake/locals.scm
new file mode 100644
index 0000000..e4726ec
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bitbake/locals.scm
@@ -0,0 +1,117 @@
+; References
+[
+  (python_identifier)
+  (identifier)
+] @local.reference
+
+; Imports
+(aliased_import
+  alias: (python_identifier) @local.definition.import)
+
+(import_statement
+  name: (dotted_name
+    (python_identifier) @local.definition.import))
+
+(import_from_statement
+  name: (dotted_name
+    (python_identifier) @local.definition.import))
+
+; Function with parameters, defines parameters
+(parameters
+  (python_identifier) @local.definition.parameter)
+
+(default_parameter
+  (python_identifier) @local.definition.parameter)
+
+(typed_parameter
+  (python_identifier) @local.definition.parameter)
+
+(typed_default_parameter
+  (python_identifier) @local.definition.parameter)
+
+; *args parameter
+(parameters
+  (list_splat_pattern
+    (python_identifier) @local.definition.parameter))
+
+; **kwargs parameter
+(parameters
+  (dictionary_splat_pattern
+    (python_identifier) @local.definition.parameter))
+
+; Function defines function and scope
+((python_function_definition
+  name: (python_identifier) @local.definition.function) @local.scope
+  (#set! definition.function.scope "parent"))
+
+(function_definition
+  (identifier) @local.definition.function)
+
+(anonymous_python_function
+  (identifier) @local.definition.function)
+
+; Loops
+; not a scope!
+(for_statement
+  left: (pattern_list
+    (python_identifier) @local.definition.var))
+
+(for_statement
+  left: (tuple_pattern
+    (python_identifier) @local.definition.var))
+
+(for_statement
+  left: (python_identifier) @local.definition.var)
+
+; not a scope!
+;(while_statement) @local.scope
+; for in list comprehension
+(for_in_clause
+  left: (python_identifier) @local.definition.var)
+
+(for_in_clause
+  left: (tuple_pattern
+    (python_identifier) @local.definition.var))
+
+(for_in_clause
+  left: (pattern_list
+    (python_identifier) @local.definition.var))
+
+(dictionary_comprehension) @local.scope
+
+(list_comprehension) @local.scope
+
+(set_comprehension) @local.scope
+
+; Assignments
+(assignment
+  left: (python_identifier) @local.definition.var)
+
+(assignment
+  left: (pattern_list
+    (python_identifier) @local.definition.var))
+
+(assignment
+  left: (tuple_pattern
+    (python_identifier) @local.definition.var))
+
+(assignment
+  left: (attribute
+    (python_identifier)
+    (python_identifier) @local.definition.field))
+
+(variable_assignment
+  (identifier)
+  operator: [
+    "="
+    "?="
+    "??="
+    ":="
+  ] @local.definition.var)
+
+; Walrus operator  x := 1
+(named_expression
+  (python_identifier) @local.definition.var)
+
+(as_pattern
+  alias: (as_pattern_target) @local.definition.var)
diff --git a/pack/ant/start/nvim-treesitter/queries/blueprint/highlights.scm b/pack/ant/start/nvim-treesitter/queries/blueprint/highlights.scm
new file mode 100644
index 0000000..f3c39f2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/blueprint/highlights.scm
@@ -0,0 +1,75 @@
+(object_id) @variable
+
+(string) @string
+
+(escape_sequence) @string.escape
+
+(comment) @comment @spell
+
+(constant) @constant.builtin
+
+(boolean) @boolean
+
+(using) @keyword.import
+
+(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)
+
+(import_statement
+  (gobject_library) @module)
+
+(import_statement
+  (version_number) @number.float)
+
+(float) @number.float
+
+(number) @number
+
+[
+  ";"
+  "."
+  ","
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/blueprint/injections.scm b/pack/ant/start/nvim-treesitter/queries/blueprint/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/blueprint/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/bp/folds.scm b/pack/ant/start/nvim-treesitter/queries/bp/folds.scm
new file mode 100644
index 0000000..c40ea3d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bp/folds.scm
@@ -0,0 +1,6 @@
+[
+  (list_expression)
+  (map_expression)
+  (module)
+  (select_expression)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/bp/highlights.scm b/pack/ant/start/nvim-treesitter/queries/bp/highlights.scm
new file mode 100644
index 0000000..5f94f4c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bp/highlights.scm
@@ -0,0 +1,56 @@
+(comment) @comment @spell
+
+(operator) @operator
+
+(integer_literal
+  "-" @operator)
+
+[
+  ","
+  ":"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+(boolean_literal) @boolean
+
+(integer_literal) @number
+
+[
+  (raw_string_literal)
+  (interpreted_string_literal)
+] @string
+
+(escape_sequence) @string.escape
+
+(identifier) @variable
+
+(module
+  type: (identifier) @function.call)
+
+(module
+  (property
+    field: (identifier) @variable.parameter))
+
+[
+  (unset)
+  (default)
+  (any)
+] @variable.builtin
+
+(condition
+  name: (identifier) @function.builtin)
+
+(map_expression
+  (property
+    field: (identifier) @property))
+
+(select_expression
+  "select" @keyword.conditional)
diff --git a/pack/ant/start/nvim-treesitter/queries/bp/indents.scm b/pack/ant/start/nvim-treesitter/queries/bp/indents.scm
new file mode 100644
index 0000000..8cf8adc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bp/indents.scm
@@ -0,0 +1,38 @@
+(list_expression) @indent.begin
+
+(list_expression
+  "]" @indent.branch)
+
+(map_expression) @indent.begin
+
+(map_expression
+  "}" @indent.branch)
+
+(select_expression) @indent.begin
+
+(select_expression
+  ")" @indent.branch)
+
+(select_value) @indent.begin
+
+(select_value
+  ")" @indent.branch)
+
+(select_pattern
+  "(" @indent.begin)
+
+(select_pattern
+  ")" @indent.branch)
+
+(select_cases) @indent.begin
+
+(select_cases
+  "}" @indent.branch)
+
+(module) @indent.begin
+
+(module
+  ")" @indent.branch)
+
+(module
+  "}" @indent.branch)
diff --git a/pack/ant/start/nvim-treesitter/queries/bp/injections.scm b/pack/ant/start/nvim-treesitter/queries/bp/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bp/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/bp/locals.scm b/pack/ant/start/nvim-treesitter/queries/bp/locals.scm
new file mode 100644
index 0000000..c8a5a17
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/bp/locals.scm
@@ -0,0 +1,15 @@
+(module
+  (property
+    field: (identifier) @local.definition.parameter))
+
+(map_expression
+  (property
+    field: (identifier) @local.definition.field))
+
+(assignment
+  left: (identifier) @local.definition.var)
+
+(pattern_binding
+  binding: (identifier) @local.definition.var)
+
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/c/folds.scm b/pack/ant/start/nvim-treesitter/queries/c/folds.scm
new file mode 100644
index 0000000..bb26a62
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/c/folds.scm
@@ -0,0 +1,23 @@
+[
+  (for_statement)
+  (if_statement)
+  (while_statement)
+  (do_statement)
+  (switch_statement)
+  (case_statement)
+  (function_definition)
+  (struct_specifier)
+  (enum_specifier)
+  (comment)
+  (preproc_if)
+  (preproc_elif)
+  (preproc_else)
+  (preproc_ifdef)
+  (preproc_function_def)
+  (initializer_list)
+  (gnu_asm_expression)
+  (preproc_include)+
+] @fold
+
+(compound_statement
+  (compound_statement) @fold)
diff --git a/pack/ant/start/nvim-treesitter/queries/c/highlights.scm b/pack/ant/start/nvim-treesitter/queries/c/highlights.scm
new file mode 100644
index 0000000..bd6857f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/c/highlights.scm
@@ -0,0 +1,341 @@
+; Lower priority to prefer @variable.parameter when identifier appears in parameter_declaration.
+((identifier) @variable
+  (#set! priority 95))
+
+(preproc_def
+  (preproc_arg) @variable)
+
+[
+  "default"
+  "goto"
+  "asm"
+  "__asm__"
+] @keyword
+
+[
+  "enum"
+  "struct"
+  "union"
+  "typedef"
+] @keyword.type
+
+[
+  "sizeof"
+  "offsetof"
+] @keyword.operator
+
+(alignof_expression
+  .
+  _ @keyword.operator)
+
+"return" @keyword.return
+
+[
+  "while"
+  "for"
+  "do"
+  "continue"
+  "break"
+] @keyword.repeat
+
+[
+  "if"
+  "else"
+  "case"
+  "switch"
+] @keyword.conditional
+
+[
+  "#if"
+  "#ifdef"
+  "#ifndef"
+  "#else"
+  "#elif"
+  "#endif"
+  "#elifdef"
+  "#elifndef"
+  (preproc_directive)
+] @keyword.directive
+
+"#define" @keyword.directive.define
+
+"#include" @keyword.import
+
+[
+  ";"
+  ":"
+  ","
+  "::"
+] @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
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+(string_literal) @string
+
+(system_lib_string) @string
+
+(escape_sequence) @string.escape
+
+(null) @constant.builtin
+
+(number_literal) @number
+
+(char_literal) @character
+
+(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
+
+(declaration
+  type: (type_identifier) @_type
+  declarator: (identifier) @label
+  (#eq? @_type "__label__"))
+
+[
+  (type_identifier)
+  (type_descriptor)
+] @type
+
+(storage_class_specifier) @keyword.modifier
+
+[
+  (type_qualifier)
+  (gnu_asm_qualifier)
+  "__extension__"
+] @keyword.modifier
+
+(linkage_specification
+  "extern" @keyword.modifier)
+
+(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
+  ; format-ignore
+  (#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
+  ; format-ignore
+  (#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.macro)
+
+(preproc_call
+  directive: (preproc_directive) @_u
+  argument: (_) @constant.macro
+  (#eq? @_u "#undef"))
+
+(preproc_ifdef
+  name: (identifier) @constant.macro)
+
+(preproc_elifdef
+  name: (identifier) @constant.macro)
+
+(preproc_defined
+  (identifier) @constant.macro)
+
+(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) @variable.parameter)
+
+(parameter_declaration
+  declarator: (array_declarator) @variable.parameter)
+
+(parameter_declaration
+  declarator: (pointer_declarator) @variable.parameter)
+
+; K&R functions
+; To enable support for K&R functions,
+; add the following lines to your own query config and uncomment them.
+; They are commented out as they'll conflict with C++
+; Note that you'll need to have `; extends` at the top of your query file.
+;
+; (parameter_list (identifier) @variable.parameter)
+;
+; (function_definition
+;   declarator: _
+;   (declaration
+;     declarator: (identifier) @variable.parameter))
+;
+; (function_definition
+;   declarator: _
+;   (declaration
+;     declarator: (array_declarator) @variable.parameter))
+;
+; (function_definition
+;   declarator: _
+;   (declaration
+;     declarator: (pointer_declarator) @variable.parameter))
+(preproc_params
+  (identifier) @variable.parameter)
+
+[
+  "__attribute__"
+  "__declspec"
+  "__based"
+  "__cdecl"
+  "__clrcall"
+  "__stdcall"
+  "__fastcall"
+  "__thiscall"
+  "__vectorcall"
+  (ms_pointer_modifier)
+  (attribute_declaration)
+] @attribute
diff --git a/pack/ant/start/nvim-treesitter/queries/c/indents.scm b/pack/ant/start/nvim-treesitter/queries/c/indents.scm
new file mode 100644
index 0000000..1932ce8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/c/indents.scm
@@ -0,0 +1,99 @@
+[
+  (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-kind-eq? @_body "compound_statement"))
+
+(while_statement
+  condition: (_) @indent.begin)
+
+((while_statement
+  body: (_) @_body) @indent.begin
+  (#not-kind-eq? @_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-kind-eq? @_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
diff --git a/pack/ant/start/nvim-treesitter/queries/c/injections.scm b/pack/ant/start/nvim-treesitter/queries/c/injections.scm
new file mode 100644
index 0000000..77b4d7a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/c/injections.scm
@@ -0,0 +1,128 @@
+((preproc_arg) @injection.content
+  (#set! injection.language "c"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((comment) @injection.content
+  (#match? @injection.content "/\\*!([a-zA-Z]+:)?re2c")
+  (#set! injection.language "re2c"))
+
+((comment) @injection.content
+  (#lua-match? @injection.content "/[*\/][!*\/]<?[^a-zA-Z]")
+  (#set! injection.language "doxygen"))
+
+((call_expression
+  function: (identifier) @_function
+  arguments: (argument_list
+    .
+    [
+      (string_literal
+        (string_content) @injection.content)
+      (concatenated_string
+        (string_literal
+          (string_content) @injection.content))
+    ]))
+  ; format-ignore
+  (#any-of? @_function 
+    "printf" "printf_s"
+    "vprintf" "vprintf_s"
+    "scanf" "scanf_s"
+    "vscanf" "vscanf_s"
+    "wprintf" "wprintf_s"
+    "vwprintf" "vwprintf_s"
+    "wscanf" "wscanf_s"
+    "vwscanf" "vwscanf_s"
+    "cscanf" "_cscanf"
+    "printw"
+    "scanw")
+  (#set! injection.language "printf"))
+
+((call_expression
+  function: (identifier) @_function
+  arguments: (argument_list
+    (_)
+    .
+    [
+      (string_literal
+        (string_content) @injection.content)
+      (concatenated_string
+        (string_literal
+          (string_content) @injection.content))
+    ]))
+  ; format-ignore
+  (#any-of? @_function 
+    "fprintf" "fprintf_s"
+    "sprintf"
+    "dprintf"
+    "fscanf" "fscanf_s"
+    "sscanf" "sscanf_s"
+    "vsscanf" "vsscanf_s"
+    "vfprintf" "vfprintf_s"
+    "vsprintf"
+    "vdprintf"
+    "fwprintf" "fwprintf_s"
+    "vfwprintf" "vfwprintf_s"
+    "fwscanf" "fwscanf_s"
+    "swscanf" "swscanf_s"
+    "vswscanf" "vswscanf_s"
+    "vfscanf" "vfscanf_s"
+    "vfwscanf" "vfwscanf_s"
+    "wprintw"
+    "vw_printw" "vwprintw"
+    "wscanw"
+    "vw_scanw" "vwscanw")
+  (#set! injection.language "printf"))
+
+((call_expression
+  function: (identifier) @_function
+  arguments: (argument_list
+    (_)
+    .
+    (_)
+    .
+    [
+      (string_literal
+        (string_content) @injection.content)
+      (concatenated_string
+        (string_literal
+          (string_content) @injection.content))
+    ]))
+  ; format-ignore
+  (#any-of? @_function 
+    "sprintf_s"
+    "snprintf" "snprintf_s"
+    "vsprintf_s"
+    "vsnprintf" "vsnprintf_s"
+    "swprintf" "swprintf_s"
+    "snwprintf_s"
+    "vswprintf" "vswprintf_s"
+    "vsnwprintf_s"
+    "mvprintw"
+    "mvscanw")
+  (#set! injection.language "printf"))
+
+((call_expression
+  function: (identifier) @_function
+  arguments: (argument_list
+    (_)
+    .
+    (_)
+    .
+    (_)
+    .
+    [
+      (string_literal
+        (string_content) @injection.content)
+      (concatenated_string
+        (string_literal
+          (string_content) @injection.content))
+    ]))
+  (#any-of? @_function "mvwprintw" "mvwscanw")
+  (#set! injection.language "printf"))
+
+; TODO: add when asm is added
+; (gnu_asm_expression assembly_code: (string_literal) @injection.content
+; (#set! injection.language "asm"))
+; (gnu_asm_expression assembly_code: (concatenated_string (string_literal) @injection.content)
+; (#set! injection.language "asm"))
diff --git a/pack/ant/start/nvim-treesitter/queries/c/locals.scm b/pack/ant/start/nvim-treesitter/queries/c/locals.scm
new file mode 100644
index 0000000..13a1227
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/c/locals.scm
@@ -0,0 +1,67 @@
+; Functions definitions
+(function_declarator
+  declarator: (identifier) @local.definition.function)
+
+(preproc_function_def
+  name: (identifier) @local.definition.macro) @local.scope
+
+(preproc_def
+  name: (identifier) @local.definition.macro)
+
+(pointer_declarator
+  declarator: (identifier) @local.definition.var)
+
+(parameter_declaration
+  declarator: (identifier) @local.definition.parameter)
+
+(init_declarator
+  declarator: (identifier) @local.definition.var)
+
+(array_declarator
+  declarator: (identifier) @local.definition.var)
+
+(declaration
+  declarator: (identifier) @local.definition.var)
+
+(enum_specifier
+  name: (_) @local.definition.type
+  (enumerator_list
+    (enumerator
+      name: (identifier) @local.definition.var)))
+
+; Type / Struct / Enum
+(field_declaration
+  declarator: (field_identifier) @local.definition.field)
+
+(type_definition
+  declarator: (type_identifier) @local.definition.type)
+
+(struct_specifier
+  name: (type_identifier) @local.definition.type)
+
+; goto
+(labeled_statement
+  (statement_identifier) @local.definition)
+
+; References
+(identifier) @local.reference
+
+((field_identifier) @local.reference
+  (#set! reference.kind "field"))
+
+((type_identifier) @local.reference
+  (#set! reference.kind "type"))
+
+(goto_statement
+  (statement_identifier) @local.reference)
+
+; Scope
+[
+  (for_statement)
+  (if_statement)
+  (while_statement)
+  (translation_unit)
+  (function_definition)
+  (compound_statement) ; a block in curly braces
+  (struct_specifier)
+] @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/c_sharp/folds.scm b/pack/ant/start/nvim-treesitter/queries/c_sharp/folds.scm
new file mode 100644
index 0000000..16967b6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/c_sharp/folds.scm
@@ -0,0 +1,17 @@
+body: [
+  (declaration_list)
+  (switch_body)
+  (enum_member_declaration_list)
+] @fold
+
+accessors: (accessor_list) @fold
+
+initializer: (initializer_expression) @fold
+
+[
+  (block)
+  (preproc_if)
+  (preproc_elif)
+  (preproc_else)
+  (using_directive)+
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/c_sharp/highlights.scm b/pack/ant/start/nvim-treesitter/queries/c_sharp/highlights.scm
new file mode 100644
index 0000000..f23d7ec
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/c_sharp/highlights.scm
@@ -0,0 +1,577 @@
+[
+  (identifier)
+  (preproc_arg)
+] @variable
+
+((preproc_arg) @constant.macro
+  (#lua-match? @constant.macro "^[_A-Z][_A-Z0-9]*$"))
+
+((identifier) @keyword
+  (#eq? @keyword "value")
+  (#has-ancestor? @keyword accessor_declaration))
+
+(method_declaration
+  name: (identifier) @function.method)
+
+(local_function_statement
+  name: (identifier) @function.method)
+
+(method_declaration
+  returns: [
+    (identifier) @type
+    (generic_name
+      (identifier) @type)
+  ])
+
+(event_declaration
+  type: (identifier) @type)
+
+(event_declaration
+  name: (identifier) @variable.member)
+
+(event_field_declaration
+  (variable_declaration
+    (variable_declarator
+      name: (identifier) @variable.member)))
+
+(declaration_pattern
+  type: (identifier) @type)
+
+(local_function_statement
+  type: (identifier) @type)
+
+(interpolation) @none
+
+(member_access_expression
+  name: (identifier) @variable.member)
+
+(invocation_expression
+  (member_access_expression
+    name: (identifier) @function.method.call))
+
+(invocation_expression
+  function: (conditional_access_expression
+    (member_binding_expression
+      name: (identifier) @function.method.call)))
+
+(namespace_declaration
+  name: [
+    (qualified_name)
+    (identifier)
+  ] @module)
+
+(qualified_name
+  (identifier) @type)
+
+(namespace_declaration
+  name: (identifier) @module)
+
+(file_scoped_namespace_declaration
+  name: (identifier) @module)
+
+(qualified_name
+  (identifier) @module
+  (#not-has-ancestor? @module method_declaration)
+  (#not-has-ancestor? @module record_declaration)
+  (#has-ancestor? @module namespace_declaration file_scoped_namespace_declaration))
+
+(invocation_expression
+  (identifier) @function.method.call)
+
+(field_declaration
+  (variable_declaration
+    (variable_declarator
+      (identifier) @variable.member)))
+
+(initializer_expression
+  (assignment_expression
+    left: (identifier) @variable.member))
+
+(parameter
+  name: (identifier) @variable.parameter)
+
+(parameter_list
+  name: (identifier) @variable.parameter)
+
+(bracketed_parameter_list
+  name: (identifier) @variable.parameter)
+
+(implicit_parameter) @variable.parameter
+
+(parameter_list
+  (parameter
+    type: (identifier) @type))
+
+(integer_literal) @number
+
+(real_literal) @number.float
+
+(null_literal) @constant.builtin
+
+(calling_convention
+  [
+    (identifier)
+    "Cdecl"
+    "Stdcall"
+    "Thiscall"
+    "Fastcall"
+  ] @attribute.builtin)
+
+(character_literal) @character
+
+[
+  (string_literal)
+  (raw_string_literal)
+  (verbatim_string_literal)
+  (interpolated_string_expression)
+] @string
+
+(escape_sequence) @string.escape
+
+[
+  "true"
+  "false"
+] @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
+  (type) @type.definition)
+
+(property_declaration
+  name: (identifier) @property)
+
+(property_declaration
+  type: (identifier) @type)
+
+(nullable_type
+  type: (identifier) @type)
+
+(array_type
+  type: (identifier) @type)
+
+(ref_type
+  type: (identifier) @type)
+
+(pointer_type
+  type: (identifier) @type)
+
+(catch_declaration
+  type: (identifier) @type)
+
+(interface_declaration
+  name: (identifier) @type)
+
+(class_declaration
+  name: (identifier) @type)
+
+(record_declaration
+  name: (identifier) @type)
+
+(struct_declaration
+  name: (identifier) @type)
+
+(enum_declaration
+  name: (identifier) @type)
+
+(enum_member_declaration
+  name: (identifier) @variable.member)
+
+(operator_declaration
+  type: (identifier) @type)
+
+(conversion_operator_declaration
+  type: (identifier) @type)
+
+(explicit_interface_specifier
+  [
+    (identifier) @type
+    (generic_name
+      (identifier) @type)
+  ])
+
+(explicit_interface_specifier
+  (identifier) @type)
+
+(primary_constructor_base_type
+  type: (identifier) @type)
+
+[
+  "assembly"
+  "module"
+  "this"
+  "base"
+] @variable.builtin
+
+(constructor_declaration
+  name: (identifier) @constructor)
+
+(destructor_declaration
+  name: (identifier) @constructor)
+
+(constructor_initializer
+  "base" @constructor)
+
+(variable_declaration
+  (identifier) @type)
+
+(object_creation_expression
+  (identifier) @type)
+
+; Generic Types.
+(typeof_expression
+  (generic_name
+    (identifier) @type))
+
+(type_argument_list
+  (generic_name
+    (identifier) @type))
+
+(base_list
+  (generic_name
+    (identifier) @type))
+
+(type_parameter_constraint
+  [
+    (identifier) @type
+    (type
+      (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) @function.method.call))
+
+(invocation_expression
+  (member_access_expression
+    (generic_name
+      (identifier) @function.method)))
+
+(base_list
+  (identifier) @type)
+
+(type_argument_list
+  (identifier) @type)
+
+(type_parameter_list
+  (type_parameter) @type)
+
+(type_parameter
+  name: (identifier) @type)
+
+(type_parameter_constraints_clause
+  "where"
+  .
+  (identifier) @type)
+
+(attribute
+  name: (identifier) @attribute)
+
+(foreach_statement
+  type: (identifier) @type)
+
+(goto_statement
+  (identifier) @label)
+
+(labeled_statement
+  (identifier) @label)
+
+(tuple_element
+  type: (identifier) @type)
+
+(tuple_expression
+  (argument
+    (declaration_expression
+      type: (identifier) @type)))
+
+(cast_expression
+  type: (identifier) @type)
+
+(lambda_expression
+  type: (identifier) @type)
+
+(as_expression
+  right: (identifier) @type)
+
+(typeof_expression
+  (identifier) @type)
+
+(preproc_error) @keyword.exception
+
+[
+  "#define"
+  "#undef"
+] @keyword.directive.define
+
+[
+  "#if"
+  "#elif"
+  "#else"
+  "#endif"
+  "#region"
+  "#endregion"
+  "#line"
+  "#pragma"
+  "#nullable"
+  "#error"
+  (shebang_directive)
+] @keyword.directive
+
+[
+  (preproc_line)
+  (preproc_pragma)
+  (preproc_nullable)
+] @constant.macro
+
+(preproc_pragma
+  (identifier) @constant)
+
+(preproc_if
+  (identifier) @constant)
+
+[
+  "if"
+  "else"
+  "switch"
+  "break"
+  "case"
+  "when"
+] @keyword.conditional
+
+[
+  "while"
+  "for"
+  "do"
+  "continue"
+  "goto"
+  "foreach"
+] @keyword.repeat
+
+[
+  "try"
+  "catch"
+  "throw"
+  "finally"
+] @keyword.exception
+
+[
+  "+"
+  "?"
+  ":"
+  "++"
+  "-"
+  "--"
+  "&"
+  "&&"
+  "|"
+  "||"
+  "!"
+  "!="
+  "=="
+  "*"
+  "/"
+  "%"
+  "<"
+  "<="
+  ">"
+  ">="
+  "="
+  "-="
+  "+="
+  "*="
+  "/="
+  "%="
+  "^"
+  "^="
+  "&="
+  "|="
+  "~"
+  ">>"
+  ">>>"
+  "<<"
+  "<<="
+  ">>="
+  ">>>="
+  "=>"
+  "??"
+  "??="
+  ".."
+] @operator
+
+(list_pattern
+  ".." @character.special)
+
+(discard) @character.special
+
+[
+  ";"
+  "."
+  ","
+  ":"
+] @punctuation.delimiter
+
+(conditional_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+[
+  "["
+  "]"
+  "{"
+  "}"
+  "("
+  ")"
+] @punctuation.bracket
+
+(interpolation_brace) @punctuation.special
+
+(type_argument_list
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+[
+  "using"
+  "as"
+] @keyword.import
+
+(alias_qualified_name
+  (identifier
+    "global") @keyword.import)
+
+[
+  "with"
+  "new"
+  "typeof"
+  "sizeof"
+  "is"
+  "and"
+  "or"
+  "not"
+  "stackalloc"
+  "__makeref"
+  "__reftype"
+  "__refvalue"
+  "in"
+  "out"
+  "ref"
+] @keyword.operator
+
+[
+  "lock"
+  "params"
+  "operator"
+  "default"
+  "implicit"
+  "explicit"
+  "override"
+  "get"
+  "set"
+  "init"
+  "where"
+  "add"
+  "remove"
+  "checked"
+  "unchecked"
+  "fixed"
+  "alias"
+  "file"
+  "unsafe"
+] @keyword
+
+(attribute_target_specifier
+  .
+  _ @keyword)
+
+[
+  "enum"
+  "record"
+  "class"
+  "struct"
+  "interface"
+  "namespace"
+  "event"
+  "delegate"
+] @keyword.type
+
+[
+  "async"
+  "await"
+] @keyword.coroutine
+
+[
+  "const"
+  "extern"
+  "readonly"
+  "static"
+  "volatile"
+  "required"
+  "managed"
+  "unmanaged"
+  "notnull"
+  "abstract"
+  "private"
+  "protected"
+  "internal"
+  "public"
+  "partial"
+  "sealed"
+  "virtual"
+  "global"
+] @keyword.modifier
+
+(scoped_type
+  "scoped" @keyword.modifier)
+
+(query_expression
+  (_
+    [
+      "from"
+      "orderby"
+      "select"
+      "group"
+      "by"
+      "ascending"
+      "descending"
+      "equals"
+      "let"
+    ] @keyword))
+
+[
+  "return"
+  "yield"
+] @keyword.return
diff --git a/pack/ant/start/nvim-treesitter/queries/c_sharp/injections.scm b/pack/ant/start/nvim-treesitter/queries/c_sharp/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/c_sharp/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/c_sharp/locals.scm b/pack/ant/start/nvim-treesitter/queries/c_sharp/locals.scm
new file mode 100644
index 0000000..bef0940
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/c_sharp/locals.scm
@@ -0,0 +1,42 @@
+; Definitions
+(variable_declarator
+  .
+  (identifier) @local.definition.var)
+
+(variable_declarator
+  (tuple_pattern
+    (identifier) @local.definition.var))
+
+(declaration_expression
+  name: (identifier) @local.definition.var)
+
+(foreach_statement
+  left: (identifier) @local.definition.var)
+
+(foreach_statement
+  left: (tuple_pattern
+    (identifier) @local.definition.var))
+
+(parameter
+  (identifier) @local.definition.parameter)
+
+(method_declaration
+  name: (identifier) @local.definition.method)
+
+(local_function_statement
+  name: (identifier) @local.definition.method)
+
+(property_declaration
+  name: (identifier) @local.definition)
+
+(type_parameter
+  (identifier) @local.definition.type)
+
+(class_declaration
+  name: (identifier) @local.definition)
+
+; References
+(identifier) @local.reference
+
+; Scope
+(block) @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/cairo/folds.scm b/pack/ant/start/nvim-treesitter/queries/cairo/folds.scm
new file mode 100644
index 0000000..9937da6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cairo/folds.scm
@@ -0,0 +1,26 @@
+[
+  (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
diff --git a/pack/ant/start/nvim-treesitter/queries/cairo/highlights.scm b/pack/ant/start/nvim-treesitter/queries/cairo/highlights.scm
new file mode 100644
index 0000000..1ea6245
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cairo/highlights.scm
@@ -0,0 +1,414 @@
+; Preproc
+[
+  "%builtins"
+  "%lang"
+] @keyword.directive
+
+; Includes
+(import_statement
+  [
+    "from"
+    "import"
+  ] @keyword.import
+  module_name: (dotted_name
+    (identifier) @module .))
+
+[
+  "as"
+  "use"
+  "mod"
+] @keyword.import
+
+; Variables
+(identifier) @variable
+
+; Namespaces
+(namespace_definition
+  (identifier) @module)
+
+(mod_item
+  name: (identifier) @module)
+
+(use_list
+  (self) @module)
+
+(scoped_use_list
+  (self) @module)
+
+(scoped_identifier
+  path: (identifier) @module)
+
+(scoped_identifier
+  (scoped_identifier
+    name: (identifier) @module))
+
+(scoped_type_identifier
+  path: (identifier) @module)
+
+((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) @module)
+
+(scoped_use_list
+  path: (scoped_identifier
+    (identifier) @module))
+
+(use_list
+  (scoped_identifier
+    (identifier) @module
+    .
+    (_)))
+
+(use_list
+  (identifier) @type
+  (#lua-match? @type "^[A-Z]"))
+
+(use_as_clause
+  alias: (identifier) @type
+  (#lua-match? @type "^[A-Z]"))
+
+; Keywords
+[
+  ; 0.x
+  "using"
+  "let"
+  "const"
+  "local"
+  "rel"
+  "abs"
+  "dw"
+  "alloc_locals"
+  (inst_ret)
+  "with_attr"
+  "with"
+  "call"
+  "nondet"
+  ; 1.0
+  "impl"
+  "implicits"
+  "of"
+  "ref"
+  "mut"
+] @keyword
+
+[
+  "struct"
+  "enum"
+  "namespace"
+  "type"
+  "trait"
+] @keyword.type
+
+[
+  "func"
+  "fn"
+  "end"
+] @keyword.function
+
+"return" @keyword.return
+
+[
+  "cast"
+  "new"
+  "and"
+] @keyword.operator
+
+[
+  "tempvar"
+  "extern"
+] @keyword.modifier
+
+[
+  "if"
+  "else"
+  "match"
+] @keyword.conditional
+
+"loop" @keyword.repeat
+
+[
+  "assert"
+  "static_assert"
+  "nopanic"
+] @keyword.exception
+
+; Fields
+(implicit_arguments
+  (typed_identifier
+    (identifier) @variable.member))
+
+(member_expression
+  "."
+  (identifier) @variable.member)
+
+(call_expression
+  (assignment_expression
+    left: (identifier) @variable.member))
+
+(tuple_expression
+  (assignment_expression
+    left: (identifier) @variable.member))
+
+(field_identifier) @variable.member
+
+(shorthand_field_initializer
+  (identifier) @variable.member)
+
+; Parameters
+(arguments
+  (typed_identifier
+    (identifier) @variable.parameter))
+
+(call_expression
+  (tuple_expression
+    (assignment_expression
+      left: (identifier) @variable.parameter)))
+
+(return_type
+  (tuple_type
+    (named_type
+      .
+      (identifier) @variable.parameter)))
+
+(parameter
+  (identifier) @variable.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) @variable.member)?)
+
+(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
diff --git a/pack/ant/start/nvim-treesitter/queries/cairo/indents.scm b/pack/ant/start/nvim-treesitter/queries/cairo/indents.scm
new file mode 100644
index 0000000..f63ef36
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cairo/indents.scm
@@ -0,0 +1,57 @@
+[
+  (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
diff --git a/pack/ant/start/nvim-treesitter/queries/cairo/injections.scm b/pack/ant/start/nvim-treesitter/queries/cairo/injections.scm
new file mode 100644
index 0000000..fbb66be
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cairo/injections.scm
@@ -0,0 +1,5 @@
+((python_code) @injection.content
+  (#set! injection.language "python"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/cairo/locals.scm b/pack/ant/start/nvim-treesitter/queries/cairo/locals.scm
new file mode 100644
index 0000000..0573cf6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cairo/locals.scm
@@ -0,0 +1,66 @@
+; References
+(identifier) @local.reference
+
+((type_identifier) @local.reference
+  (#set! reference.kind "type"))
+
+((field_identifier) @local.reference
+  (#set! reference.kind "field"))
+
+; Scopes
+[
+  (program)
+  (block)
+  (function_definition)
+  (loop_expression)
+  (if_expression)
+  (match_expression)
+  (match_arm)
+  (struct_item)
+  (enum_item)
+  (impl_item)
+] @local.scope
+
+(use_declaration
+  argument: (scoped_identifier
+    name: (identifier) @local.definition.import))
+
+(use_as_clause
+  alias: (identifier) @local.definition.import)
+
+(use_list
+  (identifier) @local.definition.import) ; use std::process::{Child, Command, Stdio};
+
+; Functions
+(function_definition
+  (identifier) @local.definition.function)
+
+(function_definition
+  (identifier) @local.definition.method
+  (parameter
+    (self)))
+
+; Function with parameters, defines parameters
+(parameter
+  [
+    (identifier)
+    (self)
+  ] @local.definition.parameter)
+
+; Types
+(struct_item
+  name: (type_identifier) @local.definition.type)
+
+(constrained_type_parameter
+  left: (type_identifier) @local.definition.type) ; the P in  remove_file<P: AsRef<Path>>(path: P)
+
+(enum_item
+  name: (type_identifier) @local.definition.type)
+
+; Module
+(mod_item
+  name: (identifier) @local.definition.namespace)
+
+; Variables
+(assignment_expression
+  left: (identifier) @local.definition.var)
diff --git a/pack/ant/start/nvim-treesitter/queries/capnp/folds.scm b/pack/ant/start/nvim-treesitter/queries/capnp/folds.scm
new file mode 100644
index 0000000..6e3f9c1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/capnp/folds.scm
@@ -0,0 +1,14 @@
+[
+  (annotation_targets)
+  (const_list)
+  (enum)
+  (interface)
+  (implicit_generics)
+  (generics)
+  (group)
+  (method_parameters)
+  (named_return_types)
+  (struct)
+  (struct_shorthand)
+  (union)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/capnp/highlights.scm b/pack/ant/start/nvim-treesitter/queries/capnp/highlights.scm
new file mode 100644
index 0000000..a48c007
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/capnp/highlights.scm
@@ -0,0 +1,141 @@
+; Preproc
+[
+  (unique_id)
+  (top_level_annotation_body)
+] @keyword.directive
+
+; Includes
+[
+  "import"
+  "$import"
+  "embed"
+  "using"
+] @keyword.import
+
+(import_path) @string.special.path
+
+; Keywords
+"extends" @keyword
+
+[
+  "struct"
+  "interface"
+  "union"
+  "enum"
+  "annotation"
+  "group"
+  "namespace"
+] @keyword.type
+
+; Builtins
+"const" @keyword.modifier
+
+[
+  (primitive_type)
+  "List"
+] @type.builtin
+
+; Typedefs
+(type_definition) @type.definition
+
+; Labels (@number, @number!)
+(field_version) @label
+
+; Methods
+[
+  (annotation_definition_identifier)
+  (method_identifier)
+] @function.method
+
+; Fields
+(field_identifier) @variable.member
+
+; Properties
+(property) @property
+
+; Parameters
+[
+  (param_identifier)
+  (return_identifier)
+] @variable.parameter
+
+(annotation_target) @variable.parameter.builtin
+
+; Constants
+[
+  (const_identifier)
+  (local_const)
+  (enum_member)
+] @constant
+
+(void) @constant.builtin
+
+; Types
+[
+  (enum_identifier)
+  (extend_type)
+  (type_identifier)
+] @type
+
+; Attributes
+[
+  (annotation_identifier)
+  (attribute)
+] @attribute
+
+; Operators
+"=" @operator
+
+; Literals
+[
+  (string)
+  (concatenated_string)
+  (block_text)
+  (namespace)
+] @string
+
+(namespace) @string.special
+
+(escape_sequence) @string.escape
+
+(data_string) @string.special
+
+(number) @number
+
+(float) @number.float
+
+(boolean) @boolean
+
+(data_hex) @string.special.symbol
+
+; Punctuation
+[
+  "*"
+  "$"
+  ":"
+] @punctuation.special
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "."
+  ","
+  ";"
+  "->"
+] @punctuation.delimiter
+
+; Comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/capnp/indents.scm b/pack/ant/start/nvim-treesitter/queries/capnp/indents.scm
new file mode 100644
index 0000000..cc2f4d7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/capnp/indents.scm
@@ -0,0 +1,40 @@
+[
+  (annotation_targets)
+  (const)
+  (enum)
+  (interface)
+  (implicit_generics)
+  (generics)
+  (group)
+  (method_parameters)
+  (named_return_types)
+  (struct)
+  (union)
+  (field)
+] @indent.begin
+
+((struct_shorthand
+  (property)) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+((method
+  (field_version)) @indent.align
+  (#set! indent.open_delimiter field_version))
+
+((const_list
+  (const_value)) @indent.align
+  (#set! indent.open_delimiter "[")
+  (#set! indent.close_delimiter "]"))
+
+(concatenated_string) @indent.align
+
+[
+  "}"
+  ")"
+] @indent.end @indent.branch
+
+[
+  (ERROR)
+  (comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/capnp/injections.scm b/pack/ant/start/nvim-treesitter/queries/capnp/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/capnp/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/capnp/locals.scm b/pack/ant/start/nvim-treesitter/queries/capnp/locals.scm
new file mode 100644
index 0000000..d1f0cca
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/capnp/locals.scm
@@ -0,0 +1,97 @@
+[
+  (message)
+  (annotation_targets)
+  (const_list)
+  (enum)
+  (interface)
+  (implicit_generics)
+  (generics)
+  (group)
+  (method_parameters)
+  (named_return_types)
+  (struct)
+  (struct_shorthand)
+  (union)
+] @local.scope
+
+[
+  (extend_type)
+  (field_type)
+] @local.reference
+
+(custom_type
+  (type_identifier) @local.reference)
+
+(custom_type
+  (generics
+    (generic_parameters
+      (generic_identifier) @local.reference)))
+
+(annotation_definition_identifier) @local.definition
+
+(const_identifier) @local.definition.constant
+
+(enum
+  (enum_identifier) @local.definition.enum)
+
+[
+  (enum_member)
+  (field_identifier)
+] @local.definition.field
+
+(method_identifier) @local.definition.method
+
+(namespace) @local.definition.namespace
+
+[
+  (param_identifier)
+  (return_identifier)
+] @local.definition.parameter
+
+(group
+  (type_identifier) @local.definition.type)
+
+(struct
+  (type_identifier) @local.definition.type)
+
+(union
+  (type_identifier) @local.definition.type)
+
+(interface
+  (type_identifier) @local.definition.type)
+
+; Generics Related (don't know how to combine these)
+(struct
+  (generics
+    (generic_parameters
+      (generic_identifier) @local.definition.parameter)))
+
+(interface
+  (generics
+    (generic_parameters
+      (generic_identifier) @local.definition.parameter)))
+
+(method
+  (implicit_generics
+    (implicit_generic_parameters
+      (generic_identifier) @local.definition.parameter)))
+
+(method
+  (generics
+    (generic_parameters
+      (generic_identifier) @local.definition.parameter)))
+
+(annotation
+  (generics
+    (generic_parameters
+      (generic_identifier) @local.definition.type)))
+
+(replace_using
+  (generics
+    (generic_parameters
+      (generic_identifier) @local.definition.type)))
+
+(return_type
+  (generics
+    (generic_parameters
+      (generic_identifier) @local.definition.type)))
diff --git a/pack/ant/start/nvim-treesitter/queries/chatito/folds.scm b/pack/ant/start/nvim-treesitter/queries/chatito/folds.scm
new file mode 100644
index 0000000..052dd20
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/chatito/folds.scm
@@ -0,0 +1,5 @@
+[
+  (intent_def)
+  (slot_def)
+  (alias_def)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/chatito/highlights.scm b/pack/ant/start/nvim-treesitter/queries/chatito/highlights.scm
new file mode 100644
index 0000000..47113f2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/chatito/highlights.scm
@@ -0,0 +1,54 @@
+; Punctuation
+[
+  "%["
+  "@["
+  "~["
+  "*["
+  "]"
+  "("
+  ")"
+] @punctuation.bracket
+
+"," @punctuation.delimiter
+
+(eq) @operator
+
+([
+  "\""
+  "'"
+] @punctuation.special
+  (#set! conceal ""))
+
+[
+  "%"
+  "?"
+  "#"
+] @character.special
+
+; Entities
+(intent) @module
+
+(slot) @type
+
+(variation) @attribute
+
+(alias) @keyword.directive
+
+(number) @number
+
+(argument
+  key: (string) @property
+  value: (string) @string)
+
+(escape) @string.escape
+
+; Import
+"import" @keyword.import
+
+(file) @string.special.path
+
+; Text
+(word) @spell
+
+; Comment
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/chatito/indents.scm b/pack/ant/start/nvim-treesitter/queries/chatito/indents.scm
new file mode 100644
index 0000000..dc9e13d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/chatito/indents.scm
@@ -0,0 +1,8 @@
+[
+  (intent_def)
+  (slot_def)
+  (alias_def)
+] @indent.begin
+
+(ERROR
+  "]") @indent.begin
diff --git a/pack/ant/start/nvim-treesitter/queries/chatito/injections.scm b/pack/ant/start/nvim-treesitter/queries/chatito/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/chatito/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/chatito/locals.scm b/pack/ant/start/nvim-treesitter/queries/chatito/locals.scm
new file mode 100644
index 0000000..827447f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/chatito/locals.scm
@@ -0,0 +1,16 @@
+; Definitions
+(intent_def
+  (intent) @local.definition)
+
+(slot_def
+  (slot) @local.definition)
+
+(alias_def
+  (alias) @local.definition)
+
+; References
+(slot_ref
+  (slot) @local.reference)
+
+(alias_ref
+  (alias) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/clojure/folds.scm b/pack/ant/start/nvim-treesitter/queries/clojure/folds.scm
new file mode 100644
index 0000000..eceb697
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/clojure/folds.scm
@@ -0,0 +1,2 @@
+(source
+  (list_lit) @fold)
diff --git a/pack/ant/start/nvim-treesitter/queries/clojure/highlights.scm b/pack/ant/start/nvim-treesitter/queries/clojure/highlights.scm
new file mode 100644
index 0000000..2642766
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/clojure/highlights.scm
@@ -0,0 +1,347 @@
+; >> Explanation
+; Parsers for lisps are a bit weird in that they just return the raw forms.
+; This means we have to do a bit of extra work in the queries to get things
+; highlighted as they should be.
+;
+; For the most part this means that some things have to be assigned multiple
+; groups.
+; By doing this we can add a basic capture and then later refine it with more
+; specialized captures.
+; This can mean that sometimes things are highlighted weirdly because they
+; have multiple highlight groups applied to them.
+; >> Literals
+((dis_expr) @comment
+  (#set! priority 105)
+  ; Higher priority to mark the whole sexpr as a comment
+  )
+
+(kwd_lit) @string.special.symbol
+
+(str_lit) @string
+
+(num_lit) @number
+
+(char_lit) @character
+
+(bool_lit) @boolean
+
+(nil_lit) @constant.builtin
+
+(comment) @comment @spell
+
+(regex_lit) @string.regexp
+
+[
+  "'"
+  "`"
+] @string.escape
+
+[
+  "~"
+  "~@"
+  "#"
+] @punctuation.special
+
+[
+  "{"
+  "}"
+  "["
+  "]"
+  "("
+  ")"
+] @punctuation.bracket
+
+; >> Symbols
+; General symbol highlighting
+(sym_lit) @variable
+
+; General function calls
+(list_lit
+  .
+  (sym_lit) @function.call)
+
+(anon_fn_lit
+  .
+  (sym_lit) @function.call)
+
+; Quoted symbols
+(quoting_lit
+  (sym_lit) @string.special.symbol)
+
+(syn_quoting_lit
+  (sym_lit) @string.special.symbol)
+
+; Used in destructure pattern
+((sym_lit) @variable.parameter
+  (#lua-match? @variable.parameter "^[&]"))
+
+; Inline function variables
+((sym_lit) @variable.builtin
+  (#lua-match? @variable.builtin "^%%%d*$"))
+
+((sym_lit) @variable.builtin
+  (#eq? @variable.builtin "%&"))
+
+; Constructor
+((sym_lit) @constructor
+  (#lua-match? @constructor "^-%>[^>].*"))
+
+; Builtin dynamic variables
+((sym_lit) @variable.builtin
+  (#any-of? @variable.builtin
+    "*agent*" "*allow-unresolved-vars*" "*assert*" "*clojure-version*" "*command-line-args*"
+    "*compile-files*" "*compile-path*" "*compiler-options*" "*data-readers*"
+    "*default-data-reader-fn*" "*err*" "*file*" "*flush-on-newline*" "*fn-loader*" "*in*"
+    "*math-context*" "*ns*" "*out*" "*print-dup*" "*print-length*" "*print-level*" "*print-meta*"
+    "*print-namespace-maps*" "*print-readably*" "*read-eval*" "*reader-resolver*" "*source-path*"
+    "*suppress-read*" "*unchecked-math*" "*use-context-classloader*" "*verbose-defrecords*"
+    "*warn-on-reflection*"))
+
+; Builtin repl variables
+((sym_lit) @variable.builtin
+  (#any-of? @variable.builtin "*1" "*2" "*3" "*e"))
+
+; Types
+(sym_lit
+  name: (sym_name) @_name
+  (#lua-match? @_name "^[%u][^/%s]*$")) @type
+
+; Symbols with `.` but not `/`
+(sym_lit
+  !namespace
+  name: (sym_name) @_name
+  (#lua-match? @_name "^[^.]+[.]")) @type
+
+; Interop
+; (.instanceMember instance args*)
+; (.instanceMember Classname args*)
+((sym_lit
+  name: (sym_name) @_name) @function.method
+  (#lua-match? @_name "^%.[^-]"))
+
+; (.-instanceField instance)
+((sym_name) @variable.member
+  (#lua-match? @variable.member "^%.%-%S*"))
+
+;  Classname/staticField
+(sym_lit
+  namespace: (sym_ns) @_namespace
+  (#lua-match? @_namespace "^[%u]%S*$")) @variable.member
+
+; (Classname/staticMethod args*)
+(list_lit
+  .
+  (sym_lit
+    namespace: (sym_ns) @_namespace
+    (#lua-match? @_namespace "^%u")) @function.method)
+
+; TODO: Special casing for the `.` macro
+; Operators
+((sym_lit) @operator
+  (#any-of? @operator "*" "*'" "+" "+'" "-" "-'" "/" "<" "<=" ">" ">=" "=" "=="))
+
+((sym_lit) @keyword.operator
+  (#any-of? @keyword.operator "not" "not=" "and" "or"))
+
+; Definition functions
+((sym_lit) @keyword
+  (#any-of? @keyword
+    "def" "defonce" "defrecord" "defmacro" "definline" "definterface" "defmulti" "defmethod"
+    "defstruct" "defprotocol" "deftype"))
+
+((sym_lit) @keyword
+  (#eq? @keyword "declare"))
+
+((sym_name) @keyword.coroutine
+  (#any-of? @keyword.coroutine
+    "alts!" "alts!!" "await" "await-for" "await1" "chan" "close!" "future" "go" "sync" "thread"
+    "timeout" "<!" "<!!" ">!" ">!!"))
+
+((sym_lit
+  name: (sym_name) @_keyword.function.name) @keyword.function
+  (#any-of? @_keyword.function.name "defn" "defn-" "fn" "fn*"))
+
+; Comment
+((sym_lit) @comment
+  (#eq? @comment "comment"))
+
+; Conditionals
+((sym_lit) @keyword.conditional
+  (#any-of? @keyword.conditional "case" "cond" "cond->" "cond->>" "condp"))
+
+((sym_lit) @keyword.conditional
+  (#any-of? @keyword.conditional "if" "if-let" "if-not" "if-some"))
+
+((sym_lit) @keyword.conditional
+  (#any-of? @keyword.conditional "when" "when-first" "when-let" "when-not" "when-some"))
+
+; Repeats
+((sym_lit) @keyword.repeat
+  (#any-of? @keyword.repeat "doseq" "dotimes" "for" "loop" "recur" "while"))
+
+; Exception
+((sym_lit) @keyword.exception
+  (#any-of? @keyword.exception "throw" "try" "catch" "finally"))
+
+; Includes
+((sym_lit) @keyword.import
+  (#any-of? @keyword.import "ns" "import" "require" "use"))
+
+; Builtin macros
+; TODO: Do all these items belong here?
+((sym_lit
+  name: (sym_name) @function.macro)
+  (#any-of? @function.macro
+    "." ".." "->" "->>" "amap" "areduce" "as->" "assert" "binding" "bound-fn" "delay" "do" "dosync"
+    "doto" "extend-protocol" "extend-type" "gen-class" "gen-interface" "io!" "lazy-cat" "lazy-seq"
+    "let" "letfn" "locking" "memfn" "monitor-enter" "monitor-exit" "proxy" "proxy-super" "pvalues"
+    "refer-clojure" "reify" "set!" "some->" "some->>" "time" "unquote" "unquote-splicing" "var"
+    "vswap!" "with-bindings" "with-in-str" "with-loading-context" "with-local-vars" "with-open"
+    "with-out-str" "with-precision" "with-redefs"))
+
+; All builtin functions
+; (->> (ns-publics *ns*)
+;      (keep (fn [[s v]] (when-not (:macro (meta v)) s)))
+;      sort
+;      clojure.pprint/pprint))
+; ...and then lots of manual filtering...
+((sym_lit
+  name: (sym_name) @function.builtin)
+  (#any-of? @function.builtin
+    "->ArrayChunk" "->Eduction" "->Vec" "->VecNode" "->VecSeq" "-cache-protocol-fn" "-reset-methods"
+    "PrintWriter-on" "StackTraceElement->vec" "Throwable->map" "accessor" "aclone" "add-classpath"
+    "add-tap" "add-watch" "agent" "agent-error" "agent-errors" "aget" "alength" "alias" "all-ns"
+    "alter" "alter-meta!" "alter-var-root" "ancestors" "any?" "apply" "array-map" "aset"
+    "aset-boolean" "aset-byte" "aset-char" "aset-double" "aset-float" "aset-int" "aset-long"
+    "aset-short" "assoc" "assoc!" "assoc-in" "associative?" "atom" "bases" "bean" "bigdec" "bigint"
+    "biginteger" "bit-and" "bit-and-not" "bit-clear" "bit-flip" "bit-not" "bit-or" "bit-set"
+    "bit-shift-left" "bit-shift-right" "bit-test" "bit-xor" "boolean" "boolean-array" "boolean?"
+    "booleans" "bound-fn*" "bound?" "bounded-count" "butlast" "byte" "byte-array" "bytes" "bytes?"
+    "cast" "cat" "char" "char-array" "char-escape-string" "char-name-string" "char?" "chars" "chunk"
+    "chunk-append" "chunk-buffer" "chunk-cons" "chunk-first" "chunk-next" "chunk-rest"
+    "chunked-seq?" "class" "class?" "clear-agent-errors" "clojure-version" "coll?" "commute" "comp"
+    "comparator" "compare" "compare-and-set!" "compile" "complement" "completing" "concat" "conj"
+    "conj!" "cons" "constantly" "construct-proxy" "contains?" "count" "counted?" "create-ns"
+    "create-struct" "cycle" "dec" "dec'" "decimal?" "dedupe" "default-data-readers" "delay?"
+    "deliver" "denominator" "deref" "derive" "descendants" "destructure" "disj" "disj!" "dissoc"
+    "dissoc!" "distinct" "distinct?" "doall" "dorun" "double" "double-array" "eduction" "empty"
+    "empty?" "ensure" "ensure-reduced" "enumeration-seq" "error-handler" "error-mode" "eval" "even?"
+    "every-pred" "every?" "extend" "extenders" "extends?" "false?" "ffirst" "file-seq" "filter"
+    "filterv" "find" "find-keyword" "find-ns" "find-protocol-impl" "find-protocol-method" "find-var"
+    "first" "flatten" "float" "float-array" "float?" "floats" "flush" "fn?" "fnext" "fnil" "force"
+    "format" "frequencies" "future-call" "future-cancel" "future-cancelled?" "future-done?"
+    "future?" "gensym" "get" "get-in" "get-method" "get-proxy-class" "get-thread-bindings"
+    "get-validator" "group-by" "halt-when" "hash" "hash-combine" "hash-map" "hash-ordered-coll"
+    "hash-set" "hash-unordered-coll" "ident?" "identical?" "identity" "ifn?" "in-ns" "inc" "inc'"
+    "indexed?" "init-proxy" "inst-ms" "inst-ms*" "inst?" "instance?" "int" "int-array" "int?"
+    "integer?" "interleave" "intern" "interpose" "into" "into-array" "ints" "isa?" "iterate"
+    "iterator-seq" "juxt" "keep" "keep-indexed" "key" "keys" "keyword" "keyword?" "last" "line-seq"
+    "list" "list*" "list?" "load" "load-file" "load-reader" "load-string" "loaded-libs" "long"
+    "long-array" "longs" "macroexpand" "macroexpand-1" "make-array" "make-hierarchy" "map"
+    "map-entry?" "map-indexed" "map?" "mapcat" "mapv" "max" "max-key" "memoize" "merge" "merge-with"
+    "meta" "method-sig" "methods" "min" "min-key" "mix-collection-hash" "mod" "munge" "name"
+    "namespace" "namespace-munge" "nat-int?" "neg-int?" "neg?" "newline" "next" "nfirst" "nil?"
+    "nnext" "not-any?" "not-empty" "not-every?" "ns-aliases" "ns-imports" "ns-interns" "ns-map"
+    "ns-name" "ns-publics" "ns-refers" "ns-resolve" "ns-unalias" "ns-unmap" "nth" "nthnext"
+    "nthrest" "num" "number?" "numerator" "object-array" "odd?" "parents" "partial" "partition"
+    "partition-all" "partition-by" "pcalls" "peek" "persistent!" "pmap" "pop" "pop!"
+    "pop-thread-bindings" "pos-int?" "pos?" "pr" "pr-str" "prefer-method" "prefers"
+    "primitives-classnames" "print" "print-ctor" "print-dup" "print-method" "print-simple"
+    "print-str" "printf" "println" "println-str" "prn" "prn-str" "promise" "proxy-call-with-super"
+    "proxy-mappings" "proxy-name" "push-thread-bindings" "qualified-ident?" "qualified-keyword?"
+    "qualified-symbol?" "quot" "rand" "rand-int" "rand-nth" "random-sample" "range" "ratio?"
+    "rational?" "rationalize" "re-find" "re-groups" "re-matcher" "re-matches" "re-pattern" "re-seq"
+    "read" "read+string" "read-line" "read-string" "reader-conditional" "reader-conditional?"
+    "realized?" "record?" "reduce" "reduce-kv" "reduced" "reduced?" "reductions" "ref"
+    "ref-history-count" "ref-max-history" "ref-min-history" "ref-set" "refer"
+    "release-pending-sends" "rem" "remove" "remove-all-methods" "remove-method" "remove-ns"
+    "remove-tap" "remove-watch" "repeat" "repeatedly" "replace" "replicate" "requiring-resolve"
+    "reset!" "reset-meta!" "reset-vals!" "resolve" "rest" "restart-agent" "resultset-seq" "reverse"
+    "reversible?" "rseq" "rsubseq" "run!" "satisfies?" "second" "select-keys" "send" "send-off"
+    "send-via" "seq" "seq?" "seqable?" "seque" "sequence" "sequential?" "set"
+    "set-agent-send-executor!" "set-agent-send-off-executor!" "set-error-handler!" "set-error-mode!"
+    "set-validator!" "set?" "short" "short-array" "shorts" "shuffle" "shutdown-agents"
+    "simple-ident?" "simple-keyword?" "simple-symbol?" "slurp" "some" "some-fn" "some?" "sort"
+    "sort-by" "sorted-map" "sorted-map-by" "sorted-set" "sorted-set-by" "sorted?" "special-symbol?"
+    "spit" "split-at" "split-with" "str" "string?" "struct" "struct-map" "subs" "subseq" "subvec"
+    "supers" "swap!" "swap-vals!" "symbol" "symbol?" "tagged-literal" "tagged-literal?" "take"
+    "take-last" "take-nth" "take-while" "tap>" "test" "the-ns" "thread-bound?" "to-array"
+    "to-array-2d" "trampoline" "transduce" "transient" "tree-seq" "true?" "type" "unchecked-add"
+    "unchecked-add-int" "unchecked-byte" "unchecked-char" "unchecked-dec" "unchecked-dec-int"
+    "unchecked-divide-int" "unchecked-double" "unchecked-float" "unchecked-inc" "unchecked-inc-int"
+    "unchecked-int" "unchecked-long" "unchecked-multiply" "unchecked-multiply-int"
+    "unchecked-negate" "unchecked-negate-int" "unchecked-remainder-int" "unchecked-short"
+    "unchecked-subtract" "unchecked-subtract-int" "underive" "unquote" "unquote-splicing"
+    "unreduced" "unsigned-bit-shift-right" "update" "update-in" "update-proxy" "uri?" "uuid?" "val"
+    "vals" "var-get" "var-set" "var?" "vary-meta" "vec" "vector" "vector-of" "vector?" "volatile!"
+    "volatile?" "vreset!" "with-bindings*" "with-meta" "with-redefs-fn" "xml-seq" "zero?" "zipmap"
+    ; earlier
+    "drop" "drop-last" "drop-while" "double?" "doubles" "ex-data" "ex-info"
+    ; 1.10
+    "ex-cause" "ex-message"
+    ; 1.11
+    "NaN?" "abs" "infinite?" "iteration" "random-uuid" "parse-boolean" "parse-double" "parse-long"
+    "parse-uuid" "seq-to-map-for-destructuring" "update-keys" "update-vals"
+    ; 1.12
+    "partitionv" "partitionv-all" "splitv-at"))
+
+; >> Context based highlighting
+; def-likes
+; Correctly highlight docstrings
+;(list_lit
+;.
+;(sym_lit) @_keyword ; Don't really want to highlight twice
+;(#any-of? @_keyword
+;"def" "defonce" "defrecord" "defmacro" "definline"
+;"defmulti" "defmethod" "defstruct" "defprotocol"
+;"deftype")
+;.
+;(sym_lit)
+;.
+; TODO: Add @comment highlight
+;(str_lit)?
+;.
+;(_))
+; Function definitions
+(list_lit
+  .
+  ((sym_lit
+    name: (sym_name) @_keyword.function.name)
+    (#any-of? @_keyword.function.name "defn" "defn-" "fn" "fn*"))
+  .
+  (sym_lit)? @function
+  .
+  ; TODO: Add @comment highlight
+  (str_lit)?)
+
+; TODO: Fix parameter highlighting
+;       I think there's a bug here in nvim-treesitter
+; TODO: Reproduce bug and file ticket
+;.
+;[(vec_lit
+;  (sym_lit)* @variable.parameter)
+; (list_lit
+;  (vec_lit
+;   (sym_lit)* @variable.parameter))])
+;[((list_lit
+;   (vec_lit
+;    (sym_lit) @variable.parameter)
+;   (_)
+;  +
+; ((vec_lit
+;   (sym_lit) @variable.parameter)
+;  (_)))
+; Meta punctuation
+; NOTE: When the above `Function definitions` query captures the
+;       the @function it also captures the child meta_lit
+;       We capture the meta_lit symbol (^) after so that the later
+;       highlighting overrides the former
+"^" @punctuation.special
+
+; namespaces
+(list_lit
+  .
+  (sym_lit) @_include
+  (#eq? @_include "ns")
+  .
+  (sym_lit) @module)
diff --git a/pack/ant/start/nvim-treesitter/queries/clojure/injections.scm b/pack/ant/start/nvim-treesitter/queries/clojure/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/clojure/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/clojure/locals.scm b/pack/ant/start/nvim-treesitter/queries/clojure/locals.scm
new file mode 100644
index 0000000..e47adce
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/clojure/locals.scm
@@ -0,0 +1 @@
+; placeholder file to get incremental selection to work
diff --git a/pack/ant/start/nvim-treesitter/queries/cmake/folds.scm b/pack/ant/start/nvim-treesitter/queries/cmake/folds.scm
new file mode 100644
index 0000000..ef153b9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cmake/folds.scm
@@ -0,0 +1,8 @@
+[
+  (if_condition)
+  (foreach_loop)
+  (while_loop)
+  (function_def)
+  (macro_def)
+  (block_def)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/cmake/highlights.scm b/pack/ant/start/nvim-treesitter/queries/cmake/highlights.scm
new file mode 100644
index 0000000..fbbf0d5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cmake/highlights.scm
@@ -0,0 +1,221 @@
+(normal_command
+  (identifier)
+  (argument_list
+    (argument
+      (unquoted_argument)) @constant)
+  (#lua-match? @constant "^[%u@][%u%d_]+$"))
+
+[
+  (quoted_argument)
+  (bracket_argument)
+] @string
+
+(variable_ref) @none
+
+(variable) @variable
+
+[
+  (bracket_comment)
+  (line_comment)
+] @comment @spell
+
+(normal_command
+  (identifier) @function)
+
+[
+  "ENV"
+  "CACHE"
+] @module
+
+[
+  "$"
+  "{"
+  "}"
+] @punctuation.special
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  (function)
+  (endfunction)
+  (macro)
+  (endmacro)
+] @keyword.function
+
+[
+  (if)
+  (elseif)
+  (else)
+  (endif)
+] @keyword.conditional
+
+[
+  (foreach)
+  (endforeach)
+  (while)
+  (endwhile)
+] @keyword.repeat
+
+(normal_command
+  (identifier) @keyword.repeat
+  (#match? @keyword.repeat "\\c^(continue|break)$"))
+
+(normal_command
+  (identifier) @keyword.return
+  (#match? @keyword.return "\\c^return$"))
+
+(function_command
+  (function)
+  (argument_list
+    .
+    (argument) @function
+    (argument)* @variable.parameter))
+
+(macro_command
+  (macro)
+  (argument_list
+    .
+    (argument) @function.macro
+    (argument)* @variable.parameter))
+
+(block_def
+  (block_command
+    (block) @function.builtin
+    (argument_list
+      (argument
+        (unquoted_argument) @constant))
+    (#any-of? @constant "SCOPE_FOR" "POLICIES" "VARIABLES" "PROPAGATE"))
+  (endblock_command
+    (endblock) @function.builtin))
+
+;
+((argument) @boolean
+  (#match? @boolean "\\c^(1|on|yes|true|y|0|off|no|false|n|ignore|notfound|.*-notfound)$"))
+
+;
+(if_command
+  (if)
+  (argument_list
+    (argument) @keyword.operator)
+  (#any-of? @keyword.operator
+    "NOT" "AND" "OR" "COMMAND" "POLICY" "TARGET" "TEST" "DEFINED" "IN_LIST" "EXISTS" "IS_NEWER_THAN"
+    "IS_DIRECTORY" "IS_SYMLINK" "IS_ABSOLUTE" "MATCHES" "LESS" "GREATER" "EQUAL" "LESS_EQUAL"
+    "GREATER_EQUAL" "STRLESS" "STRGREATER" "STREQUAL" "STRLESS_EQUAL" "STRGREATER_EQUAL"
+    "VERSION_LESS" "VERSION_GREATER" "VERSION_EQUAL" "VERSION_LESS_EQUAL" "VERSION_GREATER_EQUAL"))
+
+(elseif_command
+  (elseif)
+  (argument_list
+    (argument) @keyword.operator)
+  (#any-of? @keyword.operator
+    "NOT" "AND" "OR" "COMMAND" "POLICY" "TARGET" "TEST" "DEFINED" "IN_LIST" "EXISTS" "IS_NEWER_THAN"
+    "IS_DIRECTORY" "IS_SYMLINK" "IS_ABSOLUTE" "MATCHES" "LESS" "GREATER" "EQUAL" "LESS_EQUAL"
+    "GREATER_EQUAL" "STRLESS" "STRGREATER" "STREQUAL" "STRLESS_EQUAL" "STRGREATER_EQUAL"
+    "VERSION_LESS" "VERSION_GREATER" "VERSION_EQUAL" "VERSION_LESS_EQUAL" "VERSION_GREATER_EQUAL"))
+
+(normal_command
+  (identifier) @function.builtin
+  (#match? @function.builtin
+    "\\c^(cmake_host_system_information|cmake_language|cmake_minimum_required|cmake_parse_arguments|cmake_path|cmake_policy|configure_file|execute_process|file|find_file|find_library|find_package|find_path|find_program|foreach|get_cmake_property|get_directory_property|get_filename_component|get_property|include|include_guard|list|macro|mark_as_advanced|math|message|option|separate_arguments|set|set_directory_properties|set_property|site_name|string|unset|variable_watch|add_compile_definitions|add_compile_options|add_custom_command|add_custom_target|add_definitions|add_dependencies|add_executable|add_library|add_link_options|add_subdirectory|add_test|aux_source_directory|build_command|create_test_sourcelist|define_property|enable_language|enable_testing|export|fltk_wrap_ui|get_source_file_property|get_target_property|get_test_property|include_directories|include_external_msproject|include_regular_expression|install|link_directories|link_libraries|load_cache|project|remove_definitions|set_source_files_properties|set_target_properties|set_tests_properties|source_group|target_compile_definitions|target_compile_features|target_compile_options|target_include_directories|target_link_directories|target_link_libraries|target_link_options|target_precompile_headers|target_sources|try_compile|try_run|ctest_build|ctest_configure|ctest_coverage|ctest_empty_binary_directory|ctest_memcheck|ctest_read_custom_files|ctest_run_script|ctest_sleep|ctest_start|ctest_submit|ctest_test|ctest_update|ctest_upload)$"))
+
+(normal_command
+  (identifier) @_function
+  (argument_list
+    .
+    (argument) @variable)
+  (#match? @_function "\\c^set$"))
+
+(normal_command
+  (identifier) @_function
+  (#match? @_function "\\c^set$")
+  (argument_list
+    .
+    (argument)
+    ((argument) @_cache @keyword.modifier
+      .
+      (argument) @_type @type
+      (#any-of? @_cache "CACHE")
+      (#any-of? @_type "BOOL" "FILEPATH" "PATH" "STRING" "INTERNAL"))))
+
+(normal_command
+  (identifier) @_function
+  (#match? @_function "\\c^unset$")
+  (argument_list
+    .
+    (argument)
+    (argument) @keyword.modifier
+    (#any-of? @keyword.modifier "CACHE" "PARENT_SCOPE")))
+
+(normal_command
+  (identifier) @_function
+  (#match? @_function "\\c^list$")
+  (argument_list
+    .
+    (argument) @constant
+    (#any-of? @constant "LENGTH" "GET" "JOIN" "SUBLIST" "FIND")
+    .
+    (argument) @variable
+    (argument) @variable .))
+
+(normal_command
+  (identifier) @_function
+  (#match? @_function "\\c^list$")
+  (argument_list
+    .
+    (argument) @constant
+    .
+    (argument) @variable
+    (#any-of? @constant
+      "APPEND" "FILTER" "INSERT" "POP_BACK" "POP_FRONT" "PREPEND" "REMOVE_ITEM" "REMOVE_AT"
+      "REMOVE_DUPLICATES" "REVERSE" "SORT")))
+
+(normal_command
+  (identifier) @_function
+  (#match? @_function "\\c^list$")
+  (argument_list
+    .
+    (argument) @_transform @constant
+    .
+    (argument) @variable
+    .
+    (argument) @_action @constant
+    (#eq? @_transform "TRANSFORM")
+    (#any-of? @_action "APPEND" "PREPEND" "TOUPPER" "TOLOWER" "STRIP" "GENEX_STRIP" "REPLACE")))
+
+(normal_command
+  (identifier) @_function
+  (#match? @_function "\\c^list$")
+  (argument_list
+    .
+    (argument) @_transform @constant
+    .
+    (argument) @variable
+    .
+    (argument) @_action @constant
+    .
+    (argument)? @_selector @constant
+    (#eq? @_transform "TRANSFORM")
+    (#any-of? @_action "APPEND" "PREPEND" "TOUPPER" "TOLOWER" "STRIP" "GENEX_STRIP" "REPLACE")
+    (#any-of? @_selector "AT" "FOR" "REGEX")))
+
+(normal_command
+  (identifier) @_function
+  (#match? @_function "\\c^list$")
+  (argument_list
+    .
+    (argument) @_transform @constant
+    (argument) @constant
+    .
+    (argument) @variable
+    (#eq? @_transform "TRANSFORM")
+    (#eq? @constant "OUTPUT_VARIABLE")))
+
+(escape_sequence) @string.escape
+
+((source_file
+  .
+  (line_comment) @keyword.directive @nospell)
+  (#lua-match? @keyword.directive "^#!/"))
diff --git a/pack/ant/start/nvim-treesitter/queries/cmake/indents.scm b/pack/ant/start/nvim-treesitter/queries/cmake/indents.scm
new file mode 100644
index 0000000..cbd976c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cmake/indents.scm
@@ -0,0 +1,26 @@
+[
+  (normal_command)
+  (if_condition)
+  (foreach_loop)
+  (while_loop)
+  (function_def)
+  (macro_def)
+  (block_def)
+] @indent.begin
+
+[
+  (elseif_command)
+  (else_command)
+  (endif_command)
+  (endforeach_command)
+  (endwhile_command)
+  (endfunction_command)
+  (endmacro_command)
+  (endblock_command)
+] @indent.branch
+
+")" @indent.branch
+
+")" @indent.end
+
+(argument_list) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/cmake/injections.scm b/pack/ant/start/nvim-treesitter/queries/cmake/injections.scm
new file mode 100644
index 0000000..eb8e215
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cmake/injections.scm
@@ -0,0 +1,5 @@
+([
+  (bracket_comment)
+  (line_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/comment/highlights.scm b/pack/ant/start/nvim-treesitter/queries/comment/highlights.scm
new file mode 100644
index 0000000..5d18b79
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/comment/highlights.scm
@@ -0,0 +1,49 @@
+((tag
+  (name) @comment.todo @nospell
+  ("(" @punctuation.bracket
+    (user) @constant
+    ")" @punctuation.bracket)?
+  ":" @punctuation.delimiter)
+  (#any-of? @comment.todo "TODO" "WIP"))
+
+("text" @comment.todo @nospell
+  (#any-of? @comment.todo "TODO" "WIP"))
+
+((tag
+  (name) @comment.note @nospell
+  ("(" @punctuation.bracket
+    (user) @constant
+    ")" @punctuation.bracket)?
+  ":" @punctuation.delimiter)
+  (#any-of? @comment.note "NOTE" "XXX" "INFO" "DOCS" "PERF" "TEST"))
+
+("text" @comment.note @nospell
+  (#any-of? @comment.note "NOTE" "XXX" "INFO" "DOCS" "PERF" "TEST"))
+
+((tag
+  (name) @comment.warning @nospell
+  ("(" @punctuation.bracket
+    (user) @constant
+    ")" @punctuation.bracket)?
+  ":" @punctuation.delimiter)
+  (#any-of? @comment.warning "HACK" "WARNING" "WARN" "FIX"))
+
+("text" @comment.warning @nospell
+  (#any-of? @comment.warning "HACK" "WARNING" "WARN" "FIX"))
+
+((tag
+  (name) @comment.error @nospell
+  ("(" @punctuation.bracket
+    (user) @constant
+    ")" @punctuation.bracket)?
+  ":" @punctuation.delimiter)
+  (#any-of? @comment.error "FIXME" "BUG" "ERROR"))
+
+("text" @comment.error @nospell
+  (#any-of? @comment.error "FIXME" "BUG" "ERROR"))
+
+; Issue number (#123)
+("text" @number
+  (#lua-match? @number "^#[0-9]+$"))
+
+(uri) @string.special.url @nospell
diff --git a/pack/ant/start/nvim-treesitter/queries/commonlisp/folds.scm b/pack/ant/start/nvim-treesitter/queries/commonlisp/folds.scm
new file mode 100644
index 0000000..eceb697
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/commonlisp/folds.scm
@@ -0,0 +1,2 @@
+(source
+  (list_lit) @fold)
diff --git a/pack/ant/start/nvim-treesitter/queries/commonlisp/highlights.scm b/pack/ant/start/nvim-treesitter/queries/commonlisp/highlights.scm
new file mode 100644
index 0000000..7236c84
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/commonlisp/highlights.scm
@@ -0,0 +1,315 @@
+(sym_lit) @variable
+
+; A highlighting for functions/macros in th cl namespace is available in theHamsta/nvim-treesitter-commonlisp
+;(list_lit . (sym_lit) @function.builtin (#cl-standard-function? @function.builtin))
+;(list_lit . (sym_lit) @function.builtin (#cl-standard-macro? @function.macro))
+(dis_expr) @comment
+
+(defun_keyword) @function.macro
+
+(defun_header
+  function_name: (_) @function)
+
+(defun_header
+  lambda_list: (list_lit
+    (sym_lit) @variable.parameter))
+
+(defun_header
+  keyword: (defun_keyword
+    "defmethod")
+  lambda_list: (list_lit
+    (list_lit
+      .
+      (sym_lit)
+      .
+      (sym_lit) @string.special.symbol)))
+
+(defun_header
+  lambda_list: (list_lit
+    (list_lit
+      .
+      (sym_lit) @variable.parameter
+      .
+      (_))))
+
+(defun_header
+  specifier: (sym_lit) @string.special.symbol)
+
+[
+  ":"
+  "::"
+  "."
+] @punctuation.special
+
+[
+  (accumulation_verb)
+  (for_clause_word)
+  "for"
+  "and"
+  "finally"
+  "thereis"
+  "always"
+  "when"
+  "if"
+  "unless"
+  "else"
+  "do"
+  "loop"
+  "below"
+  "in"
+  "from"
+  "across"
+  "repeat"
+  "being"
+  "into"
+  "with"
+  "as"
+  "while"
+  "until"
+  "return"
+  "initially"
+] @function.macro
+
+"=" @operator
+
+(include_reader_macro) @string.special.symbol
+
+[
+  "#C"
+  "#c"
+] @number
+
+[
+  (kwd_lit)
+  (self_referential_reader_macro)
+] @string.special.symbol
+
+(package_lit
+  package: (_) @module)
+
+"cl" @module
+
+(str_lit) @string
+
+(num_lit) @number
+
+((sym_lit) @boolean
+  (#any-of? @boolean "t" "T"))
+
+(nil_lit) @constant.builtin
+
+(comment) @comment @spell
+
+; dynamic variables
+((sym_lit) @variable.builtin
+  (#lua-match? @variable.builtin "^[*].+[*]$"))
+
+; quote
+(format_specifier) @string.escape
+
+(quoting_lit
+  "'" @string.escape)
+
+(syn_quoting_lit
+  "`" @string.escape)
+
+(unquoting_lit
+  "," @string.escape)
+
+(unquote_splicing_lit
+  ",@" @string.escape)
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+(block_comment) @comment @spell
+
+(with_clause
+  type: (_) @type)
+
+(for_clause
+  type: (_) @type)
+
+; defun-like things
+(list_lit
+  .
+  (sym_lit) @function.macro
+  .
+  (sym_lit) @function
+  (#eq? @function.macro "deftest"))
+
+; Macros and Special Operators
+(list_lit
+  .
+  (sym_lit) @function.macro
+  ; Generated via https://github.com/theHamsta/nvim-treesitter-commonlisp/blob/22fdc9fd6ed594176cc7299cc6f68dd21c94c63b/scripts/generate-symbols.lisp#L1-L21
+  (#any-of? @function.macro
+    "do*" "step" "handler-bind" "decf" "prog1" "destructuring-bind" "defconstant" "do" "lambda"
+    "with-standard-io-syntax" "case" "restart-bind" "ignore-errors" "with-slots" "prog2" "defclass"
+    "define-condition" "print-unreadable-object" "defvar" "when" "with-open-file" "prog" "incf"
+    "declaim" "and" "loop-finish" "multiple-value-bind" "pop" "psetf" "defmacro" "with-open-stream"
+    "define-modify-macro" "defsetf" "formatter" "call-method" "handler-case" "pushnew" "or"
+    "with-hash-table-iterator" "ecase" "cond" "defun" "remf" "ccase" "define-compiler-macro"
+    "dotimes" "multiple-value-list" "assert" "deftype" "with-accessors" "trace"
+    "with-simple-restart" "do-symbols" "nth-value" "define-symbol-macro" "psetq" "rotatef" "dolist"
+    "check-type" "multiple-value-setq" "push" "pprint-pop" "loop" "define-setf-expander"
+    "pprint-exit-if-list-exhausted" "with-condition-restarts" "defstruct" "with-input-from-string"
+    "with-compilation-unit" "defgeneric" "with-output-to-string" "untrace" "defparameter"
+    "ctypecase" "do-external-symbols" "etypecase" "do-all-symbols" "with-package-iterator" "unless"
+    "defmethod" "in-package" "defpackage" "return" "typecase" "shiftf" "setf" "pprint-logical-block"
+    "time" "restart-case" "prog*" "define-method-combination" "optimize"))
+
+; constant
+((sym_lit) @constant
+  (#lua-match? @constant "^[+].+[+]$"))
+
+(var_quoting_lit
+  marker: "#'" @string.special.symbol
+  value: (_) @string.special.symbol)
+
+[
+  "#"
+  "#p"
+  "#P"
+] @string.special.symbol
+
+(list_lit
+  .
+  (sym_lit) @function.builtin
+  ; Generated via https://github.com/theHamsta/nvim-treesitter-commonlisp/blob/22fdc9fd6ed594176cc7299cc6f68dd21c94c63b/scripts/generate-symbols.lisp#L1-L21
+  (#any-of? @function.builtin
+    "apropos-list" "subst" "substitute" "pprint-linear" "file-namestring" "write-char" "do*"
+    "slot-exists-p" "file-author" "macro-function" "rassoc" "make-echo-stream"
+    "arithmetic-error-operation" "position-if-not" "list" "cdadr" "lisp-implementation-type"
+    "vector-push" "let" "length" "string-upcase" "adjoin" "digit-char" "step" "member-if"
+    "handler-bind" "lognot" "apply" "gcd" "slot-unbound" "stringp" "values-list" "stable-sort"
+    "decode-float" "make-list" "rplaca" "isqrt" "export" "synonym-stream-symbol" "function-keywords"
+    "replace" "tanh" "maphash" "code-char" "decf" "array-displacement" "string-not-lessp"
+    "slot-value" "remove-if" "cell-error-name" "vectorp" "cdddar" "two-way-stream-output-stream"
+    "parse-integer" "get-internal-real-time" "fourth" "make-string" "slot-missing" "byte-size"
+    "string-trim" "nstring-downcase" "cdaddr" "<" "labels" "interactive-stream-p" "fifth" "max"
+    "logxor" "pathname-name" "function" "realp" "eql" "logand" "short-site-name" "prog1"
+    "user-homedir-pathname" "list-all-packages" "exp" "cadar" "read-char-no-hang"
+    "package-error-package" "stream-external-format" "bit-andc2" "nsubstitute-if" "mapcar"
+    "complement" "load-logical-pathname-translations" "pprint-newline" "oddp" "caaar"
+    "destructuring-bind" "copy-alist" "acos" "go" "bit-nor" "defconstant" "fceiling" "tenth"
+    "nreverse" "=" "nunion" "slot-boundp" "string>" "count-if" "atom" "char=" "random-state-p"
+    "row-major-aref" "bit-andc1" "translate-pathname" "simple-vector-p" "coerce" "substitute-if-not"
+    "zerop" "invalid-method-error" "compile" "realpart" "remove-if-not" "pprint-tab"
+    "hash-table-rehash-threshold" "invoke-restart" "if" "count" "/=" "do" "initialize-instance"
+    "abs" "schar" "simple-condition-format-control" "delete-package" "subst-if" "lambda"
+    "hash-table-count" "array-has-fill-pointer-p" "bit" "with-standard-io-syntax" "parse-namestring"
+    "proclaim" "array-in-bounds-p" "multiple-value-call" "rplacd" "some" "graphic-char-p"
+    "read-from-string" "consp" "cadaar" "acons" "every" "make-pathname" "mask-field" "case"
+    "set-macro-character" "bit-and" "restart-bind" "echo-stream-input-stream" "compile-file"
+    "fill-pointer" "numberp" "acosh" "array-dimensions" "documentation" "minusp" "inspect"
+    "copy-structure" "integer-length" "ensure-generic-function" "char>=" "quote" "lognor"
+    "make-two-way-stream" "ignore-errors" "tailp" "with-slots" "fboundp"
+    "logical-pathname-translations" "equal" "float-sign" "shadow" "sleep" "numerator" "prog2" "getf"
+    "ldb-test" "round" "locally" "echo-stream-output-stream" "log" "get-macro-character"
+    "alphanumericp" "find-method" "nintersection" "defclass" "define-condition"
+    "print-unreadable-object" "defvar" "broadcast-stream-streams" "floatp" "subst-if-not" "integerp"
+    "translate-logical-pathname" "subsetp" "when" "write-string" "with-open-file" "clrhash"
+    "apropos" "intern" "min" "string-greaterp" "import" "nset-difference" "prog" "incf"
+    "both-case-p" "multiple-value-prog1" "characterp" "streamp" "digit-char-p" "random"
+    "string-lessp" "make-string-input-stream" "copy-symbol" "read-sequence" "logcount" "bit-not"
+    "boundp" "encode-universal-time" "third" "declaim" "map" "cons" "set-syntax-from-char" "and"
+    "cis" "symbol-plist" "loop-finish" "standard-char-p" "multiple-value-bind" "asin" "string" "pop"
+    "complex" "fdefinition" "psetf" "type-error-datum" "output-stream-p" "floor" "write-line" "<="
+    "defmacro" "rational" "hash-table-test" "with-open-stream" "read-char" "string-capitalize"
+    "get-properties" "y-or-n-p" "use-package" "remove" "compiler-macro-function" "read"
+    "package-nicknames" "remove-duplicates" "make-load-form-saving-slots" "dribble"
+    "define-modify-macro" "make-dispatch-macro-character" "close" "cosh" "open" "finish-output"
+    "string-downcase" "car" "nstring-capitalize" "software-type" "read-preserving-whitespace" "cadr"
+    "fround" "nsublis" "defsetf" "find-all-symbols" "char>" "no-applicable-method"
+    "compute-restarts" "pathname" "bit-orc2" "write-sequence" "pprint-tabular" "symbol-value"
+    "char-name" "get-decoded-time" "formatter" "bit-vector-p" "intersection" "pathname-type"
+    "clear-input" "call-method" "princ-to-string" "symbolp" "make-load-form" "nsubst"
+    "pprint-dispatch" "handler-case" "method-combination-error" "probe-file" "atan" "string<"
+    "type-error-expected-type" "pushnew" "unread-char" "print" "or" "with-hash-table-iterator"
+    "make-sequence" "ecase" "unwind-protect" "require" "sixth" "get-dispatch-macro-character"
+    "char-not-lessp" "read-byte" "tagbody" "file-error-pathname" "catch" "rationalp" "char-downcase"
+    "char-int" "array-rank" "cond" "last" "make-string-output-stream" "array-dimension"
+    "host-namestring" "input-stream-p" "decode-universal-time" "defun" "eval-when" "char-code"
+    "pathname-directory" "evenp" "subseq" "pprint" "ftruncate" "make-instance" "pathname-host"
+    "logbitp" "remf" "1+" "copy-pprint-dispatch" "char-upcase" "error" "read-line" "second"
+    "make-package" "directory" "special-operator-p" "open-stream-p" "rassoc-if-not" "ccase" "equalp"
+    "substitute-if" "*" "char/=" "cdr" "sqrt" "lcm" "logical-pathname" "eval"
+    "define-compiler-macro" "nsubstitute-if-not" "mapcon" "imagpart" "set-exclusive-or"
+    "simple-condition-format-arguments" "expt" "concatenate" "file-position" "macrolet" "keywordp"
+    "hash-table-rehash-size" "+" "eighth" "use-value" "char-equal" "bit-xor" "format" "byte"
+    "dotimes" "namestring" "char-not-equal" "multiple-value-list" "assert" "append" "notany" "typep"
+    "delete-file" "makunbound" "cdaar" "file-write-date" ">" "cdddr" "write-to-string" "funcall"
+    "member-if-not" "deftype" "readtable-case" "with-accessors" "truename" "constantp" "rassoc-if"
+    "caaadr" "tree-equal" "nset-exclusive-or" "nsubstitute" "make-instances-obsolete"
+    "package-use-list" "invoke-debugger" "provide" "count-if-not" "trace" "logandc1" "nthcdr"
+    "char<=" "functionp" "with-simple-restart" "set-dispatch-macro-character" "logorc2" "unexport"
+    "rest" "unbound-slot-instance" "make-hash-table" "hash-table-p" "reinitialize-instance" "nth"
+    "do-symbols" "nreconc" "macroexpand" "store-value" "float-precision" "remprop" "nth-value"
+    "define-symbol-macro" "update-instance-for-redefined-class" "identity" "progv" "progn"
+    "return-from" "readtablep" "rem" "symbol-name" "psetq" "wild-pathname-p" "char" "list*" "char<"
+    "plusp" "pairlis" "cddar" "pprint-indent" "union" "compiled-function-p" "rotatef" "abort"
+    "machine-type" "concatenated-stream-streams" "string-right-trim" "enough-namestring"
+    "arithmetic-error-operands" "ceiling" "dolist" "delete" "make-condition" "string-left-trim"
+    "integer-decode-float" "check-type" "notevery" "function-lambda-expression" "-"
+    "multiple-value-setq" "name-char" "push" "pprint-pop" "compile-file-pathname" "list-length"
+    "nstring-upcase" "eq" "find-if" "method-qualifiers" "caadr" "cddr" "string=" "let*"
+    "remove-method" "pathname-match-p" "find-package" "truncate" "caaddr" "get-setf-expansion"
+    "loop" "define-setf-expander" "caddr" "package-shadowing-symbols" "force-output"
+    "slot-makunbound" "string-not-greaterp" "cdadar" "cdaadr" "logandc2" "make-array"
+    "merge-pathnames" "sin" "1-" "machine-version" "ffloor" "packagep" "set-pprint-dispatch" "flet"
+    "gensym" "pprint-exit-if-list-exhausted" "cos" "get" "mapl" "delete-if"
+    "with-condition-restarts" "atanh" "copy-list" "fill" "char-not-greaterp" "bit-orc1" "mod"
+    "package-used-by-list" "warn" "add-method" "simple-string-p" "find-restart" "describe"
+    "pathname-version" "peek-char" "yes-or-no-p" "complexp" "aref" "not" "position-if" "string>="
+    "defstruct" "float-radix" "ninth" "caadar" "subtypep" "set" "butlast" "allocate-instance"
+    "with-input-from-string" "assoc" "write" "make-random-state" "bit-eqv" "float-digits"
+    "long-site-name" "with-compilation-unit" "delete-duplicates" "make-symbol" "room" "cdar"
+    "pprint-fill" "defgeneric" "macroexpand-1" "scale-float" "cdaaar"
+    "update-instance-for-different-class" "array-row-major-index" "ed" "file-string-length"
+    "ensure-directories-exist" "copy-readtable" "string<=" "seventh" "with-output-to-string"
+    "signum" "elt" "untrace" "null" "defparameter" "block" "prin1" "revappend" "gentemp" "ctypecase"
+    "ash" "sxhash" "listp" "do-external-symbols" "bit-ior" "etypecase" "sort" "change-class"
+    "find-class" "alpha-char-p" "map-into" "terpri" "do-all-symbols" "ldb" "logorc1" "search"
+    "fmakunbound" "load" "character" "string-not-equal" "pathnamep" "make-broadcast-stream" "arrayp"
+    "mapcan" "cerror" "invoke-restart-interactively" "assoc-if-not" "with-package-iterator"
+    "get-internal-run-time" "read-delimited-list" "unless" "lower-case-p" "restart-name" "/" "boole"
+    "defmethod" "float" "software-version" "vector-pop" "vector-push-extend" "caar" "ldiff" "member"
+    "find-symbol" "reduce" "svref" "describe-object" "logior" "string-equal" "type-of" "position"
+    "cddadr" "pathname-device" "get-output-stream-string" "symbol-package" "tan"
+    "compute-applicable-methods" "cddddr" "nsubst-if-not" "sublis" "set-difference"
+    "two-way-stream-input-stream" "adjustable-array-p" "machine-instance" "signal" "conjugate"
+    "caaaar" "endp" "lisp-implementation-version" "cddaar" "package-name" "adjust-array" "bit-nand"
+    "gethash" "in-package" "symbol-function" "make-concatenated-stream" "defpackage" "class-of"
+    "no-next-method" "logeqv" "deposit-field" "disassemble" "unuse-package" "copy-tree" "find"
+    "asinh" "class-name" "rename-file" "values" "print-not-readable-object" "mismatch" "cadadr"
+    "shadowing-import" "delete-if-not" "maplist" "listen" "return" "stream-element-type" "unintern"
+    "merge" "make-synonym-stream" "prin1-to-string" "nsubst-if" "byte-position" "phase"
+    "muffle-warning" "remhash" "continue" "load-time-value" "hash-table-size"
+    "upgraded-complex-part-type" "char-lessp" "sbit" "upgraded-array-element-type" "file-length"
+    "typecase" "cadddr" "first" "rationalize" "logtest" "find-if-not" "dpb" "mapc" "sinh"
+    "char-greaterp" "shiftf" "denominator" "get-universal-time" "nconc" "setf" "lognand"
+    "rename-package" "pprint-logical-block" "break" "symbol-macrolet" "the" "fresh-line"
+    "clear-output" "assoc-if" "string/=" "princ" "directory-namestring" "stream-error-stream"
+    "array-element-type" "setq" "copy-seq" "time" "restart-case" "prog*" "shared-initialize"
+    "array-total-size" "simple-bit-vector-p" "define-method-combination" "write-byte" "constantly"
+    "caddar" "print-object" "vector" "throw" "reverse" ">=" "upper-case-p" "nbutlast")
+  )
+
+(list_lit
+  .
+  (sym_lit) @operator
+  (#match? @operator "^([+*-+=<>]|<=|>=|/=)$"))
+
+((sym_lit) @string.special.symbol
+  (#lua-match? @string.special.symbol "^[&]"))
+
+[
+  (array_dimension)
+  "#0A"
+  "#0a"
+] @number
+
+(char_lit) @character
diff --git a/pack/ant/start/nvim-treesitter/queries/commonlisp/injections.scm b/pack/ant/start/nvim-treesitter/queries/commonlisp/injections.scm
new file mode 100644
index 0000000..dc89820
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/commonlisp/injections.scm
@@ -0,0 +1,5 @@
+([
+  (comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/commonlisp/locals.scm b/pack/ant/start/nvim-treesitter/queries/commonlisp/locals.scm
new file mode 100644
index 0000000..98036d3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/commonlisp/locals.scm
@@ -0,0 +1,109 @@
+(defun_header
+  function_name: (sym_lit) @local.definition.function
+  (#set! definition.function.scope "parent"))
+
+(defun_header
+  lambda_list: (list_lit
+    (sym_lit) @local.definition.parameter))
+
+(defun_header
+  keyword: (defun_keyword
+    "defmethod")
+  lambda_list: (list_lit
+    (list_lit
+      .
+      (sym_lit)
+      .
+      (sym_lit) @local.definition.type)))
+
+(defun_header
+  lambda_list: (list_lit
+    (list_lit
+      .
+      (sym_lit) @local.definition.parameter
+      .
+      (_))))
+
+(sym_lit) @local.reference
+
+(defun) @local.scope
+
+((list_lit
+  .
+  (sym_lit) @_defvar
+  .
+  (sym_lit) @local.definition.var)
+  (#match? @_defvar "^(cl:)?(defvar|defparameter)$"))
+
+(list_lit
+  .
+  (sym_lit) @_deftest
+  .
+  (sym_lit) @local.definition.function
+  (#eq? @_deftest "deftest")) @local.scope
+
+(list_lit
+  .
+  (sym_lit) @_deftest
+  .
+  (sym_lit) @local.definition.function
+  (#eq? @_deftest "deftest")) @local.scope
+
+(for_clause
+  .
+  (sym_lit) @local.definition.var)
+
+(with_clause
+  .
+  (sym_lit) @local.definition.var)
+
+(loop_macro) @local.scope
+
+(list_lit
+  .
+  (sym_lit) @_let
+  (#match? @_let "(cl:|cffi:)?(with-accessors|with-foreign-objects|let[*]?)")
+  .
+  (list_lit
+    (list_lit
+      .
+      (sym_lit) @local.definition.var))) @local.scope
+
+(list_lit
+  .
+  (sym_lit) @_let
+  (#match? @_let "(cl:|alexandria:)?(with-gensyms|dotimes|with-foreign-object)")
+  .
+  (list_lit
+    .
+    (sym_lit) @local.definition.var)) @local.scope
+
+(list_lit
+  .
+  (kwd_lit) @_import_from
+  (#eq? @_import_from ":import-from")
+  .
+  (_)
+  (kwd_lit
+    (kwd_symbol) @local.definition.import))
+
+(list_lit
+  .
+  (kwd_lit) @_import_from
+  (#eq? @_import_from ":import-from")
+  .
+  (_)
+  (sym_lit) @local.definition.import)
+
+(list_lit
+  .
+  (kwd_lit) @_use
+  (#eq? @_use ":use")
+  (kwd_lit
+    (kwd_symbol) @local.definition.import))
+
+(list_lit
+  .
+  (kwd_lit) @_use
+  (#eq? @_use ":use")
+  (sym_lit) @local.definition.import)
diff --git a/pack/ant/start/nvim-treesitter/queries/cooklang/highlights.scm b/pack/ant/start/nvim-treesitter/queries/cooklang/highlights.scm
new file mode 100644
index 0000000..4ac3918
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cooklang/highlights.scm
@@ -0,0 +1,31 @@
+(metadata) @comment
+
+(comment) @comment @spell
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+"%" @punctuation.special
+
+(ingredient
+  "@" @punctuation.delimiter
+  (name)? @string.special.symbol
+  (amount
+    (quantity)? @number
+    (units)? @constant)?)
+
+(timer
+  "~" @punctuation.delimiter
+  (name)? @string.special.symbol
+  (amount
+    (quantity)? @number
+    (units)? @constant)?)
+
+(cookware
+  "#" @punctuation.delimiter
+  (name)? @string.special.symbol
+  (amount
+    (quantity)? @number
+    (units)? @constant)?)
diff --git a/pack/ant/start/nvim-treesitter/queries/cooklang/injections.scm b/pack/ant/start/nvim-treesitter/queries/cooklang/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cooklang/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/corn/folds.scm b/pack/ant/start/nvim-treesitter/queries/corn/folds.scm
new file mode 100644
index 0000000..2ce5ddb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/corn/folds.scm
@@ -0,0 +1,5 @@
+[
+  (object)
+  (array)
+  (assign_block)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/corn/highlights.scm b/pack/ant/start/nvim-treesitter/queries/corn/highlights.scm
new file mode 100644
index 0000000..8f394ed
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/corn/highlights.scm
@@ -0,0 +1,37 @@
+[
+  "let"
+  "in"
+] @keyword
+
+[
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+"." @punctuation.delimiter
+
+[
+  ".."
+  "="
+] @operator
+
+(input) @constant
+
+(null) @constant.builtin
+
+(comment) @comment @spell
+
+(string) @string
+
+(integer) @number
+
+(float) @number.float
+
+(float
+  "." @number.float)
+
+(boolean) @boolean
+
+(path_seg) @property
diff --git a/pack/ant/start/nvim-treesitter/queries/corn/indents.scm b/pack/ant/start/nvim-treesitter/queries/corn/indents.scm
new file mode 100644
index 0000000..f1f5e04
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/corn/indents.scm
@@ -0,0 +1,24 @@
+[
+  (assign_block
+    "{")
+  (object)
+  (array)
+] @indent.begin
+
+(assign_block
+  "}" @indent.branch)
+
+(assign_block
+  "}" @indent.end)
+
+(object
+  "}" @indent.branch)
+
+(object
+  "}" @indent.end)
+
+(array
+  "]" @indent.branch)
+
+(array
+  "]" @indent.end)
diff --git a/pack/ant/start/nvim-treesitter/queries/corn/injections.scm b/pack/ant/start/nvim-treesitter/queries/corn/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/corn/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/corn/locals.scm b/pack/ant/start/nvim-treesitter/queries/corn/locals.scm
new file mode 100644
index 0000000..7e78c4d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/corn/locals.scm
@@ -0,0 +1,13 @@
+; scopes
+[
+  (object)
+  (array)
+] @local.scope
+
+; definitions
+(assign_block
+  (assignment
+    (input) @local.definition.constant))
+
+(value
+  (input) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/cpon/folds.scm b/pack/ant/start/nvim-treesitter/queries/cpon/folds.scm
new file mode 100644
index 0000000..02feec4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cpon/folds.scm
@@ -0,0 +1,5 @@
+[
+  (meta_map)
+  (map)
+  (array)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/cpon/highlights.scm b/pack/ant/start/nvim-treesitter/queries/cpon/highlights.scm
new file mode 100644
index 0000000..9cc438e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cpon/highlights.scm
@@ -0,0 +1,54 @@
+; Literals
+(string) @string
+
+(escape_sequence) @string.escape
+
+(hex_blob
+  "x" @character.special
+  (_) @string)
+
+(esc_blob
+  "b" @character.special
+  (_) @string)
+
+(datetime
+  "d" @character.special
+  (_) @string.special)
+
+(_
+  key: (_) @property)
+
+(number) @number
+
+(float) @number.float
+
+(boolean) @boolean
+
+(null) @constant.builtin
+
+; Punctuation
+[
+  ","
+  ":"
+] @punctuation.delimiter
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "<"
+  ">"
+] @punctuation.bracket
+
+("\"" @string
+  (#set! conceal ""))
+
+; Comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/cpon/indents.scm b/pack/ant/start/nvim-treesitter/queries/cpon/indents.scm
new file mode 100644
index 0000000..8ec2ff5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cpon/indents.scm
@@ -0,0 +1,17 @@
+[
+  (meta_map)
+  (map)
+  (imap)
+  (array)
+] @indent.begin
+
+[
+  "]"
+  "}"
+  ">"
+] @indent.end @indent.branch
+
+[
+  (ERROR)
+  (comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/cpon/injections.scm b/pack/ant/start/nvim-treesitter/queries/cpon/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cpon/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/cpon/locals.scm b/pack/ant/start/nvim-treesitter/queries/cpon/locals.scm
new file mode 100644
index 0000000..2a4ba47
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cpon/locals.scm
@@ -0,0 +1,6 @@
+[
+  (document)
+  (meta_map)
+  (map)
+  (array)
+] @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/cpp/folds.scm b/pack/ant/start/nvim-treesitter/queries/cpp/folds.scm
new file mode 100644
index 0000000..f5f5664
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cpp/folds.scm
@@ -0,0 +1,14 @@
+; inherits: c
+
+[
+  (for_range_loop)
+  (class_specifier)
+  (field_declaration
+    type: (enum_specifier)
+    default_value: (initializer_list))
+  (template_declaration)
+  (namespace_definition)
+  (try_statement)
+  (catch_clause)
+  (lambda_expression)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/cpp/highlights.scm b/pack/ant/start/nvim-treesitter/queries/cpp/highlights.scm
new file mode 100644
index 0000000..85ff2dc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cpp/highlights.scm
@@ -0,0 +1,268 @@
+; inherits: c
+
+((identifier) @variable.member
+  (#lua-match? @variable.member "^m_.*$"))
+
+(parameter_declaration
+  declarator: (reference_declarator) @variable.parameter)
+
+; function(Foo ...foo)
+(variadic_parameter_declaration
+  declarator: (variadic_declarator
+    (_) @variable.parameter))
+
+; int foo = 0
+(optional_parameter_declaration
+  declarator: (_) @variable.parameter)
+
+;(field_expression) @variable.parameter ;; How to highlight this?
+((field_expression
+  (field_identifier) @function.method) @_parent
+  (#has-parent? @_parent template_method function_declarator))
+
+(field_declaration
+  (field_identifier) @variable.member)
+
+(field_initializer
+  (field_identifier) @property)
+
+(function_declarator
+  declarator: (field_identifier) @function.method)
+
+(concept_definition
+  name: (identifier) @type.definition)
+
+(alias_declaration
+  name: (type_identifier) @type.definition)
+
+(auto) @type.builtin
+
+(namespace_identifier) @module
+
+((namespace_identifier) @type
+  (#lua-match? @type "^[%u]"))
+
+(case_statement
+  value: (qualified_identifier
+    (identifier) @constant))
+
+(using_declaration
+  .
+  "using"
+  .
+  "namespace"
+  .
+  [
+    (qualified_identifier)
+    (identifier)
+  ] @module)
+
+(destructor_name
+  (identifier) @function.method)
+
+; functions
+(function_declarator
+  (qualified_identifier
+    (identifier) @function))
+
+(function_declarator
+  (qualified_identifier
+    (qualified_identifier
+      (identifier) @function)))
+
+(function_declarator
+  (qualified_identifier
+    (qualified_identifier
+      (qualified_identifier
+        (identifier) @function))))
+
+((qualified_identifier
+  (qualified_identifier
+    (qualified_identifier
+      (qualified_identifier
+        (identifier) @function)))) @_parent
+  (#has-ancestor? @_parent function_declarator))
+
+(function_declarator
+  (template_function
+    (identifier) @function))
+
+(operator_name) @function
+
+"operator" @function
+
+"static_assert" @function.builtin
+
+(call_expression
+  (qualified_identifier
+    (identifier) @function.call))
+
+(call_expression
+  (qualified_identifier
+    (qualified_identifier
+      (identifier) @function.call)))
+
+(call_expression
+  (qualified_identifier
+    (qualified_identifier
+      (qualified_identifier
+        (identifier) @function.call))))
+
+((qualified_identifier
+  (qualified_identifier
+    (qualified_identifier
+      (qualified_identifier
+        (identifier) @function.call)))) @_parent
+  (#has-ancestor? @_parent call_expression))
+
+(call_expression
+  (template_function
+    (identifier) @function.call))
+
+(call_expression
+  (qualified_identifier
+    (template_function
+      (identifier) @function.call)))
+
+(call_expression
+  (qualified_identifier
+    (qualified_identifier
+      (template_function
+        (identifier) @function.call))))
+
+(call_expression
+  (qualified_identifier
+    (qualified_identifier
+      (qualified_identifier
+        (template_function
+          (identifier) @function.call)))))
+
+((qualified_identifier
+  (qualified_identifier
+    (qualified_identifier
+      (qualified_identifier
+        (template_function
+          (identifier) @function.call))))) @_parent
+  (#has-ancestor? @_parent call_expression))
+
+; methods
+(function_declarator
+  (template_method
+    (field_identifier) @function.method))
+
+(call_expression
+  (field_expression
+    (field_identifier) @function.method.call))
+
+; constructors
+((function_declarator
+  (qualified_identifier
+    (identifier) @constructor))
+  (#lua-match? @constructor "^%u"))
+
+((call_expression
+  function: (identifier) @constructor)
+  (#lua-match? @constructor "^%u"))
+
+((call_expression
+  function: (qualified_identifier
+    name: (identifier) @constructor))
+  (#lua-match? @constructor "^%u"))
+
+((call_expression
+  function: (field_expression
+    field: (field_identifier) @constructor))
+  (#lua-match? @constructor "^%u"))
+
+; constructing a type in an initializer list: Constructor ():  **SuperType (1)**
+((field_initializer
+  (field_identifier) @constructor
+  (argument_list))
+  (#lua-match? @constructor "^%u"))
+
+; Constants
+(this) @variable.builtin
+
+(null
+  "nullptr" @constant.builtin)
+
+(true) @boolean
+
+(false) @boolean
+
+; Literals
+(raw_string_literal) @string
+
+; Keywords
+[
+  "try"
+  "catch"
+  "noexcept"
+  "throw"
+] @keyword.exception
+
+[
+  "decltype"
+  "explicit"
+  "friend"
+  "override"
+  "using"
+  "requires"
+  "constexpr"
+] @keyword
+
+[
+  "class"
+  "namespace"
+  "template"
+  "typename"
+  "concept"
+] @keyword.type
+
+[
+  "co_await"
+  "co_yield"
+  "co_return"
+] @keyword.coroutine
+
+[
+  "public"
+  "private"
+  "protected"
+  "final"
+  "virtual"
+] @keyword.modifier
+
+[
+  "new"
+  "delete"
+  "xor"
+  "bitand"
+  "bitor"
+  "compl"
+  "not"
+  "xor_eq"
+  "and_eq"
+  "or_eq"
+  "not_eq"
+  "and"
+  "or"
+] @keyword.operator
+
+"<=>" @operator
+
+"::" @punctuation.delimiter
+
+(template_argument_list
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(template_parameter_list
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(literal_suffix) @operator
diff --git a/pack/ant/start/nvim-treesitter/queries/cpp/indents.scm b/pack/ant/start/nvim-treesitter/queries/cpp/indents.scm
new file mode 100644
index 0000000..0782d22
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cpp/indents.scm
@@ -0,0 +1,8 @@
+; inherits: c
+
+(condition_clause) @indent.begin
+
+((field_initializer_list) @indent.begin
+  (#set! indent.start_at_same_line 1))
+
+(access_specifier) @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/cpp/injections.scm b/pack/ant/start/nvim-treesitter/queries/cpp/injections.scm
new file mode 100644
index 0000000..6e16572
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cpp/injections.scm
@@ -0,0 +1,13 @@
+((preproc_arg) @injection.content
+  (#set! injection.language "cpp"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((comment) @injection.content
+  (#lua-match? @injection.content "/[*\/][!*\/]<?[^a-zA-Z]")
+  (#set! injection.language "doxygen"))
+
+(raw_string_literal
+  delimiter: (raw_string_delimiter) @injection.language
+  (raw_string_content) @injection.content)
diff --git a/pack/ant/start/nvim-treesitter/queries/cpp/locals.scm b/pack/ant/start/nvim-treesitter/queries/cpp/locals.scm
new file mode 100644
index 0000000..b24ada8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cpp/locals.scm
@@ -0,0 +1,78 @@
+; inherits: c
+
+; Parameters
+(variadic_parameter_declaration
+  declarator: (variadic_declarator
+    (identifier) @local.definition.parameter))
+
+(optional_parameter_declaration
+  declarator: (identifier) @local.definition.parameter)
+
+; Class / struct definitions
+(class_specifier) @local.scope
+
+(reference_declarator
+  (identifier) @local.definition.var)
+
+(variadic_declarator
+  (identifier) @local.definition.var)
+
+(struct_specifier
+  name: (qualified_identifier
+    name: (type_identifier) @local.definition.type))
+
+(class_specifier
+  name: (type_identifier) @local.definition.type)
+
+(concept_definition
+  name: (identifier) @local.definition.type)
+
+(class_specifier
+  name: (qualified_identifier
+    name: (type_identifier) @local.definition.type))
+
+(alias_declaration
+  name: (type_identifier) @local.definition.type)
+
+;template <typename T>
+(type_parameter_declaration
+  (type_identifier) @local.definition.type)
+
+(template_declaration) @local.scope
+
+; Namespaces
+(namespace_definition
+  name: (namespace_identifier) @local.definition.namespace
+  body: (_) @local.scope)
+
+(namespace_definition
+  name: (nested_namespace_specifier) @local.definition.namespace
+  body: (_) @local.scope)
+
+((namespace_identifier) @local.reference
+  (#set! reference.kind "namespace"))
+
+; Function definitions
+(template_function
+  name: (identifier) @local.definition.function) @local.scope
+
+(template_method
+  name: (field_identifier) @local.definition.method) @local.scope
+
+(function_declarator
+  declarator: (qualified_identifier
+    name: (identifier) @local.definition.function)) @local.scope
+
+(field_declaration
+  declarator: (function_declarator
+    (field_identifier) @local.definition.method))
+
+(lambda_expression) @local.scope
+
+; Control structures
+(try_statement
+  body: (_) @local.scope)
+
+(catch_clause) @local.scope
+
+(requires_expression) @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/css/folds.scm b/pack/ant/start/nvim-treesitter/queries/css/folds.scm
new file mode 100644
index 0000000..dc3c14d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/css/folds.scm
@@ -0,0 +1,4 @@
+[
+  (rule_set)
+  (import_statement)+
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/css/highlights.scm b/pack/ant/start/nvim-treesitter/queries/css/highlights.scm
new file mode 100644
index 0000000..acc2b63
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/css/highlights.scm
@@ -0,0 +1,107 @@
+[
+  "@media"
+  "@charset"
+  "@namespace"
+  "@supports"
+  "@keyframes"
+  (at_keyword)
+] @keyword.directive
+
+"@import" @keyword.import
+
+[
+  (to)
+  (from)
+] @keyword
+
+(comment) @comment @spell
+
+(tag_name) @tag
+
+(class_name) @type
+
+(id_name) @constant
+
+[
+  (property_name)
+  (feature_name)
+] @property
+
+[
+  (nesting_selector)
+  (universal_selector)
+] @character.special
+
+(function_name) @function
+
+[
+  "~"
+  ">"
+  "+"
+  "-"
+  "*"
+  "/"
+  "="
+  "^="
+  "|="
+  "~="
+  "$="
+  "*="
+] @operator
+
+[
+  "and"
+  "or"
+  "not"
+  "only"
+] @keyword.operator
+
+(important) @keyword.modifier
+
+(attribute_selector
+  (plain_value) @string)
+
+(pseudo_element_selector
+  "::"
+  (tag_name) @attribute)
+
+(pseudo_class_selector
+  (class_name) @attribute)
+
+(attribute_name) @tag.attribute
+
+(namespace_name) @module
+
+((property_name) @variable
+  (#lua-match? @variable "^[-][-]"))
+
+((plain_value) @variable
+  (#lua-match? @variable "^[-][-]"))
+
+[
+  (string_value)
+  (color_value)
+  (unit)
+] @string
+
+(integer_value) @number
+
+(float_value) @number.float
+
+[
+  "#"
+  ","
+  "."
+  ":"
+  "::"
+  ";"
+] @punctuation.delimiter
+
+[
+  "{"
+  ")"
+  "("
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/css/indents.scm b/pack/ant/start/nvim-treesitter/queries/css/indents.scm
new file mode 100644
index 0000000..75e4a63
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/css/indents.scm
@@ -0,0 +1,11 @@
+[
+  (block)
+  (declaration)
+] @indent.begin
+
+(block
+  "}" @indent.branch)
+
+"}" @indent.dedent
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/css/injections.scm b/pack/ant/start/nvim-treesitter/queries/css/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/css/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/csv/highlights.scm b/pack/ant/start/nvim-treesitter/queries/csv/highlights.scm
new file mode 100644
index 0000000..de2213a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/csv/highlights.scm
@@ -0,0 +1,3 @@
+; inherits: tsv
+
+"," @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/cuda/folds.scm b/pack/ant/start/nvim-treesitter/queries/cuda/folds.scm
new file mode 100644
index 0000000..b617fdc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cuda/folds.scm
@@ -0,0 +1 @@
+; inherits: cpp
diff --git a/pack/ant/start/nvim-treesitter/queries/cuda/highlights.scm b/pack/ant/start/nvim-treesitter/queries/cuda/highlights.scm
new file mode 100644
index 0000000..6605c5a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cuda/highlights.scm
@@ -0,0 +1,17 @@
+; inherits: cpp
+
+[
+  "<<<"
+  ">>>"
+] @punctuation.bracket
+
+[
+  "__host__"
+  "__device__"
+  "__global__"
+  "__managed__"
+  "__forceinline__"
+  "__noinline__"
+] @keyword.modifier
+
+"__launch_bounds__" @keyword.modifier
diff --git a/pack/ant/start/nvim-treesitter/queries/cuda/indents.scm b/pack/ant/start/nvim-treesitter/queries/cuda/indents.scm
new file mode 100644
index 0000000..b617fdc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cuda/indents.scm
@@ -0,0 +1 @@
+; inherits: cpp
diff --git a/pack/ant/start/nvim-treesitter/queries/cuda/injections.scm b/pack/ant/start/nvim-treesitter/queries/cuda/injections.scm
new file mode 100644
index 0000000..0259958
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cuda/injections.scm
@@ -0,0 +1,5 @@
+((preproc_arg) @injection.content
+  (#set! injection.language "cuda"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/cuda/locals.scm b/pack/ant/start/nvim-treesitter/queries/cuda/locals.scm
new file mode 100644
index 0000000..b617fdc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cuda/locals.scm
@@ -0,0 +1 @@
+; inherits: cpp
diff --git a/pack/ant/start/nvim-treesitter/queries/cue/folds.scm b/pack/ant/start/nvim-treesitter/queries/cue/folds.scm
new file mode 100644
index 0000000..934b59e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cue/folds.scm
@@ -0,0 +1,5 @@
+[
+  (import_spec_list)
+  (field)
+  (string)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/cue/highlights.scm b/pack/ant/start/nvim-treesitter/queries/cue/highlights.scm
new file mode 100644
index 0000000..27d4dad
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cue/highlights.scm
@@ -0,0 +1,164 @@
+; Includes
+[
+  "package"
+  "import"
+] @keyword.import
+
+; Namespaces
+(package_identifier) @module
+
+(import_spec
+  [
+    "."
+    "_"
+  ] @punctuation.special)
+
+[
+  (attr_path)
+  (package_path)
+] @string.special.url ; In attributes
+
+; Attributes
+(attribute) @attribute
+
+; Conditionals
+"if" @keyword.conditional
+
+; Repeats
+"for" @keyword.repeat
+
+(for_clause
+  "_" @punctuation.special)
+
+; Keywords
+"let" @keyword
+
+"in" @keyword.operator
+
+; Operators
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "|"
+  "&"
+  "||"
+  "&&"
+  "=="
+  "!="
+  "<"
+  "<="
+  ">"
+  ">="
+  "=~"
+  "!~"
+  "!"
+  "="
+] @operator
+
+; Fields & Properties
+(field
+  (label
+    (identifier) @variable.member))
+
+(selector_expression
+  (_)
+  (identifier) @property)
+
+; Functions
+(call_expression
+  function: (identifier) @function.call)
+
+(call_expression
+  function: (selector_expression
+    (_)
+    (identifier) @function.call))
+
+(call_expression
+  function: (builtin_function) @function.call)
+
+(builtin_function) @function.builtin
+
+; Variables
+(identifier) @variable
+
+; Types
+(primitive_type) @type.builtin
+
+((identifier) @type
+  (#lua-match? @type "^_?#"))
+
+[
+  (slice_type)
+  (pointer_type)
+] @type ; In attributes
+
+; Punctuation
+[
+  ","
+  ":"
+] @punctuation.delimiter
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "<"
+  ">"
+] @punctuation.bracket
+
+[
+  (ellipsis)
+  "?"
+] @punctuation.special
+
+; Literals
+(string) @string
+
+[
+  (escape_char)
+  (escape_unicode)
+] @string.escape
+
+(number) @number
+
+(float) @number.float
+
+(si_unit
+  (float)
+  (_) @string.special.symbol)
+
+(boolean) @boolean
+
+[
+  (null)
+  (top)
+  (bottom)
+] @constant.builtin
+
+; Interpolations
+(interpolation
+  "\\(" @punctuation.special
+  (_)
+  ")" @punctuation.special) @none
+
+(interpolation
+  "\\("
+  (identifier) @variable
+  ")")
+
+; Comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/cue/indents.scm b/pack/ant/start/nvim-treesitter/queries/cue/indents.scm
new file mode 100644
index 0000000..cef2345
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cue/indents.scm
@@ -0,0 +1,30 @@
+[
+  (import_spec_list)
+  (field)
+] @indent.begin
+
+[
+  "}"
+  "]"
+  ")"
+] @indent.end
+
+[
+  "{"
+  "}"
+] @indent.branch
+
+[
+  "["
+  "]"
+] @indent.branch
+
+[
+  "("
+  ")"
+] @indent.branch
+
+[
+  (ERROR)
+  (comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/cue/injections.scm b/pack/ant/start/nvim-treesitter/queries/cue/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cue/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/cue/locals.scm b/pack/ant/start/nvim-treesitter/queries/cue/locals.scm
new file mode 100644
index 0000000..b2a8972
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/cue/locals.scm
@@ -0,0 +1,31 @@
+; Scopes
+[
+  (source_file)
+  (field)
+  (for_clause)
+] @local.scope
+
+; References
+(identifier) @local.reference
+
+; Definitions
+(import_spec
+  path: (string) @local.definition.import)
+
+(field
+  (label
+    (identifier) @local.definition.field))
+
+(package_identifier) @local.definition.namespace
+
+(for_clause
+  (identifier) @local.definition.var
+  (expression))
+
+(for_clause
+  (identifier)
+  (identifier) @local.definition.var
+  (expression))
+
+(let_clause
+  (identifier) @local.definition.var)
diff --git a/pack/ant/start/nvim-treesitter/queries/d/folds.scm b/pack/ant/start/nvim-treesitter/queries/d/folds.scm
new file mode 100644
index 0000000..49d6256
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/d/folds.scm
@@ -0,0 +1,4 @@
+[
+  (block_statement)
+  (aggregate_body)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/d/highlights.scm b/pack/ant/start/nvim-treesitter/queries/d/highlights.scm
new file mode 100644
index 0000000..11d08a1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/d/highlights.scm
@@ -0,0 +1,374 @@
+; Keywords
+[
+  (directive)
+  (shebang)
+] @keyword.directive
+
+[
+  (import)
+  (module)
+] @keyword.import
+
+[
+  (alias)
+  (asm)
+  (class)
+  (delegate)
+  (delete)
+  (enum)
+  (interface)
+  (invariant)
+  (mixin)
+  (pragma)
+  (struct)
+  (template)
+  (union)
+  (unittest)
+  (version)
+  (with)
+  (traits)
+  (vector)
+  (parameters_)
+  (default)
+  (goto)
+] @keyword
+
+(function) @keyword.function
+
+(synchronized) @keyword.coroutine
+
+[
+  (if)
+  (else)
+  (switch)
+  (case)
+  (break)
+] @keyword.conditional
+
+[
+  (do)
+  (for)
+  (foreach)
+  (foreach_reverse)
+  (while)
+  (continue)
+] @keyword.repeat
+
+(return) @keyword.return
+
+[
+  (abstract)
+  (deprecated)
+  (private)
+  (protected)
+  (public)
+  (package)
+  (immutable)
+  (final)
+  (const)
+  (override)
+  (static)
+] @keyword.modifier
+
+[
+  (assert)
+  (try)
+  (catch)
+  (finally)
+  (throw)
+  (nothrow)
+] @keyword.exception
+
+[
+  (cast)
+  (new)
+  (in)
+  (is)
+  (not_in)
+  (not_is)
+  (typeid)
+  (typeof)
+] @keyword.operator
+
+[
+  (lazy)
+  (align)
+  (extern)
+  (scope)
+  (ref)
+  (pure)
+  (export)
+  (shared)
+  (gshared)
+  (out)
+  (inout)
+] @keyword.modifier
+
+(parameter_attribute
+  (return) @keyword.modifier)
+
+(parameter_attribute
+  (in) @keyword.modifier)
+
+(parameter_attribute
+  (out) @keyword.modifier)
+
+(debug) @keyword.debug
+
+; Operators
+[
+  "/="
+  "/"
+  ".."
+  "&"
+  "&="
+  "&&"
+  "|"
+  "|="
+  "||"
+  "-"
+  "-="
+  "--"
+  "+"
+  "+="
+  "++"
+  "<"
+  "<="
+  "<<"
+  "<<="
+  ">"
+  ">="
+  ">>="
+  ">>>="
+  ">>"
+  ">>>"
+  "!"
+  "!="
+  "$"
+  "="
+  "=="
+  "*"
+  "*="
+  "%"
+  "%="
+  "^"
+  "^="
+  "^^"
+  "^^="
+  "~"
+  "~="
+  "@"
+] @operator
+
+; Variables
+(identifier) @variable
+
+[
+  "exit"
+  "success"
+  "failure"
+  (this)
+  (super)
+] @variable.builtin
+
+(linkage_attribute
+  "("
+  _ @variable.builtin
+  ")")
+
+; Modules
+(module_fqn
+  (identifier) @module)
+
+; Attributes
+(at_attribute
+  (identifier) @attribute)
+
+; Constants
+(enum_member
+  (identifier) @constant)
+
+(manifest_declarator
+  .
+  (identifier) @constant)
+
+; Members
+(aggregate_body
+  (variable_declaration
+    (declarator
+      (identifier) @variable.member)))
+
+(property_expression
+  "."
+  (identifier) @variable.member)
+
+(type
+  "."
+  (identifier) @variable.member)
+
+; Types
+(class_declaration
+  (class)
+  .
+  (identifier) @type)
+
+(struct_declaration
+  (struct)
+  .
+  (identifier) @type)
+
+(union_declaration
+  (union)
+  .
+  (identifier) @type)
+
+(enum_declaration
+  (enum)
+  .
+  (identifier) @type)
+
+(alias_declaration
+  (alias)
+  .
+  (identifier) @type)
+
+((identifier) @type
+  (#lua-match? @type "^[A-Z].*"))
+
+(type
+  .
+  (identifier) @type .)
+
+[
+  (auto)
+  (void)
+  (bool)
+  (byte)
+  (ubyte)
+  (char)
+  (short)
+  (ushort)
+  (wchar)
+  (dchar)
+  (int)
+  (uint)
+  (long)
+  (ulong)
+  (real)
+  (double)
+  (float)
+  (cent)
+  (ucent)
+  (ireal)
+  (idouble)
+  (ifloat)
+  (creal)
+  (double)
+  (cfloat)
+] @type.builtin
+
+; Functions
+(function_declaration
+  (identifier) @function)
+
+(call_expression
+  (identifier) @function)
+
+(call_expression
+  (type
+    (identifier) @function .))
+
+(call_expression
+  (property_expression
+    (call_expression)
+    (identifier) @function .))
+
+; Parameters
+(parameter
+  (_)
+  (identifier) @variable.parameter)
+
+(function_literal
+  "("
+  (type
+    (identifier) @variable.parameter))
+
+; Constructors
+(constructor
+  (this) @constructor)
+
+(destructor
+  (this) @constructor)
+
+(postblit
+  .
+  (this) @constructor)
+
+; Punctuation
+[
+  ";"
+  "."
+  ":"
+  ","
+  "=>"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+"..." @punctuation.special
+
+; Ternaries
+(ternary_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+; Labels
+(label
+  (identifier) @label)
+
+(goto_statement
+  (identifier) @label)
+
+; Literals
+(string_literal) @string
+
+[
+  (int_literal)
+  (float_literal)
+] @number
+
+(char_literal) @character
+
+[
+  (true)
+  (false)
+] @boolean
+
+[
+  (null)
+  (special_keyword)
+] @constant.builtin
+
+; Comments
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^///[^/]"))
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^///$"))
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$"))
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[+][+][^+].*[+]/$"))
diff --git a/pack/ant/start/nvim-treesitter/queries/d/indents.scm b/pack/ant/start/nvim-treesitter/queries/d/indents.scm
new file mode 100644
index 0000000..c89b4e9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/d/indents.scm
@@ -0,0 +1,24 @@
+[
+  (parameters)
+  (template_parameters)
+  (expression_statement)
+  (aggregate_body)
+  (function_body)
+  (scope_statement)
+  (block_statement)
+  (case_statement)
+] @indent.begin
+
+(comment) @indent.auto
+
+[
+  (case)
+  (default)
+  "}"
+  "]"
+] @indent.branch
+
+[
+  (directive)
+  (shebang)
+] @indent.zero
diff --git a/pack/ant/start/nvim-treesitter/queries/d/injections.scm b/pack/ant/start/nvim-treesitter/queries/d/injections.scm
new file mode 100644
index 0000000..cfc1bf9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/d/injections.scm
@@ -0,0 +1,19 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((call_expression
+  (type) @_printf
+  (named_arguments
+    "("
+    .
+    (named_argument
+      (expression
+        (string_literal) @injection.content))))
+  (#eq? @_printf "printf")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.language "printf"))
+
+; TODO: uncomment when asm is added
+; ((asm_inline) @injection.content
+;   (#set! injection.language "asm")
+;   (#set! injection.combined))
diff --git a/pack/ant/start/nvim-treesitter/queries/d/locals.scm b/pack/ant/start/nvim-treesitter/queries/d/locals.scm
new file mode 100644
index 0000000..2cd7b9e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/d/locals.scm
@@ -0,0 +1,79 @@
+; Scopes
+[
+  (source_file)
+  (block_statement)
+  (aggregate_body)
+] @local.scope
+
+; References
+(identifier) @local.reference
+
+; Definitions
+(module_def
+  (module_declaration
+    (module_fqn) @local.definition.namespace)
+  (#set! definition.namespace.scope "global"))
+
+(enum_declaration
+  (enum_member
+    .
+    (identifier) @local.definition.enum))
+
+(class_declaration
+  (class)
+  .
+  (identifier) @local.definition.type)
+
+(struct_declaration
+  (struct)
+  .
+  (identifier) @local.definition.type)
+
+(union_declaration
+  (union)
+  .
+  (identifier) @local.definition.type)
+
+(enum_declaration
+  (enum)
+  .
+  (identifier) @local.definition.type)
+
+(alias_declaration
+  (alias_initializer
+    .
+    (identifier) @local.definition.type))
+
+(constructor
+  (this) @local.definition.method)
+
+(destructor
+  (this) @local.definition.method)
+
+(postblit
+  (this) @local.definition.method)
+
+(aggregate_body
+  (function_declaration
+    (identifier) @local.definition.method))
+
+(manifest_declarator
+  .
+  (identifier) @local.definition.constant)
+
+(anonymous_enum_declaration
+  (enum_member
+    .
+    (identifier) @local.definition.constant))
+
+(variable_declaration
+  (declarator
+    (identifier) @local.definition.var))
+
+(aggregate_body
+  (variable_declaration
+    (declarator
+      (identifier) @local.definition.field)))
+
+(function_declaration
+  (identifier) @local.definition.function)
diff --git a/pack/ant/start/nvim-treesitter/queries/dart/folds.scm b/pack/ant/start/nvim-treesitter/queries/dart/folds.scm
new file mode 100644
index 0000000..fc75ac2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dart/folds.scm
@@ -0,0 +1,13 @@
+[
+  (class_definition)
+  (enum_declaration)
+  (extension_declaration)
+  (arguments)
+  (function_body)
+  (block)
+  (switch_block)
+  (list_literal)
+  (set_or_map_literal)
+  (string_literal)
+  (import_or_export)+
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/dart/highlights.scm b/pack/ant/start/nvim-treesitter/queries/dart/highlights.scm
new file mode 100644
index 0000000..072a10d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dart/highlights.scm
@@ -0,0 +1,303 @@
+(identifier) @variable
+
+(dotted_identifier_list) @string
+
+; Methods
+; --------------------
+; TODO: add method/call_expression to grammar and
+; distinguish method call from variable access
+(function_expression_body
+  (identifier) @function.call)
+
+; ((identifier)(selector (argument_part)) @function)
+; NOTE: This query is a bit of a work around for the fact that the dart grammar doesn't
+; specifically identify a node as a function call
+(((identifier) @function.call
+  (#lua-match? @function.call "^_?[%l]"))
+  .
+  (selector
+    .
+    (argument_part))) @function.call
+
+; Annotations
+; --------------------
+(annotation
+  "@" @attribute
+  name: (identifier) @attribute)
+
+; Operators and Tokens
+; --------------------
+(template_substitution
+  "$" @punctuation.special
+  "{" @punctuation.special
+  "}" @punctuation.special) @none
+
+(template_substitution
+  "$" @punctuation.special
+  (identifier_dollar_escaped) @variable) @none
+
+(escape_sequence) @string.escape
+
+[
+  "=>"
+  ".."
+  "??"
+  "=="
+  "!"
+  "?"
+  "&&"
+  "%"
+  "<"
+  ">"
+  "="
+  ">="
+  "<="
+  "||"
+  ">>>="
+  ">>="
+  "<<="
+  "&="
+  "|="
+  "??="
+  "%="
+  "+="
+  "-="
+  "*="
+  "/="
+  "^="
+  "~/="
+  (shift_operator)
+  (multiplicative_operator)
+  (increment_operator)
+  (is_operator)
+  (prefix_operator)
+  (equality_operator)
+  (additive_operator)
+] @operator
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; Delimiters
+; --------------------
+[
+  ";"
+  "."
+  ","
+  ":"
+  "?."
+  "?"
+] @punctuation.delimiter
+
+; Types
+; --------------------
+(class_definition
+  name: (identifier) @type)
+
+(constructor_signature
+  name: (identifier) @type)
+
+(scoped_identifier
+  scope: (identifier) @type)
+
+(function_signature
+  name: (identifier) @function.method)
+
+(getter_signature
+  (identifier) @function.method)
+
+(setter_signature
+  name: (identifier) @function.method)
+
+(enum_declaration
+  name: (identifier) @type)
+
+(enum_constant
+  name: (identifier) @type)
+
+(void_type) @type
+
+((scoped_identifier
+  scope: (identifier) @type
+  name: (identifier) @type)
+  (#lua-match? @type "^[%u%l]"))
+
+(type_identifier) @type
+
+(type_alias
+  (type_identifier) @type.definition)
+
+(type_arguments
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+; Variables
+; --------------------
+; var keyword
+(inferred_type) @keyword
+
+((identifier) @type
+  (#lua-match? @type "^_?[%u].*[%l]")) ; catch Classes or IClasses not CLASSES
+
+"Function" @type
+
+; properties
+(unconditional_assignable_selector
+  (identifier) @property)
+
+(conditional_assignable_selector
+  (identifier) @property)
+
+(this) @variable.builtin
+
+; Parameters
+; --------------------
+(formal_parameter
+  (identifier) @variable.parameter)
+
+(named_argument
+  (label
+    (identifier) @variable.parameter))
+
+; Literals
+; --------------------
+[
+  (hex_integer_literal)
+  (decimal_integer_literal)
+  (decimal_floating_point_literal)
+  ; TODO: inaccessible nodes
+  ; (octal_integer_literal)
+  ; (hex_floating_point_literal)
+] @number
+
+(symbol_literal) @string.special.symbol
+
+(string_literal) @string
+
+(true) @boolean
+
+(false) @boolean
+
+(null_literal) @constant.builtin
+
+(comment) @comment @spell
+
+(documentation_comment) @comment.documentation @spell
+
+; Keywords
+; --------------------
+[
+  "import"
+  "library"
+  "export"
+  "as"
+  "show"
+  "hide"
+] @keyword.import
+
+; Reserved words (cannot be used as identifiers)
+[
+  ; TODO:
+  ; "rethrow" cannot be targeted at all and seems to be an invisible node
+  ; TODO:
+  ; the assert keyword cannot be specifically targeted
+  ; because the grammar selects the whole node or the content
+  ; of the assertion not just the keyword
+  ; assert
+  (case_builtin)
+  "late"
+  "required"
+  "on"
+  "extends"
+  "in"
+  "is"
+  "new"
+  "super"
+  "with"
+] @keyword
+
+[
+  "class"
+  "enum"
+  "extension"
+] @keyword.type
+
+"return" @keyword.return
+
+; Built in identifiers:
+; alone these are marked as keywords
+[
+  "deferred"
+  "factory"
+  "get"
+  "implements"
+  "interface"
+  "library"
+  "operator"
+  "mixin"
+  "part"
+  "set"
+  "typedef"
+] @keyword
+
+[
+  "async"
+  "async*"
+  "sync*"
+  "await"
+  "yield"
+] @keyword.coroutine
+
+[
+  (const_builtin)
+  (final_builtin)
+  "abstract"
+  "covariant"
+  "external"
+  "static"
+  "final"
+  "base"
+  "sealed"
+] @keyword.modifier
+
+; when used as an identifier:
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin
+    "abstract" "as" "covariant" "deferred" "dynamic" "export" "external" "factory" "Function" "get"
+    "implements" "import" "interface" "library" "operator" "mixin" "part" "set" "static" "typedef"))
+
+[
+  "if"
+  "else"
+  "switch"
+  "default"
+] @keyword.conditional
+
+(conditional_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+[
+  "try"
+  "throw"
+  "catch"
+  "finally"
+  (break_statement)
+] @keyword.exception
+
+[
+  "do"
+  "while"
+  "continue"
+  "for"
+] @keyword.repeat
diff --git a/pack/ant/start/nvim-treesitter/queries/dart/indents.scm b/pack/ant/start/nvim-treesitter/queries/dart/indents.scm
new file mode 100644
index 0000000..03d9464
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dart/indents.scm
@@ -0,0 +1,49 @@
+[
+  (class_body)
+  (function_body)
+  (function_expression_body)
+  (declaration
+    (initializers))
+  (switch_block)
+  (formal_parameter_list)
+  (formal_parameter)
+  (list_literal)
+  (return_statement)
+  (arguments)
+  (try_statement)
+] @indent.begin
+
+(switch_block
+  (_) @indent.begin
+  (#set! indent.immediate 1)
+  (#set! indent.start_at_same_line 1))
+
+[
+  (switch_statement_case)
+  (switch_statement_default)
+] @indent.branch
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @indent.branch
+
+"}" @indent.end
+
+(return_statement
+  ";" @indent.end)
+
+(break_statement
+  ";" @indent.end)
+
+(comment) @indent.ignore
+
+; dedenting the else block is painfully slow; replace with simpler strategy
+; (if_statement) @indent.begin
+; (if_statement
+;   (block) @indent.branch)
+(if_statement) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/dart/injections.scm b/pack/ant/start/nvim-treesitter/queries/dart/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dart/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/dart/locals.scm b/pack/ant/start/nvim-treesitter/queries/dart/locals.scm
new file mode 100644
index 0000000..3e3beb5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dart/locals.scm
@@ -0,0 +1,32 @@
+; Definitions
+(function_signature
+  name: (identifier) @local.definition.function)
+
+(formal_parameter
+  name: (identifier) @local.definition.parameter)
+
+(initialized_variable_definition
+  name: (identifier) @local.definition.var)
+
+(initialized_identifier
+  (identifier) @local.definition.var)
+
+(static_final_declaration
+  (identifier) @local.definition.var)
+
+; References
+(identifier) @local.reference
+
+; Scopes
+(class_definition
+  body: (_) @local.scope)
+
+[
+  (block)
+  (if_statement)
+  (for_statement)
+  (while_statement)
+  (try_statement)
+  (catch_clause)
+  (finally_clause)
+] @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/devicetree/folds.scm b/pack/ant/start/nvim-treesitter/queries/devicetree/folds.scm
new file mode 100644
index 0000000..206c4be
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/devicetree/folds.scm
@@ -0,0 +1 @@
+(node) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/devicetree/highlights.scm b/pack/ant/start/nvim-treesitter/queries/devicetree/highlights.scm
new file mode 100644
index 0000000..74ec89a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/devicetree/highlights.scm
@@ -0,0 +1,61 @@
+(comment) @comment @spell
+
+[
+  (preproc_include)
+  (dtsi_include)
+] @keyword.import
+
+(preproc_def) @constant.macro
+
+(preproc_function_def) @function.macro
+
+[
+  (memory_reservation)
+  (file_version)
+] @attribute
+
+[
+  (string_literal)
+  (byte_string_literal)
+  (system_lib_string)
+] @string
+
+(integer_literal) @number
+
+(identifier) @variable
+
+(node
+  (identifier) @module)
+
+(property
+  (identifier) @property)
+
+(node
+  label: (_) @label)
+
+(call_expression
+  (identifier) @function.macro)
+
+(reference) @label ; referencing labeled_item.identifier
+
+(unit_address) @constant
+
+"=" @operator
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  "<"
+  ">"
+] @punctuation.bracket
+
+[
+  ";"
+  ":"
+  ","
+  "@"
+] @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/devicetree/indents.scm b/pack/ant/start/nvim-treesitter/queries/devicetree/indents.scm
new file mode 100644
index 0000000..9740060
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/devicetree/indents.scm
@@ -0,0 +1,12 @@
+[
+  (node)
+  (property)
+  (integer_cells)
+] @indent.begin
+
+[
+  "}"
+  ">"
+] @indent.branch
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/devicetree/injections.scm b/pack/ant/start/nvim-treesitter/queries/devicetree/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/devicetree/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/devicetree/locals.scm b/pack/ant/start/nvim-treesitter/queries/devicetree/locals.scm
new file mode 100644
index 0000000..e33a81d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/devicetree/locals.scm
@@ -0,0 +1,4 @@
+[
+  (node)
+  (integer_cells)
+] @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/dhall/folds.scm b/pack/ant/start/nvim-treesitter/queries/dhall/folds.scm
new file mode 100644
index 0000000..bc92797
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dhall/folds.scm
@@ -0,0 +1,10 @@
+[
+  (let_binding)
+  (application_expression)
+  (lambda_expression)
+  (record_type)
+  (union_type)
+  (list_literal)
+  (record_literal)
+  (block_comment)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/dhall/highlights.scm b/pack/ant/start/nvim-treesitter/queries/dhall/highlights.scm
new file mode 100644
index 0000000..efd7fed
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dhall/highlights.scm
@@ -0,0 +1,193 @@
+; Text
+; Imports
+(missing_import) @keyword.import
+
+(local_import) @string.special.path
+
+(http_import) @string.special.url
+
+[
+  (env_variable)
+  (import_hash)
+] @string.special
+
+[
+  (import_as_location)
+  (import_as_text)
+] @type
+
+; Types
+([
+  (let_binding
+    (label) @type)
+  (union_type_entry
+    (label) @type)
+]
+  (#lua-match? @type "^%u"))
+
+((primitive_expression
+  (identifier
+    (label) @type)
+  (selector
+    (label) @type)) @variable
+  (#lua-match? @variable "^[A-Z][^.]*$"))
+
+; Parameters
+(lambda_expression
+  label: (label) @variable.parameter)
+
+; Variables
+(label) @variable
+
+(identifier
+  [
+    (label) @variable
+    (de_bruijn_index) @operator
+  ])
+
+(let_binding
+  label: (label) @variable)
+
+; Fields
+(record_literal_entry
+  (label) @variable.member)
+
+(record_type_entry
+  (label) @variable.member)
+
+(selector
+  (selector_dot)
+  (_) @variable.member)
+
+; Keywords
+(env_import) @keyword
+
+[
+  "let"
+  "in"
+  "assert"
+] @keyword
+
+[
+  "using"
+  "as"
+  "with"
+] @keyword.operator
+
+; Operators
+[
+  (type_operator)
+  (assign_operator)
+  (lambda_operator)
+  (arrow_operator)
+  (infix_operator)
+  (completion_operator)
+  (assert_operator)
+  (forall_operator)
+  (empty_record_literal)
+] @operator
+
+; Builtins
+(builtin_function) @function.builtin
+
+(builtin
+  [
+    "Natural"
+    "Natural/build"
+    "Natural/fold"
+    "Natural/isZero"
+    "Natural/even"
+    "Natural/odd"
+    "Natural/subtract"
+    "Natural/toInteger"
+    "Natural/show"
+    "Integer"
+    "Integer/toDouble"
+    "Integer/show"
+    "Integer/negate"
+    "Integer/clamp"
+    "Double"
+    "Double/show"
+    "List"
+    "List/build"
+    "List/fold"
+    "List/length"
+    "List/head"
+    "List/last"
+    "List/indexed"
+    "List/reverse"
+    "Text"
+    "Text/show"
+    "Text/replace"
+    "Optional"
+    "Date"
+    "Time"
+    "TimeZone"
+    "Type"
+    "Kind"
+    "Sort"
+  ] @type.builtin)
+
+; Punctuation
+[
+  ","
+  "|"
+] @punctuation.delimiter
+
+(selector_dot) @punctuation.delimiter
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "<"
+  ">"
+] @punctuation.bracket
+
+; Conditionals
+[
+  "if"
+  "then"
+  "else"
+] @keyword.conditional
+
+; Literals
+(text_literal) @string
+
+(interpolation
+  "}" @string)
+
+[
+  (double_quote_escaped)
+  (single_quote_escaped)
+] @string.escape
+
+[
+  (integer_literal)
+  (natural_literal)
+] @number
+
+(double_literal) @number.float
+
+(boolean_literal) @boolean
+
+(builtin
+  "None") @constant.builtin
+
+; Comments
+[
+  (line_comment)
+  (block_comment)
+] @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/dhall/injections.scm b/pack/ant/start/nvim-treesitter/queries/dhall/injections.scm
new file mode 100644
index 0000000..3cd6aac
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dhall/injections.scm
@@ -0,0 +1,5 @@
+([
+  (line_comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/diff/folds.scm b/pack/ant/start/nvim-treesitter/queries/diff/folds.scm
new file mode 100644
index 0000000..3560abb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/diff/folds.scm
@@ -0,0 +1,5 @@
+[
+  (block)
+  (hunks)
+  (hunk)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/diff/highlights.scm b/pack/ant/start/nvim-treesitter/queries/diff/highlights.scm
new file mode 100644
index 0000000..54c57a8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/diff/highlights.scm
@@ -0,0 +1,49 @@
+(comment) @comment @spell
+
+[
+  (addition)
+  (new_file)
+] @diff.plus
+
+[
+  (deletion)
+  (old_file)
+] @diff.minus
+
+(commit) @constant
+
+(location) @attribute
+
+(command
+  "diff" @function
+  (argument) @variable.parameter)
+
+(filename) @string.special.path
+
+(mode) @number
+
+([
+  ".."
+  "+"
+  "++"
+  "+++"
+  "++++"
+  "-"
+  "--"
+  "---"
+  "----"
+] @punctuation.special
+  (#set! priority 95))
+
+[
+  (binary_change)
+  (similarity)
+  (file_change)
+] @label
+
+(index
+  "index" @keyword)
+
+(similarity
+  (score) @number
+  "%" @number)
diff --git a/pack/ant/start/nvim-treesitter/queries/diff/injections.scm b/pack/ant/start/nvim-treesitter/queries/diff/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/diff/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/disassembly/highlights.scm b/pack/ant/start/nvim-treesitter/queries/disassembly/highlights.scm
new file mode 100644
index 0000000..b1ece9a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/disassembly/highlights.scm
@@ -0,0 +1,30 @@
+(byte) @constant
+
+[
+  (address)
+  (hexadecimal)
+  (integer)
+] @number
+
+(identifier) @variable
+
+(bad_instruction) @comment.warning
+
+(code_location
+  (identifier) @function.call)
+
+(comment) @comment
+
+(instruction) @function
+
+(memory_dump) @string
+
+[
+  "<"
+  ">"
+] @punctuation.special
+
+[
+  "+"
+  ":"
+] @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/disassembly/injections.scm b/pack/ant/start/nvim-treesitter/queries/disassembly/injections.scm
new file mode 100644
index 0000000..9fb52da
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/disassembly/injections.scm
@@ -0,0 +1,6 @@
+; TODO: https://github.com/nvim-treesitter/nvim-treesitter/pull/5548#issuecomment-1773707396
+;
+; To be added once a compatible Assembly parser is merged into nvim-treesitter
+;
+; ((instruction) @injection.content
+;  (#set! injection.language "asm"))
diff --git a/pack/ant/start/nvim-treesitter/queries/djot/folds.scm b/pack/ant/start/nvim-treesitter/queries/djot/folds.scm
new file mode 100644
index 0000000..94f3724
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/djot/folds.scm
@@ -0,0 +1,7 @@
+[
+  (section)
+  (code_block)
+  (raw_block)
+  (list)
+  (div)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/djot/highlights.scm b/pack/ant/start/nvim-treesitter/queries/djot/highlights.scm
new file mode 100644
index 0000000..8df7c92
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/djot/highlights.scm
@@ -0,0 +1,396 @@
+(heading1) @markup.heading.1
+
+(heading2) @markup.heading.2
+
+(heading3) @markup.heading.3
+
+(heading4) @markup.heading.4
+
+(heading5) @markup.heading.5
+
+(heading6) @markup.heading.6
+
+(thematic_break) @string.special
+
+[
+  (div_marker_begin)
+  (div_marker_end)
+] @punctuation.delimiter
+
+([
+  (code_block)
+  (raw_block)
+  (frontmatter)
+] @markup.raw.block
+  (#set! priority 90))
+
+; Remove @markup.raw for code with a language spec
+(code_block
+  .
+  (code_block_marker_begin)
+  (language)
+  (code) @none
+  (#set! priority 90))
+
+[
+  (code_block_marker_begin)
+  (code_block_marker_end)
+  (raw_block_marker_begin)
+  (raw_block_marker_end)
+] @punctuation.delimiter
+
+(language) @attribute
+
+(inline_attribute
+  _ @conceal
+  (#set! conceal ""))
+
+((language_marker) @punctuation.delimiter
+  (#set! conceal ""))
+
+(block_quote) @markup.quote
+
+(block_quote_marker) @punctuation.special
+
+(table_header) @markup.heading
+
+(table_header
+  "|" @punctuation.special)
+
+(table_row
+  "|" @punctuation.special)
+
+(table_separator) @punctuation.special
+
+(table_caption
+  (marker) @punctuation.special)
+
+(table_caption) @markup.italic
+
+[
+  (list_marker_dash)
+  (list_marker_plus)
+  (list_marker_star)
+  (list_marker_definition)
+  (list_marker_decimal_period)
+  (list_marker_decimal_paren)
+  (list_marker_decimal_parens)
+  (list_marker_lower_alpha_period)
+  (list_marker_lower_alpha_paren)
+  (list_marker_lower_alpha_parens)
+  (list_marker_upper_alpha_period)
+  (list_marker_upper_alpha_paren)
+  (list_marker_upper_alpha_parens)
+  (list_marker_lower_roman_period)
+  (list_marker_lower_roman_paren)
+  (list_marker_lower_roman_parens)
+  (list_marker_upper_roman_period)
+  (list_marker_upper_roman_paren)
+  (list_marker_upper_roman_parens)
+] @markup.list
+
+(list_marker_task
+  (unchecked)) @markup.list.unchecked
+
+(list_marker_task
+  (checked)) @markup.list.checked
+
+; Colorize `x` in `[x]`
+((checked) @constant.builtin
+  (#offset! @constant.builtin 0 1 0 -1))
+
+[
+  (ellipsis)
+  (en_dash)
+  (em_dash)
+  (quotation_marks)
+] @string.special
+
+(list_item
+  (term) @type.definition)
+
+; Conceal { and } but leave " and '
+((quotation_marks) @string.special
+  (#any-of? @string.special "\"}" "'}")
+  (#offset! @string.special 0 1 0 0)
+  (#set! conceal ""))
+
+((quotation_marks) @string.special
+  (#any-of? @string.special "\\\"" "\\'" "{'" "{\"")
+  (#offset! @string.special 0 0 0 -1)
+  (#set! conceal ""))
+
+[
+  (hard_line_break)
+  (backslash_escape)
+] @string.escape
+
+; Only conceal \ but leave escaped character.
+((backslash_escape) @string.escape
+  (#offset! @string.escape 0 0 0 -1)
+  (#set! conceal ""))
+
+(frontmatter_marker) @punctuation.delimiter
+
+(emphasis) @markup.italic
+
+(strong) @markup.strong
+
+(symbol) @string.special.symbol
+
+(insert) @markup.underline
+
+(delete) @markup.strikethrough
+
+[
+  (highlighted)
+  (superscript)
+  (subscript)
+] @string.special
+
+; We need to target tokens specifically because `{=` etc can exist as fallback symbols in
+; regular text, which we don't want to highlight or conceal.
+(highlighted
+  [
+    "{="
+    "=}"
+  ] @punctuation.delimiter
+  (#set! conceal ""))
+
+(insert
+  [
+    "{+"
+    "+}"
+  ] @punctuation.delimiter
+  (#set! conceal ""))
+
+(delete
+  [
+    "{-"
+    "-}"
+  ] @punctuation.delimiter
+  (#set! conceal ""))
+
+(superscript
+  [
+    "^"
+    "{^"
+    "^}"
+  ] @punctuation.delimiter
+  (#set! conceal ""))
+
+(subscript
+  [
+    "~"
+    "{~"
+    "~}"
+  ] @punctuation.delimiter
+  (#set! conceal ""))
+
+([
+  (emphasis_begin)
+  (emphasis_end)
+  (strong_begin)
+  (strong_end)
+  (verbatim_marker_begin)
+  (verbatim_marker_end)
+  (math_marker)
+  (math_marker_begin)
+  (math_marker_end)
+  (raw_inline_attribute)
+  (raw_inline_marker_begin)
+  (raw_inline_marker_end)
+] @punctuation.delimiter
+  (#set! conceal ""))
+
+((math) @markup.math
+  (#set! priority 90))
+
+(verbatim) @markup.raw
+
+((raw_inline) @markup.raw
+  (#set! priority 90))
+
+(comment
+  "%" @comment
+  (#set! conceal ""))
+
+(span
+  [
+    "["
+    "]"
+  ] @punctuation.bracket)
+
+(inline_attribute
+  [
+    "{"
+    "}"
+  ] @punctuation.bracket)
+
+(block_attribute
+  [
+    "{"
+    "}"
+  ] @punctuation.bracket)
+
+[
+  (class)
+  (class_name)
+] @type
+
+(identifier) @tag
+
+(key_value
+  "=" @operator)
+
+(key_value
+  (key) @property)
+
+(key_value
+  (value) @string)
+
+(link_text
+  [
+    "["
+    "]"
+  ] @punctuation.bracket
+  (#set! conceal ""))
+
+(autolink
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket
+  (#set! conceal ""))
+
+(inline_link
+  (inline_link_destination) @markup.link.url
+  (#set! conceal ""))
+
+(link_reference_definition
+  ":" @punctuation.special)
+
+(full_reference_link
+  (link_text) @markup.link)
+
+(full_reference_link
+  (link_label) @markup.link.label
+  (#set! conceal ""))
+
+(collapsed_reference_link
+  "[]" @punctuation.bracket
+  (#set! conceal ""))
+
+(full_reference_link
+  [
+    "["
+    "]"
+  ] @punctuation.bracket
+  (#set! conceal ""))
+
+(collapsed_reference_link
+  (link_text) @markup.link)
+
+(collapsed_reference_link
+  (link_text) @markup.link.label)
+
+(inline_link
+  (link_text) @markup.link)
+
+(full_reference_image
+  (link_label) @markup.link.label)
+
+(full_reference_image
+  [
+    "!["
+    "["
+    "]"
+  ] @punctuation.bracket)
+
+(collapsed_reference_image
+  [
+    "!["
+    "]"
+  ] @punctuation.bracket)
+
+(inline_image
+  [
+    "!["
+    "]"
+  ] @punctuation.bracket)
+
+(image_description) @markup.italic
+
+(image_description
+  [
+    "["
+    "]"
+  ] @punctuation.bracket)
+
+(link_reference_definition
+  [
+    "["
+    "]"
+  ] @punctuation.bracket)
+
+(link_reference_definition
+  (link_label) @markup.link.label)
+
+(inline_link_destination
+  [
+    "("
+    ")"
+  ] @punctuation.bracket)
+
+[
+  (autolink)
+  (inline_link_destination)
+  (link_destination)
+  (link_reference_definition)
+] @markup.link.url
+
+(footnote
+  (reference_label) @markup.link.label)
+
+(footnote_reference
+  (reference_label) @markup.link.label)
+
+[
+  (footnote_marker_begin)
+  (footnote_marker_end)
+] @punctuation.bracket
+
+(todo) @comment.todo
+
+(note) @comment.note
+
+(fixme) @comment.error
+
+[
+  (paragraph)
+  (comment)
+  (table_cell)
+] @spell
+
+[
+  (autolink)
+  (inline_link_destination)
+  (link_destination)
+  (code_block)
+  (raw_block)
+  (math)
+  (raw_inline)
+  (verbatim)
+  (reference_label)
+  (class)
+  (class_name)
+  (identifier)
+  (key_value)
+  (frontmatter)
+] @nospell
+
+(full_reference_link
+  (link_label) @nospell)
+
+(full_reference_image
+  (link_label) @nospell)
diff --git a/pack/ant/start/nvim-treesitter/queries/djot/indents.scm b/pack/ant/start/nvim-treesitter/queries/djot/indents.scm
new file mode 100644
index 0000000..3b1a56e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/djot/indents.scm
@@ -0,0 +1,10 @@
+; The intention here is to rely on Neovims `autoindent` setting.
+; This allows us to not indent after just a single list item
+; so we can create narrow lists quickly, but indent blocks inside list items
+; to the previous paragraph.
+(list_item_content) @indent.auto
+
+(footnote_content) @indent.align
+
+((table_caption) @indent.begin
+  (#set! indent.immediate 1))
diff --git a/pack/ant/start/nvim-treesitter/queries/djot/injections.scm b/pack/ant/start/nvim-treesitter/queries/djot/injections.scm
new file mode 100644
index 0000000..078b403
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/djot/injections.scm
@@ -0,0 +1,20 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+(code_block
+  (language) @injection.language
+  (code) @injection.content)
+
+(raw_block
+  (raw_block_info
+    (language) @injection.language)
+  (content) @injection.content)
+
+(raw_inline
+  (content) @injection.content
+  (raw_inline_attribute
+    (language) @injection.language))
+
+(frontmatter
+  (language) @injection.language
+  (frontmatter_content) @injection.content)
diff --git a/pack/ant/start/nvim-treesitter/queries/djot/locals.scm b/pack/ant/start/nvim-treesitter/queries/djot/locals.scm
new file mode 100644
index 0000000..1ac2752
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/djot/locals.scm
@@ -0,0 +1,17 @@
+(link_reference_definition
+  (link_label) @local.definition)
+
+(footnote
+  (reference_label) @local.definition)
+
+(collapsed_reference_link
+  (link_text) @local.reference)
+
+(full_reference_link
+  (link_label) @local.reference)
+
+(full_reference_image
+  (link_label) @local.reference)
+
+(footnote_reference
+  (reference_label) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/dockerfile/highlights.scm b/pack/ant/start/nvim-treesitter/queries/dockerfile/highlights.scm
new file mode 100644
index 0000000..72893f8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dockerfile/highlights.scm
@@ -0,0 +1,68 @@
+[
+  "FROM"
+  "AS"
+  "RUN"
+  "CMD"
+  "LABEL"
+  "EXPOSE"
+  "ENV"
+  "ADD"
+  "COPY"
+  "ENTRYPOINT"
+  "VOLUME"
+  "USER"
+  "WORKDIR"
+  "ARG"
+  "ONBUILD"
+  "STOPSIGNAL"
+  "HEALTHCHECK"
+  "SHELL"
+  "MAINTAINER"
+  "CROSS_BUILD"
+] @keyword
+
+[
+  ":"
+  "@"
+] @operator
+
+(comment) @comment @spell
+
+(image_spec
+  (image_tag
+    ":" @punctuation.special)
+  (image_digest
+    "@" @punctuation.special))
+
+(double_quoted_string) @string
+
+[
+  (heredoc_marker)
+  (heredoc_end)
+] @label
+
+((heredoc_block
+  (heredoc_line) @string)
+  (#set! priority 90))
+
+(expansion
+  [
+    "$"
+    "{"
+    "}"
+  ] @punctuation.special)
+
+((variable) @constant
+  (#lua-match? @constant "^[A-Z][A-Z_0-9]*$"))
+
+(arg_instruction
+  .
+  (unquoted_string) @property)
+
+(env_instruction
+  (env_pair
+    .
+    (unquoted_string) @property))
+
+(expose_instruction
+  (expose_port) @number)
diff --git a/pack/ant/start/nvim-treesitter/queries/dockerfile/injections.scm b/pack/ant/start/nvim-treesitter/queries/dockerfile/injections.scm
new file mode 100644
index 0000000..5d3bbff
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dockerfile/injections.scm
@@ -0,0 +1,12 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((shell_command
+  (shell_fragment) @injection.content)
+  (#set! injection.language "bash")
+  (#set! injection.combined))
+
+((run_instruction
+  (heredoc_block) @injection.content)
+  (#set! injection.language "bash")
+  (#set! injection.include-children))
diff --git a/pack/ant/start/nvim-treesitter/queries/dot/highlights.scm b/pack/ant/start/nvim-treesitter/queries/dot/highlights.scm
new file mode 100644
index 0000000..75ad922
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dot/highlights.scm
@@ -0,0 +1,49 @@
+(identifier) @type
+
+[
+  "strict"
+  "graph"
+  "digraph"
+  "subgraph"
+  "node"
+  "edge"
+] @keyword
+
+(string_literal) @string
+
+(number_literal) @number
+
+[
+  (edgeop)
+  (operator)
+] @operator
+
+[
+  ","
+  ";"
+] @punctuation.delimiter
+
+[
+  "{"
+  "}"
+  "["
+  "]"
+  "<"
+  ">"
+] @punctuation.bracket
+
+(subgraph
+  id: (id
+    (identifier) @module))
+
+(attribute
+  name: (id
+    (identifier) @variable.member))
+
+(attribute
+  value: (id
+    (identifier) @constant))
+
+(comment) @comment @spell
+
+(preproc) @keyword.directive
diff --git a/pack/ant/start/nvim-treesitter/queries/dot/indents.scm b/pack/ant/start/nvim-treesitter/queries/dot/indents.scm
new file mode 100644
index 0000000..a951e55
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dot/indents.scm
@@ -0,0 +1,9 @@
+[
+  (block)
+  (attr_list)
+] @indent.begin
+
+[
+  "}"
+  "]"
+] @indent.branch @indent.end
diff --git a/pack/ant/start/nvim-treesitter/queries/dot/injections.scm b/pack/ant/start/nvim-treesitter/queries/dot/injections.scm
new file mode 100644
index 0000000..4fe39a8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dot/injections.scm
@@ -0,0 +1,5 @@
+((html_internal) @injection.content
+  (#set! injection.language "html"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/doxygen/highlights.scm b/pack/ant/start/nvim-treesitter/queries/doxygen/highlights.scm
new file mode 100644
index 0000000..454500d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/doxygen/highlights.scm
@@ -0,0 +1,61 @@
+((tag_name) @keyword
+  (#set! priority 105))
+
+[
+  "@code"
+  "@endcode"
+] @keyword
+
+(identifier) @variable
+
+((tag
+  (tag_name) @_param
+  (identifier) @variable.parameter)
+  (#any-of? @_param "@param" "\\param"))
+
+(function
+  (identifier) @function)
+
+(function_link) @function
+
+(emphasis) @markup.italic
+
+[
+  "\\a"
+  "\\c"
+] @tag
+
+(code_block_language) @label
+
+[
+  "in"
+  "out"
+  "inout"
+] @keyword.modifier
+
+"~" @operator
+
+[
+  "<a"
+  ">"
+  "</a>"
+] @tag
+
+[
+  "."
+  ","
+  "::"
+  (code_block_start)
+  (code_block_end)
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+(code_block_content) @none
diff --git a/pack/ant/start/nvim-treesitter/queries/doxygen/indents.scm b/pack/ant/start/nvim-treesitter/queries/doxygen/indents.scm
new file mode 100644
index 0000000..ef30f1e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/doxygen/indents.scm
@@ -0,0 +1 @@
+(document) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/doxygen/injections.scm b/pack/ant/start/nvim-treesitter/queries/doxygen/injections.scm
new file mode 100644
index 0000000..994f535
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/doxygen/injections.scm
@@ -0,0 +1,15 @@
+((type) @injection.content
+  (#set! injection.parent))
+
+([
+  (function_link)
+  (code)
+] @injection.content
+  (#set! injection.parent))
+
+((link) @injection.content
+  (#set! injection.language "html"))
+
+(code_block
+  (code_block_language) @injection.language
+  (code_block_content) @injection.content)
diff --git a/pack/ant/start/nvim-treesitter/queries/dtd/folds.scm b/pack/ant/start/nvim-treesitter/queries/dtd/folds.scm
new file mode 100644
index 0000000..b1bce4f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dtd/folds.scm
@@ -0,0 +1,4 @@
+[
+  (conditionalSect)
+  (Comment)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/dtd/highlights.scm b/pack/ant/start/nvim-treesitter/queries/dtd/highlights.scm
new file mode 100644
index 0000000..9afd6e3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dtd/highlights.scm
@@ -0,0 +1,148 @@
+; Text declaration
+(TextDecl
+  "xml" @keyword.directive)
+
+(TextDecl
+  [
+    "version"
+    "encoding"
+  ] @tag.attribute)
+
+(TextDecl
+  (EncName) @string.special)
+
+(TextDecl
+  (VersionNum) @number)
+
+; Processing instructions
+(PI) @keyword.directive
+
+; Element declaration
+(elementdecl
+  "ELEMENT" @keyword.directive.define
+  (Name) @tag)
+
+(contentspec
+  (_
+    (Name) @tag.attribute))
+
+"#PCDATA" @type.builtin
+
+[
+  "EMPTY"
+  "ANY"
+] @keyword.modifier
+
+[
+  "*"
+  "?"
+  "+"
+] @character.special
+
+; Entity declaration
+(GEDecl
+  "ENTITY" @keyword.directive.define
+  (Name) @constant)
+
+(GEDecl
+  (EntityValue) @string)
+
+(NDataDecl
+  "NDATA" @keyword
+  (Name) @label)
+
+; Parsed entity declaration
+(PEDecl
+  "ENTITY" @keyword.directive.define
+  "%" @operator
+  (Name) @function.macro)
+
+(PEDecl
+  (EntityValue) @string)
+
+; Notation declaration
+(NotationDecl
+  "NOTATION" @keyword.directive
+  (Name) @label)
+
+; Attlist declaration
+(AttlistDecl
+  "ATTLIST" @keyword.directive.define
+  (Name) @tag)
+
+(AttDef
+  (Name) @tag.attribute)
+
+(AttDef
+  (Enumeration
+    (Nmtoken) @string))
+
+[
+  (StringType)
+  (TokenizedType)
+] @type.builtin
+
+(NotationType
+  "NOTATION" @type.builtin)
+
+[
+  "#REQUIRED"
+  "#IMPLIED"
+  "#FIXED"
+] @attribute
+
+; Entities
+(EntityRef) @constant
+
+((EntityRef) @constant.builtin
+  (#any-of? @constant.builtin "&amp;" "&lt;" "&gt;" "&quot;" "&apos;"))
+
+(CharRef) @character
+
+(PEReference) @function.macro
+
+; External references
+[
+  "PUBLIC"
+  "SYSTEM"
+] @keyword
+
+(PubidLiteral) @string.special
+
+(SystemLiteral
+  (URI) @string.special.url)
+
+; Delimiters & punctuation
+[
+  "<?"
+  "?>"
+  "<!"
+  ">"
+  "<!["
+  "]]>"
+] @tag.delimiter
+
+[
+  "("
+  ")"
+  "["
+] @punctuation.bracket
+
+[
+  "\""
+  "'"
+] @punctuation.delimiter
+
+[
+  ","
+  "|"
+  "="
+] @operator
+
+; Misc
+[
+  "INCLUDE"
+  "IGNORE"
+] @keyword.import
+
+(Comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/dtd/injections.scm b/pack/ant/start/nvim-treesitter/queries/dtd/injections.scm
new file mode 100644
index 0000000..ed5557a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dtd/injections.scm
@@ -0,0 +1 @@
+(Comment) @comment
diff --git a/pack/ant/start/nvim-treesitter/queries/dtd/locals.scm b/pack/ant/start/nvim-treesitter/queries/dtd/locals.scm
new file mode 100644
index 0000000..88246c0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/dtd/locals.scm
@@ -0,0 +1,11 @@
+(elementdecl
+  (Name) @local.definition.type)
+
+(elementdecl
+  (contentspec
+    (children
+      (Name) @local.reference)))
+
+(AttlistDecl
+  .
+  (Name) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/earthfile/highlights.scm b/pack/ant/start/nvim-treesitter/queries/earthfile/highlights.scm
new file mode 100644
index 0000000..cc7dce2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/earthfile/highlights.scm
@@ -0,0 +1,129 @@
+(string_array
+  "," @punctuation.delimiter)
+
+(string_array
+  [
+    "["
+    "]"
+  ] @punctuation.bracket)
+
+[
+  "ARG"
+  "AS LOCAL"
+  "BUILD"
+  "CACHE"
+  "CMD"
+  "COPY"
+  "DO"
+  "ENTRYPOINT"
+  "ENV"
+  "EXPOSE"
+  "FROM DOCKERFILE"
+  "FROM"
+  "FUNCTION"
+  "GIT CLONE"
+  "HOST"
+  "IMPORT"
+  "LABEL"
+  "LET"
+  "PROJECT"
+  "RUN"
+  "SAVE ARTIFACT"
+  "SAVE IMAGE"
+  "SET"
+  "USER"
+  "VERSION"
+  "VOLUME"
+  "WORKDIR"
+] @keyword
+
+(for_command
+  [
+    "FOR"
+    "IN"
+    "END"
+  ] @keyword.repeat)
+
+(if_command
+  [
+    "IF"
+    "END"
+  ] @keyword.conditional)
+
+(elif_block
+  "ELSE IF" @keyword.conditional)
+
+(else_block
+  "ELSE" @keyword.conditional)
+
+(import_command
+  [
+    "IMPORT"
+    "AS"
+  ] @keyword.import)
+
+(try_command
+  [
+    "TRY"
+    "FINALLY"
+    "END"
+  ] @keyword.exception)
+
+(wait_command
+  [
+    "WAIT"
+    "END"
+  ] @keyword)
+
+(with_docker_command
+  [
+    "WITH DOCKER"
+    "END"
+  ] @keyword)
+
+[
+  (comment)
+  (line_continuation_comment)
+] @comment @spell
+
+[
+  (target_ref)
+  (target_artifact)
+  (function_ref)
+] @function
+
+(target
+  (identifier) @function)
+
+[
+  (double_quoted_string)
+  (single_quoted_string)
+] @string
+
+(unquoted_string) @string.special
+
+(escape_sequence) @string.escape
+
+(variable) @variable
+
+(expansion
+  [
+    "$"
+    "{"
+    "}"
+    "("
+    ")"
+  ] @punctuation.special)
+
+(build_arg
+  [
+    "--"
+    (variable)
+  ] @variable.parameter)
+
+(options
+  (_) @property)
+
+"=" @operator
+
+(line_continuation) @operator
diff --git a/pack/ant/start/nvim-treesitter/queries/earthfile/injections.scm b/pack/ant/start/nvim-treesitter/queries/earthfile/injections.scm
new file mode 100644
index 0000000..7435a40
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/earthfile/injections.scm
@@ -0,0 +1,9 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((line_continuation_comment) @injection.content
+  (#set! injection.language "comment"))
+
+((shell_fragment) @injection.content
+  (#set! injection.language "bash")
+  (#set! injection.include-children))
diff --git a/pack/ant/start/nvim-treesitter/queries/ebnf/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ebnf/highlights.scm
new file mode 100644
index 0000000..4254d04
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ebnf/highlights.scm
@@ -0,0 +1,42 @@
+; Simple tokens ;;;;
+(terminal) @string
+
+(special_sequence) @string.special
+
+(integer) @number
+
+(comment) @comment @spell
+
+; Identifiers ;;;;
+; Allow different highlighting for specific casings
+((identifier) @type
+  (#lua-match? @type "^%u"))
+
+((identifier) @string.special.symbol
+  (#lua-match? @string.special.symbol "^%l"))
+
+((identifier) @constant
+  (#lua-match? @constant "^%u[%u%d_]+$"))
+
+; Punctuation ;;;;
+[
+  ";"
+  ","
+] @punctuation.delimiter
+
+[
+  "|"
+  "*"
+  "-"
+] @operator
+
+"=" @keyword.operator
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/ebnf/injections.scm b/pack/ant/start/nvim-treesitter/queries/ebnf/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ebnf/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/ecma/folds.scm b/pack/ant/start/nvim-treesitter/queries/ecma/folds.scm
new file mode 100644
index 0000000..a348f34
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ecma/folds.scm
@@ -0,0 +1,24 @@
+[
+  (arguments)
+  (for_in_statement)
+  (for_statement)
+  (while_statement)
+  (arrow_function)
+  (function_expression)
+  (function_declaration)
+  (class_declaration)
+  (method_definition)
+  (do_statement)
+  (with_statement)
+  (switch_statement)
+  (switch_case)
+  (switch_default)
+  (import_statement)+
+  (if_statement)
+  (try_statement)
+  (catch_clause)
+  (array)
+  (object)
+  (generator_function)
+  (generator_function_declaration)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/ecma/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ecma/highlights.scm
new file mode 100644
index 0000000..038df56
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ecma/highlights.scm
@@ -0,0 +1,380 @@
+; Types
+; Javascript
+; Variables
+;-----------
+(identifier) @variable
+
+; Properties
+;-----------
+(property_identifier) @variable.member
+
+(shorthand_property_identifier) @variable.member
+
+(private_property_identifier) @variable.member
+
+(object_pattern
+  (shorthand_property_identifier_pattern) @variable)
+
+(object_pattern
+  (object_assignment_pattern
+    (shorthand_property_identifier_pattern) @variable))
+
+; Special identifiers
+;--------------------
+((identifier) @type
+  (#lua-match? @type "^[A-Z]"))
+
+((identifier) @constant
+  (#lua-match? @constant "^_*[A-Z][A-Z%d_]*$"))
+
+((shorthand_property_identifier) @constant
+  (#lua-match? @constant "^_*[A-Z][A-Z%d_]*$"))
+
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin "arguments" "module" "console" "window" "document"))
+
+((identifier) @type.builtin
+  (#any-of? @type.builtin
+    "Object" "Function" "Boolean" "Symbol" "Number" "Math" "Date" "String" "RegExp" "Map" "Set"
+    "WeakMap" "WeakSet" "Promise" "Array" "Int8Array" "Uint8Array" "Uint8ClampedArray" "Int16Array"
+    "Uint16Array" "Int32Array" "Uint32Array" "Float32Array" "Float64Array" "ArrayBuffer" "DataView"
+    "Error" "EvalError" "InternalError" "RangeError" "ReferenceError" "SyntaxError" "TypeError"
+    "URIError"))
+
+(statement_identifier) @label
+
+; Function and method definitions
+;--------------------------------
+(function_expression
+  name: (identifier) @function)
+
+(function_declaration
+  name: (identifier) @function)
+
+(generator_function
+  name: (identifier) @function)
+
+(generator_function_declaration
+  name: (identifier) @function)
+
+(method_definition
+  name: [
+    (property_identifier)
+    (private_property_identifier)
+  ] @function.method)
+
+(method_definition
+  name: (property_identifier) @constructor
+  (#eq? @constructor "constructor"))
+
+(pair
+  key: (property_identifier) @function.method
+  value: (function_expression))
+
+(pair
+  key: (property_identifier) @function.method
+  value: (arrow_function))
+
+(assignment_expression
+  left: (member_expression
+    property: (property_identifier) @function.method)
+  right: (arrow_function))
+
+(assignment_expression
+  left: (member_expression
+    property: (property_identifier) @function.method)
+  right: (function_expression))
+
+(variable_declarator
+  name: (identifier) @function
+  value: (arrow_function))
+
+(variable_declarator
+  name: (identifier) @function
+  value: (function_expression))
+
+(assignment_expression
+  left: (identifier) @function
+  right: (arrow_function))
+
+(assignment_expression
+  left: (identifier) @function
+  right: (function_expression))
+
+; Function and method calls
+;--------------------------
+(call_expression
+  function: (identifier) @function.call)
+
+(call_expression
+  function: (member_expression
+    property: [
+      (property_identifier)
+      (private_property_identifier)
+    ] @function.method.call))
+
+; Builtins
+;---------
+((identifier) @module.builtin
+  (#eq? @module.builtin "Intl"))
+
+((identifier) @function.builtin
+  (#any-of? @function.builtin
+    "eval" "isFinite" "isNaN" "parseFloat" "parseInt" "decodeURI" "decodeURIComponent" "encodeURI"
+    "encodeURIComponent" "require"))
+
+; Constructor
+;------------
+(new_expression
+  constructor: (identifier) @constructor)
+
+; Decorators
+;----------
+(decorator
+  "@" @attribute
+  (identifier) @attribute)
+
+(decorator
+  "@" @attribute
+  (call_expression
+    (identifier) @attribute))
+
+(decorator
+  "@" @attribute
+  (member_expression
+    (property_identifier) @attribute))
+
+(decorator
+  "@" @attribute
+  (call_expression
+    (member_expression
+      (property_identifier) @attribute)))
+
+; Literals
+;---------
+[
+  (this)
+  (super)
+] @variable.builtin
+
+((identifier) @variable.builtin
+  (#eq? @variable.builtin "self"))
+
+[
+  (true)
+  (false)
+] @boolean
+
+[
+  (null)
+  (undefined)
+] @constant.builtin
+
+[
+  (comment)
+  (html_comment)
+] @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$"))
+
+(hash_bang_line) @keyword.directive
+
+((string_fragment) @keyword.directive
+  (#eq? @keyword.directive "use strict"))
+
+(string) @string
+
+(template_string) @string
+
+(escape_sequence) @string.escape
+
+(regex_pattern) @string.regexp
+
+(regex_flags) @character.special
+
+(regex
+  "/" @punctuation.bracket) ; Regex delimiters
+
+(number) @number
+
+((identifier) @number
+  (#any-of? @number "NaN" "Infinity"))
+
+; Punctuation
+;------------
+[
+  ";"
+  "."
+  ","
+  ":"
+] @punctuation.delimiter
+
+[
+  "--"
+  "-"
+  "-="
+  "&&"
+  "+"
+  "++"
+  "+="
+  "&="
+  "/="
+  "**="
+  "<<="
+  "<"
+  "<="
+  "<<"
+  "="
+  "=="
+  "==="
+  "!="
+  "!=="
+  "=>"
+  ">"
+  ">="
+  ">>"
+  "||"
+  "%"
+  "%="
+  "*"
+  "**"
+  ">>>"
+  "&"
+  "|"
+  "^"
+  "??"
+  "*="
+  ">>="
+  ">>>="
+  "^="
+  "|="
+  "&&="
+  "||="
+  "??="
+  "..."
+] @operator
+
+(binary_expression
+  "/" @operator)
+
+(ternary_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+(unary_expression
+  [
+    "!"
+    "~"
+    "-"
+    "+"
+  ] @operator)
+
+(unary_expression
+  [
+    "delete"
+    "void"
+  ] @keyword.operator)
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+(template_substitution
+  [
+    "${"
+    "}"
+  ] @punctuation.special) @none
+
+; Imports
+;----------
+(namespace_import
+  "*" @character.special
+  (identifier) @module)
+
+(namespace_export
+  "*" @character.special
+  (identifier) @module)
+
+(export_statement
+  "*" @character.special)
+
+; Keywords
+;----------
+[
+  "if"
+  "else"
+  "switch"
+  "case"
+] @keyword.conditional
+
+[
+  "import"
+  "from"
+  "as"
+  "export"
+] @keyword.import
+
+[
+  "for"
+  "of"
+  "do"
+  "while"
+  "continue"
+] @keyword.repeat
+
+[
+  "break"
+  "const"
+  "debugger"
+  "extends"
+  "get"
+  "let"
+  "set"
+  "static"
+  "target"
+  "var"
+  "with"
+] @keyword
+
+"class" @keyword.type
+
+[
+  "async"
+  "await"
+] @keyword.coroutine
+
+[
+  "return"
+  "yield"
+] @keyword.return
+
+"function" @keyword.function
+
+[
+  "new"
+  "delete"
+  "in"
+  "instanceof"
+  "typeof"
+] @keyword.operator
+
+[
+  "throw"
+  "try"
+  "catch"
+  "finally"
+] @keyword.exception
+
+(export_statement
+  "default" @keyword)
+
+(switch_default
+  "default" @keyword.conditional)
diff --git a/pack/ant/start/nvim-treesitter/queries/ecma/indents.scm b/pack/ant/start/nvim-treesitter/queries/ecma/indents.scm
new file mode 100644
index 0000000..d567416
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ecma/indents.scm
@@ -0,0 +1,82 @@
+[
+  (arguments)
+  (array)
+  (binary_expression)
+  (class_body)
+  (export_clause)
+  (formal_parameters)
+  (named_imports)
+  (object)
+  (object_pattern)
+  (parenthesized_expression)
+  (return_statement)
+  (statement_block)
+  (switch_case)
+  (switch_default)
+  (switch_statement)
+  (template_substitution)
+  (ternary_expression)
+] @indent.begin
+
+(arguments
+  (call_expression) @indent.begin)
+
+(binary_expression
+  (call_expression) @indent.begin)
+
+(expression_statement
+  (call_expression) @indent.begin)
+
+(arrow_function
+  body: (_) @_body
+  (#not-kind-eq? @_body "statement_block")) @indent.begin
+
+(assignment_expression
+  right: (_) @_right
+  (#not-kind-eq? @_right "arrow_function" "function")) @indent.begin
+
+(variable_declarator
+  value: (_) @_value
+  (#not-kind-eq? @_value "arrow_function" "call_expression" "function")) @indent.begin
+
+(arguments
+  ")" @indent.end)
+
+(object
+  "}" @indent.end)
+
+(statement_block
+  "}" @indent.end)
+
+[
+  (arguments
+    (object))
+  ")"
+  "}"
+  "]"
+] @indent.branch
+
+(statement_block
+  "{" @indent.branch)
+
+((parenthesized_expression
+  "("
+  (_)
+  ")" @indent.end) @_outer
+  (#not-has-parent? @_outer if_statement))
+
+[
+  "}"
+  "]"
+] @indent.end
+
+(template_string) @indent.ignore
+
+[
+  (comment)
+  (ERROR)
+] @indent.auto
+
+(if_statement
+  consequence: (_) @indent.dedent
+  (#not-kind-eq? @indent.dedent statement_block)) @indent.begin
diff --git a/pack/ant/start/nvim-treesitter/queries/ecma/injections.scm b/pack/ant/start/nvim-treesitter/queries/ecma/injections.scm
new file mode 100644
index 0000000..04abafc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ecma/injections.scm
@@ -0,0 +1,203 @@
+(((comment) @_jsdoc_comment
+  (#lua-match? @_jsdoc_comment "^/[*][*][^*].*[*]/$")) @injection.content
+  (#set! injection.language "jsdoc"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; html(`...`), html`...`, sql(`...`), etc.
+(call_expression
+  function: (identifier) @injection.language
+  arguments: [
+    (arguments
+      (template_string) @injection.content)
+    (template_string) @injection.content
+  ]
+  (#lua-match? @injection.language "^[a-zA-Z][a-zA-Z0-9]*$")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.include-children)
+  ; Languages excluded from auto-injection due to special rules
+  ; - svg uses the html parser
+  ; - css uses the styled parser
+  (#not-any-of? @injection.language "svg" "css"))
+
+; svg`...` or svg(`...`)
+(call_expression
+  function: (identifier) @_name
+  (#eq? @_name "svg")
+  arguments: [
+    (arguments
+      (template_string) @injection.content)
+    (template_string) @injection.content
+  ]
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.include-children)
+  (#set! injection.language "html"))
+
+; Vercel PostgreSQL
+; foo.sql`...` or foo.sql(`...`)
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @injection.language)
+  arguments: [
+    (arguments
+      (template_string) @injection.content)
+    (template_string) @injection.content
+  ]
+  (#eq? @injection.language "sql")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.include-children))
+
+(call_expression
+  function: (identifier) @_name
+  (#eq? @_name "gql")
+  arguments: (template_string) @injection.content
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.include-children)
+  (#set! injection.language "graphql"))
+
+(call_expression
+  function: (identifier) @_name
+  (#eq? @_name "hbs")
+  arguments: (template_string) @injection.content
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.include-children)
+  (#set! injection.language "glimmer"))
+
+; css`<css>`, keyframes`<css>`
+(call_expression
+  function: (identifier) @_name
+  (#any-of? @_name "css" "keyframes")
+  arguments: (template_string) @injection.content
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.include-children)
+  (#set! injection.language "styled"))
+
+; styled.div`<css>`
+(call_expression
+  function: (member_expression
+    object: (identifier) @_name
+    (#eq? @_name "styled"))
+  arguments: ((template_string) @injection.content
+    (#offset! @injection.content 0 1 0 -1)
+    (#set! injection.include-children)
+    (#set! injection.language "styled")))
+
+; styled(Component)`<css>`
+(call_expression
+  function: (call_expression
+    function: (identifier) @_name
+    (#eq? @_name "styled"))
+  arguments: ((template_string) @injection.content
+    (#offset! @injection.content 0 1 0 -1)
+    (#set! injection.include-children)
+    (#set! injection.language "styled")))
+
+; styled.div.attrs({ prop: "foo" })`<css>`
+(call_expression
+  function: (call_expression
+    function: (member_expression
+      object: (member_expression
+        object: (identifier) @_name
+        (#eq? @_name "styled"))))
+  arguments: ((template_string) @injection.content
+    (#offset! @injection.content 0 1 0 -1)
+    (#set! injection.include-children)
+    (#set! injection.language "styled")))
+
+; styled(Component).attrs({ prop: "foo" })`<css>`
+(call_expression
+  function: (call_expression
+    function: (member_expression
+      object: (call_expression
+        function: (identifier) @_name
+        (#eq? @_name "styled"))))
+  arguments: ((template_string) @injection.content
+    (#offset! @injection.content 0 1 0 -1)
+    (#set! injection.include-children)
+    (#set! injection.language "styled")))
+
+((regex_pattern) @injection.content
+  (#set! injection.language "regex"))
+
+; ((comment) @_gql_comment
+;   (#eq? @_gql_comment "/* GraphQL */")
+;   (template_string) @injection.content
+;   (#set! injection.language "graphql"))
+((template_string) @injection.content
+  (#lua-match? @injection.content "^`#graphql")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.include-children)
+  (#set! injection.language "graphql"))
+
+; el.innerHTML = `<html>`
+(assignment_expression
+  left: (member_expression
+    property: (property_identifier) @_prop
+    (#any-of? @_prop "outerHTML" "innerHTML"))
+  right: (template_string) @injection.content
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.include-children)
+  (#set! injection.language "html"))
+
+; el.innerHTML = '<html>'
+(assignment_expression
+  left: (member_expression
+    property: (property_identifier) @_prop
+    (#any-of? @_prop "outerHTML" "innerHTML"))
+  right: (string
+    (string_fragment) @injection.content)
+  (#set! injection.language "html"))
+
+;---- Angular injections -----
+; @Component({
+;   template: `<html>`
+; })
+(decorator
+  (call_expression
+    function: ((identifier) @_name
+      (#eq? @_name "Component"))
+    arguments: (arguments
+      (object
+        (pair
+          key: ((property_identifier) @_prop
+            (#eq? @_prop "template"))
+          value: ((template_string) @injection.content
+            (#offset! @injection.content 0 1 0 -1)
+            (#set! injection.include-children)
+            (#set! injection.language "angular")))))))
+
+; @Component({
+;   styles: [`<css>`]
+; })
+(decorator
+  (call_expression
+    function: ((identifier) @_name
+      (#eq? @_name "Component"))
+    arguments: (arguments
+      (object
+        (pair
+          key: ((property_identifier) @_prop
+            (#eq? @_prop "styles"))
+          value: (array
+            ((template_string) @injection.content
+              (#offset! @injection.content 0 1 0 -1)
+              (#set! injection.include-children)
+              (#set! injection.language "css"))))))))
+
+; @Component({
+;   styles: `<css>`
+; })
+(decorator
+  (call_expression
+    function: ((identifier) @_name
+      (#eq? @_name "Component"))
+    arguments: (arguments
+      (object
+        (pair
+          key: ((property_identifier) @_prop
+            (#eq? @_prop "styles"))
+          value: ((template_string) @injection.content
+            (#set! injection.include-children)
+            (#offset! @injection.content 0 1 0 -1)
+            (#set! injection.language "css")))))))
diff --git a/pack/ant/start/nvim-treesitter/queries/ecma/locals.scm b/pack/ant/start/nvim-treesitter/queries/ecma/locals.scm
new file mode 100644
index 0000000..24ea7c0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ecma/locals.scm
@@ -0,0 +1,42 @@
+; Scopes
+;-------
+(statement_block) @local.scope
+
+(function_expression) @local.scope
+
+(arrow_function) @local.scope
+
+(function_declaration) @local.scope
+
+(method_definition) @local.scope
+
+(for_statement) @local.scope
+
+(for_in_statement) @local.scope
+
+(catch_clause) @local.scope
+
+; Definitions
+;------------
+(variable_declarator
+  name: (identifier) @local.definition.var)
+
+(import_specifier
+  (identifier) @local.definition.import)
+
+(namespace_import
+  (identifier) @local.definition.import)
+
+(function_declaration
+  (identifier) @local.definition.function
+  (#set! definition.var.scope parent))
+
+(method_definition
+  (property_identifier) @local.definition.function
+  (#set! definition.var.scope parent))
+
+; References
+;------------
+(identifier) @local.reference
+
+(shorthand_property_identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/editorconfig/folds.scm b/pack/ant/start/nvim-treesitter/queries/editorconfig/folds.scm
new file mode 100644
index 0000000..911798f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/editorconfig/folds.scm
@@ -0,0 +1 @@
+(section) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/editorconfig/highlights.scm b/pack/ant/start/nvim-treesitter/queries/editorconfig/highlights.scm
new file mode 100644
index 0000000..feb0a52
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/editorconfig/highlights.scm
@@ -0,0 +1,55 @@
+(comment) @comment @spell
+
+(section
+  (section_name) @string.special.path)
+
+(character_choice
+  (character) @constant)
+
+(character_range
+  start: (character) @constant
+  end: (character) @constant)
+
+[
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  ","
+  ".."
+  (path_separator)
+] @punctuation.delimiter
+
+[
+  "-"
+  "="
+  (negation)
+] @operator
+
+[
+  (wildcard_characters)
+  (wildcard_any_characters)
+  (wildcard_single_character)
+] @character.special
+
+(escaped_character) @string.escape
+
+(pair
+  key: (identifier) @property
+  value: (_) @string)
+
+(boolean) @boolean
+
+(integer) @number
+
+(unset) @constant.builtin
+
+[
+  (spelling_language)
+  (indent_style)
+  (end_of_line)
+  (charset)
+] @string.special
diff --git a/pack/ant/start/nvim-treesitter/queries/editorconfig/injections.scm b/pack/ant/start/nvim-treesitter/queries/editorconfig/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/editorconfig/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/eds/folds.scm b/pack/ant/start/nvim-treesitter/queries/eds/folds.scm
new file mode 100644
index 0000000..911798f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/eds/folds.scm
@@ -0,0 +1 @@
+(section) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/eds/highlights.scm b/pack/ant/start/nvim-treesitter/queries/eds/highlights.scm
new file mode 100644
index 0000000..0e008c9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/eds/highlights.scm
@@ -0,0 +1,45 @@
+"=" @punctuation.delimiter
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+((section_name) @variable.builtin
+  (#match? @variable.builtin
+    "\\c^(FileInfo|DeviceInfo|DummyUsage|MandatoryObjects|OptionalObjects)$"))
+
+((section_name) @variable.builtin
+  (#lua-match? @variable.builtin "^1"))
+
+(section
+  (section_name) @_name
+  (#match? @_name "\\c^Comments$")) @comment
+
+(section
+  (section_name) @_name
+  (statement
+    (key) @_key) @string
+  (#match? @_key "\\c^ParameterName$")
+  (#not-match? @_name "\\c^Comments$"))
+
+(section
+  (section_name) @_name
+  (statement
+    (key) @_key) @type
+  (#match? @_key "\\c^(ObjectType|DataType|AccessType)$")
+  (#not-match? @_name "\\c^Comments$"))
+
+(section
+  (section_name) @_name
+  (statement
+    (key) @_key) @attribute
+  (#match? @_key "\\c^PDOMapping$")
+  (#not-match? @_name "\\c^Comments$"))
+
+(section
+  (section_name) @_name
+  (statement
+    (key) @_key) @number
+  (#match? @_key "\\c^(DefaultValue|LowLimit|HighLimit|SubNumber)$")
+  (#not-match? @_name "\\c^Comments$"))
diff --git a/pack/ant/start/nvim-treesitter/queries/eex/highlights.scm b/pack/ant/start/nvim-treesitter/queries/eex/highlights.scm
new file mode 100644
index 0000000..d032a74
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/eex/highlights.scm
@@ -0,0 +1,12 @@
+[
+  "%>"
+  "--%>"
+  "<%!--"
+  "<%"
+  "<%#"
+  "<%%="
+  "<%="
+] @tag.delimiter
+
+; EEx comments are highlighted as such
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/eex/injections.scm b/pack/ant/start/nvim-treesitter/queries/eex/injections.scm
new file mode 100644
index 0000000..f13d3c1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/eex/injections.scm
@@ -0,0 +1,8 @@
+; EEx expressions are Elixir
+((expression) @injection.content
+  (#set! injection.language "elixir"))
+
+; EEx expressions can span multiple interpolated lines
+((partial_expression) @injection.content
+  (#set! injection.language "elixir")
+  (#set! injection.combined))
diff --git a/pack/ant/start/nvim-treesitter/queries/elixir/folds.scm b/pack/ant/start/nvim-treesitter/queries/elixir/folds.scm
new file mode 100644
index 0000000..7abfe67
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/elixir/folds.scm
@@ -0,0 +1,10 @@
+[
+  (anonymous_function)
+  (stab_clause)
+  (arguments)
+  (block)
+  (do_block)
+  (list)
+  (map)
+  (tuple)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/elixir/highlights.scm b/pack/ant/start/nvim-treesitter/queries/elixir/highlights.scm
new file mode 100644
index 0000000..cbdb40d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/elixir/highlights.scm
@@ -0,0 +1,217 @@
+; Punctuation
+[
+  ","
+  ";"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "<<"
+  ">>"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+"%" @punctuation.special
+
+; Identifiers
+(identifier) @variable
+
+; Unused Identifiers
+((identifier) @comment
+  (#lua-match? @comment "^_"))
+
+; Comments
+(comment) @comment @spell
+
+; Strings
+(string) @string
+
+; Modules
+(alias) @module
+
+; Atoms & Keywords
+[
+  (atom)
+  (quoted_atom)
+  (keyword)
+  (quoted_keyword)
+] @string.special.symbol
+
+; Interpolation
+(interpolation
+  [
+    "#{"
+    "}"
+  ] @string.special)
+
+; Escape sequences
+(escape_sequence) @string.escape
+
+; Integers
+(integer) @number
+
+; Floats
+(float) @number.float
+
+; Characters
+[
+  (char)
+  (charlist)
+] @character
+
+; Booleans
+(boolean) @boolean
+
+; Nil
+(nil) @constant.builtin
+
+; Operators
+(operator_identifier) @operator
+
+(unary_operator
+  operator: _ @operator)
+
+(binary_operator
+  operator: _ @operator)
+
+; Pipe Operator
+(binary_operator
+  operator: "|>"
+  right: (identifier) @function)
+
+(dot
+  operator: _ @operator)
+
+(stab_clause
+  operator: _ @operator)
+
+; Local Function Calls
+(call
+  target: (identifier) @function.call)
+
+; Remote Function Calls
+(call
+  target: (dot
+    left: [
+      (atom) @type
+      (_)
+    ]
+    right: (identifier) @function.call)
+  (arguments))
+
+; Definition Function Calls
+(call
+  target: ((identifier) @keyword.function
+    (#any-of? @keyword.function
+      "def" "defdelegate" "defexception" "defguard" "defguardp" "defimpl" "defmacro" "defmacrop"
+      "defmodule" "defn" "defnp" "defoverridable" "defp" "defprotocol" "defstruct"))
+  (arguments
+    [
+      (call
+        (identifier) @function)
+      (identifier) @function
+      (binary_operator
+        left: (call
+          target: (identifier) @function)
+        operator: "when")
+    ])?)
+
+; Kernel Keywords & Special Forms
+(call
+  target: ((identifier) @keyword
+    (#any-of? @keyword
+      "alias" "case" "catch" "cond" "else" "for" "if" "import" "quote" "raise" "receive" "require"
+      "reraise" "super" "throw" "try" "unless" "unquote" "unquote_splicing" "use" "with")))
+
+; Special Constants
+((identifier) @constant.builtin
+  (#any-of? @constant.builtin "__CALLER__" "__DIR__" "__ENV__" "__MODULE__" "__STACKTRACE__"))
+
+; Reserved Keywords
+[
+  "after"
+  "catch"
+  "do"
+  "end"
+  "fn"
+  "rescue"
+  "when"
+  "else"
+] @keyword
+
+; Operator Keywords
+[
+  "and"
+  "in"
+  "not in"
+  "not"
+  "or"
+] @keyword.operator
+
+; Capture Operator
+(unary_operator
+  operator: "&"
+  operand: [
+    (integer) @operator
+    (binary_operator
+      left: [
+        (call
+          target: (dot
+            left: (_)
+            right: (identifier) @function))
+        (identifier) @function
+      ]
+      operator: "/"
+      right: (integer) @operator)
+  ])
+
+; Non-String Sigils
+(sigil
+  "~" @string.special
+  (sigil_name) @string.special @_sigil_name
+  quoted_start: _ @string.special
+  quoted_end: _ @string.special
+  ((sigil_modifiers) @string.special)?
+  (#not-any-of? @_sigil_name "s" "S"))
+
+; String Sigils
+(sigil
+  "~" @string
+  (sigil_name) @string @_sigil_name
+  quoted_start: _ @string
+  (quoted_content) @string
+  quoted_end: _ @string
+  ((sigil_modifiers) @string)?
+  (#any-of? @_sigil_name "s" "S"))
+
+; Module attributes
+(unary_operator
+  operator: "@"
+  operand: [
+    (identifier)
+    (call
+      target: (identifier))
+  ] @constant) @constant
+
+; Documentation
+(unary_operator
+  operator: "@"
+  operand: (call
+    target: ((identifier) @_identifier
+      (#any-of? @_identifier "moduledoc" "typedoc" "shortdoc" "doc")) @comment.documentation
+    (arguments
+      [
+        (string)
+        (boolean)
+        (charlist)
+        (sigil
+          "~" @comment.documentation
+          (sigil_name) @comment.documentation
+          quoted_start: _ @comment.documentation
+          (quoted_content) @comment.documentation
+          quoted_end: _ @comment.documentation)
+      ] @comment.documentation))) @comment.documentation
diff --git a/pack/ant/start/nvim-treesitter/queries/elixir/indents.scm b/pack/ant/start/nvim-treesitter/queries/elixir/indents.scm
new file mode 100644
index 0000000..5470b64
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/elixir/indents.scm
@@ -0,0 +1,25 @@
+[
+  (block)
+  (do_block)
+  (list)
+  (map)
+  (stab_clause)
+  (tuple)
+  (arguments)
+] @indent.begin
+
+[
+  ")"
+  "]"
+  "after"
+  "catch"
+  "else"
+  "rescue"
+  "}"
+  "end"
+] @indent.end @indent.branch
+
+; Elixir pipelines are not indented, but other binary operator chains are
+((binary_operator
+  operator: _ @_operator) @indent.begin
+  (#not-eq? @_operator "|>"))
diff --git a/pack/ant/start/nvim-treesitter/queries/elixir/injections.scm b/pack/ant/start/nvim-treesitter/queries/elixir/injections.scm
new file mode 100644
index 0000000..cc74f79
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/elixir/injections.scm
@@ -0,0 +1,59 @@
+; Comments
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; Documentation
+(unary_operator
+  operator: "@"
+  operand: (call
+    target: ((identifier) @_identifier
+      (#any-of? @_identifier "moduledoc" "typedoc" "shortdoc" "doc"))
+    (arguments
+      [
+        (string
+          (quoted_content) @injection.content)
+        (sigil
+          (quoted_content) @injection.content)
+      ])
+    (#set! injection.language "markdown")))
+
+; HEEx
+(sigil
+  (sigil_name) @_sigil_name
+  (quoted_content) @injection.content
+  (#eq? @_sigil_name "H")
+  (#set! injection.language "heex"))
+
+; Surface
+(sigil
+  (sigil_name) @_sigil_name
+  (quoted_content) @injection.content
+  (#eq? @_sigil_name "F")
+  (#set! injection.language "surface"))
+
+; Zigler
+(sigil
+  (sigil_name) @_sigil_name
+  (quoted_content) @injection.content
+  (#any-of? @_sigil_name "E" "L")
+  (#set! injection.language "eex"))
+
+(sigil
+  (sigil_name) @_sigil_name
+  (quoted_content) @injection.content
+  (#any-of? @_sigil_name "z" "Z")
+  (#set! injection.language "zig"))
+
+; Regex
+(sigil
+  (sigil_name) @_sigil_name
+  (quoted_content) @injection.content
+  (#any-of? @_sigil_name "r" "R")
+  (#set! injection.language "regex"))
+
+; Json
+(sigil
+  (sigil_name) @_sigil_name
+  (quoted_content) @injection.content
+  (#any-of? @_sigil_name "j" "J")
+  (#set! injection.language "json"))
diff --git a/pack/ant/start/nvim-treesitter/queries/elixir/locals.scm b/pack/ant/start/nvim-treesitter/queries/elixir/locals.scm
new file mode 100644
index 0000000..ac9d86e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/elixir/locals.scm
@@ -0,0 +1,200 @@
+; References
+(identifier) @local.reference
+
+(alias) @local.reference
+
+; Module Definitions
+(call
+  target: ((identifier) @_identifier
+    (#eq? @_identifier "defmodule"))
+  (arguments
+    (alias) @local.definition.type))
+
+; Pattern Match Definitions
+(binary_operator
+  ; format-ignore
+  left: 
+    [
+      (identifier) @local.definition.var
+      (_ (identifier) @local.definition.var)
+      (_ (_ (identifier) @local.definition.var))
+      (_ (_ (_ (identifier) @local.definition.var)))
+      (_ (_ (_ (_ (identifier) @local.definition.var))))
+      (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))
+      (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))
+      (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))
+      (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))
+      (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))
+      (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))
+      (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))))
+      (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))))
+      (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))))))
+      (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))))))
+      (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))))))))
+      (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))))))))
+      (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))))))))))
+      (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))))))))))
+      (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))))))))))))
+      (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))))))))))))
+    ]
+  operator: "=")
+
+; Stab Clause Definitions
+; format-ignore
+(stab_clause
+  left:
+    [
+     (arguments
+      [
+        (identifier) @local.definition.var
+        (_ (identifier) @local.definition.var)
+        (_ (_ (identifier) @local.definition.var))
+        (_ (_ (_ (identifier) @local.definition.var)))
+        (_ (_ (_ (_ (identifier) @local.definition.var))))
+        (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))
+        (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))
+        (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))
+        (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))
+        (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))
+        (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))
+        (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))))
+        (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))))
+        (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))))))
+        (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))))))
+        (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))))))))
+        (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))))))))
+        (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))))))))))
+        (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))))))))))
+        (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))))))))))))
+        (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))))))))))))
+      ])
+
+    (binary_operator
+      left:
+        (arguments
+          ; format-ignore
+          [
+            (identifier) @local.definition.var
+            (_ (identifier) @local.definition.var)
+            (_ (_ (identifier) @local.definition.var))
+            (_ (_ (_ (identifier) @local.definition.var)))
+            (_ (_ (_ (_ (identifier) @local.definition.var))))
+            (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))
+            (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))
+            (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var)))))))))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.var))))))))))))))))))))
+          ])
+      operator: "when")
+    ])
+
+; Aliases
+; format-ignore
+(call
+  target:
+    ((identifier) @_identifier
+      (#any-of? @_identifier "require" "alias" "use" "import"))
+  (arguments
+    [
+      (alias) @local.definition.import
+      (_ (alias) @local.definition.import)
+      (_ (_ (alias) @local.definition.import))
+      (_ (_ (_ (alias) @local.definition.import)))
+      (_ (_ (_ (_ (alias) @local.definition.import))))
+    ]))
+
+; Local Function Definitions & Scopes
+; format-ignore
+(call
+  target:
+    ((identifier) @_identifier
+      (#any-of? @_identifier "def" "defp" "defmacro" "defmacrop" "defguard" "defguardp" "defn" "defnp" "for"))
+  (arguments
+    [
+      (identifier) @local.definition.function
+      (binary_operator
+        left: (identifier) @local.definition.function
+        operator: "when")
+      (binary_operator
+        (identifier) @local.definition.parameter)
+      (call
+        target: (identifier) @local.definition.function
+        (arguments
+          [
+            (identifier) @local.definition.parameter
+            (_ (identifier) @local.definition.parameter)
+            (_ (_ (identifier) @local.definition.parameter))
+            (_ (_ (_ (identifier) @local.definition.parameter)))
+            (_ (_ (_ (_ (identifier) @local.definition.parameter))))
+            (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))
+            (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))
+            (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))))))))))))))))
+            (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))))))))))))))))
+          ]))
+    ]?)
+  (#set! definition.function.scope parent)(do_block)?) @local.scope
+
+; ExUnit Test Definitions & Scopes
+; format-ignore
+(call
+  target:
+    ((identifier) @_identifier
+      (#eq? @_identifier "test"))
+  (arguments
+    [
+      (string)
+      ((string)
+        .
+        ","
+        .
+        [
+          (identifier) @local.definition.parameter
+          (_ (identifier) @local.definition.parameter)
+          (_ (_ (identifier) @local.definition.parameter))
+          (_ (_ (_ (identifier) @local.definition.parameter)))
+          (_ (_ (_ (_ (identifier) @local.definition.parameter))))
+          (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))
+          (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))
+          (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))))
+          (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))))
+          (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))))))
+          (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))))))
+          (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))))))))
+          (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))))))))
+          (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))))))))))
+          (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))))))))))
+          (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))))))))))))
+          (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))))))))))))
+          (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))))))))))))))
+          (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))))))))))))))
+          (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter)))))))))))))))))))
+          (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (_ (identifier) @local.definition.parameter))))))))))))))))))))
+        ])
+    ])
+  (do_block)?) @local.scope
+
+; Stab Clause Scopes
+(stab_clause) @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/elm/folds.scm b/pack/ant/start/nvim-treesitter/queries/elm/folds.scm
new file mode 100644
index 0000000..56987d9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/elm/folds.scm
@@ -0,0 +1,14 @@
+((function_call_expr) @_fn
+  (#not-has-parent? @_fn parenthesized_expr)) @fold
+
+[
+  (case_of_branch)
+  (case_of_expr)
+  (value_declaration)
+  (type_declaration)
+  (type_alias_declaration)
+  (list_expr)
+  (record_expr)
+  (parenthesized_expr)
+  (import_clause)+
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/elm/highlights.scm b/pack/ant/start/nvim-treesitter/queries/elm/highlights.scm
new file mode 100644
index 0000000..cfa09ca
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/elm/highlights.scm
@@ -0,0 +1,229 @@
+[
+  (line_comment)
+  (block_comment)
+] @comment @spell
+
+((block_comment) @comment.documentation
+  (#lua-match? @comment.documentation "^{[-]|[^|]"))
+
+; Keywords
+;---------
+[
+  "if"
+  "then"
+  "else"
+  (case)
+  (of)
+] @keyword.conditional
+
+[
+  "let"
+  "in"
+  (as)
+  (port)
+  (alias)
+  (infix)
+  (module)
+  (type)
+] @keyword
+
+[
+  (import)
+  (exposing)
+] @keyword.import
+
+; Punctuation
+;------------
+(double_dot) @punctuation.special
+
+[
+  ","
+  "|"
+  (dot)
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+; Variables
+;----------
+(value_qid
+  (lower_case_identifier) @variable)
+
+(value_declaration
+  (function_declaration_left
+    (lower_case_identifier) @variable))
+
+(type_annotation
+  (lower_case_identifier) @variable)
+
+(port_annotation
+  (lower_case_identifier) @variable)
+
+(anything_pattern
+  (underscore) @character.special)
+
+(record_base_identifier
+  (lower_case_identifier) @variable)
+
+(lower_pattern
+  (lower_case_identifier) @variable)
+
+(exposed_value
+  (lower_case_identifier) @variable)
+
+(value_qid
+  ((dot)
+    (lower_case_identifier) @variable.member))
+
+(field_access_expr
+  ((dot)
+    (lower_case_identifier) @variable.member))
+
+(function_declaration_left
+  (anything_pattern
+    (underscore) @character.special))
+
+(function_declaration_left
+  (lower_pattern
+    (lower_case_identifier) @variable.parameter))
+
+; Functions
+;----------
+(value_declaration
+  functionDeclarationLeft: (function_declaration_left
+    (lower_case_identifier) @function
+    (pattern)))
+
+(value_declaration
+  functionDeclarationLeft: (function_declaration_left
+    (lower_case_identifier) @function
+    pattern: (_)))
+
+(value_declaration
+  functionDeclarationLeft: (function_declaration_left
+    (lower_case_identifier) @function)
+  body: (anonymous_function_expr))
+
+(type_annotation
+  name: (lower_case_identifier) @function
+  typeExpression: (type_expression
+    (arrow)))
+
+(port_annotation
+  name: (lower_case_identifier) @function
+  typeExpression: (type_expression
+    (arrow)))
+
+(function_call_expr
+  target: (value_expr
+    (value_qid
+      (lower_case_identifier) @function.call)))
+
+; Operators
+;----------
+[
+  (operator_identifier)
+  (eq)
+  (colon)
+  (arrow)
+  (backslash)
+  "::"
+] @operator
+
+; Modules
+;--------
+(module_declaration
+  (upper_case_qid
+    (upper_case_identifier) @module))
+
+(import_clause
+  (upper_case_qid
+    (upper_case_identifier) @module))
+
+(as_clause
+  (upper_case_identifier) @module)
+
+(value_expr
+  (value_qid
+    (upper_case_identifier) @module))
+
+; Types
+;------
+(type_declaration
+  (upper_case_identifier) @type)
+
+(type_ref
+  (upper_case_qid
+    (upper_case_identifier) @type))
+
+(type_variable
+  (lower_case_identifier) @type)
+
+(lower_type_name
+  (lower_case_identifier) @type)
+
+(exposed_type
+  (upper_case_identifier) @type)
+
+(type_alias_declaration
+  (upper_case_identifier) @type.definition)
+
+(field_type
+  name: (lower_case_identifier) @property)
+
+(field
+  name: (lower_case_identifier) @property)
+
+(type_declaration
+  (union_variant
+    (upper_case_identifier) @constructor))
+
+(nullary_constructor_argument_pattern
+  (upper_case_qid
+    (upper_case_identifier) @constructor))
+
+(union_pattern
+  (upper_case_qid
+    (upper_case_identifier) @constructor))
+
+(value_expr
+  (upper_case_qid
+    (upper_case_identifier)) @constructor)
+
+; Literals
+;---------
+(number_constant_expr
+  (number_literal) @number)
+
+(upper_case_qid
+  ((upper_case_identifier) @boolean
+    (#any-of? @boolean "True" "False")))
+
+[
+  (open_quote)
+  (close_quote)
+] @string
+
+(string_constant_expr
+  (string_escape) @string)
+
+(string_constant_expr
+  (regular_string_part) @string)
+
+[
+  (open_char)
+  (close_char)
+] @character
+
+(char_constant_expr
+  (string_escape) @character)
+
+(char_constant_expr
+  (regular_string_part) @character)
diff --git a/pack/ant/start/nvim-treesitter/queries/elm/injections.scm b/pack/ant/start/nvim-treesitter/queries/elm/injections.scm
new file mode 100644
index 0000000..7ee6c7f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/elm/injections.scm
@@ -0,0 +1,8 @@
+([
+  (line_comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
+
+((glsl_content) @injection.content
+  (#set! injection.language "glsl"))
diff --git a/pack/ant/start/nvim-treesitter/queries/elsa/folds.scm b/pack/ant/start/nvim-treesitter/queries/elsa/folds.scm
new file mode 100644
index 0000000..afdfec3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/elsa/folds.scm
@@ -0,0 +1 @@
+(reduction) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/elsa/highlights.scm b/pack/ant/start/nvim-treesitter/queries/elsa/highlights.scm
new file mode 100644
index 0000000..1a974bd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/elsa/highlights.scm
@@ -0,0 +1,36 @@
+; Keywords
+[
+  "eval"
+  "let"
+] @keyword
+
+; Function
+(function) @function
+
+; Method
+(method) @function.method
+
+; Parameter
+(parameter) @variable.parameter
+
+; Variables
+(identifier) @variable
+
+; Operators
+[
+  "\\"
+  "->"
+  "="
+  (step)
+] @operator
+
+; Punctuation
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+":" @punctuation.delimiter
+
+; Comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/elsa/indents.scm b/pack/ant/start/nvim-treesitter/queries/elsa/indents.scm
new file mode 100644
index 0000000..6ddd1aa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/elsa/indents.scm
@@ -0,0 +1,6 @@
+(reduction) @indent.begin
+
+[
+  (ERROR)
+  (comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/elsa/injections.scm b/pack/ant/start/nvim-treesitter/queries/elsa/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/elsa/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/elsa/locals.scm b/pack/ant/start/nvim-treesitter/queries/elsa/locals.scm
new file mode 100644
index 0000000..3e8197a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/elsa/locals.scm
@@ -0,0 +1,12 @@
+[
+  (source_file)
+  (reduction)
+] @local.scope
+
+(identifier) @local.reference
+
+(function) @local.definition.function
+
+(method) @local.definition.method
+
+(parameter) @local.definition.parameter
diff --git a/pack/ant/start/nvim-treesitter/queries/elvish/highlights.scm b/pack/ant/start/nvim-treesitter/queries/elvish/highlights.scm
new file mode 100644
index 0000000..9836a6c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/elvish/highlights.scm
@@ -0,0 +1,157 @@
+(comment) @comment @spell
+
+[
+  "if"
+  "elif"
+] @keyword.conditional
+
+(if
+  (else
+    "else" @keyword.conditional))
+
+[
+  "while"
+  "for"
+] @keyword.repeat
+
+(while
+  (else
+    "else" @keyword.repeat))
+
+(for
+  (else
+    "else" @keyword.repeat))
+
+[
+  "try"
+  "catch"
+  "finally"
+] @keyword.exception
+
+(try
+  (else
+    "else" @keyword.exception))
+
+"use" @keyword.import
+
+(import
+  (bareword) @string.special.path)
+
+(wildcard
+  [
+    "*"
+    "**"
+    "?"
+  ] @character.special)
+
+(command
+  argument: (bareword) @variable.parameter)
+
+(command
+  head: (identifier) @function.call)
+
+((command
+  head: (identifier) @keyword.return)
+  (#eq? @keyword.return "return"))
+
+((command
+  (identifier) @keyword.operator)
+  (#any-of? @keyword.operator "and" "or" "coalesce"))
+
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "<"
+  "<="
+  "=="
+  "!="
+  ">"
+  ">="
+  "<s"
+  "<=s"
+  "==s"
+  "!=s"
+  ">s"
+  ">=s"
+] @function.builtin
+
+[
+  ">"
+  "<"
+  ">>"
+  "<>"
+  "|"
+] @operator
+
+(io_port) @number
+
+(function_definition
+  "fn" @keyword.function
+  (identifier) @function)
+
+(parameter_list) @variable.parameter
+
+(parameter_list
+  "|" @punctuation.bracket)
+
+[
+  "var"
+  "set"
+  "tmp"
+  "del"
+] @keyword
+
+(variable_declaration
+  (lhs
+    (identifier) @variable))
+
+(variable_assignment
+  (lhs
+    (identifier) @variable))
+
+(temporary_assignment
+  (lhs
+    (identifier) @variable))
+
+(variable_deletion
+  (identifier) @variable)
+
+(number) @number
+
+(string) @string
+
+(variable
+  (identifier) @variable)
+
+((variable
+  (identifier) @function)
+  (#lua-match? @function ".+[~]$"))
+
+((variable
+  (identifier) @boolean)
+  (#any-of? @boolean "true" "false"))
+
+((variable
+  (identifier) @constant.builtin)
+  (#any-of? @constant.builtin
+    "_" "after-chdir" "args" "before-chdir" "buildinfo" "nil" "notify-bg-job-success" "num-bg-jobs"
+    "ok" "paths" "pid" "pwd" "value-out-indicator" "version"))
+
+[
+  "$"
+  "@"
+] @punctuation.special
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+";" @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/elvish/injections.scm b/pack/ant/start/nvim-treesitter/queries/elvish/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/elvish/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/embedded_template/highlights.scm b/pack/ant/start/nvim-treesitter/queries/embedded_template/highlights.scm
new file mode 100644
index 0000000..410983d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/embedded_template/highlights.scm
@@ -0,0 +1,12 @@
+(comment_directive) @comment @spell
+
+[
+  "<%#"
+  "<%"
+  "<%="
+  "<%_"
+  "<%-"
+  "%>"
+  "-%>"
+  "_%>"
+] @keyword
diff --git a/pack/ant/start/nvim-treesitter/queries/embedded_template/injections.scm b/pack/ant/start/nvim-treesitter/queries/embedded_template/injections.scm
new file mode 100644
index 0000000..cdeb2cd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/embedded_template/injections.scm
@@ -0,0 +1,7 @@
+((content) @injection.content
+  (#set! injection.language "html")
+  (#set! injection.combined))
+
+((code) @injection.content
+  (#set! injection.language "ruby")
+  (#set! injection.combined))
diff --git a/pack/ant/start/nvim-treesitter/queries/erlang/folds.scm b/pack/ant/start/nvim-treesitter/queries/erlang/folds.scm
new file mode 100644
index 0000000..65c2d8e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/erlang/folds.scm
@@ -0,0 +1,9 @@
+[
+  (fun_decl)
+  (anonymous_fun)
+  (case_expr)
+  (maybe_expr)
+  (map_expr)
+  (export_attribute)
+  (export_type_attribute)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/erlang/highlights.scm b/pack/ant/start/nvim-treesitter/queries/erlang/highlights.scm
new file mode 100644
index 0000000..8bba348
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/erlang/highlights.scm
@@ -0,0 +1,184 @@
+((atom) @constant
+  (#set! priority "90"))
+
+(var) @variable
+
+(char) @character
+
+(integer) @number
+
+(float) @number.float
+
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^[%%][%%]"))
+
+; keyword
+[
+  "fun"
+  "div"
+] @keyword
+
+; bracket
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+  "#"
+] @punctuation.bracket
+
+; Comparisons
+[
+  "=="
+  "=:="
+  "=/="
+  "=<"
+  ">="
+  "<"
+  ">"
+] @operator ; .comparison
+
+; operator
+[
+  ":"
+  ":="
+  "!"
+  ; "-"
+  "+"
+  "="
+  "->"
+  "=>"
+  "|"
+  "?="
+] @operator
+
+[
+  ","
+  "."
+  ";"
+] @punctuation.delimiter
+
+; conditional
+[
+  "receive"
+  "if"
+  "case"
+  "of"
+  "when"
+  "after"
+  "begin"
+  "end"
+  "maybe"
+  "else"
+] @keyword.conditional
+
+[
+  "catch"
+  "try"
+] @keyword.exception
+
+((atom) @boolean
+  (#any-of? @boolean "true" "false"))
+
+; Macros
+((macro_call_expr) @constant.macro
+  (#set! priority 101))
+
+; Preprocessor
+(pp_define
+  lhs: _ @constant.macro
+  (#set! priority 101))
+
+(_preprocessor_directive) @keyword.directive
+(#set! priority 99)
+
+; Attributes
+(pp_include) @keyword.import
+
+(pp_include_lib) @keyword.import
+
+(export_attribute) @keyword.import
+
+(export_type_attribute) @type.definition
+
+(export_type_attribute
+  types: (fa
+    fun: _ @type
+    (#set! priority 101)))
+
+(behaviour_attribute) @keyword.import
+
+(module_attribute
+  (atom) @module) @keyword.import
+
+(wild_attribute
+  name: (attr_name
+    name: _ @attribute)) @attribute
+
+; Records
+(record_expr) @type
+
+(record_field_expr
+  _ @variable.member) @type
+
+(record_field_name
+  _ @variable.member) @type
+
+(record_name
+  "#" @type
+  name: _ @type) @type
+
+(record_decl
+  name: _ @type) @type.definition
+
+(record_field
+  name: _ @variable.member)
+
+(record_field
+  name: _ @variable.member
+  ty: _ @type)
+
+; Type alias
+(type_alias
+  name: _ @type) @type.definition
+
+(spec) @type.definition
+
+[
+  (string)
+  (binary)
+] @string
+
+; expr_function_call
+(call
+  expr: [
+    (atom)
+    (remote)
+    (var)
+  ] @function)
+
+(call
+  (atom) @keyword.exception
+  (#any-of? @keyword.exception "error" "throw" "exit"))
+
+; Parenthesized expression: (SomeFunc)(), only highlight the parens
+(call
+  expr: (paren_expr
+    "(" @function.call
+    ")" @function.call))
+
+; function
+(external_fun) @function.call
+
+(internal_fun
+  fun: (atom) @function.call)
+
+(function_clause
+  name: (atom) @function)
+
+(fa
+  fun: (atom) @function)
diff --git a/pack/ant/start/nvim-treesitter/queries/erlang/injections.scm b/pack/ant/start/nvim-treesitter/queries/erlang/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/erlang/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/facility/folds.scm b/pack/ant/start/nvim-treesitter/queries/facility/folds.scm
new file mode 100644
index 0000000..7d8bafc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/facility/folds.scm
@@ -0,0 +1,6 @@
+[
+  (service)
+  (method)
+  (dto)
+  (enum)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/facility/highlights.scm b/pack/ant/start/nvim-treesitter/queries/facility/highlights.scm
new file mode 100644
index 0000000..592bf53
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/facility/highlights.scm
@@ -0,0 +1,90 @@
+[
+  ";"
+  "."
+  ","
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+(comment) @comment @spell
+
+(doc_comment) @comment.documentation @spell
+
+[
+  "service"
+  "errors"
+] @keyword
+
+[
+  "method"
+  "event"
+] @keyword.function
+
+[
+  "enum"
+  "data"
+] @keyword.type
+
+"extern" @keyword.modifier
+
+(type) @type.builtin
+
+(service
+  service_name: (identifier) @type)
+
+(error_set
+  (identifier) @variable.member)
+
+(error_set
+  name: (identifier) @type)
+
+(dto
+  name: (identifier) @type)
+
+(external_dto
+  name: (identifier) @type)
+
+(enum
+  (values_block
+    (identifier) @constant))
+
+(enum
+  name: (identifier) @type)
+
+(external_enum
+  name: (identifier) @type)
+
+(type
+  name: (identifier) @type)
+
+[
+  "map"
+  "nullable"
+  "result"
+  "required"
+  "http"
+  "csharp"
+  "js"
+  "info"
+  "obsolete"
+] @attribute.builtin
+
+(parameter
+  name: (identifier) @variable.parameter)
+
+(field
+  name: (identifier) @variable.member)
+
+(method
+  name: (identifier) @function.method)
+
+(number_literal) @number
+
+(string_literal) @string
diff --git a/pack/ant/start/nvim-treesitter/queries/facility/indents.scm b/pack/ant/start/nvim-treesitter/queries/facility/indents.scm
new file mode 100644
index 0000000..247949b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/facility/indents.scm
@@ -0,0 +1,7 @@
+[
+  (service_block)
+  (values_block)
+  (field_list)
+] @indent.begin
+
+"}" @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/facility/injections.scm b/pack/ant/start/nvim-treesitter/queries/facility/injections.scm
new file mode 100644
index 0000000..5d9b783
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/facility/injections.scm
@@ -0,0 +1,8 @@
+((remarks) @injection.content
+  (#set! injection.language "markdown"))
+
+([
+  (comment)
+  (doc_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/faust/highlights.scm b/pack/ant/start/nvim-treesitter/queries/faust/highlights.scm
new file mode 100644
index 0000000..6e7ef1d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/faust/highlights.scm
@@ -0,0 +1,219 @@
+; Identifiers
+(identifier) @variable
+
+[
+  "process"
+  "effect"
+] @variable.builtin
+
+(parameters
+  (identifier)) @variable.parameter
+
+(access
+  definition: (identifier) @variable.member)
+
+(global_metadata
+  key: (identifier) @variable.member)
+
+(function_metadata
+  function_name: (identifier) @variable.member)
+
+; Literals
+(_
+  filename: (string)) @string.special.path
+
+(documentation) @string.documentation @spell
+
+[
+  (string)
+  (fstring)
+] @string
+
+(int) @number
+
+(real) @number.float
+
+; Types
+(_
+  type: [
+    (int_type)
+    (float_type)
+    (any_type)
+  ]) @type.builtin
+
+[
+  (single_precision)
+  (double_precision)
+  (quad_precision)
+  (fixed_point_precision)
+] @attribute
+
+; Functions
+(function_definition
+  name: (identifier) @function)
+
+(function_names) @function
+
+(function_call
+  (identifier) @function.call)
+
+(function_call
+  (access
+    definition: (identifier) @function.call))
+
+[
+  "exp"
+  "log"
+  "log10"
+  "sqrt"
+  "abs"
+  "floor"
+  "ceil"
+  "rint"
+  "round"
+  "acos"
+  "asin"
+  "atan"
+  "cos"
+  "sin"
+  "tan"
+  "atan2"
+  "int"
+  "float"
+  "pow"
+  "min"
+  "max"
+  "fmod"
+  "remainder"
+  "prefix"
+  "attach"
+  "enable"
+  "control"
+  "rdtable"
+  "rwtable"
+  "select2"
+  "select3"
+  "lowest"
+  "highest"
+  "assertbounds"
+  (par)
+  (seq)
+  (sum)
+  (prod)
+  (component)
+  (library)
+  (vslider_type)
+  (hslider_type)
+  (nentry_type)
+  (vbargraph_type)
+  (hbargraph_type)
+  (vgroup_type)
+  (hgroup_type)
+  (tgroup_type)
+  "button"
+  "checkbox"
+  "soundfile"
+  "inputs"
+  "outputs"
+  "route"
+] @function.builtin
+
+; xor is a @keyword.operator
+[
+  (add)
+  (sub)
+  (mult)
+  (div)
+  (mod)
+  (pow)
+  (or)
+  (and)
+  (lshift)
+  (rshift)
+  (lt)
+  (le)
+  (gt)
+  (ge)
+  (eq)
+  (neq)
+  (delay)
+  (one_sample_delay)
+  "="
+  "=>"
+  "->"
+] @operator
+
+(recursive
+  "~" @operator)
+
+(sequential
+  ":" @operator)
+
+(split
+  "<:" @operator)
+
+(merge
+  ":>" @operator)
+
+(parallel
+  "," @operator)
+
+; Keywords
+[
+  (par)
+  (seq)
+  (sum)
+  (prod)
+] @keyword.repeat
+
+(file_import
+  "import" @keyword.import)
+
+[
+  (wire)
+  (cut)
+  (mem)
+  "declare"
+  "with"
+  "environment"
+  "case"
+  "ffunction"
+  "fconstant"
+  "fvariable"
+] @keyword
+
+(xor) @keyword.operator
+
+; Punctuation
+[
+  ","
+  ";"
+  "."
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; Comments
+(comment) @comment @spell
+
+; Tags
+[
+  "<mdoc>"
+  "</mdoc>"
+  "<metadata>"
+  "</metadata>"
+  "<equation>"
+  "</equation>"
+  "<diagram>"
+  "</diagram>"
+  "<listing"
+  "<notice"
+  "/>"
+] @tag
diff --git a/pack/ant/start/nvim-treesitter/queries/faust/injections.scm b/pack/ant/start/nvim-treesitter/queries/faust/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/faust/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/fennel/folds.scm b/pack/ant/start/nvim-treesitter/queries/fennel/folds.scm
new file mode 100644
index 0000000..0862e59
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fennel/folds.scm
@@ -0,0 +1,51 @@
+; compounds
+[
+  (list)
+  (table)
+  (sequence)
+] @fold
+
+; sub-forms / special compounds
+[
+  (list_binding)
+  (table_binding)
+  (sequence_binding)
+  (table_metadata)
+  (sequence_arguments)
+  (let_vars)
+  (case_guard_or_special)
+  (case_guard)
+  (case_catch)
+] @fold
+
+; forms
+[
+  (quote_form)
+  (unquote_form)
+  (local_form)
+  (var_form)
+  (set_form)
+  (global_form)
+  (let_form)
+  (fn_form)
+  (lambda_form)
+  (hashfn_form)
+  (each_form)
+  (collect_form)
+  (icollect_form)
+  (accumulate_form)
+  (for_form)
+  (fcollect_form)
+  (faccumulate_form)
+  (case_form)
+  (match_form)
+  (case_try_form)
+  (match_try_form)
+] @fold
+
+; reader macros
+(quote_reader_macro
+  expression: (_) @fold)
+
+(quasi_quote_reader_macro
+  expression: (_) @fold)
diff --git a/pack/ant/start/nvim-treesitter/queries/fennel/highlights.scm b/pack/ant/start/nvim-treesitter/queries/fennel/highlights.scm
new file mode 100644
index 0000000..2f0b5f7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fennel/highlights.scm
@@ -0,0 +1,193 @@
+; Most primitive nodes
+(shebang) @keyword.directive
+
+(comment) @comment @spell
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  (nil)
+  (nil_binding)
+] @constant.builtin
+
+[
+  (boolean)
+  (boolean_binding)
+] @boolean
+
+[
+  (number)
+  (number_binding)
+] @number
+
+[
+  (string)
+  (string_binding)
+] @string
+
+[
+  (symbol)
+  (symbol_binding)
+] @variable
+
+(symbol_option) @keyword.directive
+
+(escape_sequence) @string.escape
+
+(multi_symbol
+  "." @punctuation.delimiter
+  member: (symbol_fragment) @variable.member)
+
+(list
+  call: (symbol) @function.call)
+
+(list
+  call: (multi_symbol
+    member: (symbol_fragment) @function.call .))
+
+(multi_symbol_method
+  ":" @punctuation.delimiter
+  method: (symbol_fragment) @function.method.call)
+
+(quasi_quote_reader_macro
+  macro: _ @punctuation.special)
+
+(quote_reader_macro
+  macro: _ @punctuation.special)
+
+(unquote_reader_macro
+  macro: _ @punctuation.special)
+
+(hashfn_reader_macro
+  macro: _ @keyword.function)
+
+(sequence_arguments
+  (symbol_binding) @variable.parameter)
+
+(sequence_arguments
+  (rest_binding
+    rhs: (symbol_binding) @variable.parameter))
+
+(docstring) @string.documentation
+
+(fn_form
+  name: [
+    (symbol) @function
+    (multi_symbol
+      member: (symbol_fragment) @function .)
+  ])
+
+(lambda_form
+  name: [
+    (symbol) @function
+    (multi_symbol
+      member: (symbol_fragment) @function .)
+  ])
+
+; NOTE: The macro name is highlighted as @variable because it
+; gives a nicer contrast instead of everything being the same
+; color. Rust queries use this workaround too for `macro_rules!`.
+(macro_form
+  name: [
+    (symbol) @variable
+    (multi_symbol
+      member: (symbol_fragment) @variable .)
+  ])
+
+((symbol) @variable.parameter
+  (#any-of? @variable.parameter "$" "$..."))
+
+((symbol) @variable.parameter
+  (#lua-match? @variable.parameter "^%$[1-9]$"))
+
+((symbol) @operator
+  (#any-of? @operator
+    ; arithmetic
+    "+" "-" "*" "/" "//" "%" "^"
+    ; comparison
+    ">" "<" ">=" "<=" "=" "~="
+    ; other
+    "#" "." "?." ".."))
+
+((symbol) @keyword.operator
+  (#any-of? @keyword.operator
+    ; comparison
+    "not="
+    ; boolean
+    "and" "or" "not"
+    ; bitwise
+    "lshift" "rshift" "band" "bor" "bxor" "bnot"
+    ; other
+    "length"))
+
+(case_guard
+  call: (_) @keyword.conditional)
+
+(case_guard_or_special
+  call: (_) @keyword.conditional)
+
+((symbol) @keyword.function
+  (#any-of? @keyword.function "fn" "lambda" "λ" "hashfn"))
+
+((symbol) @keyword.repeat
+  (#any-of? @keyword.repeat "for" "each" "while"))
+
+((symbol) @keyword.conditional
+  (#any-of? @keyword.conditional "if" "when" "match" "case" "match-try" "case-try"))
+
+((symbol) @keyword
+  (#any-of? @keyword
+    "global" "local" "let" "set" "var" "comment" "do" "doc" "eval-compiler" "lua" "macros" "unquote"
+    "quote" "tset" "values" "tail!"))
+
+((symbol) @keyword.import
+  (#any-of? @keyword.import "require-macros" "import-macros" "include"))
+
+((symbol) @function.macro
+  (#any-of? @function.macro
+    "collect" "icollect" "fcollect" "accumulate" "faccumulate" "->" "->>" "-?>" "-?>>" "?." "doto"
+    "macro" "macrodebug" "partial" "pick-args" "pick-values" "with-open"))
+
+(case_catch
+  call: (symbol) @keyword)
+
+(import_macros_form
+  imports: (table_binding
+    (table_binding_pair
+      value: (symbol_binding) @function.macro)))
+
+; TODO: Highlight builtin methods (`table.unpack`, etc) as @function.builtin
+([
+  (symbol) @module.builtin
+  (multi_symbol
+    base: (symbol_fragment) @module.builtin)
+]
+  (#any-of? @module.builtin
+    "vim" "_G" "debug" "io" "jit" "math" "os" "package" "string" "table" "utf8"))
+
+([
+  (symbol) @variable.builtin
+  (multi_symbol
+    .
+    (symbol_fragment) @variable.builtin)
+]
+  (#eq? @variable.builtin "arg"))
+
+((symbol) @variable.builtin
+  (#eq? @variable.builtin "..."))
+
+((symbol) @constant.builtin
+  (#eq? @constant.builtin "_VERSION"))
+
+((symbol) @function.builtin
+  (#any-of? @function.builtin
+    "assert" "collectgarbage" "dofile" "error" "getmetatable" "ipairs" "load" "loadfile" "next"
+    "pairs" "pcall" "print" "rawequal" "rawget" "rawlen" "rawset" "require" "select" "setmetatable"
+    "tonumber" "tostring" "type" "warn" "xpcall" "module" "setfenv" "loadstring" "unpack"))
diff --git a/pack/ant/start/nvim-treesitter/queries/fennel/injections.scm b/pack/ant/start/nvim-treesitter/queries/fennel/injections.scm
new file mode 100644
index 0000000..f6724d3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fennel/injections.scm
@@ -0,0 +1,134 @@
+((comment_body) @injection.content
+  (#set! injection.language "comment"))
+
+(list
+  call: (multi_symbol) @_vimcmd_identifier
+  (#any-of? @_vimcmd_identifier "vim.cmd" "vim.api.nvim_command" "vim.api.nvim_exec2")
+  .
+  item: (string
+    (string_content) @injection.content
+    (#set! injection.language "vim")))
+
+; NOTE: Matches *exactly* `ffi.cdef`
+(list
+  call: (multi_symbol) @_cdef_identifier
+  (#eq? @_cdef_identifier "ffi.cdef")
+  .
+  item: (string
+    (string_content) @injection.content
+    (#set! injection.language "c")))
+
+(list
+  call: (multi_symbol) @_ts_query_identifier
+  (#any-of? @_ts_query_identifier "vim.treesitter.query.set" "vim.treesitter.query.parse")
+  .
+  item: (_)
+  .
+  item: (_)
+  .
+  item: (string
+    (string_content) @injection.content
+    (#set! injection.language "query")))
+
+(list
+  call: (multi_symbol) @_vimcmd_identifier
+  (#eq? @_vimcmd_identifier "vim.api.nvim_create_autocmd")
+  .
+  item: (_)
+  .
+  item: (table
+    (table_pair
+      key: (string
+        (string_content) @_command
+        (#eq? @_command "command"))
+      value: (string
+        (string_content) @injection.content
+        (#set! injection.language "vim")))))
+
+(list
+  call: (multi_symbol) @_user_cmd
+  (#eq? @_user_cmd "vim.api.nvim_create_user_command")
+  .
+  item: (_)
+  .
+  item: (string
+    (string_content) @injection.content
+    (#set! injection.language "vim")))
+
+(list
+  call: (multi_symbol) @_user_cmd
+  (#eq? @_user_cmd "vim.api.nvim_buf_create_user_command")
+  .
+  item: (_)
+  .
+  item: (_)
+  .
+  item: (string
+    (string_content) @injection.content
+    (#set! injection.language "vim")))
+
+(list
+  call: (multi_symbol) @_map
+  (#any-of? @_map "vim.api.nvim_set_keymap" "vim.keymap.set")
+  .
+  item: (_)
+  .
+  item: (_)
+  .
+  item: (string
+    (string_content) @injection.content
+    (#set! injection.language "vim")))
+
+(list
+  call: (multi_symbol) @_map
+  (#eq? @_map "vim.api.nvim_buf_set_keymap")
+  .
+  item: (_)
+  .
+  item: (_)
+  .
+  item: (_)
+  .
+  item: (string
+    (string_content) @injection.content
+    (#set! injection.language "vim")))
+
+; highlight string as query if starts with `; query`
+(string
+  (string_content) @injection.content
+  (#lua-match? @injection.content "^%s*;+%s?query")
+  (#set! injection.language "query"))
+
+; (string.match "123" "%d+")
+(list
+  call: (multi_symbol
+    member: (symbol_fragment) @_func
+    .
+    (#any-of? @_func "find" "match" "gmatch" "gsub"))
+  .
+  item: (_)
+  .
+  item: (string
+    (string_content) @injection.content
+    (#set! injection.language "luap")
+    (#set! injection.include-children)))
+
+; (my-string:match "%d+")
+(list
+  call: (multi_symbol_method
+    method: (symbol_fragment) @_method
+    (#any-of? @_method "find" "match" "gmatch" "gsub"))
+  .
+  item: (string
+    (string_content) @injection.content
+    (#set! injection.language "luap")
+    (#set! injection.include-children)))
+
+; (string.format "pi = %.2f" 3.14159)
+(list
+  call: (multi_symbol) @_func
+  (#eq? @_func "string.format")
+  .
+  item: (string
+    (string_content) @injection.content
+    (#set! injection.language "printf")))
diff --git a/pack/ant/start/nvim-treesitter/queries/fennel/locals.scm b/pack/ant/start/nvim-treesitter/queries/fennel/locals.scm
new file mode 100644
index 0000000..be63e72
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fennel/locals.scm
@@ -0,0 +1,56 @@
+(program) @local.scope
+
+(symbol) @local.reference
+
+[
+  (let_form)
+  (fn_form)
+  (lambda_form)
+  (each_form)
+  (for_form)
+  (collect_form)
+  (icollect_form)
+  (accumulate_form)
+  (for_form)
+  (fcollect_form)
+  (faccumulate_form)
+  (case_form)
+  (match_form)
+  (case_try_form)
+  (match_try_form)
+  (if_form)
+] @local.scope
+
+(list
+  call: (symbol) @_call
+  (#any-of? @_call "while" "when" "do")) @local.scope
+
+(fn_form
+  name: [
+    (symbol) @local.definition.function
+    (multi_symbol
+      member: (symbol_fragment) @local.definition.function .)
+  ]
+  args: (sequence_arguments
+    (symbol_binding) @local.definition.parameter)
+  (#set! definition.function.scope "parent"))
+
+(lambda_form
+  name: [
+    (symbol) @local.definition.function
+    (multi_symbol
+      member: (symbol_fragment) @local.definition.function .)
+  ]
+  args: (sequence_arguments
+    (symbol_binding) @local.definition.parameter)
+  (#set! definition.function.scope "parent"))
+
+(macro_form
+  name: [
+    (symbol) @local.definition.function
+    (multi_symbol
+      member: (symbol_fragment) @local.definition.function .)
+  ]
+  args: (sequence_arguments
+    (symbol_binding) @local.definition.parameter)
+  (#set! definition.function.scope "parent"))
diff --git a/pack/ant/start/nvim-treesitter/queries/fidl/folds.scm b/pack/ant/start/nvim-treesitter/queries/fidl/folds.scm
new file mode 100644
index 0000000..f524c45
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fidl/folds.scm
@@ -0,0 +1,6 @@
+[
+  (layout_declaration)
+  (protocol_declaration)
+  (resource_declaration)
+  (service_declaration)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/fidl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/fidl/highlights.scm
new file mode 100644
index 0000000..f1960c6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fidl/highlights.scm
@@ -0,0 +1,67 @@
+[
+  "ajar"
+  "alias"
+  "as"
+  "bits"
+  "closed"
+  "compose"
+  "const"
+  "error"
+  "flexible"
+  "library"
+  "open"
+  ; "optional" we did not specify a node for optional yet
+  "overlay"
+  "protocol"
+  "reserved"
+  "strict"
+  "using"
+] @keyword
+
+[
+  "enum"
+  "struct"
+  "table"
+  "union"
+  "resource"
+  "service"
+  "type"
+] @keyword.type
+
+(primitives_type) @type.builtin
+
+(builtin_complex_type) @type.builtin
+
+(const_declaration
+  (identifier) @constant)
+
+[
+  "="
+  "|"
+  "&"
+  "->"
+] @operator
+
+(attribute
+  "@" @attribute
+  (identifier) @attribute)
+
+(string_literal) @string
+
+(numeric_literal) @number
+
+[
+  (true)
+  (false)
+] @boolean
+
+(comment) @comment
+
+[
+  "("
+  ")"
+  "<"
+  ">"
+  "{"
+  "}"
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/fidl/injections.scm b/pack/ant/start/nvim-treesitter/queries/fidl/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fidl/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/firrtl/folds.scm b/pack/ant/start/nvim-treesitter/queries/firrtl/folds.scm
new file mode 100644
index 0000000..4c64e64
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/firrtl/folds.scm
@@ -0,0 +1,6 @@
+[
+  (circuit)
+  (module)
+  (when)
+  (else)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/firrtl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/firrtl/highlights.scm
new file mode 100644
index 0000000..0a90fa5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/firrtl/highlights.scm
@@ -0,0 +1,198 @@
+; Namespaces
+(circuit
+  (identifier) @module)
+
+(module
+  (identifier) @module)
+
+; Types
+((identifier) @type
+  (#lua-match? @type "^[A-Z][A-Za-z0-9_$]*$"))
+
+; Keywords
+[
+  "circuit"
+  "module"
+  "extmodule"
+  "flip"
+  "parameter"
+  "reset"
+  "wire"
+  "cmem"
+  "smem"
+  "mem"
+  "reg"
+  "with"
+  "mport"
+  "inst"
+  "of"
+  "node"
+  "is"
+  "invalid"
+  "skip"
+  "infer"
+  "read"
+  "write"
+  "rdwr"
+  "defname"
+] @keyword
+
+; Qualifiers
+(qualifier) @keyword.modifier
+
+; Storageclasses
+[
+  "input"
+  "output"
+] @keyword.modifier
+
+; Conditionals
+[
+  "when"
+  "else"
+] @keyword.conditional
+
+; Annotations
+(info) @attribute
+
+; Builtins
+[
+  "stop"
+  "printf"
+  "assert"
+  "assume"
+  "cover"
+  "attach"
+  "mux"
+  "validif"
+] @function.builtin
+
+[
+  "UInt"
+  "SInt"
+  "Analog"
+  "Fixed"
+  "Clock"
+  "AsyncReset"
+  "Reset"
+] @type.builtin
+
+; Fields
+[
+  "data-type"
+  "depth"
+  "read-latency"
+  "write-latency"
+  "read-under-write"
+  "reader"
+  "writer"
+  "readwriter"
+] @variable.member
+
+((field_id) @variable.member
+  (#set! priority 105))
+
+(port
+  (identifier) @variable.member)
+
+(wire
+  (identifier) @variable.member)
+
+(cmem
+  (identifier) @variable.member)
+
+(smem
+  (identifier) @variable.member)
+
+(memory
+  (identifier) @variable.member)
+
+(register
+  (identifier) @variable.member)
+
+; Parameters
+(primitive_operation
+  (identifier) @variable.parameter)
+
+(mux
+  (identifier) @variable.parameter)
+
+(printf
+  (identifier) @variable.parameter)
+
+(reset
+  (identifier) @variable.parameter)
+
+(stop
+  (identifier) @variable.parameter)
+
+; Variables
+(identifier) @variable
+
+; Operators
+(primop) @keyword.operator
+
+[
+  "+"
+  "-"
+  "="
+  "=>"
+  "<="
+  "<-"
+] @operator
+
+; Literals
+[
+  (uint)
+  (number)
+] @number
+
+(number_str) @string.special
+
+(double) @number.float
+
+(string) @string
+
+(escape_sequence) @string.escape
+
+[
+  "old"
+  "new"
+  "undefined"
+] @constant.builtin
+
+; Punctuation
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "<"
+  ">"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  ","
+  "."
+  ":"
+] @punctuation.delimiter
+
+; Comments
+(comment) @comment @spell
+
+[
+  "=>"
+  "<="
+  "="
+] @operator
diff --git a/pack/ant/start/nvim-treesitter/queries/firrtl/indents.scm b/pack/ant/start/nvim-treesitter/queries/firrtl/indents.scm
new file mode 100644
index 0000000..e172e1e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/firrtl/indents.scm
@@ -0,0 +1,12 @@
+[
+  (circuit)
+  (module)
+  (memory)
+  (when)
+  (else)
+] @indent.begin
+
+[
+  (ERROR)
+  (comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/firrtl/injections.scm b/pack/ant/start/nvim-treesitter/queries/firrtl/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/firrtl/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/firrtl/locals.scm b/pack/ant/start/nvim-treesitter/queries/firrtl/locals.scm
new file mode 100644
index 0000000..97b7931
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/firrtl/locals.scm
@@ -0,0 +1,45 @@
+; Scopes
+[
+  (source_file)
+  (circuit)
+  (module)
+  (else)
+  (when)
+] @local.scope
+
+; References
+(identifier) @local.reference
+
+; Definitions
+(port
+  (identifier) @local.definition.field)
+
+(wire
+  (identifier) @local.definition.field)
+
+(cmem
+  (identifier) @local.definition.field)
+
+(smem
+  (identifier) @local.definition.field)
+
+(memory
+  (identifier) @local.definition.field)
+
+(register
+  (identifier) @local.definition.field)
+
+(circuit
+  (identifier) @local.definition.namespace)
+
+(module
+  (identifier) @local.definition.namespace)
+
+(parameter
+  (identifier) @local.definition.parameter)
+
+(rdwr
+  (identifier) @local.definition.var)
+
+(node
+  (identifier) @local.definition.var)
diff --git a/pack/ant/start/nvim-treesitter/queries/fish/folds.scm b/pack/ant/start/nvim-treesitter/queries/fish/folds.scm
new file mode 100644
index 0000000..06363e1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fish/folds.scm
@@ -0,0 +1,8 @@
+[
+  (function_definition)
+  (if_statement)
+  (switch_statement)
+  (for_statement)
+  (while_statement)
+  (begin_statement)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/fish/highlights.scm b/pack/ant/start/nvim-treesitter/queries/fish/highlights.scm
new file mode 100644
index 0000000..10ed533
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fish/highlights.scm
@@ -0,0 +1,176 @@
+; Fish highlighting
+; Operators
+[
+  "&&"
+  "||"
+  "|"
+  "&|"
+  "2>|"
+  "&"
+  ".."
+  "!"
+  (direction)
+  (stream_redirect)
+] @operator
+
+; match operators of test command
+(command
+  name: (word) @function.builtin
+  (#eq? @function.builtin "test")
+  argument: (word) @operator
+  (#match? @operator "^(!?\\=|-[a-zA-Z]+)$"))
+
+; match operators of [ command
+(command
+  name: (word) @punctuation.bracket
+  (#eq? @punctuation.bracket "[")
+  argument: (word) @operator
+  (#match? @operator "^(!?\\=|-[a-zA-Z]+)$"))
+
+[
+  "not"
+  "and"
+  "or"
+] @keyword.operator
+
+; Conditionals
+(if_statement
+  [
+    "if"
+    "end"
+  ] @keyword.conditional)
+
+(switch_statement
+  [
+    "switch"
+    "end"
+  ] @keyword.conditional)
+
+(case_clause
+  "case" @keyword.conditional)
+
+(else_clause
+  "else" @keyword.conditional)
+
+(else_if_clause
+  [
+    "else"
+    "if"
+  ] @keyword.conditional)
+
+; Loops/Blocks
+(while_statement
+  [
+    "while"
+    "end"
+  ] @keyword.repeat)
+
+(for_statement
+  [
+    "for"
+    "end"
+  ] @keyword.repeat)
+
+(begin_statement
+  [
+    "begin"
+    "end"
+  ] @keyword.repeat)
+
+; Keywords
+[
+  "in"
+  (break)
+  (continue)
+] @keyword
+
+"return" @keyword.return
+
+; Punctuation
+[
+  "["
+  "]"
+  "{"
+  "}"
+  "("
+  ")"
+] @punctuation.bracket
+
+"," @punctuation.delimiter
+
+; Commands
+(command
+  argument: [
+    (word) @variable.parameter
+    (#lua-match? @variable.parameter "^[-]")
+  ])
+
+(command_substitution
+  "$" @punctuation.bracket)
+
+; non-builtin command names
+(command
+  name: (word) @function.call)
+
+; derived from builtin -n (fish 3.2.2)
+(command
+  name: [
+    (word) @function.builtin
+    (#any-of? @function.builtin
+      "." ":" "_" "alias" "argparse" "bg" "bind" "block" "breakpoint" "builtin" "cd" "command"
+      "commandline" "complete" "contains" "count" "disown" "echo" "emit" "eval" "exec" "exit" "fg"
+      "functions" "history" "isatty" "jobs" "math" "printf" "pwd" "random" "read" "realpath" "set"
+      "set_color" "source" "status" "string" "test" "time" "type" "ulimit" "wait")
+  ])
+
+; Functions
+(function_definition
+  [
+    "function"
+    "end"
+  ] @keyword.function)
+
+(function_definition
+  name: [
+    (word)
+    (concatenation)
+  ] @function)
+
+(function_definition
+  option: [
+    (word)
+    (concatenation
+      (word))
+  ] @variable.parameter
+  (#lua-match? @variable.parameter "^[-]"))
+
+; Strings
+[
+  (double_quote_string)
+  (single_quote_string)
+] @string
+
+(escape_sequence) @string.escape
+
+; Variables
+(variable_name) @variable
+
+(variable_expansion) @constant
+
+; Nodes
+[
+  (integer)
+  (float)
+] @number
+
+(comment) @comment
+
+(comment) @spell
+
+((word) @boolean
+  (#any-of? @boolean "true" "false"))
+
+((program
+  .
+  (comment) @keyword.directive @nospell)
+  (#lua-match? @keyword.directive "^#!/"))
diff --git a/pack/ant/start/nvim-treesitter/queries/fish/indents.scm b/pack/ant/start/nvim-treesitter/queries/fish/indents.scm
new file mode 100644
index 0000000..4984c4c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fish/indents.scm
@@ -0,0 +1,18 @@
+[
+  (function_definition)
+  (while_statement)
+  (for_statement)
+  (if_statement)
+  (begin_statement)
+  (switch_statement)
+] @indent.begin
+
+[
+  "else" ; else and else if must both start the line with "else", so tag the string directly
+  "case"
+  "end"
+] @indent.branch
+
+"end" @indent.end
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/fish/injections.scm b/pack/ant/start/nvim-treesitter/queries/fish/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fish/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/fish/locals.scm b/pack/ant/start/nvim-treesitter/queries/fish/locals.scm
new file mode 100644
index 0000000..904d568
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fish/locals.scm
@@ -0,0 +1,19 @@
+; Scopes
+[
+  (command)
+  (function_definition)
+  (if_statement)
+  (for_statement)
+  (begin_statement)
+  (while_statement)
+  (switch_statement)
+] @local.scope
+
+; Definitions
+(function_definition
+  name: (word) @local.definition.function)
+
+; References
+(variable_name) @local.reference
+
+(word) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/foam/folds.scm b/pack/ant/start/nvim-treesitter/queries/foam/folds.scm
new file mode 100644
index 0000000..e05d0db
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/foam/folds.scm
@@ -0,0 +1,8 @@
+[
+  (comment)
+  (list)
+  (dict_core)
+] @fold
+
+(code
+  (code_body)* @fold)
diff --git a/pack/ant/start/nvim-treesitter/queries/foam/highlights.scm b/pack/ant/start/nvim-treesitter/queries/foam/highlights.scm
new file mode 100644
index 0000000..9c96f19
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/foam/highlights.scm
@@ -0,0 +1,64 @@
+; Comments
+(comment) @comment @spell
+
+; Generic Key-value pairs and dictionary keywords
+(key_value
+  keyword: (identifier) @function)
+
+(dict
+  key: (identifier) @type)
+
+; Macros
+(macro
+  "$" @keyword.conditional
+  (prev_scope)* @keyword.conditional
+  (identifier)* @module)
+
+; Directives
+"#" @keyword.conditional
+
+(preproc_call
+  directive: (identifier)* @keyword.conditional
+  argument: (identifier)* @module)
+
+((preproc_call
+  argument: (identifier)* @module) @keyword.conditional
+  (#eq? @keyword.conditional "ifeq"))
+
+((preproc_call) @keyword.conditional
+  (#any-of? @keyword.conditional "else" "endif"))
+
+; Literals
+(number_literal) @number.float
+
+(string_literal) @string
+
+(escape_sequence) @string.escape
+
+(boolean) @boolean
+
+; Treat [m^2 s^-2] the same as if it was put in numbers format
+(dimensions
+  dimension: (identifier) @number.float)
+
+; Punctuation
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  "#{"
+  "#}"
+  "|-"
+  "-|"
+  "<!--("
+  ")-->"
+  "$$"
+] @punctuation.bracket
+
+";" @punctuation.delimiter
+
+((identifier) @constant.builtin
+  (#any-of? @constant.builtin "uniform" "non-uniform" "and" "or"))
diff --git a/pack/ant/start/nvim-treesitter/queries/foam/indents.scm b/pack/ant/start/nvim-treesitter/queries/foam/indents.scm
new file mode 100644
index 0000000..be02b80
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/foam/indents.scm
@@ -0,0 +1,11 @@
+[
+  "{"
+  "}"
+] @indent.branch
+
+[
+  (dict)
+  (key_value)
+] @indent.begin
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/foam/injections.scm b/pack/ant/start/nvim-treesitter/queries/foam/injections.scm
new file mode 100644
index 0000000..b9f8f83
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/foam/injections.scm
@@ -0,0 +1,23 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; Pass code blocks to Cpp highlighter
+(code
+  (code_body) @injection.content
+  (#set! injection.language "cpp"))
+
+; Pass identifiers to Go highlighter (Cheating I know)
+; ((identifier) @injection.content
+;  (#set! injection.language "lua")
+; Highlight regex syntax inside literal strings
+((string_literal) @injection.content
+  (#set! injection.language "regex"))
+
+; Highlight PyFoam syntax as Python statements
+(pyfoam_variable
+  code_body: (_) @injection.content
+  (#set! injection.language "python"))
+
+(pyfoam_expression
+  code_body: (_) @injection.content
+  (#set! injection.language "python"))
diff --git a/pack/ant/start/nvim-treesitter/queries/foam/locals.scm b/pack/ant/start/nvim-treesitter/queries/foam/locals.scm
new file mode 100644
index 0000000..f3f6890
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/foam/locals.scm
@@ -0,0 +1,11 @@
+(dict) @local.scope
+
+(dict
+  key: (_) @local.definition.type)
+
+(key_value
+  keyword: (_) @local.definition.parameter)
+
+(key_value
+  value: (macro
+    (identifier)*)* @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/forth/folds.scm b/pack/ant/start/nvim-treesitter/queries/forth/folds.scm
new file mode 100644
index 0000000..443abb3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/forth/folds.scm
@@ -0,0 +1 @@
+(word_definition) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/forth/highlights.scm b/pack/ant/start/nvim-treesitter/queries/forth/highlights.scm
new file mode 100644
index 0000000..1e72075
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/forth/highlights.scm
@@ -0,0 +1,19 @@
+(core) @function
+
+(operator) @operator
+
+(word) @variable
+
+((word) @constant
+  (#lua-match? @constant "^[A-Z_]+$"))
+
+(number) @number
+
+(string) @string
+
+[
+  (start_definition)
+  (end_definition)
+] @punctuation.delimiter
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/forth/indents.scm b/pack/ant/start/nvim-treesitter/queries/forth/indents.scm
new file mode 100644
index 0000000..0677554
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/forth/indents.scm
@@ -0,0 +1,3 @@
+(word_definition) @indent.begin
+
+(end_definition) @indent.end @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/forth/injections.scm b/pack/ant/start/nvim-treesitter/queries/forth/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/forth/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/forth/locals.scm b/pack/ant/start/nvim-treesitter/queries/forth/locals.scm
new file mode 100644
index 0000000..d91d3aa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/forth/locals.scm
@@ -0,0 +1,3 @@
+(word) @local.reference
+
+(word_definition) @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/fortran/folds.scm b/pack/ant/start/nvim-treesitter/queries/fortran/folds.scm
new file mode 100644
index 0000000..cedbdb6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fortran/folds.scm
@@ -0,0 +1,11 @@
+; by @oponkork
+[
+  (if_statement)
+  (where_statement)
+  (enum_statement)
+  (do_loop_statement)
+  (derived_type_definition)
+  (function)
+  (subroutine)
+  (interface)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/fortran/highlights.scm b/pack/ant/start/nvim-treesitter/queries/fortran/highlights.scm
new file mode 100644
index 0000000..6a6dbba
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fortran/highlights.scm
@@ -0,0 +1,319 @@
+; Preprocs
+(preproc_directive) @keyword.directive
+
+; Namespaces
+(program_statement
+  (name) @module)
+
+(end_program_statement
+  (name) @module)
+
+(module_statement
+  (name) @module)
+
+(end_module_statement
+  (name) @module)
+
+(submodule_statement
+  (name) @module)
+
+(end_submodule_statement
+  (name) @module)
+
+; Includes
+[
+  "import"
+  "include"
+  "use"
+] @keyword.import
+
+(import_statement
+  ","
+  [
+    "all"
+    "none"
+  ] @keyword)
+
+; Attributes
+[
+  (none)
+  "implicit"
+  "intent"
+] @attribute
+
+(implicit_statement
+  "type" @attribute)
+
+; Keywords
+[
+  "attributes"
+  "associate"
+  "block"
+  "classis"
+  "contains"
+  "default"
+  "dimension"
+  "endassociate"
+  "endselect"
+  "enumerator"
+  "equivalence"
+  "extends"
+  "goto"
+  "intrinsic"
+  "non_intrinsic"
+  "namelist"
+  "parameter"
+  "quiet"
+  "rank"
+  "save"
+  "selectcase"
+  "selectrank"
+  "selecttype"
+  "sequence"
+  "stop"
+  "target"
+  "typeis"
+] @keyword
+
+[
+  "class"
+  "enum"
+  "endenum"
+  "type"
+  "endtype"
+  "module"
+  "endmodule"
+  "submodule"
+  "endsubmodule"
+  "interface"
+  "endinterface"
+] @keyword.type
+
+(default) @keyword
+
+; Types
+(type_name) @type
+
+(intrinsic_type) @type.builtin
+
+; Qualifiers
+[
+  "abstract"
+  "allocatable"
+  "automatic"
+  "constant"
+  "contiguous"
+  "data"
+  "deferred"
+  "device"
+  "external"
+  "family"
+  "final"
+  "generic"
+  "global"
+  "grid_global"
+  "host"
+  "initial"
+  "local"
+  "local_init"
+  "managed"
+  "nopass"
+  "non_overridable"
+  "optional"
+  "pass"
+  "pinned"
+  "pointer"
+  "private"
+  "property"
+  "protected"
+  "public"
+  "shared"
+  "static"
+  "texture"
+  "value"
+  "volatile"
+  (procedure_qualifier)
+] @keyword.modifier
+
+[
+  "common"
+  "in"
+  "inout"
+  "out"
+] @keyword.modifier
+
+; Labels
+[
+  (statement_label)
+  (statement_label_reference)
+] @label
+
+[
+  "call"
+  "endfunction"
+  "endprogram"
+  "endprocedure"
+  "endsubroutine"
+  "function"
+  "procedure"
+  "program"
+  "subroutine"
+] @keyword.function
+
+[
+  "result"
+  "return"
+] @keyword.return
+
+; Functions
+(function_statement
+  (name) @function)
+
+(end_function_statement
+  (name) @function)
+
+(subroutine_statement
+  (name) @function)
+
+(end_subroutine_statement
+  (name) @function)
+
+(module_procedure_statement
+  (name) @function)
+
+(end_module_procedure_statement
+  (name) @function)
+
+(subroutine_call
+  (identifier) @function.call)
+
+[
+  "character"
+  "close"
+  "bind"
+  "format"
+  "open"
+  "print"
+  "read"
+  "write"
+] @function.builtin
+
+; Exceptions
+"error" @keyword.exception
+
+; Conditionals
+[
+  "else"
+  "elseif"
+  "elsewhere"
+  "endif"
+  "endwhere"
+  "if"
+  "then"
+  "where"
+] @keyword.conditional
+
+; Repeats
+[
+  "do"
+  "concurrent"
+  "enddo"
+  "endforall"
+  "forall"
+  "while"
+  "continue"
+  "cycle"
+  "exit"
+] @keyword.repeat
+
+; Variables
+(identifier) @variable
+
+; Parameters
+(keyword_argument
+  name: (identifier) @variable.parameter)
+
+(parameters
+  (identifier) @variable.parameter)
+
+; Properties
+(derived_type_member_expression
+  (type_member) @variable.member)
+
+; Operators
+[
+  "+"
+  "-"
+  "*"
+  "**"
+  "/"
+  "="
+  "<"
+  ">"
+  "<="
+  ">="
+  "=="
+  "/="
+  "//"
+  (assumed_rank)
+] @operator
+
+[
+  "\\.and\\."
+  "\\.or\\."
+  "\\.eqv\\."
+  "\\.neqv\\."
+  "\\.lt\\."
+  "\\.gt\\."
+  "\\.le\\."
+  "\\.ge\\."
+  "\\.eq\\."
+  "\\.ne\\."
+  "\\.not\\."
+] @keyword.operator
+
+; Punctuation
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "<<<"
+  ">>>"
+] @punctuation.bracket
+
+(array_literal
+  [
+    "(/"
+    "/)"
+  ] @punctuation.bracket)
+
+[
+  ":"
+  ","
+  "/"
+  "%"
+  "::"
+  "=>"
+] @punctuation.delimiter
+
+; Literals
+(string_literal) @string
+
+(number_literal) @number
+
+(boolean_literal) @boolean
+
+(null_literal) @constant.builtin
+
+; Comments
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^!>"))
diff --git a/pack/ant/start/nvim-treesitter/queries/fortran/indents.scm b/pack/ant/start/nvim-treesitter/queries/fortran/indents.scm
new file mode 100644
index 0000000..86704c4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fortran/indents.scm
@@ -0,0 +1,27 @@
+[
+  (module)
+  (program)
+  (subroutine)
+  (function)
+  ; (interface)
+  (if_statement)
+  (do_loop_statement)
+  (where_statement)
+  (derived_type_definition)
+  (enum)
+] @indent.begin
+
+[
+  (end_module_statement)
+  (end_program_statement)
+  (end_subroutine_statement)
+  (end_function_statement)
+  ; (end_interface_statement)
+  (end_if_statement)
+  (end_do_loop_statement)
+  (else_clause)
+  (elseif_clause)
+  (end_type_statement)
+  (end_enum_statement)
+  (end_where_statement)
+] @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/fortran/injections.scm b/pack/ant/start/nvim-treesitter/queries/fortran/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fortran/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/fsh/highlights.scm b/pack/ant/start/nvim-treesitter/queries/fsh/highlights.scm
new file mode 100644
index 0000000..2354a20
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fsh/highlights.scm
@@ -0,0 +1,97 @@
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "^"
+  "="
+  ":"
+] @operator
+
+[
+  "#"
+  ".."
+  "*"
+  "->"
+] @punctuation.special
+
+; Entities
+[
+  "Profile"
+  "Alias"
+  "Extension"
+  "Invariant"
+  "Instance"
+  "ValueSet"
+  "CodeSystem"
+  "Mapping"
+  "Logical"
+  "Resource"
+  "RuleSet"
+] @keyword
+
+; Metadata Keywords
+[
+  "Parent"
+  "Title"
+  "Description"
+  "Id"
+  "Severity"
+  "InstanceOf"
+  "Usage"
+  "Source"
+  "XPath"
+  "Target"
+] @keyword
+
+; Rule Keywords
+[
+  "contentReference"
+  "insert"
+  "and"
+  "or"
+  "contains"
+  "named"
+  "only"
+  "obeys"
+  "valueset"
+  "codes"
+  "from"
+  "include"
+  "exclude"
+  "where"
+  "system"
+  "exactly"
+] @keyword.operator
+
+; Types
+[
+  "Reference"
+  "Canonical"
+] @type.builtin
+
+(sd_metadata
+  (parent
+    (name))) @type
+
+(target_type
+  (name)) @type
+
+; Strings
+(string) @string
+
+(multiline_string) @string
+
+; Constants
+(strength_value) @constant
+
+(bool) @boolean
+
+(flag) @constant
+
+; Special Params
+(code_value) @variable.parameter
+
+; Extras
+(fsh_comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/fsh/injections.scm b/pack/ant/start/nvim-treesitter/queries/fsh/injections.scm
new file mode 100644
index 0000000..7bf6d00
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fsh/injections.scm
@@ -0,0 +1,2 @@
+((fsh_comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/fsharp/highlights.scm b/pack/ant/start/nvim-treesitter/queries/fsharp/highlights.scm
new file mode 100644
index 0000000..e400e35
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fsharp/highlights.scm
@@ -0,0 +1,411 @@
+[
+  (line_comment)
+  (block_comment)
+] @comment @spell
+
+((line_comment) @comment.documentation @spell
+  (#lua-match? @comment.documentation "^///"))
+
+(const
+  [
+    (_) @constant
+    (unit) @constant.builtin
+  ])
+
+(primary_constr_args
+  (_) @variable.parameter)
+
+(class_as_reference
+  (_) @variable.parameter.builtin)
+
+(type_name
+  type_name: (_) @type.definition)
+
+[
+  (_type)
+  (atomic_type)
+] @type
+
+(member_signature
+  .
+  (identifier) @function.method)
+
+(member_signature
+  (curried_spec
+    (arguments_spec
+      (argument_spec
+        (argument_name_spec
+          "?"? @character.special
+          name: (_) @variable.parameter)))))
+
+(union_type_case
+  (identifier) @constant)
+
+(rules
+  (rule
+    pattern: (_) @constant
+    block: (_)))
+
+(wildcard_pattern) @character.special
+
+(identifier_pattern
+  .
+  (_) @constant
+  .
+  (_) @variable)
+
+(optional_pattern
+  "?" @character.special)
+
+(fsi_directive_decl
+  .
+  (string) @module)
+
+(import_decl
+  .
+  (_) @module)
+
+(named_module
+  name: (_) @module)
+
+(namespace
+  name: (_) @module)
+
+(module_defn
+  (identifier) @module)
+
+(ce_expression
+  .
+  (_) @constant.macro)
+
+(field_initializer
+  field: (_) @property)
+
+(record_fields
+  (record_field
+    .
+    (identifier) @property))
+
+(value_declaration_left
+  .
+  (_) @variable)
+
+(function_declaration_left
+  .
+  (_) @function)
+
+(argument_patterns
+  [
+    (const)
+    (long_identifier)
+    (_pattern)
+  ] @variable.parameter)
+
+(argument_patterns
+  (typed_pattern
+    (_pattern) @variable.parameter
+    (_type) @type))
+
+(argument_patterns
+  (record_pattern
+    (field_pattern
+      .
+      (long_identifier) @variable.parameter)))
+
+(argument_patterns
+  (array_pattern
+    (_pattern)? @variable.parameter))
+
+(argument_patterns
+  (list_pattern
+    (_pattern)? @variable.parameter))
+
+((argument_patterns
+  (long_identifier
+    (identifier) @character.special))
+  (#lua-match? @character.special "^\_.*"))
+
+(member_defn
+  (method_or_prop_defn
+    [
+      (property_or_ident) @function
+      (property_or_ident
+        instance: (identifier) @variable.parameter.builtin
+        method: (identifier) @function.method)
+    ]
+    args: (_)* @variable.parameter))
+
+(dot_expression
+  .
+  (_) @variable.member
+  .
+  (_))
+
+(application_expression
+  .
+  (_) @function.call
+  .
+  (_) @variable)
+
+((infix_expression
+  .
+  (_)
+  .
+  (infix_op) @operator
+  .
+  (_) @function.call)
+  (#eq? @operator "|>"))
+
+((infix_expression
+  .
+  (_) @function.call
+  .
+  (infix_op) @operator
+  .
+  (_))
+  (#eq? @operator "<|"))
+
+[
+  (xint)
+  (int)
+  (int16)
+  (uint16)
+  (int32)
+  (uint32)
+  (int64)
+  (uint64)
+  (nativeint)
+  (unativeint)
+] @number
+
+[
+  (ieee32)
+  (ieee64)
+  (float)
+  (decimal)
+] @number.float
+
+(bool) @boolean
+
+[
+  (string)
+  (triple_quoted_string)
+  (verbatim_string)
+  (char)
+] @spell @string
+
+(compiler_directive_decl) @keyword.directive
+
+(preproc_line
+  "#line" @keyword.directive)
+
+(attribute
+  target: (identifier)? @keyword
+  (_type) @attribute)
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  ".["
+  "["
+  "]"
+  "[|"
+  "|]"
+  "{|"
+  "|}"
+] @punctuation.bracket
+
+[
+  "[<"
+  ">]"
+] @punctuation.special
+
+(format_string_eval
+  [
+    "{"
+    "}"
+  ] @punctuation.special)
+
+[
+  ","
+  ";"
+  ":"
+  "."
+] @punctuation.delimiter
+
+[
+  "|"
+  "="
+  ">"
+  "<"
+  "-"
+  "~"
+  "->"
+  "<-"
+  "&"
+  "&&"
+  "|"
+  "||"
+  ":>"
+  ":?>"
+  ".."
+  "*"
+  (infix_op)
+  (prefix_op)
+  (op_identifier)
+] @operator
+
+(generic_type
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+[
+  "if"
+  "then"
+  "else"
+  "elif"
+  "when"
+  "match"
+  "match!"
+] @keyword.conditional
+
+[
+  "and"
+  "or"
+  "not"
+  "upcast"
+  "downcast"
+] @keyword.operator
+
+[
+  "return"
+  "return!"
+  "yield"
+  "yield!"
+] @keyword.return
+
+[
+  "for"
+  "while"
+  "downto"
+  "to"
+] @keyword.repeat
+
+[
+  "open"
+  "#r"
+  "#load"
+] @keyword.import
+
+[
+  "abstract"
+  "delegate"
+  "static"
+  "inline"
+  "mutable"
+  "override"
+  "rec"
+  "global"
+  (access_modifier)
+] @keyword.modifier
+
+[
+  "let"
+  "let!"
+  "use"
+  "use!"
+  "member"
+] @keyword.function
+
+[
+  "enum"
+  "type"
+  "inherit"
+  "interface"
+  "and"
+  "class"
+  "struct"
+] @keyword.type
+
+((identifier) @keyword.exception
+  (#any-of? @keyword.exception "failwith" "failwithf" "raise" "reraise"))
+
+[
+  "as"
+  "assert"
+  "begin"
+  "end"
+  "done"
+  "default"
+  "in"
+  "do"
+  "do!"
+  "fun"
+  "function"
+  "get"
+  "set"
+  "lazy"
+  "new"
+  "of"
+  "struct"
+  "val"
+  "module"
+  "namespace"
+  "with"
+] @keyword
+
+[
+  "null"
+  (unit)
+] @constant.builtin
+
+(match_expression
+  "with" @keyword.conditional)
+
+(try_expression
+  [
+    "try"
+    "with"
+    "finally"
+  ] @keyword.exception)
+
+(application_expression
+  (unit) @function.call)
+
+((_type
+  (long_identifier
+    (identifier) @type.builtin))
+  (#any-of? @type.builtin
+    "bool" "byte" "sbyte" "int16" "uint16" "int" "uint" "int64" "uint64" "nativeint" "unativeint"
+    "decimal" "float" "double" "float32" "single" "char" "string" "unit"))
+
+(preproc_if
+  [
+    "#if" @keyword.directive
+    "#endif" @keyword.directive
+  ]
+  condition: (_)? @keyword.directive)
+
+(preproc_else
+  "#else" @keyword.directive)
+
+((identifier) @module.builtin
+  (#any-of? @module.builtin
+    "Array" "Async" "Directory" "File" "List" "Option" "Path" "Map" "Set" "Lazy" "Seq" "Task"
+    "String" "Result"))
+
+((value_declaration
+  (attributes
+    (attribute
+      (_type
+        (long_identifier
+          (identifier) @attribute))))
+  (function_or_value_defn
+    (value_declaration_left
+      .
+      (_) @constant)))
+  (#eq? @attribute "Literal"))
diff --git a/pack/ant/start/nvim-treesitter/queries/fsharp/injections.scm b/pack/ant/start/nvim-treesitter/queries/fsharp/injections.scm
new file mode 100644
index 0000000..211b263
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fsharp/injections.scm
@@ -0,0 +1,11 @@
+([
+  (line_comment)
+  (block_comment_content)
+] @injection.content
+  (#set! injection.language "comment"))
+
+((line_comment) @injection.content
+  (#lua-match? @injection.content "^///")
+  (#offset! @injection.content 0 3 0 0)
+  (#set! injection.language "xml")
+  (#set! injection.combined))
diff --git a/pack/ant/start/nvim-treesitter/queries/func/highlights.scm b/pack/ant/start/nvim-treesitter/queries/func/highlights.scm
new file mode 100644
index 0000000..9fd6dd8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/func/highlights.scm
@@ -0,0 +1,167 @@
+; Include
+"#include" @keyword.import
+
+(include_path) @string
+
+; Preproc
+"#pragma" @keyword.directive
+
+(pragma_directive
+  [
+    "version"
+    "not-version"
+    "test-version-set"
+  ] @keyword.directive)
+
+; Keywords
+[
+  "asm"
+  "impure"
+  "inline"
+  "inline_ref"
+  "method_id"
+  "type"
+] @keyword
+
+"return" @keyword.return
+
+; Conditionals
+[
+  "if"
+  "ifnot"
+  "else"
+  "elseif"
+  "elseifnot"
+  "until"
+] @keyword.conditional
+
+; Exceptions
+[
+  "try"
+  "catch"
+] @keyword.exception
+
+; Repeats
+[
+  "do"
+  "forall"
+  "repeat"
+  "while"
+] @keyword.repeat
+
+; Qualifiers
+[
+  "const"
+  "global"
+  (var)
+] @keyword.modifier
+
+; Variables
+(identifier) @variable
+
+; Constants
+(const_var_declarations
+  name: (identifier) @constant)
+
+; Functions/Methods
+(function_definition
+  name: (function_name) @function)
+
+(function_application
+  function: (identifier) @function)
+
+(method_call
+  method_name: (identifier) @function.method.call)
+
+; Parameters
+(parameter) @variable.parameter
+
+; Types
+(type_identifier) @type
+
+(primitive_type) @type.builtin
+
+; Operators
+[
+  "="
+  "+="
+  "-="
+  "*="
+  "/="
+  "~/="
+  "^/="
+  "%="
+  "~%="
+  "^%="
+  "<<="
+  ">>="
+  "~>>="
+  "^>>="
+  "&="
+  "|="
+  "^="
+  "=="
+  "<"
+  ">"
+  "<="
+  ">="
+  "!="
+  "<=>"
+  "<<"
+  ">>"
+  "~>>"
+  "^>>"
+  "-"
+  "+"
+  "|"
+  "^"
+  "*"
+  "/"
+  "%"
+  "~/"
+  "^/"
+  "~%"
+  "^%"
+  "/%"
+  "&"
+  "~"
+] @operator
+
+; Literals
+[
+  (string)
+  (asm_instruction)
+] @string
+
+[
+  (string_type)
+  (underscore)
+] @character.special
+
+(number) @number
+
+; Punctuation
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+  "()"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ";"
+  ","
+  "->"
+] @punctuation.delimiter
+
+; Comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/func/injections.scm b/pack/ant/start/nvim-treesitter/queries/func/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/func/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/fusion/folds.scm b/pack/ant/start/nvim-treesitter/queries/fusion/folds.scm
new file mode 100644
index 0000000..179fc16
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fusion/folds.scm
@@ -0,0 +1,6 @@
+[
+  (comment)
+  (block)
+  (afx_comment)
+  (afx_element)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/fusion/highlights.scm b/pack/ant/start/nvim-treesitter/queries/fusion/highlights.scm
new file mode 100644
index 0000000..7108e57
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fusion/highlights.scm
@@ -0,0 +1,132 @@
+(comment) @comment @spell
+
+(afx_comment) @comment @spell
+
+; identifiers afx
+(afx_opening_element
+  (afx_identifier) @tag)
+
+(afx_closing_element
+  (afx_identifier) @tag)
+
+(afx_element_self_closing
+  (afx_identifier) @tag)
+
+(afx_attribute
+  (afx_property_identifier) @tag.attribute)
+
+(afx_text) @spell
+
+; identifiers eel
+(eel_object_path
+  (eel_path_identifier) @variable.builtin
+  (#any-of? @variable.builtin "this" "props"))
+
+(eel_object_path
+  (eel_path_identifier) @variable)
+
+(eel_object_pair
+  key: (eel_property_name) @property)
+
+(eel_method_name) @function
+
+(eel_parameter) @variable
+
+; identifiers fusion
+; -----------
+(path_part) @property
+
+(meta_property) @attribute
+
+(prototype_signature
+  "prototype" @keyword)
+
+(include_statement
+  "include" @keyword.import
+  (source_file) @string.special.url)
+
+(namespace_declaration
+  "namespace" @keyword.type
+  (alias_namespace) @module)
+
+(type
+  name: (type_name) @type)
+
+; tokens
+; ------
+(afx_opening_element
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(afx_closing_element
+  [
+    "<"
+    ">"
+    "/"
+  ] @punctuation.bracket)
+
+(afx_element_self_closing
+  [
+    "<"
+    "/>"
+  ] @punctuation.bracket)
+
+[
+  (package_name)
+  (alias_namespace)
+] @module
+
+(namespace_declaration
+  "=" @operator)
+
+(assignment
+  "=" @operator)
+
+(copy
+  "<" @operator)
+
+(deletion) @operator
+
+(eel_binary_expression
+  operator: _ @operator)
+
+(eel_not_expression
+  [
+    "!"
+    "not"
+  ] @operator)
+
+(string) @string
+
+(number) @number
+
+(boolean) @boolean
+
+(null) @constant.builtin
+
+(value_expression
+  start: _ @punctuation.special
+  end: _ @punctuation.special)
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ":"
+  "."
+  "?"
+] @punctuation.delimiter
+
+(eel_ternary_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
diff --git a/pack/ant/start/nvim-treesitter/queries/fusion/indents.scm b/pack/ant/start/nvim-treesitter/queries/fusion/indents.scm
new file mode 100644
index 0000000..0ba6cf7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fusion/indents.scm
@@ -0,0 +1,24 @@
+[
+  (block)
+  (value_dsl)
+  (afx_element)
+  (afx_element_self_closing)
+  (eel_array)
+  (eel_object)
+] @indent.begin
+
+(block
+  end: _ @indent.branch)
+
+(value_dsl
+  end: _ @indent.branch)
+
+(eel_array
+  end: _ @indent.branch)
+
+(eel_object
+  end: _ @indent.branch)
+
+(afx_closing_element) @indent.branch
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/fusion/injections.scm b/pack/ant/start/nvim-treesitter/queries/fusion/injections.scm
new file mode 100644
index 0000000..085cdb4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fusion/injections.scm
@@ -0,0 +1,5 @@
+([
+  (comment)
+  (afx_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/fusion/locals.scm b/pack/ant/start/nvim-treesitter/queries/fusion/locals.scm
new file mode 100644
index 0000000..d23e0ab
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/fusion/locals.scm
@@ -0,0 +1,23 @@
+; Fusion base
+(block) @local.scope
+
+(namespace_declaration
+  (alias_namespace) @local.definition.namespace)
+
+(property
+  (path
+    (path_part) @local.definition.field))
+
+(type
+  namespace: (package_name)? @local.definition.namespace
+  name: (type_name) @local.definition.type)
+
+; Eel Expressions
+(eel_arrow_function) @local.scope
+
+(eel_object) @local.scope
+
+(eel_parameter) @local.definition.parameter
+
+(eel_object_pair
+  key: (eel_property_name) @local.definition.field)
diff --git a/pack/ant/start/nvim-treesitter/queries/gap/folds.scm b/pack/ant/start/nvim-treesitter/queries/gap/folds.scm
new file mode 100644
index 0000000..7cf0888
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gap/folds.scm
@@ -0,0 +1,12 @@
+[
+  (if_statement)
+  (elif_clause)
+  (else_clause)
+  (while_statement)
+  (repeat_statement)
+  (for_statement)
+  (atomic_statement)
+  (lambda)
+  (function)
+  (atomic_function)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/gap/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gap/highlights.scm
new file mode 100644
index 0000000..6c0c856
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gap/highlights.scm
@@ -0,0 +1,208 @@
+(identifier) @variable
+
+; Functions
+(assignment_statement
+  left: (identifier) @function
+  right: (function))
+
+(assignment_statement
+  left: (identifier) @function
+  right: (atomic_function))
+
+(assignment_statement
+  left: (identifier) @function
+  right: (lambda))
+
+(call
+  function: (identifier) @function.call)
+
+((call
+  function: (identifier) @function.builtin)
+  (#any-of? @function.builtin "Assert" "Info" "IsBound" "Unbind" "TryNextMethod"))
+
+(parameters
+  (identifier) @variable.parameter)
+
+(qualified_parameters
+  (identifier) @variable.parameter)
+
+(qualified_parameters
+  (qualified_identifier
+    (identifier) @variable.parameter))
+
+(lambda_parameters
+  (identifier) @variable.parameter)
+
+; arg is treated specially when it is the only parameter of a function
+((parameters
+  .
+  (identifier) @variable.parameter.builtin .)
+  (#eq? @variable.parameter.builtin "arg"))
+
+((qualified_parameters
+  .
+  (identifier) @variable.parameter.builtin .)
+  (#eq? @variable.parameter.builtin "arg"))
+
+((qualified_parameters
+  .
+  (qualified_identifier
+    (identifier) @variable.parameter.builtin) .)
+  (#eq? @variable.parameter.builtin "arg"))
+
+((lambda_parameters
+  .
+  (identifier) @variable.parameter.builtin .)
+  (#eq? @variable.parameter.builtin "arg"))
+
+; Literals
+(bool) @constant.builtin
+
+(integer) @number
+
+(float) @number.float
+
+(string) @string
+
+(char) @character
+
+(escape_sequence) @string.escape
+
+[
+  (help_topic)
+  (help_book)
+] @string.special
+
+(tilde) @variable.builtin
+
+; Record selectors
+(record_entry
+  left: [
+    (identifier)
+    (integer)
+  ] @variable.member)
+
+(record_selector
+  selector: [
+    (identifier)
+    (integer)
+  ] @variable.member)
+
+(component_selector
+  selector: [
+    (identifier)
+    (integer)
+  ] @variable.member)
+
+(function_call_option
+  [
+    (identifier)
+    (record_entry ;Record entries specify global properties in function calls
+      left: [
+        (identifier)
+        (integer)
+      ])
+  ] @property)
+
+(help_statement
+  (help_selector) @property)
+
+; Operators
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "^"
+  "->"
+  ":="
+  "<"
+  "<="
+  "<>"
+  "="
+  ">"
+  ">="
+  ".."
+  (ellipsis)
+] @operator
+
+(help_statement
+  (help_operator) @operator)
+
+; Keywords
+[
+  (break_statement)
+  (continue_statement)
+  "atomic"
+  (quit_statement)
+] @keyword
+
+[
+  "function"
+  "local"
+  "end"
+] @keyword.function
+
+[
+  "and"
+  "in"
+  "mod"
+  "not"
+  "or"
+] @keyword.operator
+
+"rec" @keyword.type
+
+[
+  "readonly"
+  "readwrite"
+] @keyword.modifier
+
+(atomic_function
+  "atomic" @keyword.modifier)
+
+[
+  "for"
+  "while"
+  "do"
+  "od"
+  "repeat"
+  "until"
+] @keyword.repeat
+
+[
+  "if"
+  "then"
+  "elif"
+  "else"
+  "fi"
+] @keyword.conditional
+
+"return" @keyword.return
+
+(pragma) @keyword.directive
+
+;Punctuation
+[
+  ","
+  ";"
+  "."
+  "!."
+  ":"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "!["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+(help_statement
+  "?" @punctuation.special)
+
+;Comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/gap/injections.scm b/pack/ant/start/nvim-treesitter/queries/gap/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gap/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/gap/locals.scm b/pack/ant/start/nvim-treesitter/queries/gap/locals.scm
new file mode 100644
index 0000000..d695d1f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gap/locals.scm
@@ -0,0 +1,43 @@
+[
+  (lambda)
+  (function)
+  (atomic_function)
+] @local.scope
+
+(parameters
+  (identifier) @local.definition.parameter)
+
+(qualified_parameters
+  (identifier) @local.definition.parameter)
+
+(qualified_parameters
+  (qualified_identifier
+    (identifier) @local.definition.parameter))
+
+(lambda_parameters
+  (identifier) @local.definition.parameter)
+
+(locals
+  (identifier) @local.definition.var)
+
+(record_entry
+  left: [
+    (identifier)
+    (integer)
+  ] @local.definition.field)
+
+(assignment_statement
+  left: (identifier) @local.definition.var)
+
+(for_statement
+  identifier: (identifier) @local.definition.var)
+
+(assignment_statement
+  left: (identifier) @local.definition.function
+  right: [
+    (lambda)
+    (function)
+    (atomic_function)
+  ])
+
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/gaptst/folds.scm b/pack/ant/start/nvim-treesitter/queries/gaptst/folds.scm
new file mode 100644
index 0000000..0ec72d1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gaptst/folds.scm
@@ -0,0 +1,7 @@
+[
+  (if_statement)
+  (else_clause)
+  (local_statement)
+  (exec_statement)
+  (test_case)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/gaptst/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gaptst/highlights.scm
new file mode 100644
index 0000000..22ab2d0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gaptst/highlights.scm
@@ -0,0 +1,19 @@
+(output_line) @markup.raw.block
+
+[
+  "#@local"
+  "#@exec"
+] @keyword
+
+[
+  "gap> "
+  "> "
+] @keyword.debug
+
+[
+  "#@if"
+  "#@else"
+  "#@fi"
+] @keyword.conditional
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/gaptst/injections.scm b/pack/ant/start/nvim-treesitter/queries/gaptst/injections.scm
new file mode 100644
index 0000000..bdcba35
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gaptst/injections.scm
@@ -0,0 +1,9 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((gap_expression) @injection.content
+  (#set! injection.language "gap"))
+
+((input_line) @injection.content
+  (#set! injection.language "gap")
+  (#set! injection.combined))
diff --git a/pack/ant/start/nvim-treesitter/queries/gdscript/folds.scm b/pack/ant/start/nvim-treesitter/queries/gdscript/folds.scm
new file mode 100644
index 0000000..cda7090
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gdscript/folds.scm
@@ -0,0 +1,26 @@
+[
+  ; Body fold will "join" the next adjacent fold into a SUPER fold.
+  ; This is an issue with the grammar.
+  ; (body)
+  (if_statement)
+  (elif_clause)
+  (else_clause)
+  (for_statement)
+  (while_statement)
+  (class_definition)
+  (enum_definition)
+  (match_statement)
+  (pattern_section)
+  (function_definition)
+  (lambda)
+  (constructor_definition)
+] @fold
+
+; It's nice to be able to fold the if/elif/else clauses and the entire
+; if_statement.
+(if_statement
+  (body) @fold)
+
+; Fold strings that are probably doc strings.
+(expression_statement
+  (string) @fold)
diff --git a/pack/ant/start/nvim-treesitter/queries/gdscript/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gdscript/highlights.scm
new file mode 100644
index 0000000..bc62bc2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gdscript/highlights.scm
@@ -0,0 +1,422 @@
+; Basic
+(identifier) @variable
+
+(name) @variable
+
+(type
+  (identifier) @type)
+
+(comment) @comment @spell
+
+(string_name) @string
+
+(string) @string
+
+(float) @number.float
+
+(integer) @number
+
+(null) @constant
+
+(setter) @function
+
+(getter) @function
+
+(set_body
+  "set" @keyword.function)
+
+(get_body
+  "get" @keyword.function)
+
+(static_keyword) @keyword.modifier
+
+(tool_statement) @keyword
+
+(breakpoint_statement) @keyword.debug
+
+(inferred_type) @operator
+
+[
+  (true)
+  (false)
+] @boolean
+
+[
+  (get_node)
+  (node_path)
+] @string.special.url
+
+(class_name_statement
+  (name) @type) @keyword
+
+(const_statement
+  "const" @keyword.modifier
+  (name) @constant)
+
+(expression_statement
+  (string) @comment @spell)
+
+; Functions
+(constructor_definition
+  "_init" @constructor)
+
+(function_definition
+  (name) @function)
+
+(parameters
+  (identifier) @variable.parameter)
+
+(typed_parameter
+  (identifier) @variable.parameter)
+
+(default_parameter
+  (identifier) @variable.parameter)
+
+(typed_default_parameter
+  (identifier) @variable.parameter)
+
+(call
+  (identifier) @function.call)
+
+(call
+  (identifier) @keyword.import
+  (#any-of? @keyword.import "preload" "load"))
+
+; Properties and Methods
+; We'll use @property since that's the term Godot uses.
+; But, should (source (variable_statement (name))) be @property, too? Since a
+; script file is a class in gdscript.
+(class_definition
+  (body
+    (variable_statement
+      (name) @property)))
+
+; Same question but for methods?
+(class_definition
+  (body
+    (function_definition
+      (name) @function.method)))
+
+(attribute_call
+  (identifier) @function.method.call)
+
+(attribute_subscript
+  (identifier) @property)
+
+(attribute
+  (_)
+  (identifier) @property)
+
+; Identifier naming conventions
+; - Make sure the following query is below the attribute queries so that it
+;   takes precedence on a `(type (attribute (identifier)))`
+((identifier) @type
+  (#lua-match? @type "^[A-Z]"))
+
+((identifier) @constant
+  (#lua-match? @constant "^[A-Z][A-Z_0-9]*$"))
+
+; Enums
+(enumerator
+  left: (identifier) @constant)
+
+; Special Builtins
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin "self" "super"))
+
+(attribute_call
+  (identifier) @keyword.operator
+  (#eq? @keyword.operator "new"))
+
+; Match Pattern
+[
+  (underscore)
+  (pattern_open_ending)
+] @character.special
+
+; Alternations
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  ","
+  "."
+  ":"
+] @punctuation.delimiter
+
+[
+  "if"
+  "elif"
+  "else"
+  "match"
+] @keyword.conditional
+
+(pattern_guard
+  "when" @keyword.conditional)
+
+[
+  "for"
+  "while"
+  "break"
+  "continue"
+] @keyword.repeat
+
+[
+  "~"
+  "-"
+  "*"
+  "/"
+  "%"
+  "+"
+  "-"
+  "<<"
+  ">>"
+  "&"
+  "^"
+  "|"
+  "<"
+  ">"
+  "=="
+  "!="
+  ">="
+  "<="
+  "!"
+  "&&"
+  "||"
+  "="
+  "+="
+  "-="
+  "*="
+  "/="
+  "%="
+  "&="
+  "|="
+  "->"
+] @operator
+
+[
+  "and"
+  "as"
+  "in"
+  "is"
+  "not"
+  "or"
+] @keyword.operator
+
+[
+  "pass"
+  "class_name"
+  "extends"
+  "signal"
+  "var"
+  "onready"
+  "setget"
+  "remote"
+  "master"
+  "puppet"
+  "remotesync"
+  "mastersync"
+  "puppetsync"
+] @keyword
+
+"export" @keyword.import
+
+[
+  "enum"
+  "class"
+] @keyword.type
+
+"func" @keyword.function
+
+"return" @keyword.return
+
+"await" @keyword.coroutine
+
+(call
+  (identifier) @keyword.coroutine
+  (#eq? @keyword.coroutine "yield"))
+
+; Builtins
+; generated from
+; - godot commit: fb10e67fef
+; - https://github.com/godotengine/godot/blob/fb10e67fef/doc/classes
+; - https://github.com/godotengine/godot/blob/fb10e67fef/doc/classes/@GlobalScope.xml
+; - https://github.com/godotengine/godot/blob/fb10e67fef/modules/gdscript/doc_classes/@GDScript.xml
+; Built-in Annotations
+((annotation
+  "@" @attribute
+  (identifier) @attribute)
+  (#any-of? @attribute
+    ; from modules/gdscript/doc_classes/@GDScript.xml
+    "export" "export_category" "export_color_no_alpha" "export_dir" "export_enum"
+    "export_exp_easing" "export_file" "export_flags" "export_flags_2d_navigation"
+    "export_flags_2d_physics" "export_flags_2d_render" "export_flags_3d_navigation"
+    "export_flags_3d_physics" "export_flags_3d_render" "export_flags_avoidance" "export_global_dir"
+    "export_global_file" "export_group" "export_multiline" "export_node_path" "export_placeholder"
+    "export_range" "export_subgroup" "icon" "onready" "rpc" "static_unload" "tool" "warning_ignore"))
+
+; Builtin Types
+((identifier) @type.builtin
+  (#any-of? @type.builtin
+    ; from doc/classes/*.xml
+    "AABB" "Array" "Basis" "Callable" "Color" "Dictionary" "NodePath" "PackedByteArray"
+    "PackedColorArray" "PackedFloat32Array" "PackedFloat64Array" "PackedInt32Array"
+    "PackedInt64Array" "PackedStringArray" "PackedVector2Array" "PackedVector3Array" "Plane"
+    "Projection" "Quaternion" "RID" "Rect2" "Rect2i" "Signal" "String" "StringName" "Transform2D"
+    "Transform3D" "Vector2" "Vector2i" "Vector3" "Vector3i" "Vector4" "Vector4i" "bool" "float"
+    "int"
+    ; from doc/classes/@GlobalScope.xml
+    "AudioServer" "CameraServer" "ClassDB" "DisplayServer" "EditorInterface" "Engine"
+    "EngineDebugger" "GDExtensionManager" "Geometry2D" "Geometry3D" "GodotSharp" "IP" "Input"
+    "InputMap" "JavaClassWrapper" "JavaScriptBridge" "Marshalls" "NavigationMeshGenerator"
+    "NavigationServer2D" "NavigationServer3D" "OS" "Performance" "PhysicsServer2D"
+    "PhysicsServer2DManager" "PhysicsServer3D" "PhysicsServer3DManager" "ProjectSettings"
+    "RenderingServer" "ResourceLoader" "ResourceSaver" "ResourceUID" "TextServerManager" "ThemeDB"
+    "Time" "TranslationServer" "WorkerThreadPool" "XRServer"))
+
+; Builtin Funcs
+(call
+  (identifier) @function.builtin
+  (#any-of? @function.builtin
+    ; from doc/classes/@GlobalScope.xml
+    "abs" "absf" "absi" "acos" "acosh" "angle_difference" "asin" "asinh" "atan" "atan2" "atanh"
+    "bezier_derivative" "bezier_interpolate" "bytes_to_var" "bytes_to_var_with_objects" "ceil"
+    "ceilf" "ceili" "clamp" "clampf" "clampi" "cos" "cosh" "cubic_interpolate"
+    "cubic_interpolate_angle" "cubic_interpolate_angle_in_time" "cubic_interpolate_in_time"
+    "db_to_linear" "deg_to_rad" "ease" "error_string" "exp" "floor" "floorf" "floori" "fmod"
+    "fposmod" "hash" "instance_from_id" "inverse_lerp" "is_equal_approx" "is_finite" "is_inf"
+    "is_instance_id_valid" "is_instance_valid" "is_nan" "is_same" "is_zero_approx" "lerp"
+    "lerp_angle" "lerpf" "linear_to_db" "log" "max" "maxf" "maxi" "min" "minf" "mini" "move_toward"
+    "nearest_po2" "pingpong" "posmod" "pow" "print" "print_rich" "print_verbose" "printerr"
+    "printraw" "prints" "printt" "push_error" "push_warning" "rad_to_deg" "rand_from_seed" "randf"
+    "randf_range" "randfn" "randi" "randi_range" "randomize" "remap" "rid_allocate_id"
+    "rid_from_int64" "rotate_toward" "round" "roundf" "roundi" "seed" "sign" "signf" "signi" "sin"
+    "sinh" "smoothstep" "snapped" "snappedf" "snappedi" "sqrt" "step_decimals" "str" "str_to_var"
+    "tan" "tanh" "type_convert" "type_string" "typeof" "var_to_bytes" "var_to_bytes_with_objects"
+    "var_to_str" "weakref" "wrap" "wrapf" "wrapi"
+    ; from modules/gdscript/doc_classes/@GDScript.xml
+    "Color8" "assert" "char" "convert" "dict_to_inst" "get_stack" "inst_to_dict" "is_instance_of"
+    "len" "load" "preload" "print_debug" "print_stack" "range" "type_exists")
+  )
+
+; Builtin Constants
+((identifier) @constant.builtin
+  (#any-of? @constant.builtin
+    ; from modules/gdscript/doc_classes/@GDScript.xml
+    "INF" "NAN" "PI" "TAU"
+    ; from doc/classes/@GlobalScope.xml
+    "CLOCKWISE" "CORNER_BOTTOM_LEFT" "CORNER_BOTTOM_RIGHT" "CORNER_TOP_LEFT" "CORNER_TOP_RIGHT"
+    "COUNTERCLOCKWISE" "ERR_ALREADY_EXISTS" "ERR_ALREADY_IN_USE" "ERR_BUG" "ERR_BUSY"
+    "ERR_CANT_ACQUIRE_RESOURCE" "ERR_CANT_CONNECT" "ERR_CANT_CREATE" "ERR_CANT_FORK" "ERR_CANT_OPEN"
+    "ERR_CANT_RESOLVE" "ERR_COMPILATION_FAILED" "ERR_CONNECTION_ERROR" "ERR_CYCLIC_LINK"
+    "ERR_DATABASE_CANT_READ" "ERR_DATABASE_CANT_WRITE" "ERR_DOES_NOT_EXIST" "ERR_DUPLICATE_SYMBOL"
+    "ERR_FILE_ALREADY_IN_USE" "ERR_FILE_BAD_DRIVE" "ERR_FILE_BAD_PATH" "ERR_FILE_CANT_OPEN"
+    "ERR_FILE_CANT_READ" "ERR_FILE_CANT_WRITE" "ERR_FILE_CORRUPT" "ERR_FILE_EOF"
+    "ERR_FILE_MISSING_DEPENDENCIES" "ERR_FILE_NOT_FOUND" "ERR_FILE_NO_PERMISSION"
+    "ERR_FILE_UNRECOGNIZED" "ERR_HELP" "ERR_INVALID_DATA" "ERR_INVALID_DECLARATION"
+    "ERR_INVALID_PARAMETER" "ERR_LINK_FAILED" "ERR_LOCKED" "ERR_METHOD_NOT_FOUND"
+    "ERR_OUT_OF_MEMORY" "ERR_PARAMETER_RANGE_ERROR" "ERR_PARSE_ERROR" "ERR_PRINTER_ON_FIRE"
+    "ERR_QUERY_FAILED" "ERR_SCRIPT_FAILED" "ERR_SKIP" "ERR_TIMEOUT" "ERR_UNAUTHORIZED"
+    "ERR_UNAVAILABLE" "ERR_UNCONFIGURED" "EULER_ORDER_XYZ" "EULER_ORDER_XZY" "EULER_ORDER_YXZ"
+    "EULER_ORDER_YZX" "EULER_ORDER_ZXY" "EULER_ORDER_ZYX" "FAILED" "HORIZONTAL"
+    "HORIZONTAL_ALIGNMENT_CENTER" "HORIZONTAL_ALIGNMENT_FILL" "HORIZONTAL_ALIGNMENT_LEFT"
+    "HORIZONTAL_ALIGNMENT_RIGHT" "INLINE_ALIGNMENT_BASELINE_TO" "INLINE_ALIGNMENT_BOTTOM"
+    "INLINE_ALIGNMENT_BOTTOM_TO" "INLINE_ALIGNMENT_CENTER" "INLINE_ALIGNMENT_CENTER_TO"
+    "INLINE_ALIGNMENT_IMAGE_MASK" "INLINE_ALIGNMENT_TEXT_MASK" "INLINE_ALIGNMENT_TOP"
+    "INLINE_ALIGNMENT_TOP_TO" "INLINE_ALIGNMENT_TO_BASELINE" "INLINE_ALIGNMENT_TO_BOTTOM"
+    "INLINE_ALIGNMENT_TO_CENTER" "INLINE_ALIGNMENT_TO_TOP" "JOY_AXIS_INVALID" "JOY_AXIS_LEFT_X"
+    "JOY_AXIS_LEFT_Y" "JOY_AXIS_MAX" "JOY_AXIS_RIGHT_X" "JOY_AXIS_RIGHT_Y" "JOY_AXIS_SDL_MAX"
+    "JOY_AXIS_TRIGGER_LEFT" "JOY_AXIS_TRIGGER_RIGHT" "JOY_BUTTON_A" "JOY_BUTTON_B" "JOY_BUTTON_BACK"
+    "JOY_BUTTON_DPAD_DOWN" "JOY_BUTTON_DPAD_LEFT" "JOY_BUTTON_DPAD_RIGHT" "JOY_BUTTON_DPAD_UP"
+    "JOY_BUTTON_GUIDE" "JOY_BUTTON_INVALID" "JOY_BUTTON_LEFT_SHOULDER" "JOY_BUTTON_LEFT_STICK"
+    "JOY_BUTTON_MAX" "JOY_BUTTON_MISC1" "JOY_BUTTON_PADDLE1" "JOY_BUTTON_PADDLE2"
+    "JOY_BUTTON_PADDLE3" "JOY_BUTTON_PADDLE4" "JOY_BUTTON_RIGHT_SHOULDER" "JOY_BUTTON_RIGHT_STICK"
+    "JOY_BUTTON_SDL_MAX" "JOY_BUTTON_START" "JOY_BUTTON_TOUCHPAD" "JOY_BUTTON_X" "JOY_BUTTON_Y"
+    "KEY_0" "KEY_1" "KEY_2" "KEY_3" "KEY_4" "KEY_5" "KEY_6" "KEY_7" "KEY_8" "KEY_9" "KEY_A"
+    "KEY_ALT" "KEY_AMPERSAND" "KEY_APOSTROPHE" "KEY_ASCIICIRCUM" "KEY_ASCIITILDE" "KEY_ASTERISK"
+    "KEY_AT" "KEY_B" "KEY_BACK" "KEY_BACKSLASH" "KEY_BACKSPACE" "KEY_BACKTAB" "KEY_BAR"
+    "KEY_BRACELEFT" "KEY_BRACERIGHT" "KEY_BRACKETLEFT" "KEY_BRACKETRIGHT" "KEY_C" "KEY_CAPSLOCK"
+    "KEY_CLEAR" "KEY_CODE_MASK" "KEY_COLON" "KEY_COMMA" "KEY_CTRL" "KEY_D" "KEY_DELETE" "KEY_DOLLAR"
+    "KEY_DOWN" "KEY_E" "KEY_END" "KEY_ENTER" "KEY_EQUAL" "KEY_ESCAPE" "KEY_EXCLAM" "KEY_F" "KEY_F1"
+    "KEY_F10" "KEY_F11" "KEY_F12" "KEY_F13" "KEY_F14" "KEY_F15" "KEY_F16" "KEY_F17" "KEY_F18"
+    "KEY_F19" "KEY_F2" "KEY_F20" "KEY_F21" "KEY_F22" "KEY_F23" "KEY_F24" "KEY_F25" "KEY_F26"
+    "KEY_F27" "KEY_F28" "KEY_F29" "KEY_F3" "KEY_F30" "KEY_F31" "KEY_F32" "KEY_F33" "KEY_F34"
+    "KEY_F35" "KEY_F4" "KEY_F5" "KEY_F6" "KEY_F7" "KEY_F8" "KEY_F9" "KEY_FAVORITES" "KEY_FORWARD"
+    "KEY_G" "KEY_GLOBE" "KEY_GREATER" "KEY_H" "KEY_HELP" "KEY_HOME" "KEY_HOMEPAGE" "KEY_HYPER"
+    "KEY_I" "KEY_INSERT" "KEY_J" "KEY_JIS_EISU" "KEY_JIS_KANA" "KEY_K" "KEY_KEYBOARD" "KEY_KP_0"
+    "KEY_KP_1" "KEY_KP_2" "KEY_KP_3" "KEY_KP_4" "KEY_KP_5" "KEY_KP_6" "KEY_KP_7" "KEY_KP_8"
+    "KEY_KP_9" "KEY_KP_ADD" "KEY_KP_DIVIDE" "KEY_KP_ENTER" "KEY_KP_MULTIPLY" "KEY_KP_PERIOD"
+    "KEY_KP_SUBTRACT" "KEY_L" "KEY_LAUNCH0" "KEY_LAUNCH1" "KEY_LAUNCH2" "KEY_LAUNCH3" "KEY_LAUNCH4"
+    "KEY_LAUNCH5" "KEY_LAUNCH6" "KEY_LAUNCH7" "KEY_LAUNCH8" "KEY_LAUNCH9" "KEY_LAUNCHA"
+    "KEY_LAUNCHB" "KEY_LAUNCHC" "KEY_LAUNCHD" "KEY_LAUNCHE" "KEY_LAUNCHF" "KEY_LAUNCHMAIL"
+    "KEY_LAUNCHMEDIA" "KEY_LEFT" "KEY_LESS" "KEY_LOCATION_LEFT" "KEY_LOCATION_RIGHT"
+    "KEY_LOCATION_UNSPECIFIED" "KEY_M" "KEY_MASK_ALT" "KEY_MASK_CMD_OR_CTRL" "KEY_MASK_CTRL"
+    "KEY_MASK_GROUP_SWITCH" "KEY_MASK_KPAD" "KEY_MASK_META" "KEY_MASK_SHIFT" "KEY_MEDIANEXT"
+    "KEY_MEDIAPLAY" "KEY_MEDIAPREVIOUS" "KEY_MEDIARECORD" "KEY_MEDIASTOP" "KEY_MENU" "KEY_META"
+    "KEY_MINUS" "KEY_MODIFIER_MASK" "KEY_N" "KEY_NONE" "KEY_NUMBERSIGN" "KEY_NUMLOCK" "KEY_O"
+    "KEY_OPENURL" "KEY_P" "KEY_PAGEDOWN" "KEY_PAGEUP" "KEY_PARENLEFT" "KEY_PARENRIGHT" "KEY_PAUSE"
+    "KEY_PERCENT" "KEY_PERIOD" "KEY_PLUS" "KEY_PRINT" "KEY_Q" "KEY_QUESTION" "KEY_QUOTEDBL"
+    "KEY_QUOTELEFT" "KEY_R" "KEY_REFRESH" "KEY_RIGHT" "KEY_S" "KEY_SCROLLLOCK" "KEY_SEARCH"
+    "KEY_SECTION" "KEY_SEMICOLON" "KEY_SHIFT" "KEY_SLASH" "KEY_SPACE" "KEY_SPECIAL" "KEY_STANDBY"
+    "KEY_STOP" "KEY_SYSREQ" "KEY_T" "KEY_TAB" "KEY_U" "KEY_UNDERSCORE" "KEY_UNKNOWN" "KEY_UP"
+    "KEY_V" "KEY_VOLUMEDOWN" "KEY_VOLUMEMUTE" "KEY_VOLUMEUP" "KEY_W" "KEY_X" "KEY_Y" "KEY_YEN"
+    "KEY_Z" "METHOD_FLAGS_DEFAULT" "METHOD_FLAG_CONST" "METHOD_FLAG_EDITOR" "METHOD_FLAG_NORMAL"
+    "METHOD_FLAG_OBJECT_CORE" "METHOD_FLAG_STATIC" "METHOD_FLAG_VARARG" "METHOD_FLAG_VIRTUAL"
+    "MIDI_MESSAGE_ACTIVE_SENSING" "MIDI_MESSAGE_AFTERTOUCH" "MIDI_MESSAGE_CHANNEL_PRESSURE"
+    "MIDI_MESSAGE_CONTINUE" "MIDI_MESSAGE_CONTROL_CHANGE" "MIDI_MESSAGE_NONE"
+    "MIDI_MESSAGE_NOTE_OFF" "MIDI_MESSAGE_NOTE_ON" "MIDI_MESSAGE_PITCH_BEND"
+    "MIDI_MESSAGE_PROGRAM_CHANGE" "MIDI_MESSAGE_QUARTER_FRAME" "MIDI_MESSAGE_SONG_POSITION_POINTER"
+    "MIDI_MESSAGE_SONG_SELECT" "MIDI_MESSAGE_START" "MIDI_MESSAGE_STOP"
+    "MIDI_MESSAGE_SYSTEM_EXCLUSIVE" "MIDI_MESSAGE_SYSTEM_RESET" "MIDI_MESSAGE_TIMING_CLOCK"
+    "MIDI_MESSAGE_TUNE_REQUEST" "MOUSE_BUTTON_LEFT" "MOUSE_BUTTON_MASK_LEFT"
+    "MOUSE_BUTTON_MASK_MB_XBUTTON1" "MOUSE_BUTTON_MASK_MB_XBUTTON2" "MOUSE_BUTTON_MASK_MIDDLE"
+    "MOUSE_BUTTON_MASK_RIGHT" "MOUSE_BUTTON_MIDDLE" "MOUSE_BUTTON_NONE" "MOUSE_BUTTON_RIGHT"
+    "MOUSE_BUTTON_WHEEL_DOWN" "MOUSE_BUTTON_WHEEL_LEFT" "MOUSE_BUTTON_WHEEL_RIGHT"
+    "MOUSE_BUTTON_WHEEL_UP" "MOUSE_BUTTON_XBUTTON1" "MOUSE_BUTTON_XBUTTON2" "OK" "OP_ADD" "OP_AND"
+    "OP_BIT_AND" "OP_BIT_NEGATE" "OP_BIT_OR" "OP_BIT_XOR" "OP_DIVIDE" "OP_EQUAL" "OP_GREATER"
+    "OP_GREATER_EQUAL" "OP_IN" "OP_LESS" "OP_LESS_EQUAL" "OP_MAX" "OP_MODULE" "OP_MULTIPLY"
+    "OP_NEGATE" "OP_NOT" "OP_NOT_EQUAL" "OP_OR" "OP_POSITIVE" "OP_POWER" "OP_SHIFT_LEFT"
+    "OP_SHIFT_RIGHT" "OP_SUBTRACT" "OP_XOR" "PROPERTY_HINT_ARRAY_TYPE"
+    "PROPERTY_HINT_COLOR_NO_ALPHA" "PROPERTY_HINT_DIR" "PROPERTY_HINT_ENUM"
+    "PROPERTY_HINT_ENUM_SUGGESTION" "PROPERTY_HINT_EXPRESSION" "PROPERTY_HINT_EXP_EASING"
+    "PROPERTY_HINT_FILE" "PROPERTY_HINT_FLAGS" "PROPERTY_HINT_GLOBAL_DIR"
+    "PROPERTY_HINT_GLOBAL_FILE" "PROPERTY_HINT_GLOBAL_SAVE_FILE"
+    "PROPERTY_HINT_HIDE_QUATERNION_EDIT" "PROPERTY_HINT_INT_IS_OBJECTID"
+    "PROPERTY_HINT_INT_IS_POINTER" "PROPERTY_HINT_LAYERS_2D_NAVIGATION"
+    "PROPERTY_HINT_LAYERS_2D_PHYSICS" "PROPERTY_HINT_LAYERS_2D_RENDER"
+    "PROPERTY_HINT_LAYERS_3D_NAVIGATION" "PROPERTY_HINT_LAYERS_3D_PHYSICS"
+    "PROPERTY_HINT_LAYERS_3D_RENDER" "PROPERTY_HINT_LAYERS_AVOIDANCE" "PROPERTY_HINT_LINK"
+    "PROPERTY_HINT_LOCALE_ID" "PROPERTY_HINT_LOCALIZABLE_STRING" "PROPERTY_HINT_MAX"
+    "PROPERTY_HINT_MULTILINE_TEXT" "PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE"
+    "PROPERTY_HINT_NODE_PATH_VALID_TYPES" "PROPERTY_HINT_NODE_TYPE" "PROPERTY_HINT_NONE"
+    "PROPERTY_HINT_OBJECT_ID" "PROPERTY_HINT_OBJECT_TOO_BIG" "PROPERTY_HINT_PASSWORD"
+    "PROPERTY_HINT_PLACEHOLDER_TEXT" "PROPERTY_HINT_RANGE" "PROPERTY_HINT_RESOURCE_TYPE"
+    "PROPERTY_HINT_SAVE_FILE" "PROPERTY_HINT_TYPE_STRING" "PROPERTY_USAGE_ALWAYS_DUPLICATE"
+    "PROPERTY_USAGE_ARRAY" "PROPERTY_USAGE_CATEGORY" "PROPERTY_USAGE_CHECKABLE"
+    "PROPERTY_USAGE_CHECKED" "PROPERTY_USAGE_CLASS_IS_BITFIELD" "PROPERTY_USAGE_CLASS_IS_ENUM"
+    "PROPERTY_USAGE_DEFAULT" "PROPERTY_USAGE_DEFERRED_SET_RESOURCE" "PROPERTY_USAGE_EDITOR"
+    "PROPERTY_USAGE_EDITOR_BASIC_SETTING" "PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT"
+    "PROPERTY_USAGE_GROUP" "PROPERTY_USAGE_HIGH_END_GFX" "PROPERTY_USAGE_INTERNAL"
+    "PROPERTY_USAGE_KEYING_INCREMENTS" "PROPERTY_USAGE_NEVER_DUPLICATE"
+    "PROPERTY_USAGE_NIL_IS_VARIANT" "PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT" "PROPERTY_USAGE_NONE"
+    "PROPERTY_USAGE_NO_EDITOR" "PROPERTY_USAGE_NO_INSTANCE_STATE" "PROPERTY_USAGE_READ_ONLY"
+    "PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT" "PROPERTY_USAGE_RESTART_IF_CHANGED"
+    "PROPERTY_USAGE_SCRIPT_DEFAULT_VALUE" "PROPERTY_USAGE_SCRIPT_VARIABLE" "PROPERTY_USAGE_SECRET"
+    "PROPERTY_USAGE_STORAGE" "PROPERTY_USAGE_STORE_IF_NULL" "PROPERTY_USAGE_SUBGROUP"
+    "PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED" "SIDE_BOTTOM" "SIDE_LEFT" "SIDE_RIGHT" "SIDE_TOP"
+    "TYPE_AABB" "TYPE_ARRAY" "TYPE_BASIS" "TYPE_BOOL" "TYPE_CALLABLE" "TYPE_COLOR" "TYPE_DICTIONARY"
+    "TYPE_FLOAT" "TYPE_INT" "TYPE_MAX" "TYPE_NIL" "TYPE_NODE_PATH" "TYPE_OBJECT"
+    "TYPE_PACKED_BYTE_ARRAY" "TYPE_PACKED_COLOR_ARRAY" "TYPE_PACKED_FLOAT32_ARRAY"
+    "TYPE_PACKED_FLOAT64_ARRAY" "TYPE_PACKED_INT32_ARRAY" "TYPE_PACKED_INT64_ARRAY"
+    "TYPE_PACKED_STRING_ARRAY" "TYPE_PACKED_VECTOR2_ARRAY" "TYPE_PACKED_VECTOR3_ARRAY" "TYPE_PLANE"
+    "TYPE_PROJECTION" "TYPE_QUATERNION" "TYPE_RECT2" "TYPE_RECT2I" "TYPE_RID" "TYPE_SIGNAL"
+    "TYPE_STRING" "TYPE_STRING_NAME" "TYPE_TRANSFORM2D" "TYPE_TRANSFORM3D" "TYPE_VECTOR2"
+    "TYPE_VECTOR2I" "TYPE_VECTOR3" "TYPE_VECTOR3I" "TYPE_VECTOR4" "TYPE_VECTOR4I" "VERTICAL"
+    "VERTICAL_ALIGNMENT_BOTTOM" "VERTICAL_ALIGNMENT_CENTER" "VERTICAL_ALIGNMENT_FILL"
+    "VERTICAL_ALIGNMENT_TOP"))
diff --git a/pack/ant/start/nvim-treesitter/queries/gdscript/indents.scm b/pack/ant/start/nvim-treesitter/queries/gdscript/indents.scm
new file mode 100644
index 0000000..36b989f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gdscript/indents.scm
@@ -0,0 +1,78 @@
+[
+  (lambda)
+  (function_definition)
+  (constructor_definition)
+  (for_statement)
+  (while_statement)
+  (if_statement)
+  (class_definition)
+  (match_statement)
+  (pattern_section)
+  (setget)
+  (match_body)
+  (set_body)
+  (get_body)
+] @indent.begin
+
+[
+  (elif_clause)
+  (else_clause)
+] @indent.branch
+
+[
+  (string)
+  (comment)
+  (array)
+  (dictionary)
+  (parenthesized_expression)
+  (ERROR)
+] @indent.auto
+
+[
+  (pass_statement)
+  (continue_statement)
+  (break_statement)
+  (return_statement)
+] @indent.dedent
+
+[
+  (ERROR
+    "[")
+  (ERROR
+    "(")
+  (ERROR
+    "{")
+] @indent.begin
+
+; This only works with expanded tabs.
+; ((parameters) @indent.align (#set! indent.open_delimiter "(") (#set! indent.close_delimiter ")"))
+; ((arguments)  @indent.align (#set! indent.open_delimiter "(") (#set! indent.close_delimiter ")"))
+; The following queries either do not agree with the current body parsing or are
+; attempted workarounds. Specifically as the last statement of a body. Opening
+; a new line in between statements works well.
+;
+; The overall experience is poor, so I've opted for @indent.auto.
+;
+; The gdscript parser will need to be patched to accommodate more interactive
+; edits. As far as I can tell the parser greedily consumes whitespace
+; as a zero-width token which causes trouble when inserting indents.
+; This indents correctly with tabs.
+; (arguments) @indent.begin
+; (parameters) @indent.begin
+; (array) @indent.begin
+; (dictionary) @indent.begin
+; (parenthesized_expression) @indent.begin
+; Partial workaround for when the cursor is on the bracket character and a newline
+; is created with <o>. Without this the newline is opened with extra
+; indentation.
+; (body (_ (array "]" @indent.end) ) _)
+; Problematic behaviors occur at the last statement of a body.
+; with @dedent:
+;   - [ | ] i<CR> will dedent ] to 0.
+;   - [
+;   ]| o will open new line at correct indentation.
+; with @auto:
+;   - [ | ] i<CR> same
+;   - [
+;   ]| o will open new line with extra indent.
+;(body (_ (array "]" @indent.auto) ) .)
diff --git a/pack/ant/start/nvim-treesitter/queries/gdscript/injections.scm b/pack/ant/start/nvim-treesitter/queries/gdscript/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gdscript/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/gdscript/locals.scm b/pack/ant/start/nvim-treesitter/queries/gdscript/locals.scm
new file mode 100644
index 0000000..62166e6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gdscript/locals.scm
@@ -0,0 +1,121 @@
+; Scopes
+[
+  (if_statement)
+  (elif_clause)
+  (else_clause)
+  (for_statement)
+  (while_statement)
+  (function_definition)
+  (constructor_definition)
+  (class_definition)
+  (match_statement)
+  (pattern_section)
+  (lambda)
+  (get_body)
+  (set_body)
+] @local.scope
+
+; Parameters
+(parameters
+  (identifier) @local.definition.parameter)
+
+(default_parameter
+  (identifier) @local.definition.parameter)
+
+(typed_parameter
+  (identifier) @local.definition.parameter)
+
+(typed_default_parameter
+  (identifier) @local.definition.parameter)
+
+; Signals
+; Can gdscript 2 signals be considered fields?
+(signal_statement
+  (name) @local.definition.field)
+
+; Variable Definitions
+(const_statement
+  (name) @local.definition.constant)
+
+; onready and export variations are only properties.
+(variable_statement
+  (name) @local.definition.var)
+
+(setter) @local.reference
+
+(getter) @local.reference
+
+; Function Definition
+((function_definition
+  (name) @local.definition.function)
+  (#set! definition.function.scope "parent"))
+
+; Lambda
+; lambda names are not accessible and are only for debugging.
+(lambda
+  (name) @local.definition.function)
+
+; Source
+(class_name_statement
+  (name) @local.definition.type)
+
+(source
+  (variable_statement
+    (name) @local.definition.field))
+
+(source
+  (onready_variable_statement
+    (name) @local.definition.field))
+
+(source
+  (export_variable_statement
+    (name) @local.definition.field))
+
+; Class
+((class_definition
+  (name) @local.definition.type)
+  (#set! definition.type.scope "parent"))
+
+(class_definition
+  (body
+    (variable_statement
+      (name) @local.definition.field)))
+
+(class_definition
+  (body
+    (onready_variable_statement
+      (name) @local.definition.field)))
+
+(class_definition
+  (body
+    (export_variable_statement
+      (name) @local.definition.field)))
+
+(class_definition
+  (body
+    (signal_statement
+      (name) @local.definition.field)))
+
+; Although a script is also a class, let's only define functions in an inner class as
+; methods.
+((class_definition
+  (body
+    (function_definition
+      (name) @local.definition.method)))
+  (#set! definition.method.scope "parent"))
+
+; Enum
+(enum_definition
+  (name) @local.definition.enum)
+
+; Repeat
+(for_statement
+  .
+  (identifier) @local.definition.var)
+
+; Match Statement
+(pattern_binding
+  (identifier) @local.definition.var)
+
+; References
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/gdshader/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gdshader/highlights.scm
new file mode 100644
index 0000000..c93fd47
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gdshader/highlights.scm
@@ -0,0 +1,142 @@
+[
+  "render_mode"
+  "shader_type"
+  "group_uniforms"
+  "global"
+  "instance"
+  "const"
+  "varying"
+  "uniform"
+] @keyword
+
+"struct" @keyword.type
+
+[
+  (precision_qualifier)
+  (interpolation_qualifier)
+] @keyword.modifier
+
+[
+  "in"
+  "out"
+  "inout"
+] @keyword.modifier
+
+[
+  "while"
+  "for"
+] @keyword.repeat
+
+[
+  "continue"
+  "break"
+  "return"
+] @keyword.return
+
+[
+  "if"
+  "else"
+  "switch"
+  "case"
+  "default"
+] @keyword.conditional
+
+[
+  "#"
+  "include"
+] @keyword.directive
+
+(string) @string
+
+[
+  "="
+  "+="
+  "-="
+  "!"
+  "~"
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "||"
+  "&&"
+  "|"
+  "^"
+  "&"
+  "=="
+  "!="
+  ">"
+  ">="
+  "<="
+  "<"
+  "<<"
+  ">>"
+  "++"
+  "--"
+] @operator
+
+(boolean) @boolean
+
+(integer) @number
+
+(float) @number.float
+
+[
+  "."
+  ","
+  ";"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+(builtin_type) @type.builtin
+
+(ident_type) @type.definition
+
+[
+  (shader_type)
+  (render_mode)
+  (hint_name)
+] @attribute
+
+(builtin_variable) @constant.builtin
+
+(builtin_function) @function.builtin
+
+(group_uniforms_declaration
+  group_name: (ident) @property
+  subgroup_name: (ident) @property)
+
+(struct_declaration
+  name: (ident) @type)
+
+(struct_member
+  name: (ident) @property)
+
+(function_declaration
+  name: (ident) @function)
+
+(parameter
+  name: (ident) @variable.parameter)
+
+(member_expr
+  member: (ident) @property)
+
+(call_expr
+  function: [
+    (ident)
+    (builtin_type)
+  ] @function)
+
+(call_expr
+  function: (builtin_type) @function.call)
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/gdshader/injections.scm b/pack/ant/start/nvim-treesitter/queries/gdshader/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gdshader/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/git_config/folds.scm b/pack/ant/start/nvim-treesitter/queries/git_config/folds.scm
new file mode 100644
index 0000000..cb376d5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/git_config/folds.scm
@@ -0,0 +1,2 @@
+((section) @fold
+  (#trim! @fold))
diff --git a/pack/ant/start/nvim-treesitter/queries/git_config/highlights.scm b/pack/ant/start/nvim-treesitter/queries/git_config/highlights.scm
new file mode 100644
index 0000000..6b37e90
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/git_config/highlights.scm
@@ -0,0 +1,59 @@
+; Sections
+(section_name) @markup.heading
+
+((section_name) @keyword.import
+  (#eq? @keyword.import "include"))
+
+((section_header
+  (section_name) @keyword.import
+  (subsection_name))
+  (#eq? @keyword.import "includeIf"))
+
+(variable
+  (name) @property)
+
+; Operators
+"=" @operator
+
+; Literals
+(integer) @number
+
+[
+  (true)
+  (false)
+] @boolean
+
+(string) @string
+
+(escape_sequence) @string.escape
+
+((string) @string.special.path
+  (#lua-match? @string.special.path "^[.]?[.]?[/]"))
+
+((string) @string.special.path
+  (#lua-match? @string.special.path "^[~]"))
+
+(section_header
+  [
+    "\""
+    (subsection_name)
+  ] @string.special)
+
+((section_header
+  (section_name) @_name
+  (subsection_name) @string.special.url)
+  (#any-of? @_name "credential" "url"))
+
+((variable
+  (name) @_name
+  value: (string) @string.special.url)
+  (#eq? @_name "insteadOf"))
+
+; Punctuation
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+; Comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/git_config/injections.scm b/pack/ant/start/nvim-treesitter/queries/git_config/injections.scm
new file mode 100644
index 0000000..7bda697
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/git_config/injections.scm
@@ -0,0 +1,69 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((variable
+  (name) @_name
+  value: (string) @injection.content)
+  (#any-of? @_name "cmd" "command" "textconv" "sendmailCmd")
+  (#set! injection.language "bash"))
+
+(section
+  (variable
+    (name) @_name
+    value: (string) @injection.content)
+  (#eq? @_name "tool")
+  (#set! injection.language "bash"))
+
+(section
+  (section_header
+    (section_name) @_pager)
+  (variable
+    value: (string) @injection.content)
+  (#eq? @_pager "pager")
+  (#set! injection.language "bash"))
+
+(section
+  (section_header
+    (section_name) @_interactive)
+  (variable
+    (name) @_name
+    value: (string) @injection.content)
+  (#eq? @_interactive "interactive")
+  (#eq? @_name "diffFilter")
+  (#set! injection.language "bash"))
+
+; https://github.com/git-lfs/git-lfs
+; git lfs install
+(section
+  (section_header
+    (section_name) @_filter
+    (subsection_name) @_lfs)
+  (variable
+    (name) @_name
+    value: (string) @injection.content)
+  (#eq? @_filter "filter")
+  (#eq? @_lfs "lfs")
+  (#any-of? @_name "smudge" "process" "clean")
+  (#set! injection.language "bash"))
+
+(section
+  (section_header
+    (section_name) @_alias)
+  (variable
+    value: (string) @injection.content)
+  (#eq? @_alias "alias")
+  (#lua-match? @injection.content "^!")
+  (#offset! @injection.content 0 1 0 0)
+  (#set! injection.language "bash"))
+
+(section
+  (section_header
+    (section_name) @_alias)
+  (variable
+    value: (string
+      "\""
+      "\"") @injection.content)
+  (#eq? @_alias "alias")
+  (#lua-match? @injection.content "^\"!")
+  (#offset! @injection.content 0 2 0 -1)
+  (#set! injection.language "bash"))
diff --git a/pack/ant/start/nvim-treesitter/queries/git_rebase/highlights.scm b/pack/ant/start/nvim-treesitter/queries/git_rebase/highlights.scm
new file mode 100644
index 0000000..248366e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/git_rebase/highlights.scm
@@ -0,0 +1,7 @@
+((command) @keyword
+  (label)? @constant
+  (message)? @none @spell)
+
+(option) @operator
+
+(comment) @comment
diff --git a/pack/ant/start/nvim-treesitter/queries/git_rebase/injections.scm b/pack/ant/start/nvim-treesitter/queries/git_rebase/injections.scm
new file mode 100644
index 0000000..c831594
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/git_rebase/injections.scm
@@ -0,0 +1,8 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((operation
+  (command) @_command
+  (message) @injection.content)
+  (#set! injection.language "bash")
+  (#any-of? @_command "exec" "x"))
diff --git a/pack/ant/start/nvim-treesitter/queries/gitattributes/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gitattributes/highlights.scm
new file mode 100644
index 0000000..aec7750
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gitattributes/highlights.scm
@@ -0,0 +1,55 @@
+(dir_sep) @punctuation.delimiter
+
+(quoted_pattern
+  "\"" @punctuation.special)
+
+(range_notation) @string.special
+
+(range_notation
+  [
+    "["
+    "]"
+  ] @punctuation.bracket)
+
+(wildcard) @character.special
+
+(range_negation) @operator
+
+(character_class) @constant
+
+(class_range
+  "-" @operator)
+
+[
+  (ansi_c_escape)
+  (escaped_char)
+] @string.escape
+
+(attribute
+  (attr_name) @variable.parameter)
+
+(attribute
+  (builtin_attr) @variable.builtin)
+
+[
+  (attr_reset)
+  (attr_unset)
+  (attr_set)
+] @operator
+
+(boolean_value) @boolean
+
+(string_value) @string
+
+(macro_tag) @keyword.directive
+
+(macro_def
+  macro_name: (_) @property)
+
+; we do not lint syntax errors
+; [
+;   (pattern_negation)
+;   (redundant_escape)
+;   (trailing_slash)
+; ] @error
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/gitattributes/injections.scm b/pack/ant/start/nvim-treesitter/queries/gitattributes/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gitattributes/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/gitattributes/locals.scm b/pack/ant/start/nvim-treesitter/queries/gitattributes/locals.scm
new file mode 100644
index 0000000..2471b8b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gitattributes/locals.scm
@@ -0,0 +1,8 @@
+(macro_def
+  (attr_name) @local.definition.macro)
+
+(attribute
+  (attr_name) @local.reference)
+
+(attribute
+  (builtin_attr) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/gitcommit/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gitcommit/highlights.scm
new file mode 100644
index 0000000..b096056
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gitcommit/highlights.scm
@@ -0,0 +1,49 @@
+(comment) @comment
+
+(generated_comment) @comment
+
+(title) @markup.heading
+
+; (text) @none
+(branch) @markup.link
+
+(change) @keyword
+
+(filepath) @string.special.path
+
+(arrow) @punctuation.delimiter
+
+(subject) @markup.heading @spell
+
+(subject
+  (subject_prefix) @function @nospell)
+
+(prefix
+  (type) @keyword @nospell)
+
+(prefix
+  (scope) @variable.parameter @nospell)
+
+(prefix
+  [
+    "("
+    ")"
+    ":"
+  ] @punctuation.delimiter)
+
+(prefix
+  "!" @punctuation.special)
+
+(message) @spell
+
+(trailer
+  (token) @label)
+
+; (trailer (value) @none)
+(breaking_change
+  (token) @comment.error)
+
+(breaking_change
+  (value) @none @spell)
+
+(scissor) @comment
diff --git a/pack/ant/start/nvim-treesitter/queries/gitcommit/injections.scm b/pack/ant/start/nvim-treesitter/queries/gitcommit/injections.scm
new file mode 100644
index 0000000..5613d7e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gitcommit/injections.scm
@@ -0,0 +1,5 @@
+((diff) @injection.content
+  (#set! injection.language "diff"))
+
+((rebase_command) @injection.content
+  (#set! injection.language "git_rebase"))
diff --git a/pack/ant/start/nvim-treesitter/queries/gitignore/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gitignore/highlights.scm
new file mode 100644
index 0000000..aafbe54
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gitignore/highlights.scm
@@ -0,0 +1,36 @@
+(comment) @comment @spell
+
+(pattern_char) @string.special.path
+
+[
+  (directory_separator)
+  (directory_separator_escaped)
+] @punctuation.delimiter
+
+[
+  (wildcard_char_single)
+  (wildcard_chars)
+  (wildcard_chars_allow_slash)
+] @character.special
+
+[
+  (pattern_char_escaped)
+  (bracket_char_escaped)
+] @string.escape
+
+(negation) @punctuation.special
+
+(bracket_negation) @operator
+
+; bracket expressions
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+(bracket_char) @constant
+
+(bracket_range
+  "-" @operator)
+
+(bracket_char_class) @constant.builtin
diff --git a/pack/ant/start/nvim-treesitter/queries/gitignore/injections.scm b/pack/ant/start/nvim-treesitter/queries/gitignore/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gitignore/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/gleam/folds.scm b/pack/ant/start/nvim-treesitter/queries/gleam/folds.scm
new file mode 100644
index 0000000..b4cd225
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gleam/folds.scm
@@ -0,0 +1,7 @@
+; Folds
+[
+  (case)
+  (function)
+  (anonymous_function)
+  (type_definition)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/gleam/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gleam/highlights.scm
new file mode 100644
index 0000000..5238c60
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gleam/highlights.scm
@@ -0,0 +1,199 @@
+; Keywords
+[
+  "as"
+  "let"
+  "panic"
+  "todo"
+  "use"
+] @keyword
+
+"type" @keyword.type
+
+; Function Keywords
+"fn" @keyword.function
+
+; Imports
+"import" @keyword.import
+
+; Conditionals
+[
+  "case"
+  "if"
+] @keyword.conditional
+
+; Exceptions
+"assert" @keyword.exception
+
+; Punctuation
+[
+  "("
+  ")"
+  "<<"
+  ">>"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  ","
+  "."
+  ":"
+  "->"
+] @punctuation.delimiter
+
+"#" @punctuation.special
+
+; Operators
+[
+  "%"
+  "&&"
+  "*"
+  "*."
+  "+"
+  "+."
+  "-"
+  "-."
+  ".."
+  "/"
+  "/."
+  "<"
+  "<."
+  "<="
+  "<=."
+  "="
+  "=="
+  ">"
+  ">."
+  ">="
+  ">=."
+  "|>"
+  "||"
+] @operator
+
+; Identifiers
+(identifier) @variable
+
+; Comments
+(comment) @comment @spell
+
+[
+  (module_comment)
+  (statement_comment)
+] @comment.documentation @spell
+
+; Unused Identifiers
+[
+  (discard)
+  (hole)
+] @comment
+
+; Modules & Imports
+(module) @module
+
+(import
+  alias: ((identifier) @module)?)
+
+(remote_type_identifier
+  module: (identifier) @module)
+
+(unqualified_import
+  name: (identifier) @function)
+
+; Strings
+(string) @string
+
+; Bit Strings
+(bit_string_segment) @string.special
+
+; Numbers
+(integer) @number
+
+(float) @number.float
+
+; Function Parameter Labels
+(function_call
+  arguments: (arguments
+    (argument
+      label: (label) @label)))
+
+(function_parameter
+  label: (label)? @label
+  name: (identifier) @variable.parameter)
+
+; Records
+(record
+  arguments: (arguments
+    (argument
+      label: (label) @variable.member)?))
+
+(record_pattern_argument
+  label: (label) @variable.member)
+
+(record_update_argument
+  label: (label) @variable.member)
+
+(field_access
+  record: (identifier) @variable
+  field: (label) @variable.member)
+
+(data_constructor_argument
+  (label) @variable.member)
+
+; Types
+[
+  (type_identifier)
+  (type_parameter)
+  (type_var)
+] @type
+
+; Type Qualifiers
+[
+  "const"
+  "external"
+  (opacity_modifier)
+  (visibility_modifier)
+] @keyword.modifier
+
+; Tuples
+(tuple_access
+  index: (integer) @operator)
+
+; Functions
+(function
+  name: (identifier) @function)
+
+(function_call
+  function: (identifier) @function.call)
+
+(function_call
+  function: (field_access
+    field: (label) @function.call))
+
+; External Functions
+(external_function
+  name: (identifier) @function)
+
+(external_function_body
+  (string) @module
+  .
+  (string) @function)
+
+; Constructors
+(constructor_name) @type @constructor
+
+([
+  (type_identifier)
+  (constructor_name)
+] @constant.builtin
+  (#any-of? @constant.builtin "Ok" "Error"))
+
+; Booleans
+((constructor_name) @boolean
+  (#any-of? @boolean "True" "False"))
+
+; Pipe Operator
+(binary_expression
+  operator: "|>"
+  right: (identifier) @function)
diff --git a/pack/ant/start/nvim-treesitter/queries/gleam/indents.scm b/pack/ant/start/nvim-treesitter/queries/gleam/indents.scm
new file mode 100644
index 0000000..c798545
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gleam/indents.scm
@@ -0,0 +1,30 @@
+; Gleam indents similar to Rust and JavaScript
+[
+  (anonymous_function)
+  (assert)
+  (case)
+  (case_clause)
+  (constant)
+  (external_function)
+  (function)
+  (import)
+  (let)
+  (list)
+  (constant)
+  (function)
+  (type_definition)
+  (type_alias)
+  (todo)
+  (tuple)
+] @indent.begin
+
+[
+  ")"
+  "]"
+  "}"
+] @indent.end @indent.branch
+
+; Gleam pipelines are not indented, but other binary expression chains are
+((binary_expression
+  operator: _ @_operator) @indent.begin
+  (#not-eq? @_operator "|>"))
diff --git a/pack/ant/start/nvim-treesitter/queries/gleam/injections.scm b/pack/ant/start/nvim-treesitter/queries/gleam/injections.scm
new file mode 100644
index 0000000..11d4f5d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gleam/injections.scm
@@ -0,0 +1,7 @@
+; Comments
+([
+  (module_comment)
+  (statement_comment)
+  (comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/gleam/locals.scm b/pack/ant/start/nvim-treesitter/queries/gleam/locals.scm
new file mode 100644
index 0000000..39909a4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gleam/locals.scm
@@ -0,0 +1,34 @@
+; Let Binding Definition
+(let
+  pattern: (identifier) @local.definition)
+
+; List Pattern Definitions
+(list_pattern
+  (identifier) @local.definition)
+
+(list_pattern
+  assign: (identifier) @local.definition)
+
+; Tuple Pattern Definition
+(tuple_pattern
+  (identifier) @local.definition)
+
+; Record Pattern Definition
+(record_pattern_argument
+  pattern: (identifier) @local.definition)
+
+; Function Parameter Definition
+(function_parameter
+  name: (identifier) @local.definition)
+
+; References
+(identifier) @local.reference
+
+; Block Scope
+(block) @local.scope
+
+; Function Body Scope
+(function_body) @local.scope
+
+; Case Scope
+(case_clause) @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/glimmer/folds.scm b/pack/ant/start/nvim-treesitter/queries/glimmer/folds.scm
new file mode 100644
index 0000000..6502455
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glimmer/folds.scm
@@ -0,0 +1,5 @@
+[
+  (element_node
+    (element_node_start))
+  (block_statement)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/glimmer/highlights.scm b/pack/ant/start/nvim-treesitter/queries/glimmer/highlights.scm
new file mode 100644
index 0000000..9f11468
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glimmer/highlights.scm
@@ -0,0 +1,117 @@
+; === Tag Names ===
+; Tags that start with a lower case letter are HTML tags
+; We'll also use this highlighting for named blocks (which start with `:`)
+((tag_name) @tag
+  (#lua-match? @tag "^:?[%l]"))
+
+; Tags that start with a capital letter are Glimmer components
+((tag_name) @constructor
+  (#lua-match? @constructor "^%u"))
+
+(attribute_name) @attribute
+
+(string_literal) @string
+
+(number_literal) @number
+
+(boolean_literal) @boolean
+
+(concat_statement) @string
+
+; === Block Statements ===
+; Highlight the brackets
+(block_statement_start) @tag.delimiter
+
+(block_statement_end) @tag.delimiter
+
+; Highlight `if`/`each`/`let`
+(block_statement_start
+  path: (identifier) @keyword.conditional)
+
+(block_statement_end
+  path: (identifier) @keyword.conditional)
+
+((mustache_statement
+  (identifier) @keyword.conditional)
+  (#lua-match? @keyword.conditional "else"))
+
+; == Mustache Statements ===
+; Highlight the whole statement, to color brackets and separators
+(mustache_statement) @tag.delimiter
+
+; An identifier in a mustache expression is a variable
+((mustache_statement
+  [
+    (path_expression
+      (identifier) @variable)
+    (identifier) @variable
+  ])
+  (#not-any-of? @variable "yield" "outlet" "this" "else"))
+
+; As are arguments in a block statement
+(block_statement_start
+  argument: [
+    (path_expression
+      (identifier) @variable)
+    (identifier) @variable
+  ])
+
+; As is an identifier in a block param
+(block_params
+  (identifier) @variable)
+
+; As are helper arguments
+((helper_invocation
+  argument: [
+    (path_expression
+      (identifier) @variable)
+    (identifier) @variable
+  ])
+  (#not-eq? @variable "this"))
+
+; `this` should be highlighted as a built-in variable
+((identifier) @variable.builtin
+  (#eq? @variable.builtin "this"))
+
+; If the identifier is just "yield" or "outlet", it's a keyword
+((mustache_statement
+  (identifier) @keyword)
+  (#any-of? @keyword "yield" "outlet"))
+
+; Helpers are functions
+((helper_invocation
+  helper: [
+    (path_expression
+      (identifier) @function)
+    (identifier) @function
+  ])
+  (#not-any-of? @function "if" "yield"))
+
+((helper_invocation
+  helper: (identifier) @keyword.conditional)
+  (#eq? @keyword.conditional "if"))
+
+((helper_invocation
+  helper: (identifier) @keyword)
+  (#eq? @keyword "yield"))
+
+(hash_pair
+  key: (identifier) @property)
+
+(comment_statement) @comment @spell
+
+(attribute_node
+  "=" @operator)
+
+(block_params
+  "as" @keyword)
+
+(block_params
+  "|" @operator)
+
+[
+  "<"
+  ">"
+  "</"
+  "/>"
+] @tag.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/glimmer/indents.scm b/pack/ant/start/nvim-treesitter/queries/glimmer/indents.scm
new file mode 100644
index 0000000..c1ef130
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glimmer/indents.scm
@@ -0,0 +1,34 @@
+[
+  (element_node
+    (element_node_start))
+  (element_node_void)
+  (block_statement
+    (block_statement_start))
+  (mustache_statement)
+] @indent.begin
+
+(element_node
+  (element_node_end
+    ">" @indent.end))
+
+(element_node_void
+  "/>" @indent.end)
+
+[
+  ">"
+  "/>"
+  "</"
+  "{{/"
+  "}}"
+] @indent.branch
+
+(mustache_statement
+  (helper_invocation
+    helper: (identifier) @_identifier
+    (#eq? @_identifier "else"))) @indent.branch
+
+(mustache_statement
+  ((identifier) @_identifier
+    (#eq? @_identifier "else"))) @indent.branch
+
+(comment_statement) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/glimmer/injections.scm b/pack/ant/start/nvim-treesitter/queries/glimmer/injections.scm
new file mode 100644
index 0000000..30b4386
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glimmer/injections.scm
@@ -0,0 +1,21 @@
+; comments
+((comment_statement) @injection.content
+  (#set! injection.language "comment"))
+
+; <style> tags
+((element_node
+  (element_node_start
+    (tag_name) @_tag_name
+    (#eq? @_tag_name "style"))) @injection.content
+  (#offset! @injection.content 0 7 0 -8)
+  (#set! injection.language "css")
+  (#set! injection.include-children))
+
+; <script> tags
+((element_node
+  (element_node_start
+    (tag_name) @_tag_name
+    (#eq? @_tag_name "script"))) @injection.content
+  (#offset! @injection.content 0 8 0 -9)
+  (#set! injection.language "glimmer_javascript")
+  (#set! injection.include-children))
diff --git a/pack/ant/start/nvim-treesitter/queries/glimmer/locals.scm b/pack/ant/start/nvim-treesitter/queries/glimmer/locals.scm
new file mode 100644
index 0000000..8fde3a2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glimmer/locals.scm
@@ -0,0 +1,9 @@
+[
+  (element_node)
+  (block_statement)
+] @local.scope
+
+(identifier) @local.reference
+
+(block_params
+  (identifier) @local.definition.var)
diff --git a/pack/ant/start/nvim-treesitter/queries/glimmer_javascript/highlights.scm b/pack/ant/start/nvim-treesitter/queries/glimmer_javascript/highlights.scm
new file mode 100644
index 0000000..5bec5b1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glimmer_javascript/highlights.scm
@@ -0,0 +1,61 @@
+; inherits: ecma
+
+(glimmer_opening_tag) @tag.builtin
+
+(glimmer_closing_tag) @tag.builtin
+
+; Copied from javascript
+; Parameters
+(formal_parameters
+  (identifier) @variable.parameter)
+
+(formal_parameters
+  (rest_pattern
+    (identifier) @variable.parameter))
+
+; ({ a }) => null
+(formal_parameters
+  (object_pattern
+    (shorthand_property_identifier_pattern) @variable.parameter))
+
+; ({ a = b }) => null
+(formal_parameters
+  (object_pattern
+    (object_assignment_pattern
+      (shorthand_property_identifier_pattern) @variable.parameter)))
+
+; ({ a: b }) => null
+(formal_parameters
+  (object_pattern
+    (pair_pattern
+      value: (identifier) @variable.parameter)))
+
+; ([ a ]) => null
+(formal_parameters
+  (array_pattern
+    (identifier) @variable.parameter))
+
+; ({ a } = { a }) => null
+(formal_parameters
+  (assignment_pattern
+    (object_pattern
+      (shorthand_property_identifier_pattern) @variable.parameter)))
+
+; ({ a = b } = { a }) => null
+(formal_parameters
+  (assignment_pattern
+    (object_pattern
+      (object_assignment_pattern
+        (shorthand_property_identifier_pattern) @variable.parameter))))
+
+; a => null
+(arrow_function
+  parameter: (identifier) @variable.parameter)
+
+; optional parameters
+(formal_parameters
+  (assignment_pattern
+    left: (identifier) @variable.parameter))
+
+; punctuation
+(optional_chain) @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/glimmer_javascript/indents.scm b/pack/ant/start/nvim-treesitter/queries/glimmer_javascript/indents.scm
new file mode 100644
index 0000000..2bf2b78
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glimmer_javascript/indents.scm
@@ -0,0 +1,5 @@
+; inherits: ecma
+
+(glimmer_opening_tag) @indent.begin
+
+(glimmer_closing_tag) @indent.end
diff --git a/pack/ant/start/nvim-treesitter/queries/glimmer_javascript/injections.scm b/pack/ant/start/nvim-treesitter/queries/glimmer_javascript/injections.scm
new file mode 100644
index 0000000..38cf529
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glimmer_javascript/injections.scm
@@ -0,0 +1,15 @@
+; inherits: ecma
+
+; Parse Ember/Glimmer/Handlebars/HTMLBars/etc. template literals
+; e.g.: await render(hbs`<SomeComponent />`)
+(call_expression
+  function: ((identifier) @_name
+    (#eq? @_name "hbs"))
+  arguments: ((template_string) @glimmer
+    (#offset! @glimmer 0 1 0 -1)))
+
+; Ember Unified <template> syntax
+; e.g.: <template><SomeComponent @arg={{double @value}} /></template>
+((glimmer_template) @injection.content
+  (#set! injection.language "glimmer")
+  (#set! injection.include-children))
diff --git a/pack/ant/start/nvim-treesitter/queries/glimmer_javascript/locals.scm b/pack/ant/start/nvim-treesitter/queries/glimmer_javascript/locals.scm
new file mode 100644
index 0000000..04328f0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glimmer_javascript/locals.scm
@@ -0,0 +1 @@
+; inherits: ecma
diff --git a/pack/ant/start/nvim-treesitter/queries/glimmer_typescript/highlights.scm b/pack/ant/start/nvim-treesitter/queries/glimmer_typescript/highlights.scm
new file mode 100644
index 0000000..042387b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glimmer_typescript/highlights.scm
@@ -0,0 +1,6 @@
+; inherits: typescript
+
+; Sub-language delimeters
+(glimmer_opening_tag) @tag.builtin
+
+(glimmer_closing_tag) @tag.builtin
diff --git a/pack/ant/start/nvim-treesitter/queries/glimmer_typescript/indents.scm b/pack/ant/start/nvim-treesitter/queries/glimmer_typescript/indents.scm
new file mode 100644
index 0000000..237254d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glimmer_typescript/indents.scm
@@ -0,0 +1,3 @@
+(glimmer_opening_tag) @indent.begin
+
+(glimmer_closing_tag) @indent.end
diff --git a/pack/ant/start/nvim-treesitter/queries/glimmer_typescript/injections.scm b/pack/ant/start/nvim-treesitter/queries/glimmer_typescript/injections.scm
new file mode 100644
index 0000000..487d697
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glimmer_typescript/injections.scm
@@ -0,0 +1,15 @@
+; inherits: typescript
+
+; Parse Ember/Glimmer/Handlebars/HTMLBars/etc. template literals
+; e.g.: await render(hbs`<SomeComponent />`)
+(call_expression
+  function: ((identifier) @_name
+    (#eq? @_name "hbs"))
+  arguments: ((template_string) @glimmer
+    (#offset! @glimmer 0 1 0 -1)))
+
+; Ember Unified <template> syntax
+; e.g.: <template><SomeComponent @arg={{double @value}} /></template>
+((glimmer_template) @injection.content
+  (#set! injection.language "glimmer")
+  (#set! injection.include-children))
diff --git a/pack/ant/start/nvim-treesitter/queries/glsl/folds.scm b/pack/ant/start/nvim-treesitter/queries/glsl/folds.scm
new file mode 100644
index 0000000..a5a5208
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glsl/folds.scm
@@ -0,0 +1 @@
+; inherits: c
diff --git a/pack/ant/start/nvim-treesitter/queries/glsl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/glsl/highlights.scm
new file mode 100644
index 0000000..d4583f0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glsl/highlights.scm
@@ -0,0 +1,35 @@
+; inherits: c
+
+[
+  "in"
+  "out"
+  "inout"
+  "uniform"
+  "shared"
+  "layout"
+  "attribute"
+  "varying"
+  "buffer"
+  "coherent"
+  "readonly"
+  "writeonly"
+  "precision"
+  "highp"
+  "mediump"
+  "lowp"
+  "centroid"
+  "sample"
+  "patch"
+  "smooth"
+  "flat"
+  "noperspective"
+  "invariant"
+  "precise"
+] @keyword.modifier
+
+"subroutine" @keyword.function
+
+(extension_storage_class) @keyword.modifier
+
+((identifier) @variable.builtin
+  (#lua-match? @variable.builtin "^gl_"))
diff --git a/pack/ant/start/nvim-treesitter/queries/glsl/indents.scm b/pack/ant/start/nvim-treesitter/queries/glsl/indents.scm
new file mode 100644
index 0000000..a5a5208
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glsl/indents.scm
@@ -0,0 +1 @@
+; inherits: c
diff --git a/pack/ant/start/nvim-treesitter/queries/glsl/injections.scm b/pack/ant/start/nvim-treesitter/queries/glsl/injections.scm
new file mode 100644
index 0000000..90ca7b5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glsl/injections.scm
@@ -0,0 +1,5 @@
+((preproc_arg) @injection.content
+  (#set! injection.language "glsl"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/glsl/locals.scm b/pack/ant/start/nvim-treesitter/queries/glsl/locals.scm
new file mode 100644
index 0000000..a5a5208
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/glsl/locals.scm
@@ -0,0 +1 @@
+; inherits: c
diff --git a/pack/ant/start/nvim-treesitter/queries/gn/folds.scm b/pack/ant/start/nvim-treesitter/queries/gn/folds.scm
new file mode 100644
index 0000000..352b0f0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gn/folds.scm
@@ -0,0 +1,6 @@
+[
+  (list)
+  (block)
+  (if_statement)
+  (else_statement)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/gn/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gn/highlights.scm
new file mode 100644
index 0000000..7bd97ff
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gn/highlights.scm
@@ -0,0 +1,78 @@
+; Includes
+"import" @keyword.import
+
+; Conditionals
+[
+  "if"
+  "else"
+] @keyword.conditional
+
+; Repeats
+"foreach" @keyword.repeat
+
+; Operators
+[
+  "="
+  "+="
+  "-="
+  "!"
+  "+"
+  "-"
+  "<"
+  "<="
+  ">"
+  ">="
+  "=="
+  "!="
+  "&&"
+  "||"
+] @operator
+
+; Variables
+(identifier) @variable
+
+; Functions
+(call_expression
+  function: (identifier) @function.call)
+
+; Fields
+(scope_access
+  field: (identifier) @variable.member)
+
+; Literals
+(string) @string
+
+(escape_sequence) @string.escape
+
+(expansion) @none
+
+(integer) @number
+
+(hex) @string.special
+
+(boolean) @boolean
+
+; Punctuation
+[
+  "{"
+  "}"
+  "["
+  "]"
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "."
+  ","
+] @punctuation.delimiter
+
+(expansion
+  [
+    "$"
+    "${"
+    "}"
+  ] @punctuation.special)
+
+; Comments
+(comment) @comment
diff --git a/pack/ant/start/nvim-treesitter/queries/gn/indents.scm b/pack/ant/start/nvim-treesitter/queries/gn/indents.scm
new file mode 100644
index 0000000..82f4471
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gn/indents.scm
@@ -0,0 +1,12 @@
+[
+  (block)
+  (parenthesized_expression)
+] @indent.begin
+
+[
+  "}"
+  ")"
+  "]"
+] @indent.end @indent.branch
+
+(comment) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/gn/injections.scm b/pack/ant/start/nvim-treesitter/queries/gn/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gn/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/gn/locals.scm b/pack/ant/start/nvim-treesitter/queries/gn/locals.scm
new file mode 100644
index 0000000..eecb342
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gn/locals.scm
@@ -0,0 +1,6 @@
+[
+  (source_file)
+  (block)
+] @local.scope
+
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/gnuplot/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gnuplot/highlights.scm
new file mode 100644
index 0000000..884c726
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gnuplot/highlights.scm
@@ -0,0 +1,648 @@
+; highlights.scm
+(comment) @comment @spell
+
+(identifier) @variable
+
+[
+  "-"
+  "+"
+  "~"
+  "!"
+  "$"
+  "|"
+  "**"
+  "*"
+  "/"
+  "%"
+  "=="
+  "!="
+  "<"
+  "<="
+  ">"
+  ">="
+  "<<"
+  ">>"
+  "&"
+  "^"
+  "&&"
+  "||"
+  "="
+  ","
+  "."
+] @operator
+
+[
+  "eq"
+  "ne"
+] @keyword.operator
+
+(ternary_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+"sum" @function.builtin
+
+[
+  "for"
+  "in"
+  "do"
+  "while"
+] @keyword.repeat
+
+[
+  (c_break)
+  (c_cd)
+  (c_clear)
+  "evaluate"
+  "fit"
+  "help"
+  "load"
+  "lower"
+  "print"
+  (c_replot)
+  (c_reread)
+  "reset"
+  "splot"
+  "cmd"
+  "test"
+  "undefine"
+  "vfill"
+] @keyword
+
+(c_pause
+  "pause" @keyword
+  "mouse" @variable.member
+  _? @attribute
+  (","
+    _ @attribute)?)
+
+(c_plot
+  "plot" @keyword)
+
+(c_show
+  "show" @keyword
+  "plot"? @attribute)
+
+(c_stats
+  "stats" @keyword
+  ("name"
+    (_))? @variable.member)
+
+[
+  "via"
+  "inverse"
+  "sample"
+] @keyword.function
+
+[
+  "if"
+  "else"
+] @keyword.conditional
+
+(plot_element
+  "axes"? @variable.member)
+
+(cntrparam
+  "auto"? @variable.member)
+
+(colorbox
+  "origin"? @attribute)
+
+(contourfill
+  "auto"? @variable.member)
+
+(format
+  _? @attribute
+  (_)
+  _? @attribute)
+
+(key
+  "auto"? @variable.member)
+
+(style ; TODO: complete
+  [
+    "arrow"
+    "boxplot"
+    ("data"
+      [
+        (_)
+        "spiderplot" @attribute
+      ])
+    "fs"
+    "function"
+    "line"
+    "circle"
+    "rectangle"
+    "ellipse"
+    "parallelaxis"
+    ; (spiderplot) ; TODO: complete
+    "textbox"
+    ("watchpoint"
+      "labels" @attribute
+      (_)?)
+  ] @variable.member)
+
+(terminal
+  "name" @variable.member)
+
+; TODO: complete terminals in grammar and then simplify its options here
+(t_cairolatex
+  [
+    "eps"
+    "pdf"
+    "png"
+    "standalone"
+    "input"
+    "blacktext"
+    "colortext"
+    "colourtext"
+    ("header"
+      (_))
+    "mono"
+    "color"
+    "background"
+    "rounded"
+    "butt"
+  ]* @attribute)
+
+; (t_canvas)
+; (t_cgm)
+; (t_context)
+; (t_domterm)
+; (t_dumb)
+; (t_dxf)
+; (t_emf)
+; (t_epscairo)
+; (t_epslatex)
+; (t_fig)
+; (t_gif)
+; (t_hpgl)
+; (t_jpeg)
+; (t_lua)
+; (t_pc15)
+; (t_pdfcairo)
+; (t_png)
+; (t_pngcairo)
+; (t_postscript)
+; (t_pslatex)
+; (t_pstricks)
+; (t_qt)
+; (t_sixelgd)
+; (t_svg [(font_spec)]* @attribute)
+; (t_tek4xxx)
+; (t_texdraw)
+; (t_tikz)
+; (t_tkcanvas)
+(plot_style
+  [
+    "lines"
+    "points"
+    "lp"
+    "financebars"
+    "dots"
+    "impulses"
+    "labels"
+    "surface"
+    "steps"
+    "fsteps"
+    "histeps"
+    "arrows"
+    "vectors"
+    "sectors"
+    "contourfill"
+    "errorbar"
+    "errorlines"
+    "parallelaxes"
+    "boxes"
+    "boxerrorbars"
+    "boxxyerror"
+    "isosurface"
+    "boxplot"
+    "candlesticks"
+    "circles"
+    "zerrorfill"
+    "ellipses"
+    "filledcurves"
+    "fillsteps"
+    "histograms"
+    "image"
+    "spiderplot"
+    "pm3d"
+    "rgbalpha"
+    "rgbimage"
+    "polygons"
+    "table"
+    "mask"
+  ] @attribute)
+
+[
+  "tc"
+  "fc"
+  "fs"
+  "lc"
+  "ls"
+  "lw"
+  "lt"
+  "pt"
+  "ps"
+  "pi"
+  "pn"
+  "dt"
+  "as"
+  "start"
+  "cycles"
+  "saturation"
+  "interval"
+  "format"
+  "keywidth"
+  "samplen"
+  "columns"
+  "title"
+  "notitle"
+  "every"
+  "index"
+  "using"
+  "with"
+  "frac"
+  "cb"
+  "arg"
+  "prefix"
+  "output"
+  "primary"
+  "specular"
+  "spec2"
+  "firstlinetype"
+  "width"
+  "height"
+  "expand"
+  "array"
+  "dx"
+  "dy"
+  "dz"
+  "filetype"
+  "center"
+  "record"
+] @variable.member
+
+; Workaround because formatter cannot handle 300 list nodes
+[
+  (angles)
+  (clip)
+  (colorsequence)
+  (contour)
+  (encoding)
+  (mapping)
+  (xdata)
+  (theta)
+  "wall"
+  "on"
+  "off"
+  "opaque"
+  "inside"
+  "outside"
+  "margin"
+  "cen"
+  "lef"
+  "rig"
+  "top"
+  "bot"
+  "lr"
+  "a"
+  "maxcols"
+  "maxrows"
+  "autojustify"
+  "overlap"
+  "spread"
+  "wrap"
+  "swarm"
+  "range"
+  "label"
+  "mixed"
+  "triangles"
+  "insidecolor"
+  "noinsidecolor"
+  "cycle"
+  "tics"
+  "ztics"
+  "cbtics"
+  "user"
+  "front"
+  "back"
+  "bdefault"
+  "time"
+  "palette"
+  "terminal"
+  "onecolor"
+  "invert"
+  "reverse"
+  "writeback"
+  "extend"
+  "restore"
+  "linear"
+  "cubicspline"
+  "bspline"
+  "points"
+  "order"
+  "levels"
+  "sorted"
+  "autofreq"
+  "add"
+  "inout"
+  "axis"
+  "mirror"
+  "type"
+  "rowsfirst"
+  "columnsfirst"
+  "downwards"
+  "upwards"
+  "prevnext"
+  "gray"
+  "color"
+  "gamma"
+  "defined"
+  "cubehelix"
+  "model"
+  "maxcolors"
+  "file"
+  "colormap"
+  "rgbformulae"
+  "viridis"
+  "positive"
+  "negative"
+  "nops_allcF"
+  "ps_allcF"
+  "quiet"
+  "full"
+  "trip"
+  "numbers"
+  "small"
+  "large"
+  "fullwidth"
+  "append"
+  "bind"
+  "errors"
+  "session"
+  "behind"
+  "polar"
+  "layerdefault"
+  "locale"
+  "axes"
+  "fix"
+  "keepfix"
+  "noextend"
+  "head"
+  "fixed"
+  "filled"
+  "nofilled"
+  "absolute"
+  "at"
+  "relative"
+  "enhanced"
+  "border"
+  "noborder"
+  "rgbcolor"
+  "empty"
+  "black"
+  "bgnd"
+  "nodraw"
+  "size"
+  "new"
+  "first"
+  "second"
+  "screen"
+  "graph"
+  "character"
+  "trianglepattern"
+  "undefined"
+  "noundefined"
+  "altdiagonal"
+  "bentover"
+  "vertical"
+  "horizontal"
+  "square"
+  "ratio"
+  "noratio"
+  "solid"
+  "transparent"
+  "pattern"
+  "from"
+  "to_rto"
+  "length"
+  "angle"
+  "columnheaders"
+  "fortran"
+  "nofpe_trap"
+  "missing"
+  "separator"
+  "commentschars"
+  "log"
+  "rangelimited"
+  "offset"
+  "nooffset"
+  "scale"
+  "font"
+  "point"
+  "nopoint"
+  "boxed"
+  "noboxed"
+  "hypertext"
+  "defaults"
+  "keyentry"
+  "splines"
+  "qnorm"
+  "gauss"
+  "cauchy"
+  "exp"
+  "box"
+  "hann"
+  "implicit"
+  "explicit"
+  "rotate"
+  "by"
+  "parallel"
+  "norotate"
+  "map"
+  "projection"
+  "equal"
+  "azimuth"
+  "nohidden3d"
+  "nocontours"
+  "nosurface"
+  "colornames"
+  "functions"
+  "variables"
+  "version"
+  "nologfile"
+  "logfile"
+  "fit_out"
+  "errorvariables"
+  "covariancevariables"
+  "errorscaling"
+  "prescale"
+  "maxiter"
+  "limit"
+  "limit_abs"
+  "start-lambda"
+  "lambda-factor"
+  "script"
+  "clip"
+  "fontscale"
+  "lighting"
+  "depthorder"
+  "interpolate"
+  "corners2color"
+  "flush"
+  "scanorder"
+  "hidden3d"
+  "clipcb"
+  "layout"
+  "margins"
+  "spacing"
+  "smooth"
+  "binary"
+  "skip"
+  "bins"
+  "binrange"
+  "binwidth"
+  "binvalue"
+  "mask"
+  "convexhull"
+  "concavehull"
+  "volatile"
+  "zsort"
+  "nonuniform"
+  "sparse"
+  "matrix"
+] @attribute
+
+[
+  "x1"
+  "x2"
+  "y1"
+  "y2"
+  "y"
+  "r"
+  "z"
+  "xy"
+  "xz"
+  "yz"
+  "xyz"
+  "x1y1"
+  "x2y2"
+  "x1y2"
+  "x2y1"
+  "columnheader"
+  "seconds"
+  "minutes"
+  "hours"
+  "days"
+  "weeks"
+  "months"
+  "years"
+  "cm"
+  "in"
+  "discrete"
+  "incremental"
+  "default"
+  "long"
+  "nogrid"
+  "unique"
+  "frequency"
+  "fnormal"
+  "cumulative"
+  "cnormal"
+  "csplines"
+  "acsplines"
+  "mcsplines"
+  "path"
+  "bezier"
+  "sbezier"
+  "unwrap"
+  "kdensity"
+  "closed"
+  "between"
+  "above"
+  "below"
+  "variable"
+  "pixels"
+  "RGB"
+  "CMY"
+  "HSV"
+  "base"
+  "begin"
+  "center"
+  "end"
+  "ftriangles"
+  "clip1in"
+  "clip4in"
+  "c2c"
+  "retrace"
+  "whitespace"
+  "tab"
+  "comma"
+  "push"
+  "pop"
+  "flipx"
+  "flipy"
+  "flipz"
+] @variable.member
+
+(colorspec
+  "palette" @attribute)
+
+(datafile_modifiers
+  "origin"? @variable.member)
+
+((datafile_modifiers
+  filetype: (identifier) @variable.member)
+  (#any-of? @variable.member
+    "avs" "bin" "edf" "ehf" "gif" "gpbin" "jpeg" "jpg" "png" "raw" "rgb" "auto"))
+
+(macro) @function.macro
+
+(datablock) @function.macro
+
+(function
+  name: (identifier) @function)
+
+((function
+  name: (identifier) @function.builtin)
+  (#any-of? @function.builtin
+    "abs" "acos" "acosh" "airy" "arg" "asin" "asinh" "atan" "atan2" "atanh" "besj0" "besj1" "besjn"
+    "besy0" "besy1" "besyn" "besi0" "besi1" "besin" "cbrt" "ceil" "conj" "cos" "cosh" "EllipticK"
+    "EllipticE" "EllipticPi" "erf" "erfc" "exp" "expint" "floor" "gamma" "ibeta" "inverf" "igamma"
+    "imag" "int" "invnorm" "invibeta" "invigamma" "LambertW" "lambertw" "lgamma" "lnGamma" "log"
+    "log10" "norm" "rand" "real" "round" "sgn" "sin" "sinh" "sqrt" "SynchrotronF" "tan" "tanh"
+    "uigamma" "voigt" "zeta" "cerf" "cdawson" "faddeva" "erfi" "FresnelC" "FresnelS" "VP" "VP_fwhm"
+    "Ai" "Bi" "BesselH1" "BesselH2" "BesselJ" "BesselY" "BesselI" "BesselK" "gprintf" "sprintf"
+    "strlen" "strstrt" "substr" "strptime" "srtftime" "system" "trim" "word" "words" "time"
+    "timecolumn" "tm_hour" "tm_mday" "tm_min" "tm_mon" "tm_sec" "tm_wday" "tm_week" "tm_yday"
+    "tm_year" "weekday_iso" "weekday_cdc" "column" "columnhead" "exists" "hsv2rgb" "index" "palette"
+    "rgbcolor" "stringcolumn" "valid" "value" "voxel"))
+
+((identifier) @variable.builtin
+  (#match? @variable.builtin
+    "^\\w+_(records|headers|outofrange|invalid|blank|blocks|columns|column_header|index_(min|max)(_x|_y)?|(min|max)(_x|_y)?|mean(_err)?(_x|_y)?|stddev(_err)?(_x|_y)?)$"))
+
+((identifier) @variable.builtin
+  (#match? @variable.builtin
+    "^\\w+_(sdd(_x|_y)?|(lo|up)_quartile(_x|_y)?|median(_x|_y)?|sum(sq)?(_x|_y)?|skewness(_err)?(_x|_y)?)$"))
+
+((identifier) @variable.builtin
+  (#match? @variable.builtin
+    "^\\w+_(kurtosis(_err)?(_x|_y)?|adev(_x|_y)?|correlation|slope(_err)?|intercept(_err)?|sumxy|pos(_min|_max)_y|size(_x|_y))$"))
+
+((identifier) @variable.builtin
+  (#match? @variable.builtin "^((GPVAL|MOUSE|FIT)_\\w+|GNUTERM|NaN|VoxelDistance|GridDistance|pi)$"))
+
+(array_def
+  "array" @keyword.function)
+
+(array
+  (identifier) @function)
+
+(number) @number
+
+(string_literal) @string
diff --git a/pack/ant/start/nvim-treesitter/queries/gnuplot/injections.scm b/pack/ant/start/nvim-treesitter/queries/gnuplot/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gnuplot/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/go/folds.scm b/pack/ant/start/nvim-treesitter/queries/go/folds.scm
new file mode 100644
index 0000000..44b452d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/go/folds.scm
@@ -0,0 +1,19 @@
+[
+  (const_declaration)
+  (expression_switch_statement)
+  (expression_case)
+  (default_case)
+  (type_switch_statement)
+  (type_case)
+  (for_statement)
+  (func_literal)
+  (function_declaration)
+  (if_statement)
+  (import_declaration)
+  (method_declaration)
+  (type_declaration)
+  (var_declaration)
+  (composite_literal)
+  (literal_element)
+  (block)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/go/highlights.scm b/pack/ant/start/nvim-treesitter/queries/go/highlights.scm
new file mode 100644
index 0000000..62497b0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/go/highlights.scm
@@ -0,0 +1,239 @@
+; Forked from tree-sitter-go
+; Copyright (c) 2014 Max Brunsfeld (The MIT License)
+;
+; Identifiers
+(type_identifier) @type
+
+(type_spec
+  name: (type_identifier) @type.definition)
+
+(field_identifier) @property
+
+(identifier) @variable
+
+(package_identifier) @module
+
+(parameter_declaration
+  (identifier) @variable.parameter)
+
+(variadic_parameter_declaration
+  (identifier) @variable.parameter)
+
+(label_name) @label
+
+(const_spec
+  name: (identifier) @constant)
+
+; Function calls
+(call_expression
+  function: (identifier) @function.call)
+
+(call_expression
+  function: (selector_expression
+    field: (field_identifier) @function.method.call))
+
+; Function definitions
+(function_declaration
+  name: (identifier) @function)
+
+(method_declaration
+  name: (field_identifier) @function.method)
+
+(method_elem
+  name: (field_identifier) @function.method)
+
+; Constructors
+((call_expression
+  (identifier) @constructor)
+  (#lua-match? @constructor "^[nN]ew.+$"))
+
+((call_expression
+  (identifier) @constructor)
+  (#lua-match? @constructor "^[mM]ake.+$"))
+
+; Operators
+[
+  "--"
+  "-"
+  "-="
+  ":="
+  "!"
+  "!="
+  "..."
+  "*"
+  "*"
+  "*="
+  "/"
+  "/="
+  "&"
+  "&&"
+  "&="
+  "&^"
+  "&^="
+  "%"
+  "%="
+  "^"
+  "^="
+  "+"
+  "++"
+  "+="
+  "<-"
+  "<"
+  "<<"
+  "<<="
+  "<="
+  "="
+  "=="
+  ">"
+  ">="
+  ">>"
+  ">>="
+  "|"
+  "|="
+  "||"
+  "~"
+] @operator
+
+; Keywords
+[
+  "break"
+  "const"
+  "continue"
+  "default"
+  "defer"
+  "goto"
+  "range"
+  "select"
+  "var"
+  "fallthrough"
+] @keyword
+
+[
+  "type"
+  "struct"
+  "interface"
+] @keyword.type
+
+"func" @keyword.function
+
+"return" @keyword.return
+
+"go" @keyword.coroutine
+
+"for" @keyword.repeat
+
+[
+  "import"
+  "package"
+] @keyword.import
+
+[
+  "else"
+  "case"
+  "switch"
+  "if"
+] @keyword.conditional
+
+; Builtin types
+[
+  "chan"
+  "map"
+] @type.builtin
+
+((type_identifier) @type.builtin
+  (#any-of? @type.builtin
+    "any" "bool" "byte" "comparable" "complex128" "complex64" "error" "float32" "float64" "int"
+    "int16" "int32" "int64" "int8" "rune" "string" "uint" "uint16" "uint32" "uint64" "uint8"
+    "uintptr"))
+
+; Builtin functions
+((identifier) @function.builtin
+  (#any-of? @function.builtin
+    "append" "cap" "clear" "close" "complex" "copy" "delete" "imag" "len" "make" "max" "min" "new"
+    "panic" "print" "println" "real" "recover"))
+
+; Delimiters
+"." @punctuation.delimiter
+
+"," @punctuation.delimiter
+
+":" @punctuation.delimiter
+
+";" @punctuation.delimiter
+
+"(" @punctuation.bracket
+
+")" @punctuation.bracket
+
+"{" @punctuation.bracket
+
+"}" @punctuation.bracket
+
+"[" @punctuation.bracket
+
+"]" @punctuation.bracket
+
+; Literals
+(interpreted_string_literal) @string
+
+(raw_string_literal) @string
+
+(rune_literal) @string
+
+(escape_sequence) @string.escape
+
+(int_literal) @number
+
+(float_literal) @number.float
+
+(imaginary_literal) @number
+
+[
+  (true)
+  (false)
+] @boolean
+
+[
+  (nil)
+  (iota)
+] @constant.builtin
+
+(keyed_element
+  .
+  (literal_element
+    (identifier) @variable.member))
+
+(field_declaration
+  name: (field_identifier) @variable.member)
+
+; Comments
+(comment) @comment @spell
+
+; Doc Comments
+(source_file
+  .
+  (comment)+ @comment.documentation)
+
+(source_file
+  (comment)+ @comment.documentation
+  .
+  (const_declaration))
+
+(source_file
+  (comment)+ @comment.documentation
+  .
+  (function_declaration))
+
+(source_file
+  (comment)+ @comment.documentation
+  .
+  (type_declaration))
+
+(source_file
+  (comment)+ @comment.documentation
+  .
+  (var_declaration))
+
+; Spell
+((interpreted_string_literal) @spell
+  (#not-has-parent? @spell import_spec))
diff --git a/pack/ant/start/nvim-treesitter/queries/go/indents.scm b/pack/ant/start/nvim-treesitter/queries/go/indents.scm
new file mode 100644
index 0000000..28edfe9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/go/indents.scm
@@ -0,0 +1,48 @@
+[
+  (import_declaration)
+  (const_declaration)
+  (var_declaration)
+  (type_declaration)
+  (func_literal)
+  (literal_value)
+  (expression_case)
+  (communication_case)
+  (type_case)
+  (default_case)
+  (block)
+  (call_expression)
+  (parameter_list)
+  (field_declaration_list)
+  (interface_type)
+] @indent.begin
+
+(literal_value
+  "}" @indent.branch)
+
+(block
+  "}" @indent.branch)
+
+(field_declaration_list
+  "}" @indent.branch)
+
+(interface_type
+  "}" @indent.branch)
+
+(const_declaration
+  ")" @indent.branch)
+
+(import_spec_list
+  ")" @indent.branch)
+
+(var_spec_list
+  ")" @indent.branch)
+
+[
+  "}"
+  ")"
+] @indent.end
+
+(parameter_list
+  ")" @indent.branch)
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/go/injections.scm b/pack/ant/start/nvim-treesitter/queries/go/injections.scm
new file mode 100644
index 0000000..38ba3e1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/go/injections.scm
@@ -0,0 +1,39 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+(call_expression
+  (selector_expression) @_function
+  (#any-of? @_function
+    "regexp.Match" "regexp.MatchReader" "regexp.MatchString" "regexp.Compile" "regexp.CompilePOSIX"
+    "regexp.MustCompile" "regexp.MustCompilePOSIX")
+  (argument_list
+    .
+    [
+      (raw_string_literal)
+      (interpreted_string_literal)
+    ] @injection.content
+    (#offset! @injection.content 0 1 0 -1)
+    (#set! injection.language "regex")))
+
+((comment) @injection.content
+  (#match? @injection.content "/\\*!([a-zA-Z]+:)?re2c")
+  (#set! injection.language "re2c"))
+
+((call_expression
+  function: (selector_expression
+    field: (field_identifier) @_method)
+  arguments: (argument_list
+    .
+    (interpreted_string_literal) @injection.content))
+  (#any-of? @_method "Printf" "Sprintf" "Fatalf" "Scanf" "Errorf" "Skipf" "Logf")
+  (#set! injection.language "printf"))
+
+((call_expression
+  function: (selector_expression
+    field: (field_identifier) @_method)
+  arguments: (argument_list
+    (_)
+    .
+    (interpreted_string_literal) @injection.content))
+  (#any-of? @_method "Fprintf" "Fscanf" "Appendf" "Sscanf")
+  (#set! injection.language "printf"))
diff --git a/pack/ant/start/nvim-treesitter/queries/go/locals.scm b/pack/ant/start/nvim-treesitter/queries/go/locals.scm
new file mode 100644
index 0000000..608c458
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/go/locals.scm
@@ -0,0 +1,88 @@
+((function_declaration
+  name: (identifier) @local.definition.function) ; @function
+  )
+
+((method_declaration
+  name: (field_identifier) @local.definition.method) ; @function.method
+  )
+
+(short_var_declaration
+  left: (expression_list
+    (identifier) @local.definition.var))
+
+(var_spec
+  name: (identifier) @local.definition.var)
+
+(parameter_declaration
+  (identifier) @local.definition.var)
+
+(variadic_parameter_declaration
+  (identifier) @local.definition.var)
+
+(for_statement
+  (range_clause
+    left: (expression_list
+      (identifier) @local.definition.var)))
+
+(const_declaration
+  (const_spec
+    name: (identifier) @local.definition.var))
+
+(type_declaration
+  (type_spec
+    name: (type_identifier) @local.definition.type))
+
+; reference
+(identifier) @local.reference
+
+(type_identifier) @local.reference
+
+(field_identifier) @local.reference
+
+((package_identifier) @local.reference
+  (#set! reference.kind "namespace"))
+
+(package_clause
+  (package_identifier) @local.definition.namespace)
+
+(import_spec_list
+  (import_spec
+    name: (package_identifier) @local.definition.namespace))
+
+; Call references
+((call_expression
+  function: (identifier) @local.reference)
+  (#set! reference.kind "call"))
+
+((call_expression
+  function: (selector_expression
+    field: (field_identifier) @local.reference))
+  (#set! reference.kind "call"))
+
+((call_expression
+  function: (parenthesized_expression
+    (identifier) @local.reference))
+  (#set! reference.kind "call"))
+
+((call_expression
+  function: (parenthesized_expression
+    (selector_expression
+      field: (field_identifier) @local.reference)))
+  (#set! reference.kind "call"))
+
+; Scopes
+(func_literal) @local.scope
+
+(source_file) @local.scope
+
+(function_declaration) @local.scope
+
+(if_statement) @local.scope
+
+(block) @local.scope
+
+(expression_switch_statement) @local.scope
+
+(for_statement) @local.scope
+
+(method_declaration) @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/goctl/folds.scm b/pack/ant/start/nvim-treesitter/queries/goctl/folds.scm
new file mode 100644
index 0000000..7049286
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/goctl/folds.scm
@@ -0,0 +1,11 @@
+[
+  (typeGroupSpec)
+  (typeSingleSpec)
+  (typeStruct)
+  (serviceSpec)
+  (serviceBody)
+  (importStatement)
+  (serviceServerSpec)
+  (infoStatement)
+  (structType)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/goctl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/goctl/highlights.scm
new file mode 100644
index 0000000..a4b809a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/goctl/highlights.scm
@@ -0,0 +1,79 @@
+; Key Symbol
+"=" @operator
+
+[
+  "."
+  ","
+  ":"
+  ";"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+; Keywords
+[
+  "syntax"
+  "info"
+  "service"
+] @keyword
+
+"import" @keyword.import
+
+"returns" @keyword.return
+
+[
+  "type"
+  "struct"
+] @keyword.type
+
+[
+  "@doc"
+  "@handler"
+  "@server"
+] @attribute
+
+; Service
+(serviceName) @type
+
+; Httpmethod
+(HTTPMETHOD) @keyword.operator
+
+; Field
+(fieldType) @type.builtin
+
+(fieldName) @variable.member
+
+(anonymousField) @variable.member
+
+; Functions
+(handlerValue) @function.method
+
+; Strings
+(VALUE) @string
+
+(tag) @string.documentation
+
+(PATH) @string.special.path
+
+; Comments
+(comment) @comment @spell
+
+(key) @variable.member
+
+(identValue) @string
+
+(DURATION) @number
+
+(NUMBER) @number
+
+; Struct
+(structNameId) @type
+
+(body) @type
diff --git a/pack/ant/start/nvim-treesitter/queries/goctl/indents.scm b/pack/ant/start/nvim-treesitter/queries/goctl/indents.scm
new file mode 100644
index 0000000..ffa1269
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/goctl/indents.scm
@@ -0,0 +1,15 @@
+[
+  (importGroup)
+  (typeGroupSpec)
+  (structType)
+  (infoStatement)
+  (serviceServerSpec)
+  (serviceSpec)
+] @indent.begin
+
+[
+  ")"
+  "}"
+] @indent.branch @indent.end
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/goctl/injections.scm b/pack/ant/start/nvim-treesitter/queries/goctl/injections.scm
new file mode 100644
index 0000000..a53abee
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/goctl/injections.scm
@@ -0,0 +1,3 @@
+; Inject comment language for goctl
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/godot_resource/folds.scm b/pack/ant/start/nvim-treesitter/queries/godot_resource/folds.scm
new file mode 100644
index 0000000..911798f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/godot_resource/folds.scm
@@ -0,0 +1 @@
+(section) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/godot_resource/highlights.scm b/pack/ant/start/nvim-treesitter/queries/godot_resource/highlights.scm
new file mode 100644
index 0000000..15cbadd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/godot_resource/highlights.scm
@@ -0,0 +1,49 @@
+(identifier) @variable
+
+(section
+  (identifier) @tag)
+
+(section
+  [
+    "["
+    "]"
+  ] @tag.delimiter)
+
+(attribute
+  (identifier) @tag.attribute)
+
+(property
+  (path) @property)
+
+(constructor
+  (identifier) @constructor)
+
+(string) @string
+
+(integer) @number
+
+(float) @number.float
+
+[
+  (true)
+  (false)
+] @boolean
+
+(null) @constant.builtin
+
+(array
+  [
+    "["
+    "]"
+  ] @punctuation.bracket)
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+] @punctuation.bracket
+
+"=" @operator
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/godot_resource/injections.scm b/pack/ant/start/nvim-treesitter/queries/godot_resource/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/godot_resource/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/godot_resource/locals.scm b/pack/ant/start/nvim-treesitter/queries/godot_resource/locals.scm
new file mode 100644
index 0000000..b946a5e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/godot_resource/locals.scm
@@ -0,0 +1 @@
+(section) @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/gomod/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gomod/highlights.scm
new file mode 100644
index 0000000..29cbe65
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gomod/highlights.scm
@@ -0,0 +1,20 @@
+[
+  "require"
+  "replace"
+  "go"
+  "toolchain"
+  "exclude"
+  "retract"
+  "module"
+] @keyword
+
+"=>" @operator
+
+(comment) @comment @spell
+
+(module_path) @string.special.url
+
+[
+  (version)
+  (go_version)
+] @string
diff --git a/pack/ant/start/nvim-treesitter/queries/gomod/injections.scm b/pack/ant/start/nvim-treesitter/queries/gomod/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gomod/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/gosum/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gosum/highlights.scm
new file mode 100644
index 0000000..f20c5f1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gosum/highlights.scm
@@ -0,0 +1,32 @@
+[
+  "alpha"
+  "beta"
+  "dev"
+  "pre"
+  "rc"
+  "+incompatible"
+] @keyword
+
+(module_path) @string.special.url
+
+(module_version) @string.special
+
+(hash_version) @attribute
+
+(hash) @string.special.symbol
+
+[
+  (number)
+  (number_with_decimal)
+  (hex_number)
+] @number
+
+(checksum
+  "go.mod" @string)
+
+[
+  ":"
+  "."
+  "-"
+  "/"
+] @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/gotmpl/folds.scm b/pack/ant/start/nvim-treesitter/queries/gotmpl/folds.scm
new file mode 100644
index 0000000..f3a22e9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gotmpl/folds.scm
@@ -0,0 +1,8 @@
+[
+  (if_action)
+  (range_action)
+  (block_action)
+  (with_action)
+  (define_action)
+  (comment)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/gotmpl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gotmpl/highlights.scm
new file mode 100644
index 0000000..fd81894
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gotmpl/highlights.scm
@@ -0,0 +1,132 @@
+; Priorities of the highlight queries are raised, so that they overrule the
+; often surrounding and overlapping highlights from the non-gotmpl injections.
+;
+; Identifiers
+([
+  (field)
+  (field_identifier)
+] @variable.member
+  (#set! priority 110))
+
+((variable) @variable
+  (#set! priority 110))
+
+; Function calls
+(function_call
+  function: (identifier) @function
+  (#set! priority 110))
+
+(method_call
+  method: (selector_expression
+    field: (field_identifier) @function
+    (#set! priority 110)))
+
+; Builtin functions
+(function_call
+  function: (identifier) @function.builtin
+  (#set! priority 110)
+  (#any-of? @function.builtin
+    "and" "call" "html" "index" "slice" "js" "len" "not" "or" "print" "printf" "println" "urlquery"
+    "eq" "ne" "lt" "ge" "gt" "ge"))
+
+; Operators
+([
+  "|"
+  ":="
+] @operator
+  (#set! priority 110))
+
+; Delimiters
+([
+  "."
+  ","
+] @punctuation.delimiter
+  (#set! priority 110))
+
+([
+  "{{"
+  "}}"
+  "{{-"
+  "-}}"
+  ")"
+  "("
+] @punctuation.bracket
+  (#set! priority 110))
+
+; Actions
+(if_action
+  [
+    "if"
+    "else"
+    "else if"
+    "end"
+  ] @keyword.conditional
+  (#set! priority 110))
+
+(range_action
+  [
+    "range"
+    "else"
+    "end"
+  ] @keyword.repeat
+  (#set! priority 110))
+
+(template_action
+  "template" @function.builtin
+  (#set! priority 110))
+
+(block_action
+  [
+    "block"
+    "end"
+  ] @keyword.directive
+  (#set! priority 110))
+
+(define_action
+  [
+    "define"
+    "end"
+  ] @keyword.directive.define
+  (#set! priority 110))
+
+(with_action
+  [
+    "with"
+    "else"
+    "end"
+  ] @keyword.conditional
+  (#set! priority 110))
+
+; Literals
+([
+  (interpreted_string_literal)
+  (raw_string_literal)
+] @string
+  (#set! priority 110))
+
+((rune_literal) @string.special.symbol
+  (#set! priority 110))
+
+((escape_sequence) @string.escape
+  (#set! priority 110))
+
+([
+  (int_literal)
+  (imaginary_literal)
+] @number
+  (#set! priority 110))
+
+((float_literal) @number.float
+  (#set! priority 110))
+
+([
+  (true)
+  (false)
+] @boolean
+  (#set! priority 110))
+
+((nil) @constant.builtin
+  (#set! priority 110))
+
+((comment) @comment @spell
+  (#set! priority 110))
diff --git a/pack/ant/start/nvim-treesitter/queries/gotmpl/injections.scm b/pack/ant/start/nvim-treesitter/queries/gotmpl/injections.scm
new file mode 100644
index 0000000..3cfc263
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gotmpl/injections.scm
@@ -0,0 +1,31 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; {{"put" | printf "%s%s" "out" | printf "%q"}}
+(function_call
+  function: (identifier) @_function
+  arguments: (argument_list
+    .
+    (interpreted_string_literal) @injection.content)
+  (#eq? @_function "printf")
+  (#set! injection.language "printf"))
+
+; {{ js "var a = 1 + 1" }}
+(function_call
+  function: (identifier) @_function
+  arguments: (argument_list
+    .
+    (interpreted_string_literal) @injection.content)
+  (#eq? @_function "js")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.language "javascript"))
+
+; {{ html "<h1>hello</h1>" }}
+(function_call
+  function: (identifier) @_function
+  arguments: (argument_list
+    .
+    (interpreted_string_literal) @injection.content)
+  (#eq? @_function "html")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.language "html"))
diff --git a/pack/ant/start/nvim-treesitter/queries/gotmpl/locals.scm b/pack/ant/start/nvim-treesitter/queries/gotmpl/locals.scm
new file mode 100644
index 0000000..528e9fa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gotmpl/locals.scm
@@ -0,0 +1,12 @@
+[
+  (if_action)
+  (range_action)
+  (block_action)
+  (with_action)
+  (define_action)
+] @local.scope
+
+(variable_definition
+  variable: (variable) @local.definition.var)
+
+(variable) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/gowork/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gowork/highlights.scm
new file mode 100644
index 0000000..bca9a5f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gowork/highlights.scm
@@ -0,0 +1,14 @@
+[
+  "replace"
+  "go"
+  "use"
+] @keyword
+
+"=>" @operator
+
+(comment) @comment @spell
+
+[
+  (version)
+  (go_version)
+] @string
diff --git a/pack/ant/start/nvim-treesitter/queries/gowork/injections.scm b/pack/ant/start/nvim-treesitter/queries/gowork/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gowork/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/gpg/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gpg/highlights.scm
new file mode 100644
index 0000000..f028344
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gpg/highlights.scm
@@ -0,0 +1,54 @@
+(option
+  .
+  _ @keyword)
+
+(option
+  ("no-" @variable.parameter)?
+  (name) @variable.parameter)
+
+(string
+  (content) @string)
+
+[
+  (value)
+  "clear"
+] @string.special
+
+(url) @string.special.url
+
+(key) @constant
+
+[
+  (number)
+  (expire_time)
+  (iso_time)
+] @number
+
+(format) @character.special
+
+"sensitive:" @keyword.modifier
+
+(filter_name) @variable.parameter
+
+(filter_scope) @module
+
+(filter_property) @property
+
+(filter_value) @string
+
+[
+  (filter_op0)
+  (filter_op1)
+  (filter_lc)
+  "="
+] @operator
+
+"!" @punctuation.special
+
+[
+  "\""
+  "'"
+  ","
+] @punctuation.delimiter
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/gpg/injections.scm b/pack/ant/start/nvim-treesitter/queries/gpg/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gpg/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/graphql/highlights.scm b/pack/ant/start/nvim-treesitter/queries/graphql/highlights.scm
new file mode 100644
index 0000000..c1ee501
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/graphql/highlights.scm
@@ -0,0 +1,163 @@
+; Types
+;------
+(scalar_type_definition
+  (name) @type)
+
+(object_type_definition
+  (name) @type)
+
+(interface_type_definition
+  (name) @type)
+
+(union_type_definition
+  (name) @type)
+
+(enum_type_definition
+  (name) @type)
+
+(input_object_type_definition
+  (name) @type)
+
+(scalar_type_extension
+  (name) @type)
+
+(object_type_extension
+  (name) @type)
+
+(interface_type_extension
+  (name) @type)
+
+(union_type_extension
+  (name) @type)
+
+(enum_type_extension
+  (name) @type)
+
+(input_object_type_extension
+  (name) @type)
+
+(named_type
+  (name) @type)
+
+; Directives
+;-----------
+(directive_definition
+  "@" @attribute
+  (name) @attribute)
+
+(directive) @attribute
+
+; Properties
+;-----------
+(field
+  (name) @property)
+
+(field
+  (alias
+    (name) @property))
+
+(field_definition
+  (name) @property)
+
+(object_value
+  (object_field
+    (name) @property))
+
+(enum_value
+  (name) @property)
+
+; Variable Definitions and Arguments
+;-----------------------------------
+(operation_definition
+  (name) @variable)
+
+(fragment_name
+  (name) @variable)
+
+(input_fields_definition
+  (input_value_definition
+    (name) @variable.parameter))
+
+(argument
+  (name) @variable.parameter)
+
+(arguments_definition
+  (input_value_definition
+    (name) @variable.parameter))
+
+(variable_definition
+  (variable) @variable.parameter)
+
+(argument
+  (value
+    (variable) @variable))
+
+; Constants
+;----------
+(string_value) @string
+
+(int_value) @number
+
+(float_value) @number.float
+
+(boolean_value) @boolean
+
+; Literals
+;---------
+(description
+  (string_value) @string.documentation @spell)
+
+(comment) @comment @spell
+
+(directive_location
+  (executable_directive_location) @type.builtin)
+
+(directive_location
+  (type_system_directive_location) @type.builtin)
+
+; Keywords
+;----------
+[
+  "query"
+  "mutation"
+  "subscription"
+  "fragment"
+  "scalar"
+  "input"
+  "extend"
+  "directive"
+  "schema"
+  "on"
+  "repeatable"
+  "implements"
+] @keyword
+
+[
+  "enum"
+  "union"
+  "type"
+  "interface"
+] @keyword.type
+
+; Punctuation
+;------------
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+"=" @operator
+
+"|" @punctuation.delimiter
+
+"&" @punctuation.delimiter
+
+":" @punctuation.delimiter
+
+"..." @punctuation.special
+
+"!" @punctuation.special
diff --git a/pack/ant/start/nvim-treesitter/queries/graphql/indents.scm b/pack/ant/start/nvim-treesitter/queries/graphql/indents.scm
new file mode 100644
index 0000000..fcffeb8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/graphql/indents.scm
@@ -0,0 +1,11 @@
+[
+  (definition)
+  (selection)
+] @indent.begin
+
+[
+  "{"
+  "}"
+] @indent.branch
+
+"}" @indent.end
diff --git a/pack/ant/start/nvim-treesitter/queries/graphql/injections.scm b/pack/ant/start/nvim-treesitter/queries/graphql/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/graphql/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/gren/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gren/highlights.scm
new file mode 100644
index 0000000..5cc6fff
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gren/highlights.scm
@@ -0,0 +1,121 @@
+; Keywords
+[
+  (as)
+  (port)
+  (exposing)
+  (alias)
+  (infix)
+] @keyword
+
+; Keywords - Conditionals
+[
+  "if"
+  "then"
+  "else"
+  "let"
+  "in"
+  (case)
+  (of)
+] @keyword.conditional
+
+; Keywords - Imports
+[
+  (import)
+  (module)
+] @keyword.import
+
+; Operators
+[
+  (arrow)
+  (backslash)
+  (colon)
+  (operator_identifier)
+  (eq)
+] @operator
+
+; Punctuation
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ","
+  "|"
+  (dot)
+] @punctuation.delimiter
+
+; Comments
+[
+  (block_comment)
+  (line_comment)
+] @comment
+
+; Strings
+[
+  (close_quote)
+  (open_quote)
+  (regular_string_part)
+] @string
+
+; Strings - Escape
+(string_escape) @string.escape
+
+; Characters
+[
+  (open_char)
+  (close_char)
+] @character
+
+(type_annotation
+  (lower_case_identifier) @function)
+
+(port_annotation
+  (lower_case_identifier) @function)
+
+(function_declaration_left
+  (lower_case_identifier) @function)
+
+(function_call_expr
+  target: (value_expr) @function)
+
+(field_access_expr
+  (value_expr
+    (value_qid) @variable.member))
+
+(lower_pattern) @variable.parameter
+
+(record_base_identifier) @variable
+
+(number_constant_expr) @number
+
+(type) @keyword.type
+
+(type_declaration
+  (upper_case_identifier) @type)
+
+(type_ref) @type
+
+(type_alias_declaration
+  name: (upper_case_identifier) @type)
+
+(union_variant
+  (upper_case_identifier) @type)
+
+(union_pattern
+  constructor: (upper_case_qid
+    (upper_case_identifier) @label
+    (dot)
+    (upper_case_identifier) @type))
+
+(union_pattern
+  constructor: (upper_case_qid
+    (upper_case_identifier) @type))
+
+(value_expr
+  (upper_case_qid
+    (upper_case_identifier)) @type)
diff --git a/pack/ant/start/nvim-treesitter/queries/gren/injections.scm b/pack/ant/start/nvim-treesitter/queries/gren/injections.scm
new file mode 100644
index 0000000..3cd6aac
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gren/injections.scm
@@ -0,0 +1,5 @@
+([
+  (line_comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/groovy/folds.scm b/pack/ant/start/nvim-treesitter/queries/groovy/folds.scm
new file mode 100644
index 0000000..354861a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/groovy/folds.scm
@@ -0,0 +1,6 @@
+[
+  (argument_list)
+  (closure)
+  (list)
+  (map)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/groovy/highlights.scm b/pack/ant/start/nvim-treesitter/queries/groovy/highlights.scm
new file mode 100644
index 0000000..4504e16
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/groovy/highlights.scm
@@ -0,0 +1,269 @@
+[
+  "!instanceof"
+  "assert"
+  "extends"
+  "instanceof"
+  "package"
+] @keyword
+
+"class" @keyword.type
+
+[
+  "!in"
+  "as"
+  "in"
+] @keyword.operator
+
+[
+  "case"
+  "default"
+  "else"
+  "if"
+  "switch"
+] @keyword.conditional
+
+[
+  "catch"
+  "finally"
+  "try"
+] @keyword.exception
+
+"def" @keyword.function
+
+"import" @keyword.import
+
+[
+  "for"
+  "while"
+  (break)
+  (continue)
+] @keyword.repeat
+
+"return" @keyword.return
+
+[
+  "true"
+  "false"
+] @boolean
+
+(null) @constant.builtin
+
+"this" @variable.builtin
+
+[
+  "int"
+  "char"
+  "short"
+  "long"
+  "boolean"
+  "float"
+  "double"
+  "void"
+] @type.builtin
+
+[
+  "final"
+  "private"
+  "protected"
+  "public"
+  "static"
+  "synchronized"
+] @keyword.modifier
+
+(comment) @comment @spell
+
+(shebang) @keyword.directive
+
+(string) @string
+
+(string
+  (escape_sequence) @string.escape)
+
+(string
+  (interpolation
+    "$" @punctuation.special))
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  ":"
+  ","
+  "."
+] @punctuation.delimiter
+
+(number_literal) @number
+
+(identifier) @variable
+
+((identifier) @constant
+  (#match? @constant "^[A-Z][A-Z_]+"))
+
+[
+  "%"
+  "*"
+  "/"
+  "+"
+  "-"
+  "<<"
+  ">>"
+  ">>>"
+  ".."
+  "..<"
+  "<..<"
+  "<.."
+  "<"
+  "<="
+  ">"
+  ">="
+  "=="
+  "!="
+  "<=>"
+  "==="
+  "!=="
+  "=~"
+  "==~"
+  "&"
+  "^"
+  "|"
+  "&&"
+  "||"
+  "?:"
+  "+"
+  "*"
+  ".&"
+  ".@"
+  "?."
+  "*."
+  "*"
+  "*:"
+  "++"
+  "--"
+  "!"
+] @operator
+
+(wildcard_import) @character.special
+
+(string
+  "/" @string)
+
+(ternary_op
+  ([
+    "?"
+    ":"
+  ]) @keyword.conditional.ternary)
+
+(map
+  (map_item
+    key: (identifier) @variable.parameter))
+
+(parameter
+  type: (identifier) @type
+  name: (identifier) @variable.parameter)
+
+(generic_param
+  name: (identifier) @variable.parameter)
+
+(declaration
+  type: (identifier) @type)
+
+(function_definition
+  type: (identifier) @type)
+
+(function_declaration
+  type: (identifier) @type)
+
+(class_definition
+  name: (identifier) @type)
+
+(class_definition
+  superclass: (identifier) @type)
+
+(generic_param
+  superclass: (identifier) @type)
+
+(type_with_generics
+  (identifier) @type)
+
+(type_with_generics
+  (generics
+    (identifier) @type))
+
+(generics
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(generic_parameters
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+; TODO: Class literals with PascalCase
+(declaration
+  "=" @operator)
+
+(assignment
+  "=" @operator)
+
+(function_call
+  function: (identifier) @function)
+
+(function_call
+  function: (dotted_identifier
+    (identifier) @function .))
+
+(function_call
+  (argument_list
+    (map_item
+      key: (identifier) @variable.parameter)))
+
+(juxt_function_call
+  function: (identifier) @function)
+
+(juxt_function_call
+  function: (dotted_identifier
+    (identifier) @function .))
+
+(juxt_function_call
+  (argument_list
+    (map_item
+      key: (identifier) @variable.parameter)))
+
+(function_definition
+  function: (identifier) @function)
+
+(function_declaration
+  function: (identifier) @function)
+
+(annotation) @function.macro
+
+(annotation
+  (identifier) @function.macro)
+
+"@interface" @function.macro
+
+(groovy_doc) @comment.documentation @spell
+
+(groovy_doc
+  [
+    (groovy_doc_param)
+    (groovy_doc_throws)
+    (groovy_doc_tag)
+  ] @string.special @nospell)
+
+(groovy_doc
+  (groovy_doc_param
+    (identifier) @variable.parameter) @nospell)
+
+(groovy_doc
+  (groovy_doc_throws
+    (identifier) @type @nospell))
diff --git a/pack/ant/start/nvim-treesitter/queries/groovy/indents.scm b/pack/ant/start/nvim-treesitter/queries/groovy/indents.scm
new file mode 100644
index 0000000..ba3a2e8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/groovy/indents.scm
@@ -0,0 +1,35 @@
+[
+  (closure)
+  (map)
+  (list)
+  (argument_list)
+  (parameter_list)
+  (for_parameters)
+] @indent.begin
+
+; (function_definition "(" @indent.begin)
+(closure
+  "}" @indent.end)
+
+(argument_list
+  ")" @indent.end)
+
+(for_parameters
+  ")" @indent.end)
+
+((for_loop
+  body: (_) @_body) @indent.begin
+  (#not-kind-eq? @_body "closure"))
+
+; TODO: while, try
+(list
+  "]" @indent.end)
+
+(map
+  "]" @indent.end)
+
+[
+  "}"
+  ")"
+  "]"
+] @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/groovy/injections.scm b/pack/ant/start/nvim-treesitter/queries/groovy/injections.scm
new file mode 100644
index 0000000..1c04c65
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/groovy/injections.scm
@@ -0,0 +1,5 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((groovy_doc) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/groovy/locals.scm b/pack/ant/start/nvim-treesitter/queries/groovy/locals.scm
new file mode 100644
index 0000000..23cb5f0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/groovy/locals.scm
@@ -0,0 +1,6 @@
+(function_definition) @local.scope
+
+(parameter
+  name: (identifier) @local.definition.parameter)
+
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/gstlaunch/highlights.scm b/pack/ant/start/nvim-treesitter/queries/gstlaunch/highlights.scm
new file mode 100644
index 0000000..90729f8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/gstlaunch/highlights.scm
@@ -0,0 +1,35 @@
+[
+  "!"
+  "="
+] @operator
+
+[
+  ","
+  "."
+  ";"
+  "/"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+(property
+  key: (identifier) @variable.member)
+
+(value) @string
+
+(string_literal) @string
+
+(cap
+  .
+  (identifier) @string
+  .
+  (identifier) @string)
+
+(simple_element
+  type: (_) @type)
+
+(bin
+  type: (_) @type)
diff --git a/pack/ant/start/nvim-treesitter/queries/hack/highlights.scm b/pack/ant/start/nvim-treesitter/queries/hack/highlights.scm
new file mode 100644
index 0000000..bb9d2a5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hack/highlights.scm
@@ -0,0 +1,366 @@
+(variable) @variable
+
+(identifier) @variable
+
+((variable) @variable.builtin
+  (#eq? @variable.builtin "$this"))
+
+(braced_expression) @none
+
+(scoped_identifier
+  (qualified_identifier
+    (identifier) @type))
+
+[
+  (comment)
+  (heredoc)
+] @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$"))
+
+"function" @keyword.function
+
+[
+  "implements"
+  "using"
+  "attribute"
+  "const"
+  "extends"
+  "insteadof"
+] @keyword
+
+[
+  "class"
+  "type"
+  "interface"
+  "namespace"
+] @keyword.type
+
+[
+  "async"
+  "await"
+] @keyword.coroutine
+
+[
+  "use"
+  "include"
+  "include_once"
+  "require"
+  "require_once"
+] @keyword.import
+
+[
+  "new"
+  "print"
+  "echo"
+  "newtype"
+  "clone"
+  "as"
+] @keyword.operator
+
+"return" @keyword.return
+
+[
+  (abstract_modifier)
+  (final_modifier)
+  (static_modifier)
+  (visibility_modifier)
+  (xhp_modifier)
+] @keyword.modifier
+
+[
+  "shape"
+  "tuple"
+  (array_type)
+  "bool"
+  "float"
+  "int"
+  "string"
+  "arraykey"
+  "void"
+  "nonnull"
+  "mixed"
+  "dynamic"
+  "noreturn"
+] @type.builtin
+
+(null) @constant.builtin
+
+[
+  (true)
+  (false)
+] @boolean
+
+(type_specifier) @type
+
+(new_expression
+  (_) @type)
+
+(alias_declaration
+  "newtype"
+  .
+  (_) @type)
+
+(alias_declaration
+  "type"
+  .
+  (_) @type)
+
+(class_declaration
+  name: (identifier) @type)
+
+(type_parameter
+  name: (identifier) @type)
+
+(collection
+  (qualified_identifier
+    (identifier) @type .))
+
+[
+  "@required"
+  "@lateinit"
+  (attribute_modifier)
+] @attribute
+
+[
+  "="
+  "??="
+  ".="
+  "|="
+  "^="
+  "&="
+  "<<="
+  ">>="
+  "+="
+  "-="
+  "*="
+  "/="
+  "%="
+  "**="
+  "==>"
+  "|>"
+  "??"
+  "||"
+  "&&"
+  "|"
+  "^"
+  "&"
+  "=="
+  "!="
+  "==="
+  "!=="
+  "<"
+  ">"
+  "<="
+  ">="
+  "<=>"
+  "<<"
+  ">>"
+  "->"
+  "+"
+  "-"
+  "."
+  "*"
+  "/"
+  "%"
+  "**"
+  "++"
+  "--"
+  "!"
+  "?:"
+  "="
+  "??="
+  ".="
+  "|="
+  "^="
+  "&="
+  "<<="
+  ">>="
+  "+="
+  "-="
+  "*="
+  "/="
+  "%="
+  "**="
+  "=>"
+  ; type modifiers
+  "@"
+  "?"
+  "~"
+] @operator
+
+(integer) @number
+
+(float) @number.float
+
+(parameter
+  (variable) @variable.parameter)
+
+(call_expression
+  function: (qualified_identifier
+    (identifier) @function.call .))
+
+(call_expression
+  function: (scoped_identifier
+    (identifier) @function.call .))
+
+(call_expression
+  function: (selection_expression
+    (qualified_identifier
+      (identifier) @function.method.call .)))
+
+(qualified_identifier
+  (_) @module
+  .
+  (_))
+
+(use_statement
+  (qualified_identifier
+    (_) @module .)
+  (use_clause))
+
+(use_statement
+  (use_type
+    "namespace")
+  (use_clause
+    (qualified_identifier
+      (identifier) @module .)
+    alias: (identifier)? @module))
+
+(use_statement
+  (use_type
+    "const")
+  (use_clause
+    (qualified_identifier
+      (identifier) @constant .)
+    alias: (identifier)? @constant))
+
+(use_statement
+  (use_type
+    "function")
+  (use_clause
+    (qualified_identifier
+      (identifier) @function .)
+    alias: (identifier)? @function))
+
+(use_statement
+  (use_type
+    "type")
+  (use_clause
+    (qualified_identifier
+      (identifier) @type .)
+    alias: (identifier)? @type))
+
+(use_clause
+  (use_type
+    "namespace")
+  (qualified_identifier
+    (_) @module .)
+  alias: (identifier)? @module)
+
+(use_clause
+  (use_type
+    "function")
+  (qualified_identifier
+    (_) @function .)
+  alias: (identifier)? @function)
+
+(use_clause
+  (use_type
+    "const")
+  (qualified_identifier
+    (_) @constant .)
+  alias: (identifier)? @constant)
+
+(use_clause
+  (use_type
+    "type")
+  (qualified_identifier
+    (_) @type .)
+  alias: (identifier)? @type)
+
+(function_declaration
+  name: (identifier) @function)
+
+(method_declaration
+  name: (identifier) @function.method)
+
+(type_arguments
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  "<<"
+  ">>"
+] @punctuation.bracket
+
+(xhp_open
+  [
+    "<"
+    ">"
+  ] @tag.delimiter)
+
+(xhp_close
+  [
+    "</"
+    ">"
+  ] @tag.delimiter)
+
+[
+  "."
+  ";"
+  "::"
+  ":"
+  ","
+] @punctuation.delimiter
+
+(qualified_identifier
+  "\\" @punctuation.delimiter)
+
+(ternary_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+[
+  "if"
+  "else"
+  "elseif"
+  "switch"
+  "case"
+] @keyword.conditional
+
+[
+  "try"
+  "catch"
+  "finally"
+] @keyword.exception
+
+[
+  "for"
+  "while"
+  "foreach"
+  "do"
+  "continue"
+  "break"
+] @keyword.repeat
+
+[
+  (string)
+  (xhp_string)
+] @string
+
+[
+  (xhp_open)
+  (xhp_close)
+] @tag
diff --git a/pack/ant/start/nvim-treesitter/queries/hack/injections.scm b/pack/ant/start/nvim-treesitter/queries/hack/injections.scm
new file mode 100644
index 0000000..655c29e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hack/injections.scm
@@ -0,0 +1,5 @@
+([
+  (comment)
+  (heredoc)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/hare/folds.scm b/pack/ant/start/nvim-treesitter/queries/hare/folds.scm
new file mode 100644
index 0000000..58b10bf
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hare/folds.scm
@@ -0,0 +1,18 @@
+[
+  (imports)
+  (function_declaration)
+  (enum_type)
+  (struct_type)
+  (tuple_type)
+  (union_type)
+  (block)
+  (if_statement)
+  (for_statement)
+  (call_expression)
+  (switch_expression)
+  (match_expression)
+  (case)
+  (array_literal)
+  (struct_literal)
+  (tuple_literal)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/hare/highlights.scm b/pack/ant/start/nvim-treesitter/queries/hare/highlights.scm
new file mode 100644
index 0000000..deaecd2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hare/highlights.scm
@@ -0,0 +1,272 @@
+; Variables
+(identifier) @variable
+
+; Types
+(type) @type
+
+(scoped_type_identifier
+  (identifier)
+  .
+  (identifier) @type)
+
+(struct_literal
+  .
+  (identifier) @type)
+
+(builtin_type) @type.builtin
+
+; Constants
+((identifier) @constant
+  (#lua-match? @constant "^[A-Z_]+$"))
+
+; Includes
+[
+  "use"
+  "export"
+] @keyword.import
+
+(use_statement
+  (scoped_type_identifier
+    (identifier) @module))
+
+(use_statement
+  (identifier) @module
+  "{")
+
+(use_statement
+  .
+  (identifier) @module .)
+
+((scoped_type_identifier
+  path: (_) @module)
+  (#set! priority 105))
+
+; Keywords
+[
+  "def"
+  "let"
+] @keyword
+
+[
+  "enum"
+  "struct"
+  "union"
+  "type"
+] @keyword.type
+
+"fn" @keyword.function
+
+[
+  "defer"
+  "yield"
+  "return"
+] @keyword.return
+
+[
+  "as"
+  "is"
+] @keyword.operator
+
+; Typedefs
+(type_declaration
+  "type"
+  (identifier) @type.definition
+  .
+  "=")
+
+; Qualifiers
+[
+  "const"
+  "static"
+  "nullable"
+] @keyword.modifier
+
+; Attributes
+[
+  "@fini"
+  "@init"
+  "@test"
+  "@noreturn"
+  "@packed"
+  (declaration_attribute)
+] @attribute
+
+; Labels
+((label) @label
+  (#set! priority 105))
+
+; Functions
+(function_declaration
+  "fn"
+  .
+  (identifier) @function)
+
+(call_expression
+  .
+  (identifier) @function.call)
+
+(call_expression
+  .
+  (scoped_type_identifier
+    .
+    (identifier)
+    .
+    "::"
+    .
+    (identifier) @function.method.call))
+
+((call_expression
+  .
+  (identifier) @function.builtin)
+  (#any-of? @function.builtin "align" "assert" "free" "len" "offset" "size"))
+
+(size_expression
+  "size" @function.builtin)
+
+((function_declaration
+  "fn"
+  .
+  (identifier) @constructor)
+  (#eq? @constructor "init"))
+
+((call_expression
+  .
+  (identifier) @constructor)
+  (#eq? @constructor "init"))
+
+; Parameters
+(parameter
+  (_) @variable.parameter
+  .
+  ":")
+
+; Fields
+((member_expression
+  "."
+  (_) @variable.member)
+  (#set! priority 105))
+
+(field
+  .
+  (identifier) @variable.member)
+
+(field_assignment
+  .
+  (identifier) @variable.member)
+
+; Repeats
+"for" @keyword.repeat
+
+; Conditionals
+[
+  "if"
+  "else"
+  "break"
+  "switch"
+  "match"
+  "case"
+] @keyword.conditional
+
+; Operators
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "||"
+  "&&"
+  "^^"
+  "|"
+  "&"
+  "^"
+  "=="
+  "!="
+  ">"
+  ">="
+  "<="
+  "<"
+  "<<"
+  ">>"
+  "~"
+  "!"
+  "+="
+  "-="
+  "*="
+  "/="
+  "%="
+  "<<="
+  ">>="
+  "|="
+  "&="
+  "^="
+  "||="
+  "&&="
+  "^^="
+  "="
+  "?"
+] @operator
+
+; Punctuation
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  ".."
+  "..."
+  "_"
+] @punctuation.special
+
+(pointer_type
+  "*" @punctuation.special)
+
+(slice_type
+  "*" @punctuation.special)
+
+(error_type
+  "!" @punctuation.special)
+
+[
+  ","
+  "."
+  ":"
+  ";"
+  "::"
+  "=>"
+] @punctuation.delimiter
+
+; Literals
+[
+  (string)
+  (raw_string)
+] @string
+
+(rune) @character
+
+(escape_sequence) @string.escape
+
+(number) @number
+
+(float) @number.float
+
+(boolean) @boolean
+
+[
+  (void)
+  (null)
+] @constant.builtin
+
+; Comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/hare/indents.scm b/pack/ant/start/nvim-treesitter/queries/hare/indents.scm
new file mode 100644
index 0000000..9e41ea6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hare/indents.scm
@@ -0,0 +1,45 @@
+[
+  (enum_type)
+  (struct_type)
+  (tuple_type)
+  (union_type)
+  (block)
+  (for_statement)
+  (call_expression)
+  (case)
+  (array_literal)
+  (struct_literal)
+  (tuple_literal)
+] @indent.begin
+
+(if_statement
+  ("("
+    condition: (_)
+    ")") @indent.begin)
+
+[
+  "}"
+  "]"
+  ")"
+] @indent.end
+
+[
+  "{"
+  "}"
+] @indent.branch
+
+[
+  "["
+  "]"
+] @indent.branch
+
+[
+  "("
+  ")"
+] @indent.branch
+
+[
+  (ERROR)
+  (comment)
+  (concatenated_string)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/hare/injections.scm b/pack/ant/start/nvim-treesitter/queries/hare/injections.scm
new file mode 100644
index 0000000..88a3f1c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hare/injections.scm
@@ -0,0 +1,18 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((call_expression
+  .
+  (_) @_fnname
+  .
+  "("
+  .
+  (_
+    [
+      (string_content)
+      (raw_string_content)
+    ] @injection.content)
+  .
+  ")")
+  (#any-of? @_fnname "compile" "regex::compile")
+  (#set! injection.language "regex"))
diff --git a/pack/ant/start/nvim-treesitter/queries/hare/locals.scm b/pack/ant/start/nvim-treesitter/queries/hare/locals.scm
new file mode 100644
index 0000000..12a214b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hare/locals.scm
@@ -0,0 +1,65 @@
+; Scopes
+[
+  (module)
+  (function_declaration)
+  (if_statement)
+  (for_statement)
+  (match_expression)
+  (switch_expression)
+] @local.scope
+
+; References
+[
+  (identifier)
+  (scoped_type_identifier)
+] @local.reference
+
+; Definitions
+(global_binding
+  (identifier) @local.definition.constant
+  .
+  ":"
+  (_))
+
+(const_declaration
+  "const"
+  (identifier) @local.definition.constant
+  .
+  "=")
+
+(field
+  .
+  (identifier) @local.definition.field)
+
+(field_assignment
+  .
+  (identifier) @local.definition.field)
+
+(function_declaration
+  "fn"
+  .
+  (identifier) @local.definition.function)
+
+(parameter
+  (_) @local.definition.parameter
+  .
+  ":")
+
+(type_declaration
+  "type"
+  (identifier) @local.definition.type
+  .
+  "=")
+
+(type_declaration
+  "type"
+  (identifier) @local.definition.enum
+  .
+  "="
+  (enum_type))
+
+(let_declaration
+  "let"
+  .
+  (identifier) @local.definition.var
+  ","?)
diff --git a/pack/ant/start/nvim-treesitter/queries/haskell/folds.scm b/pack/ant/start/nvim-treesitter/queries/haskell/folds.scm
new file mode 100644
index 0000000..d7b820c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/haskell/folds.scm
@@ -0,0 +1,6 @@
+[
+  (apply)
+  (do)
+  (function)
+  (import)+
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/haskell/highlights.scm b/pack/ant/start/nvim-treesitter/queries/haskell/highlights.scm
new file mode 100644
index 0000000..0880f02
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/haskell/highlights.scm
@@ -0,0 +1,467 @@
+; ----------------------------------------------------------------------------
+; Parameters and variables
+; NOTE: These are at the top, so that they have low priority,
+; and don't override destructured parameters
+(variable) @variable
+
+(decl/function
+  patterns: (patterns
+    (_) @variable.parameter))
+
+(expression/lambda
+  (_)+ @variable.parameter
+  "->")
+
+(decl/function
+  (infix
+    (pattern) @variable.parameter))
+
+; ----------------------------------------------------------------------------
+; Literals and comments
+(integer) @number
+
+(negation) @number
+
+(expression/literal
+  (float)) @number.float
+
+(char) @character
+
+(string) @string
+
+(comment) @comment
+
+(haddock) @comment.documentation
+
+; ----------------------------------------------------------------------------
+; Punctuation
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ","
+  ";"
+] @punctuation.delimiter
+
+; ----------------------------------------------------------------------------
+; Keywords, operators, includes
+[
+  "forall"
+  ; "∀" ; utf-8 is not cross-platform safe
+] @keyword.repeat
+
+(pragma) @keyword.directive
+
+[
+  "if"
+  "then"
+  "else"
+  "case"
+  "of"
+] @keyword.conditional
+
+[
+  "import"
+  "qualified"
+  "module"
+] @keyword.import
+
+[
+  (operator)
+  (constructor_operator)
+  (all_names)
+  "."
+  ".."
+  "="
+  "|"
+  "::"
+  "=>"
+  "->"
+  "<-"
+  "\\"
+  "`"
+  "@"
+] @operator
+
+(wildcard) @character.special
+
+(module
+  (module_id) @module)
+
+[
+  "where"
+  "let"
+  "in"
+  "class"
+  "instance"
+  "pattern"
+  "data"
+  "newtype"
+  "family"
+  "type"
+  "as"
+  "hiding"
+  "deriving"
+  "via"
+  "stock"
+  "anyclass"
+  "do"
+  "mdo"
+  "rec"
+  "infix"
+  "infixl"
+  "infixr"
+] @keyword
+
+; ----------------------------------------------------------------------------
+; Functions and variables
+(decl
+  [
+    name: (variable) @function
+    names: (binding_list
+      (variable) @function)
+  ])
+
+(decl/bind
+  name: (variable) @variable)
+
+; Consider signatures (and accompanying functions)
+; with only one value on the rhs as variables
+(decl/signature
+  name: (variable) @variable
+  type: (type))
+
+((decl/signature
+  name: (variable) @_name
+  type: (type))
+  .
+  (decl
+    name: (variable) @variable)
+  match: (_)
+  (#eq? @_name @variable))
+
+; but consider a type that involves 'IO' a decl/function
+(decl/signature
+  name: (variable) @function
+  type: (type/apply
+    constructor: (name) @_type)
+  (#eq? @_type "IO"))
+
+((decl/signature
+  name: (variable) @_name
+  type: (type/apply
+    constructor: (name) @_type)
+  (#eq? @_type "IO"))
+  .
+  (decl
+    name: (variable) @function)
+  match: (_)
+  (#eq? @_name @function))
+
+((decl/signature) @function
+  .
+  (decl/function
+    name: (variable) @function))
+
+(decl/bind
+  name: (variable) @function
+  (match
+    expression: (expression/lambda)))
+
+; view patterns
+(view_pattern
+  [
+    (expression/variable) @function.call
+    (expression/qualified
+      (variable) @function.call)
+  ])
+
+; consider infix functions as operators
+(infix_id
+  [
+    (variable) @operator
+    (qualified
+      (variable) @operator)
+  ])
+
+; decl/function calls with an infix operator
+; e.g. func <$> a <*> b
+(infix
+  left_operand: [
+    (variable) @function.call
+    (qualified
+      ((module) @module
+        (variable) @function.call))
+  ])
+
+; infix operators applied to variables
+((expression/variable) @variable
+  .
+  (operator))
+
+((operator)
+  .
+  [
+    (expression/variable) @variable
+    (expression/qualified
+      (variable) @variable)
+  ])
+
+; infix operator function definitions
+(function
+  (infix
+    left_operand: [
+      (variable) @variable
+      (qualified
+        ((module) @module
+          (variable) @variable))
+    ])
+  match: (match))
+
+; decl/function calls with infix operators
+([
+  (expression/variable) @function.call
+  (expression/qualified
+    (variable) @function.call)
+]
+  .
+  (operator) @_op
+  (#any-of? @_op "$" "<$>" ">>=" "=<<"))
+
+; right hand side of infix operator
+((infix
+  [
+    (operator)
+    (infix_id
+      (variable))
+  ] ; infix or `func`
+  .
+  [
+    (variable) @function.call
+    (qualified
+      (variable) @function.call)
+  ])
+  .
+  (operator) @_op
+  (#any-of? @_op "$" "<$>" "=<<"))
+
+; decl/function composition, arrows, monadic composition (lhs)
+([
+  (expression/variable) @function
+  (expression/qualified
+    (variable) @function)
+]
+  .
+  (operator) @_op
+  (#any-of? @_op "." ">>>" "***" ">=>" "<=<"))
+
+; right hand side of infix operator
+((infix
+  [
+    (operator)
+    (infix_id
+      (variable))
+  ] ; infix or `func`
+  .
+  [
+    (variable) @function
+    (qualified
+      (variable) @function)
+  ])
+  .
+  (operator) @_op
+  (#any-of? @_op "." ">>>" "***" ">=>" "<=<"))
+
+; function composition, arrows, monadic composition (rhs)
+((operator) @_op
+  .
+  [
+    (expression/variable) @function
+    (expression/qualified
+      (variable) @function)
+  ]
+  (#any-of? @_op "." ">>>" "***" ">=>" "<=<"))
+
+; function defined in terms of a function composition
+(decl/function
+  name: (variable) @function
+  (match
+    expression: (infix
+      operator: (operator) @_op
+      (#any-of? @_op "." ">>>" "***" ">=>" "<=<"))))
+
+(apply
+  [
+    (expression/variable) @function.call
+    (expression/qualified
+      (variable) @function.call)
+  ])
+
+; function compositions, in parentheses, applied
+; lhs
+(apply
+  .
+  (expression/parens
+    (infix
+      [
+        (variable) @function.call
+        (qualified
+          (variable) @function.call)
+      ]
+      .
+      (operator))))
+
+; rhs
+(apply
+  .
+  (expression/parens
+    (infix
+      (operator)
+      .
+      [
+        (variable) @function.call
+        (qualified
+          (variable) @function.call)
+      ])))
+
+; variables being passed to a function call
+(apply
+  (_)
+  .
+  [
+    (expression/variable) @variable
+    (expression/qualified
+      (variable) @variable)
+  ])
+
+; main is always a function
+; (this prevents `main = undefined` from being highlighted as a variable)
+(decl/bind
+  name: (variable) @function
+  (#eq? @function "main"))
+
+; scoped function types (func :: a -> b)
+(signature
+  pattern: (pattern/variable) @function
+  type: (function))
+
+; signatures that have a function type
+; + binds that follow them
+(decl/signature
+  name: (variable) @function
+  type: (function))
+
+((decl/signature
+  name: (variable) @_name
+  type: (quantified_type))
+  .
+  (decl/bind
+    (variable) @function)
+  (#eq? @function @_name))
+
+; Treat constructor assignments (smart constructors) as functions, e.g. mkJust = Just
+(bind
+  name: (variable) @function
+  match: (match
+    expression: (constructor)))
+
+; Function composition
+(bind
+  name: (variable) @function
+  match: (match
+    expression: (infix
+      operator: (operator) @_op
+      (#eq? @_op "."))))
+
+; ----------------------------------------------------------------------------
+; Types
+(name) @type
+
+(type/unit) @type
+
+(type/unit
+  [
+    "("
+    ")"
+  ] @type)
+
+(type/list
+  [
+    "["
+    "]"
+  ] @type)
+
+(type/star) @type
+
+(constructor) @constructor
+
+; True or False
+((constructor) @boolean
+  (#any-of? @boolean "True" "False"))
+
+; otherwise (= True)
+((variable) @boolean
+  (#eq? @boolean "otherwise"))
+
+; ----------------------------------------------------------------------------
+; Quasi-quotes
+(quoter) @function.call
+
+(quasiquote
+  quoter: [
+    (quoter) @_name
+    (quoter
+      (qualified
+        id: (variable) @_name))
+  ]
+  (#eq? @_name "qq")
+  body: (quasiquote_body) @string)
+
+; namespaced quasi-quoter
+(quoter
+  [
+    (variable) @function.call
+    (_
+      (module) @module
+      .
+      (variable) @function.call)
+  ])
+
+; Highlighting of quasiquote_body for other languages is handled by injections.scm
+; ----------------------------------------------------------------------------
+; Exceptions/error handling
+((variable) @keyword.exception
+  (#any-of? @keyword.exception
+    "error" "undefined" "try" "tryJust" "tryAny" "catch" "catches" "catchJust" "handle" "handleJust"
+    "throw" "throwIO" "throwTo" "throwError" "ioError" "mask" "mask_" "uninterruptibleMask"
+    "uninterruptibleMask_" "bracket" "bracket_" "bracketOnErrorSource" "finally" "fail"
+    "onException" "expectationFailure"))
+
+; ----------------------------------------------------------------------------
+; Debugging
+((variable) @keyword.debug
+  (#any-of? @keyword.debug
+    "trace" "traceId" "traceShow" "traceShowId" "traceWith" "traceShowWith" "traceStack" "traceIO"
+    "traceM" "traceShowM" "traceEvent" "traceEventWith" "traceEventIO" "flushEventLog" "traceMarker"
+    "traceMarkerIO"))
+
+; ----------------------------------------------------------------------------
+; Fields
+(field_name
+  (variable) @variable.member)
+
+(import_name
+  (name)
+  .
+  (children
+    (variable) @variable.member))
+
+; ----------------------------------------------------------------------------
+; Spell checking
+(comment) @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/haskell/injections.scm b/pack/ant/start/nvim-treesitter/queries/haskell/injections.scm
new file mode 100644
index 0000000..59fe733
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/haskell/injections.scm
@@ -0,0 +1,76 @@
+; -----------------------------------------------------------------------------
+; General language injection
+(quasiquote
+  (quoter) @injection.language
+  (quasiquote_body) @injection.content)
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; -----------------------------------------------------------------------------
+; shakespeare library
+; NOTE: doesn't support templating
+; TODO: add once CoffeeScript parser is added
+; ; CoffeeScript: Text.Coffee
+; (quasiquote
+;  (quoter) @_name
+;  (#eq? @_name "coffee")
+;  ((quasiquote_body) @injection.content
+;   (#set! injection.language "coffeescript")))
+; CSS: Text.Cassius, Text.Lucius
+(quasiquote
+  (quoter) @_name
+  (#any-of? @_name "cassius" "lucius")
+  (quasiquote_body) @injection.content
+  (#set! injection.language "css"))
+
+; HTML: Text.Hamlet
+(quasiquote
+  (quoter) @_name
+  (#any-of? @_name "shamlet" "xshamlet" "hamlet" "xhamlet" "ihamlet")
+  (quasiquote_body) @injection.content
+  (#set! injection.language "html"))
+
+; JS: Text.Julius
+(quasiquote
+  (quoter) @_name
+  (#any-of? @_name "js" "julius")
+  (quasiquote_body) @injection.content
+  (#set! injection.language "javascript"))
+
+; TS: Text.TypeScript
+(quasiquote
+  (quoter) @_name
+  (#any-of? @_name "tsc" "tscJSX")
+  (quasiquote_body) @injection.content
+  (#set! injection.language "typescript"))
+
+; -----------------------------------------------------------------------------
+; HSX
+(quasiquote
+  (quoter) @_name
+  (#eq? @_name "hsx")
+  (quasiquote_body) @injection.content
+  (#set! injection.language "html"))
+
+; -----------------------------------------------------------------------------
+; Inline JSON from aeson
+(quasiquote
+  (quoter) @_name
+  (#eq? @_name "aesonQQ")
+  (quasiquote_body) @injection.content
+  (#set! injection.language "json"))
+
+; -----------------------------------------------------------------------------
+; SQL
+; postgresql-simple
+(quasiquote
+  (quoter) @injection.language
+  (#eq? @injection.language "sql")
+  (quasiquote_body) @injection.content)
+
+(quasiquote
+  (quoter) @_name
+  (#any-of? @_name "persistUpperCase" "persistLowerCase" "persistWith")
+  (quasiquote_body) @injection.content
+  (#set! injection.language "haskell_persistent"))
diff --git a/pack/ant/start/nvim-treesitter/queries/haskell/locals.scm b/pack/ant/start/nvim-treesitter/queries/haskell/locals.scm
new file mode 100644
index 0000000..7177f9d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/haskell/locals.scm
@@ -0,0 +1,9 @@
+(signature
+  name: (variable)) @local.definition
+
+(function
+  name: (variable)) @local.definition
+
+(pattern/variable) @local.definition
+
+(expression/variable) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/haskell_persistent/folds.scm b/pack/ant/start/nvim-treesitter/queries/haskell_persistent/folds.scm
new file mode 100644
index 0000000..dd34d9f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/haskell_persistent/folds.scm
@@ -0,0 +1 @@
+(entity_definition) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/haskell_persistent/highlights.scm b/pack/ant/start/nvim-treesitter/queries/haskell_persistent/highlights.scm
new file mode 100644
index 0000000..22cbf5c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/haskell_persistent/highlights.scm
@@ -0,0 +1,38 @@
+; ----------------------------------------------------------------------------
+; Literals and comments
+(integer) @number
+
+(float) @number.float
+
+(char) @character
+
+(string) @string
+
+(attribute_name) @attribute
+
+(attribute_exclamation_mark) @attribute
+
+(con_unit) @string.special.symbol ; unit, as in ()
+
+(comment) @comment @spell
+
+; ----------------------------------------------------------------------------
+; Keywords, operators, includes
+[
+  "Id"
+  "Primary"
+  "Foreign"
+  "deriving"
+] @keyword
+
+"=" @operator
+
+; ----------------------------------------------------------------------------
+; Functions and variables
+(variable) @variable
+
+; ----------------------------------------------------------------------------
+; Types
+(type) @type
+
+(constructor) @constructor
diff --git a/pack/ant/start/nvim-treesitter/queries/hcl/folds.scm b/pack/ant/start/nvim-treesitter/queries/hcl/folds.scm
new file mode 100644
index 0000000..e0c5313
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hcl/folds.scm
@@ -0,0 +1,6 @@
+[
+  (comment)
+  (block)
+  (heredoc_template)
+  (object)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/hcl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/hcl/highlights.scm
new file mode 100644
index 0000000..4fb7d1f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hcl/highlights.scm
@@ -0,0 +1,118 @@
+; highlights.scm
+[
+  "!"
+  "\*"
+  "/"
+  "%"
+  "\+"
+  "-"
+  ">"
+  ">="
+  "<"
+  "<="
+  "=="
+  "!="
+  "&&"
+  "||"
+] @operator
+
+[
+  "{"
+  "}"
+  "["
+  "]"
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "."
+  ".*"
+  ","
+  "[*]"
+] @punctuation.delimiter
+
+[
+  (ellipsis)
+  "\?"
+  "=>"
+] @punctuation.special
+
+[
+  ":"
+  "="
+] @none
+
+[
+  "for"
+  "endfor"
+  "in"
+] @keyword.repeat
+
+[
+  "if"
+  "else"
+  "endif"
+] @keyword.conditional
+
+[
+  (quoted_template_start) ; "
+  (quoted_template_end) ; "
+  (template_literal) ; non-interpolation/directive content
+] @string
+
+[
+  (heredoc_identifier) ; END
+  (heredoc_start) ; << or <<-
+] @punctuation.delimiter
+
+[
+  (template_interpolation_start) ; ${
+  (template_interpolation_end) ; }
+  (template_directive_start) ; %{
+  (template_directive_end) ; }
+  (strip_marker) ; ~
+] @punctuation.special
+
+(numeric_lit) @number
+
+(bool_lit) @boolean
+
+(null_lit) @constant
+
+(comment) @comment @spell
+
+(identifier) @variable
+
+(body
+  (block
+    (identifier) @keyword))
+
+(body
+  (block
+    (body
+      (block
+        (identifier) @type))))
+
+(function_call
+  (identifier) @function)
+
+(attribute
+  (identifier) @variable.member)
+
+; { key: val }
+;
+; highlight identifier keys as though they were block attributes
+(object_elem
+  key: (expression
+    (variable_expr
+      (identifier) @variable.member)))
+
+; var.foo, data.bar
+;
+; first element in get_attr is a variable.builtin or a reference to a variable.builtin
+(expression
+  (variable_expr
+    (identifier) @variable.builtin)
+  (get_attr
+    (identifier) @variable.member))
diff --git a/pack/ant/start/nvim-treesitter/queries/hcl/indents.scm b/pack/ant/start/nvim-treesitter/queries/hcl/indents.scm
new file mode 100644
index 0000000..1d7dc49
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hcl/indents.scm
@@ -0,0 +1,16 @@
+[
+  (block)
+  (object)
+  (tuple)
+  (function_call)
+] @indent.begin
+
+[
+  "]"
+  ")"
+  "}"
+] @indent.branch @indent.end
+
+(comment) @indent.auto
+
+(ERROR) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/hcl/injections.scm b/pack/ant/start/nvim-treesitter/queries/hcl/injections.scm
new file mode 100644
index 0000000..b68f4ca
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hcl/injections.scm
@@ -0,0 +1,7 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+(heredoc_template
+  (template_literal) @injection.content
+  (heredoc_identifier) @injection.language
+  (#downcase! @injection.language))
diff --git a/pack/ant/start/nvim-treesitter/queries/heex/folds.scm b/pack/ant/start/nvim-treesitter/queries/heex/folds.scm
new file mode 100644
index 0000000..88d4f17
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/heex/folds.scm
@@ -0,0 +1,6 @@
+; HEEx tags, components, and slots fold similar to HTML
+[
+  (component)
+  (tag)
+  (slot)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/heex/highlights.scm b/pack/ant/start/nvim-treesitter/queries/heex/highlights.scm
new file mode 100644
index 0000000..e2fb018
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/heex/highlights.scm
@@ -0,0 +1,54 @@
+; HEEx delimiters
+[
+  "%>"
+  "--%>"
+  "-->"
+  "/>"
+  "<!"
+  "<!--"
+  "<"
+  "<%!--"
+  "<%"
+  "<%#"
+  "<%%="
+  "<%="
+  "</"
+  "</:"
+  "<:"
+  ">"
+  "{"
+  "}"
+] @tag.delimiter
+
+; HEEx operators are highlighted as such
+"=" @operator
+
+; HEEx inherits the DOCTYPE tag from HTML
+(doctype) @constant
+
+; HEEx comments are highlighted as such
+(comment) @comment @spell
+
+; HEEx text content is treated as markup
+; (text) @none
+; HEEx tags and slots are highlighted as HTML
+[
+  (tag_name)
+  (slot_name)
+] @tag
+
+; HEEx attributes are highlighted as HTML attributes
+(attribute_name) @tag.attribute
+
+[
+  (attribute_value)
+  (quoted_attribute_value)
+] @string
+
+; HEEx components are highlighted as modules and function calls
+(component_name
+  [
+    (module) @type
+    (function) @function
+    "." @punctuation.delimiter
+  ])
diff --git a/pack/ant/start/nvim-treesitter/queries/heex/indents.scm b/pack/ant/start/nvim-treesitter/queries/heex/indents.scm
new file mode 100644
index 0000000..82a2f89
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/heex/indents.scm
@@ -0,0 +1,20 @@
+; HEEx tags, components, and slots indent like HTML
+[
+  (component)
+  (slot)
+  (tag)
+] @indent.begin
+
+; Dedent at the end of each tag, component, and slot
+[
+  (end_component)
+  (end_slot)
+  (end_tag)
+] @indent.branch @indent.dedent
+
+; Self-closing tags and components should not change
+; indentation level of sibling nodes
+[
+  (self_closing_component)
+  (self_closing_tag)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/heex/injections.scm b/pack/ant/start/nvim-treesitter/queries/heex/injections.scm
new file mode 100644
index 0000000..4f179ee
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/heex/injections.scm
@@ -0,0 +1,30 @@
+; directives are standalone tags like '<%= @x %>'
+;
+; partial_expression_values are elixir code that is part of an expression that
+; spans multiple directive nodes, so they must be combined. For example:
+;     <%= if true do %>
+;       <p>hello, tree-sitter!</p>
+;     <% end %>
+(directive
+  [
+    (partial_expression_value)
+    (ending_expression_value)
+  ] @injection.content
+  (#set! injection.language "elixir")
+  (#set! injection.include-children)
+  (#set! injection.combined))
+
+; Regular expression_values do not need to be combined
+((directive
+  (expression_value) @injection.content)
+  (#set! injection.language "elixir"))
+
+; expressions live within HTML tags, and do not need to be combined
+;     <link href={ Routes.static_path(..) } />
+(expression
+  (expression_value) @injection.content
+  (#set! injection.language "elixir"))
+
+; HEEx comments
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/heex/locals.scm b/pack/ant/start/nvim-treesitter/queries/heex/locals.scm
new file mode 100644
index 0000000..cfa239e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/heex/locals.scm
@@ -0,0 +1,13 @@
+; HEEx tags, components, and slots are references
+[
+  (component_name)
+  (slot_name)
+  (tag_name)
+] @local.reference
+
+; Create a new scope within each HEEx tag, component, and slot
+[
+  (component)
+  (slot)
+  (tag)
+] @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/helm/folds.scm b/pack/ant/start/nvim-treesitter/queries/helm/folds.scm
new file mode 100644
index 0000000..6ffb4b7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/helm/folds.scm
@@ -0,0 +1 @@
+; inherits: gotmpl
diff --git a/pack/ant/start/nvim-treesitter/queries/helm/highlights.scm b/pack/ant/start/nvim-treesitter/queries/helm/highlights.scm
new file mode 100644
index 0000000..f9af8a5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/helm/highlights.scm
@@ -0,0 +1,50 @@
+; inherits: gotmpl
+
+; For the reasoning concerning the priorities, see gotmpl highlights.
+;
+; Builtin functions
+(function_call
+  function: (identifier) @function.builtin
+  (#set! priority 110)
+  (#any-of? @function.builtin
+    "and" "or" "not" "eq" "ne" "lt" "le" "gt" "ge" "default" "required" "empty" "fail" "coalesce"
+    "ternary" "print" "println" "printf" "trim" "trimAll" "trimPrefix" "trimSuffix" "lower" "upper"
+    "title" "untitle" "repeat" "substr" "nospace" "trunc" "abbrev" "abbrevboth" "initials"
+    "randAlphaNum" "randAlpha" "randNumeric" "randAscii" "wrap" "wrapWith" "contains" "hasPrefix"
+    "hasSuffix" "quote" "squote" "cat" "indent" "nindent" "replace" "plural" "snakecase" "camelcase"
+    "kebabcase" "swapcase" "shuffle" "toStrings" "toDecimal" "toJson" "mustToJson" "toPrettyJson"
+    "mustToPrettyJson" "toRawJson" "mustToRawJson" "fromYaml" "fromJson" "fromJsonArray"
+    "fromYamlArray" "toYaml" "regexMatch" "mustRegexMatch" "regexFindAll" "mustRegexFinDall"
+    "regexFind" "mustRegexFind" "regexReplaceAll" "mustRegexReplaceAll" "regexReplaceAllLiteral"
+    "mustRegexReplaceAllLiteral" "regexSplit" "mustRegexSplit" "sha1sum" "sha256sum" "adler32sum"
+    "htpasswd" "derivePassword" "genPrivateKey" "buildCustomCert" "genCA" "genSelfSignedCert"
+    "genSignedCert" "encryptAES" "decryptAES" "now" "ago" "date" "dateInZone" "duration"
+    "durationRound" "unixEpoch" "dateModify" "mustDateModify" "htmlDate" "htmlDateInZone" "toDate"
+    "mustToDate" "dict" "get" "set" "unset" "hasKey" "pluck" "dig" "merge" "mustMerge"
+    "mergeOverwrite" "mustMergeOverwrite" "keys" "pick" "omit" "values" "deepCopy" "mustDeepCopy"
+    "b64enc" "b64dec" "b32enc" "b32dec" "list" "first" "mustFirst" "rest" "mustRest" "last"
+    "mustLast" "initial" "mustInitial" "append" "mustAppend" "prepend" "mustPrepend" "concat"
+    "reverse" "mustReverse" "uniq" "mustUniq" "without" "mustWithout" "has" "mustHas" "compact"
+    "mustCompact" "index" "slice" "mustSlice" "until" "untilStep" "seq" "add" "add1" "sub" "div"
+    "mod" "mul" "max" "min" "len" "addf" "add1f" "subf" "divf" "mulf" "maxf" "minf" "floor" "ceil"
+    "round" "getHostByName" "base" "dir" "clean" "ext" "isAbs" "kindOf" "kindIs" "typeOf" "typeIs"
+    "typeIsLike" "deepequal" "semver" "semverCompare" "urlParse" "urlJoin" "urlquery" "lookup"
+    "include")
+  )
+
+; {{ .Values.test }}
+(selector_expression
+  operand: (field
+    name: (identifier) @constant.builtin
+    (#set! priority 110)
+    (#any-of? @constant.builtin
+      "Values" "Chart" "Release" "Capabilities" "Files" "Subcharts" "Template"))
+  (field_identifier))
+
+; {{ $.Values.test }}
+(selector_expression
+  operand: (variable)
+  field: (field_identifier) @constant.builtin
+  (#set! priority 110)
+  (#any-of? @constant.builtin
+    "Values" "Chart" "Release" "Capabilities" "Files" "Subcharts" "Template"))
diff --git a/pack/ant/start/nvim-treesitter/queries/helm/injections.scm b/pack/ant/start/nvim-treesitter/queries/helm/injections.scm
new file mode 100644
index 0000000..2adf874
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/helm/injections.scm
@@ -0,0 +1,36 @@
+; inherits: gotmpl
+
+((text) @injection.content
+  (#set! injection.language "yaml")
+  (#set! injection.combined))
+
+; {{ regexFind "[a-zA-Z][1-9]" "abcd1234" }}
+(function_call
+  function: (identifier) @_function
+  arguments: (argument_list
+    .
+    (interpreted_string_literal) @injection.content)
+  (#any-of? @_function
+    "regexMatch" "mustRegexMatch" "regexFindAll" "mustRegexFinDall" "regexFind" "mustRegexFind"
+    "regexReplaceAll" "mustRegexReplaceAll" "regexReplaceAllLiteral" "mustRegexReplaceAllLiteral"
+    "regexSplit" "mustRegexSplit")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.language "regex"))
+
+(function_call
+  function: (identifier) @_function
+  arguments: (argument_list
+    .
+    (interpreted_string_literal) @injection.content)
+  (#any-of? @_function "fromYaml" "fromYamlArray")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.language "yaml"))
+
+(function_call
+  function: (identifier) @_function
+  arguments: (argument_list
+    .
+    (interpreted_string_literal) @injection.content)
+  (#any-of? @_function "fromJson" "fromJsonArray")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.language "json"))
diff --git a/pack/ant/start/nvim-treesitter/queries/helm/locals.scm b/pack/ant/start/nvim-treesitter/queries/helm/locals.scm
new file mode 100644
index 0000000..6ffb4b7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/helm/locals.scm
@@ -0,0 +1 @@
+; inherits: gotmpl
diff --git a/pack/ant/start/nvim-treesitter/queries/hjson/folds.scm b/pack/ant/start/nvim-treesitter/queries/hjson/folds.scm
new file mode 100644
index 0000000..4126921
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hjson/folds.scm
@@ -0,0 +1 @@
+; inherits: json
diff --git a/pack/ant/start/nvim-treesitter/queries/hjson/highlights.scm b/pack/ant/start/nvim-treesitter/queries/hjson/highlights.scm
new file mode 100644
index 0000000..8333d8f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hjson/highlights.scm
@@ -0,0 +1,28 @@
+(true) @boolean
+
+(false) @boolean
+
+(null) @constant.builtin
+
+(number) @number
+
+(pair
+  key: (string) @label)
+
+(pair
+  value: (string) @string)
+
+(array
+  (string) @string)
+
+;  (string_content (escape_sequence) @string.escape)
+;  "," @punctuation.delimiter
+"[" @punctuation.bracket
+
+"]" @punctuation.bracket
+
+"{" @punctuation.bracket
+
+"}" @punctuation.bracket
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/hjson/indents.scm b/pack/ant/start/nvim-treesitter/queries/hjson/indents.scm
new file mode 100644
index 0000000..3b01ca9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hjson/indents.scm
@@ -0,0 +1,3 @@
+; inherits: json
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/hjson/injections.scm b/pack/ant/start/nvim-treesitter/queries/hjson/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hjson/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/hjson/locals.scm b/pack/ant/start/nvim-treesitter/queries/hjson/locals.scm
new file mode 100644
index 0000000..4126921
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hjson/locals.scm
@@ -0,0 +1 @@
+; inherits: json
diff --git a/pack/ant/start/nvim-treesitter/queries/hlsl/folds.scm b/pack/ant/start/nvim-treesitter/queries/hlsl/folds.scm
new file mode 100644
index 0000000..b617fdc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hlsl/folds.scm
@@ -0,0 +1 @@
+; inherits: cpp
diff --git a/pack/ant/start/nvim-treesitter/queries/hlsl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/hlsl/highlights.scm
new file mode 100644
index 0000000..839d8d7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hlsl/highlights.scm
@@ -0,0 +1,38 @@
+; inherits: cpp
+
+[
+  "in"
+  "out"
+  "inout"
+  "uniform"
+  "shared"
+  "groupshared"
+  "discard"
+  "cbuffer"
+  "row_major"
+  "column_major"
+  "globallycoherent"
+  "centroid"
+  "noperspective"
+  "nointerpolation"
+  "sample"
+  "linear"
+  "snorm"
+  "unorm"
+  "point"
+  "line"
+  "triangleadj"
+  "lineadj"
+  "triangle"
+] @keyword.modifier
+
+((identifier) @variable.builtin
+  (#lua-match? @variable.builtin "^SV_"))
+
+(hlsl_attribute) @attribute
+
+(hlsl_attribute
+  [
+    "["
+    "]"
+  ] @attribute)
diff --git a/pack/ant/start/nvim-treesitter/queries/hlsl/indents.scm b/pack/ant/start/nvim-treesitter/queries/hlsl/indents.scm
new file mode 100644
index 0000000..b617fdc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hlsl/indents.scm
@@ -0,0 +1 @@
+; inherits: cpp
diff --git a/pack/ant/start/nvim-treesitter/queries/hlsl/injections.scm b/pack/ant/start/nvim-treesitter/queries/hlsl/injections.scm
new file mode 100644
index 0000000..c2fca71
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hlsl/injections.scm
@@ -0,0 +1,5 @@
+((preproc_arg) @injection.content
+  (#set! injection.language "hlsl"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/hlsl/locals.scm b/pack/ant/start/nvim-treesitter/queries/hlsl/locals.scm
new file mode 100644
index 0000000..b617fdc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hlsl/locals.scm
@@ -0,0 +1 @@
+; inherits: cpp
diff --git a/pack/ant/start/nvim-treesitter/queries/hlsplaylist/highlights.scm b/pack/ant/start/nvim-treesitter/queries/hlsplaylist/highlights.scm
new file mode 100644
index 0000000..9852aed
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hlsplaylist/highlights.scm
@@ -0,0 +1,41 @@
+; Comments
+(comment) @comment @spell
+
+; General
+(uri) @string.special.url
+
+(tag_name) @keyword
+
+(attribute_name) @attribute
+
+[
+  (dec)
+  (hex)
+  (resolution)
+  (range)
+] @number
+
+(float) @number.float
+
+(string) @string
+
+[
+  (enum)
+  (date_time_msec)
+] @string.special
+
+(title) @markup.heading
+
+; Literals
+[
+  "="
+  "x"
+  "@"
+] @operator
+
+[
+  ":"
+  ","
+] @punctuation.delimiter
+
+"#" @punctuation.special
diff --git a/pack/ant/start/nvim-treesitter/queries/hlsplaylist/injections.scm b/pack/ant/start/nvim-treesitter/queries/hlsplaylist/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hlsplaylist/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/hocon/folds.scm b/pack/ant/start/nvim-treesitter/queries/hocon/folds.scm
new file mode 100644
index 0000000..cc8a231
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hocon/folds.scm
@@ -0,0 +1,4 @@
+[
+  (object)
+  (array)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/hocon/highlights.scm b/pack/ant/start/nvim-treesitter/queries/hocon/highlights.scm
new file mode 100644
index 0000000..0eb94e6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hocon/highlights.scm
@@ -0,0 +1,65 @@
+(comment) @comment @spell
+
+(null) @constant.builtin
+
+[
+  (true)
+  (false)
+] @boolean
+
+(number) @number
+
+(unit) @keyword
+
+(string) @string
+
+(multiline_string) @string
+
+(string
+  (escape_sequence) @string.escape)
+
+(unquoted_string) @string
+
+[
+  "url"
+  "file"
+  "classpath"
+  "required"
+] @keyword
+
+(include
+  "include" @keyword.import)
+
+(substitution
+  [
+    "${"
+    "${?"
+    "}"
+  ] @punctuation.special)
+
+(substitution
+  (_) @variable.member)
+
+(path
+  (_) @variable.member)
+
+(value
+  [
+    ":"
+    "="
+    "+="
+  ] @operator)
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+"," @punctuation.delimiter
+
+(unquoted_path
+  "." @punctuation.delimiter)
diff --git a/pack/ant/start/nvim-treesitter/queries/hocon/injections.scm b/pack/ant/start/nvim-treesitter/queries/hocon/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hocon/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/hoon/folds.scm b/pack/ant/start/nvim-treesitter/queries/hoon/folds.scm
new file mode 100644
index 0000000..cfb4b6d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hoon/folds.scm
@@ -0,0 +1,6 @@
+[
+  (bartisTall)
+  (luslusTall)
+  (lusbucTall)
+  (barcenTall)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/hoon/highlights.scm b/pack/ant/start/nvim-treesitter/queries/hoon/highlights.scm
new file mode 100644
index 0000000..90ac872
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hoon/highlights.scm
@@ -0,0 +1,35 @@
+(number) @number
+
+(string) @string
+
+[
+  "("
+  ")"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  (coreTerminator)
+  (seriesTerminator)
+] @punctuation.delimiter
+
+(rune) @operator
+
+(term) @constant
+
+(aura) @constant.builtin
+
+(lineComment) @comment
+
+(boolean) @constant.builtin
+
+(date) @string.special
+
+(mold) @string.special.symbol
+
+(specialIndex) @number
+
+(lark) @operator
+
+(fullContext) @string.special.symbol
diff --git a/pack/ant/start/nvim-treesitter/queries/hoon/injections.scm b/pack/ant/start/nvim-treesitter/queries/hoon/injections.scm
new file mode 100644
index 0000000..a004ba0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hoon/injections.scm
@@ -0,0 +1,2 @@
+((lineComment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/hoon/locals.scm b/pack/ant/start/nvim-treesitter/queries/hoon/locals.scm
new file mode 100644
index 0000000..fd7cc02
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hoon/locals.scm
@@ -0,0 +1,4 @@
+(tisfasTall
+  name: (name) @local.definition.var)
+
+(name) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/html/folds.scm b/pack/ant/start/nvim-treesitter/queries/html/folds.scm
new file mode 100644
index 0000000..69b57ea
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/html/folds.scm
@@ -0,0 +1,5 @@
+[
+  (element)
+  (style_element)
+  (script_element)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/html/highlights.scm b/pack/ant/start/nvim-treesitter/queries/html/highlights.scm
new file mode 100644
index 0000000..4e2371d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/html/highlights.scm
@@ -0,0 +1,7 @@
+; inherits: html_tags
+
+(doctype) @constant
+
+"<!" @tag.delimiter
+
+(entity) @character.special
diff --git a/pack/ant/start/nvim-treesitter/queries/html/indents.scm b/pack/ant/start/nvim-treesitter/queries/html/indents.scm
new file mode 100644
index 0000000..448e942
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/html/indents.scm
@@ -0,0 +1 @@
+; inherits: html_tags
diff --git a/pack/ant/start/nvim-treesitter/queries/html/injections.scm b/pack/ant/start/nvim-treesitter/queries/html/injections.scm
new file mode 100644
index 0000000..adb067d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/html/injections.scm
@@ -0,0 +1,26 @@
+; inherits html_tags
+(element
+  (start_tag
+    (tag_name) @_py_script)
+  (text) @injection.content
+  (#any-of? @_py_script "py-script" "py-repl")
+  (#set! injection.language "python"))
+
+(script_element
+  (start_tag
+    (attribute
+      (attribute_name) @_attr
+      (quoted_attribute_value
+        (attribute_value) @_type)))
+  (raw_text) @injection.content
+  (#eq? @_attr "type")
+  ; not adding type="py" here as it's handled by html_tags
+  (#any-of? @_type "pyscript" "py-script")
+  (#set! injection.language "python"))
+
+(element
+  (start_tag
+    (tag_name) @_py_config)
+  (text) @injection.content
+  (#eq? @_py_config "py-config")
+  (#set! injection.language "toml"))
diff --git a/pack/ant/start/nvim-treesitter/queries/html/locals.scm b/pack/ant/start/nvim-treesitter/queries/html/locals.scm
new file mode 100644
index 0000000..4e3325d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/html/locals.scm
@@ -0,0 +1 @@
+(element) @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/html_tags/highlights.scm b/pack/ant/start/nvim-treesitter/queries/html_tags/highlights.scm
new file mode 100644
index 0000000..9eaf813
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/html_tags/highlights.scm
@@ -0,0 +1,106 @@
+(tag_name) @tag
+
+; (erroneous_end_tag_name) @error ; we do not lint syntax errors
+(comment) @comment @spell
+
+(attribute_name) @tag.attribute
+
+((attribute
+  (quoted_attribute_value) @string)
+  (#set! priority 99))
+
+(text) @none @spell
+
+((element
+  (start_tag
+    (tag_name) @_tag)
+  (text) @markup.heading)
+  (#eq? @_tag "title"))
+
+((element
+  (start_tag
+    (tag_name) @_tag)
+  (text) @markup.heading.1)
+  (#eq? @_tag "h1"))
+
+((element
+  (start_tag
+    (tag_name) @_tag)
+  (text) @markup.heading.2)
+  (#eq? @_tag "h2"))
+
+((element
+  (start_tag
+    (tag_name) @_tag)
+  (text) @markup.heading.3)
+  (#eq? @_tag "h3"))
+
+((element
+  (start_tag
+    (tag_name) @_tag)
+  (text) @markup.heading.4)
+  (#eq? @_tag "h4"))
+
+((element
+  (start_tag
+    (tag_name) @_tag)
+  (text) @markup.heading.5)
+  (#eq? @_tag "h5"))
+
+((element
+  (start_tag
+    (tag_name) @_tag)
+  (text) @markup.heading.6)
+  (#eq? @_tag "h6"))
+
+((element
+  (start_tag
+    (tag_name) @_tag)
+  (text) @markup.strong)
+  (#any-of? @_tag "strong" "b"))
+
+((element
+  (start_tag
+    (tag_name) @_tag)
+  (text) @markup.italic)
+  (#any-of? @_tag "em" "i"))
+
+((element
+  (start_tag
+    (tag_name) @_tag)
+  (text) @markup.strikethrough)
+  (#any-of? @_tag "s" "del"))
+
+((element
+  (start_tag
+    (tag_name) @_tag)
+  (text) @markup.underline)
+  (#eq? @_tag "u"))
+
+((element
+  (start_tag
+    (tag_name) @_tag)
+  (text) @markup.raw)
+  (#any-of? @_tag "code" "kbd"))
+
+((element
+  (start_tag
+    (tag_name) @_tag)
+  (text) @markup.link.label)
+  (#eq? @_tag "a"))
+
+((attribute
+  (attribute_name) @_attr
+  (quoted_attribute_value
+    (attribute_value) @string.special.url))
+  (#any-of? @_attr "href" "src")
+  (#set! @string.special.url url @string.special.url))
+
+[
+  "<"
+  ">"
+  "</"
+  "/>"
+] @tag.delimiter
+
+"=" @operator
diff --git a/pack/ant/start/nvim-treesitter/queries/html_tags/indents.scm b/pack/ant/start/nvim-treesitter/queries/html_tags/indents.scm
new file mode 100644
index 0000000..dc57c33
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/html_tags/indents.scm
@@ -0,0 +1,37 @@
+((element
+  (start_tag
+    (tag_name) @_not_void_element))
+  (#not-any-of? @_not_void_element
+    "area" "base" "basefont" "bgsound" "br" "col" "command" "embed" "frame" "hr" "image" "img"
+    "input" "isindex" "keygen" "link" "menuitem" "meta" "nextid" "param" "source" "track" "wbr")) @indent.begin
+
+(element
+  (self_closing_tag)) @indent.begin
+
+((start_tag
+  (tag_name) @_void_element)
+  (#any-of? @_void_element
+    "area" "base" "basefont" "bgsound" "br" "col" "command" "embed" "frame" "hr" "image" "img"
+    "input" "isindex" "keygen" "link" "menuitem" "meta" "nextid" "param" "source" "track" "wbr")) @indent.begin
+
+; These are the nodes that will be captured when we do `normal o`
+; But last element has already been ended, so capturing this
+; to mark end of last element
+(element
+  (end_tag
+    ">" @indent.end))
+
+(element
+  (self_closing_tag
+    "/>" @indent.end))
+
+; Script/style elements aren't indented, so only branch the end tag of other elements
+(element
+  (end_tag) @indent.branch)
+
+[
+  ">"
+  "/>"
+] @indent.branch
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/html_tags/injections.scm b/pack/ant/start/nvim-treesitter/queries/html_tags/injections.scm
new file mode 100644
index 0000000..5b78e37
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/html_tags/injections.scm
@@ -0,0 +1,91 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; <style>...</style>
+; <style blocking> ...</style>
+; Add "lang" to predicate check so that vue/svelte can inherit this
+; without having this element being captured twice
+((style_element
+  (start_tag) @_no_type_lang
+  (raw_text) @injection.content)
+  (#not-lua-match? @_no_type_lang "%slang%s*=")
+  (#not-lua-match? @_no_type_lang "%stype%s*=")
+  (#set! injection.language "css"))
+
+((style_element
+  (start_tag
+    (attribute
+      (attribute_name) @_type
+      (quoted_attribute_value
+        (attribute_value) @_css)))
+  (raw_text) @injection.content)
+  (#eq? @_type "type")
+  (#eq? @_css "text/css")
+  (#set! injection.language "css"))
+
+; <script>...</script>
+; <script defer>...</script>
+((script_element
+  (start_tag) @_no_type_lang
+  (raw_text) @injection.content)
+  (#not-lua-match? @_no_type_lang "%slang%s*=")
+  (#not-lua-match? @_no_type_lang "%stype%s*=")
+  (#set! injection.language "javascript"))
+
+; <script type="mimetype-or-well-known-script-type">
+(script_element
+  (start_tag
+    (attribute
+      (attribute_name) @_attr
+      (#eq? @_attr "type")
+      (quoted_attribute_value
+        (attribute_value) @_type)))
+  (raw_text) @injection.content
+  (#set-lang-from-mimetype! @_type))
+
+; <a style="/* css */">
+((attribute
+  (attribute_name) @_attr
+  (quoted_attribute_value
+    (attribute_value) @injection.content))
+  (#eq? @_attr "style")
+  (#set! injection.language "css"))
+
+; lit-html style template interpolation
+; <a @click=${e => console.log(e)}>
+; <a @click="${e => console.log(e)}">
+((attribute
+  (quoted_attribute_value
+    (attribute_value) @injection.content))
+  (#lua-match? @injection.content "%${")
+  (#offset! @injection.content 0 2 0 -1)
+  (#set! injection.language "javascript"))
+
+((attribute
+  (attribute_value) @injection.content)
+  (#lua-match? @injection.content "%${")
+  (#offset! @injection.content 0 2 0 -2)
+  (#set! injection.language "javascript"))
+
+; <input pattern="[0-9]"> or <input pattern=[0-9]>
+(element
+  (_
+    (tag_name) @_tagname
+    (#eq? @_tagname "input")
+    (attribute
+      (attribute_name) @_attr
+      [
+        (quoted_attribute_value
+          (attribute_value) @injection.content)
+        (attribute_value) @injection.content
+      ]
+      (#eq? @_attr "pattern"))
+    (#set! injection.language "regex")))
+
+; <input type="checkbox" onchange="this.closest('form').elements.output.value = this.checked">
+(attribute
+  (attribute_name) @_name
+  (#lua-match? @_name "^on[a-z]+$")
+  (quoted_attribute_value
+    (attribute_value) @injection.content)
+  (#set! injection.language "javascript"))
diff --git a/pack/ant/start/nvim-treesitter/queries/htmldjango/folds.scm b/pack/ant/start/nvim-treesitter/queries/htmldjango/folds.scm
new file mode 100644
index 0000000..5e8f17c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/htmldjango/folds.scm
@@ -0,0 +1,4 @@
+[
+  (paired_statement)
+  (paired_comment)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/htmldjango/highlights.scm b/pack/ant/start/nvim-treesitter/queries/htmldjango/highlights.scm
new file mode 100644
index 0000000..3992b82
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/htmldjango/highlights.scm
@@ -0,0 +1,73 @@
+; adapted from https://github.com/interdependence/tree-sitter-htmldjango
+[
+  (unpaired_comment)
+  (paired_comment)
+] @comment @spell
+
+[
+  "{{"
+  "}}"
+  "{%"
+  "%}"
+  (end_paired_statement)
+] @punctuation.special
+
+(tag_name) @function
+
+((tag_name) @keyword.conditional
+  (#any-of? @keyword.conditional "if" "elif" "else" "endif"))
+
+((tag_name) @keyword.repeat
+  (#any-of? @keyword.repeat "for" "endfor"))
+
+(variable_name) @variable
+
+(unpaired_statement
+  (tag_name)
+  (variable
+    (variable_name) @variable.parameter)
+  .
+  "="
+  .
+  (_))
+
+(filter_name) @function.method
+
+(filter_argument) @variable.parameter
+
+(keyword) @keyword
+
+[
+  "|"
+  "="
+  (operator)
+] @operator
+
+(keyword_operator) @keyword.operator
+
+(string) @string
+
+(filter
+  [
+    "'"
+    "\""
+  ]
+  .
+  (filter_argument) @string)
+
+(number) @number
+
+((filter
+  (filter_argument) @number)
+  (#lua-match? @number "^%d+$"))
+
+(boolean) @boolean
+
+((filter
+  (filter_argument) @boolean)
+  (#any-of? @boolean "True" "False"))
+
+[
+  ":"
+  ","
+] @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/htmldjango/indents.scm b/pack/ant/start/nvim-treesitter/queries/htmldjango/indents.scm
new file mode 100644
index 0000000..d671f04
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/htmldjango/indents.scm
@@ -0,0 +1,5 @@
+(paired_statement) @indent.begin
+
+(end_paired_statement) @indent.end
+
+(branch_statement) @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/htmldjango/injections.scm b/pack/ant/start/nvim-treesitter/queries/htmldjango/injections.scm
new file mode 100644
index 0000000..2d3bdb6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/htmldjango/injections.scm
@@ -0,0 +1,9 @@
+([
+  (paired_comment)
+  (unpaired_comment)
+] @injection.content
+  (#set! injection.language "comment"))
+
+((content) @injection.content
+  (#set! injection.language "html")
+  (#set! injection.combined))
diff --git a/pack/ant/start/nvim-treesitter/queries/http/highlights.scm b/pack/ant/start/nvim-treesitter/queries/http/highlights.scm
new file mode 100644
index 0000000..76d6277
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/http/highlights.scm
@@ -0,0 +1,52 @@
+; Methods
+(method) @function.method
+
+; Headers
+(header
+  name: (_) @constant)
+
+; Variables
+(variable_declaration
+  name: (identifier) @variable)
+
+; Operators
+(comment
+  "=" @operator)
+
+(variable_declaration
+  "=" @operator)
+
+; keywords
+(comment
+  "@" @keyword
+  name: (_) @keyword)
+
+; Literals
+(request
+  url: (_) @string.special.url)
+
+(http_version) @constant
+
+; Response
+(status_code) @number
+
+(status_text) @string
+
+; Punctuation
+[
+  "{{"
+  "}}"
+] @punctuation.bracket
+
+(header
+  ":" @punctuation.delimiter)
+
+; external JSON body
+(external_body
+  path: (_) @string.special.path)
+
+; Comments
+[
+  (comment)
+  (request_separator)
+] @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/http/injections.scm b/pack/ant/start/nvim-treesitter/queries/http/injections.scm
new file mode 100644
index 0000000..f0e0865
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/http/injections.scm
@@ -0,0 +1,24 @@
+; Comments
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; Body
+((json_body) @injection.content
+  (#set! injection.language "json"))
+
+((xml_body) @injection.content
+  (#set! injection.language "xml"))
+
+((graphql_data) @injection.content
+  (#set! injection.language "graphql"))
+
+; Script (default to javascript)
+((comment
+  name: (_) @_name
+  (#eq? @_name "lang")
+  value: (_) @injection.language)?
+  .
+  (_
+    (script) @injection.content
+    (#offset! @injection.content 0 2 0 -2))
+  (#set! injection.language "javascript"))
diff --git a/pack/ant/start/nvim-treesitter/queries/hurl/folds.scm b/pack/ant/start/nvim-treesitter/queries/hurl/folds.scm
new file mode 100644
index 0000000..a0edfa9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hurl/folds.scm
@@ -0,0 +1,19 @@
+; fold.scm
+[
+  (comment)
+  (entry)
+  (request)
+  (response)
+  (header)
+  (request_section)
+  (body)
+  (response_section)
+  (multipart_form_data_section)
+  (cookies_section)
+  (captures_section)
+  (asserts_section)
+  (options_section)
+  (basic_auth_section)
+  (json_object)
+  (json_array)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/hurl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/hurl/highlights.scm
new file mode 100644
index 0000000..70b2209
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hurl/highlights.scm
@@ -0,0 +1,148 @@
+; highlights.scm
+[
+  (key_string)
+  (json_key_string)
+] @property
+
+[
+  "[QueryStringParams]"
+  "[FormParams]"
+  "[MultipartFormData]"
+  "[Cookies]"
+  "[Captures]"
+  "[Asserts]"
+  "[Options]"
+  "[BasicAuth]"
+] @module
+
+[
+  "\\"
+  (regex_escaped_char)
+  (quoted_string_escaped_char)
+  (key_string_escaped_char)
+  (value_string_escaped_char)
+  (oneline_string_escaped_char)
+  (multiline_string_escaped_char)
+  (filename_escaped_char)
+  (json_string_escaped_char)
+] @string.escape
+
+[
+  "status"
+  "url"
+  "header"
+  "cookie"
+  "body"
+  "xpath"
+  "jsonpath"
+  "regex"
+  "variable"
+  "duration"
+  "sha256"
+  "md5"
+  "bytes"
+] @function.builtin
+
+[
+  "null"
+  "cacert"
+  "compressed"
+  "location"
+  "insecure"
+  "path-as-is"
+  "proxy"
+  "max-redirs"
+  "retry"
+  "retry-interval"
+  "retry-max-count"
+  "verbose"
+  "very-verbose"
+] @constant.builtin
+
+(variable_option
+  "variable" @constant.builtin)
+
+(boolean) @boolean
+
+(variable_name) @variable
+
+[
+  "not"
+  "equals"
+  "notEquals"
+  "greaterThan"
+  "greaterThanOrEquals"
+  "lessThan"
+  "lessThanOrEquals"
+  "startsWith"
+  "endsWith"
+  "contains"
+  "matches"
+  "exists"
+  "includes"
+  "isInteger"
+  "isFloat"
+  "isBoolean"
+  "isString"
+  "isCollection"
+] @keyword.operator
+
+[
+  "=="
+  "!="
+  ">"
+  ">="
+  "<"
+  "<="
+] @operator
+
+[
+  (integer)
+  (status)
+] @number
+
+[
+  (float)
+  (json_number)
+] @number.float
+
+[
+  ":"
+  ","
+] @punctuation.delimiter
+
+[
+  "["
+  "]"
+  "{"
+  "}"
+  "{{"
+  "}}"
+] @punctuation.bracket
+
+[
+  (value_string)
+  (quoted_string)
+  (json_string)
+] @string
+
+[
+  "base64,"
+  "hex,"
+  (version)
+] @string.special
+
+[
+  "file,"
+  (file_value)
+] @string.special.path
+
+(regex) @string.regexp
+
+(multiline_string_type) @type
+
+(comment) @comment @spell
+
+(filter) @attribute
+
+(method) @type.builtin
diff --git a/pack/ant/start/nvim-treesitter/queries/hurl/indents.scm b/pack/ant/start/nvim-treesitter/queries/hurl/indents.scm
new file mode 100644
index 0000000..af6fdfa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hurl/indents.scm
@@ -0,0 +1,14 @@
+; indents.scm
+[
+  (json_object)
+  (json_array)
+] @indent.begin
+
+[
+  "}"
+  "]"
+] @indent.branch
+
+(xml_tag) @indent.begin
+
+(xml_close_tag) @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/hurl/injections.scm b/pack/ant/start/nvim-treesitter/queries/hurl/injections.scm
new file mode 100644
index 0000000..41abb38
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hurl/injections.scm
@@ -0,0 +1,15 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; injections.scm
+((json_value) @injection.content
+  (#set! injection.language "json"))
+
+((xml) @injection.content
+  (#set! injection.language "xml"))
+
+(multiline_string
+  (multiline_string_type) @_lang
+  (multiline_string_content) @injection.content
+  (#set-lang-from-info-string! @_lang)
+  (#set! injection.combined))
diff --git a/pack/ant/start/nvim-treesitter/queries/hyprlang/folds.scm b/pack/ant/start/nvim-treesitter/queries/hyprlang/folds.scm
new file mode 100644
index 0000000..911798f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hyprlang/folds.scm
@@ -0,0 +1 @@
+(section) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/hyprlang/highlights.scm b/pack/ant/start/nvim-treesitter/queries/hyprlang/highlights.scm
new file mode 100644
index 0000000..597edcb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hyprlang/highlights.scm
@@ -0,0 +1,58 @@
+(comment) @comment @spell
+
+[
+  "source"
+  "exec"
+  "exec-once"
+] @keyword
+
+(keyword
+  (name) @keyword)
+
+(assignment
+  (name) @property)
+
+(section
+  (name) @module)
+
+(section
+  device: (device_name) @type)
+
+(variable) @variable
+
+"$" @punctuation.special
+
+(boolean) @boolean
+
+(mod) @constant
+
+[
+  "rgb"
+  "rgba"
+] @function.builtin
+
+[
+  (number)
+  (legacy_hex)
+  (angle)
+  (hex)
+  (display)
+  (position)
+] @number
+
+"deg" @type
+
+"," @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "="
+  "-"
+  "+"
+] @operator
diff --git a/pack/ant/start/nvim-treesitter/queries/hyprlang/indents.scm b/pack/ant/start/nvim-treesitter/queries/hyprlang/indents.scm
new file mode 100644
index 0000000..731ae9a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hyprlang/indents.scm
@@ -0,0 +1,6 @@
+(section) @indent.begin
+
+(section
+  "}" @indent.end)
+
+"}" @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/hyprlang/injections.scm b/pack/ant/start/nvim-treesitter/queries/hyprlang/injections.scm
new file mode 100644
index 0000000..d38d499
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/hyprlang/injections.scm
@@ -0,0 +1,6 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+(exec
+  (string) @injection.content
+  (#set! injection.language "bash"))
diff --git a/pack/ant/start/nvim-treesitter/queries/idl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/idl/highlights.scm
new file mode 100644
index 0000000..de19372
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/idl/highlights.scm
@@ -0,0 +1,379 @@
+; https://neovim.io/doc/user/treesitter.html#treesitter-highlight-groups
+(comment) @comment @spell
+
+[
+  "enum"
+  "struct"
+  "union"
+  "bitmask"
+  "bitset"
+  "@annotation"
+  "exception"
+  "typedef"
+  "home"
+  "typeid"
+  "typeprefix"
+  (interface_kind)
+  (value_kind)
+  "component"
+  "porttype"
+  "connector"
+  "eventtype"
+  "valuetype"
+] @keyword.type
+
+(import_dcl
+  "import" @keyword.directive)
+
+[
+  "module"
+  "attribute"
+  "factory"
+  "manages"
+] @keyword
+
+[
+  "const"
+  "readonly"
+  "abstract"
+  "custom"
+  "supports"
+  "provides"
+  "uses"
+  "port"
+  "mirrorport"
+  "emits"
+  "publishes"
+  "consumes"
+  "primarykey"
+  "finder"
+] @keyword.modifier
+
+[
+  "switch"
+  "case"
+  "default"
+] @keyword.conditional
+
+[
+  "void"
+  (signed_short_int)
+  (signed_long_int)
+  (signed_longlong_int)
+  (unsigned_tiny_int)
+  (boolean_type)
+  (fixed_pt_const_type)
+  (octet_type)
+  (signed_tiny_int)
+  (unsigned_short_int)
+  (unsigned_long_int)
+  (unsigned_longlong_int)
+  (floating_pt_type)
+  (char_type)
+  (string_type)
+  (any_type)
+  (fixed_pt_type)
+  (sequence_type)
+  (map_type)
+  (object_type)
+  (value_base_type)
+  (wide_string_type)
+  (wide_char_type)
+] @type.builtin
+
+(escape_sequence) @string.escape
+
+(scoped_name) @type
+
+(boolean_literal) @boolean
+
+(integer_literal) @number
+
+[
+  (floating_pt_literal)
+  (fixed_pt_literal)
+] @number.float
+
+(char_literal) @character
+
+(wide_character_literal) @character
+
+(string_literal) @string
+
+(wide_string_literal) @string
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "<"
+  ">"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "-"
+  "*"
+  "+"
+  "="
+  "<<"
+  ">>"
+  "%"
+  "~"
+  "|"
+  "^"
+  "&"
+] @operator
+
+[
+  "::"
+  ";"
+  ":"
+  ","
+] @punctuation.delimiter
+
+(readonly_attr_declarator
+  (simple_declarator) @variable.member)
+
+(attr_declarator
+  (simple_declarator) @variable.member)
+
+(annotation_appl
+  "@" @attribute)
+
+(annotation_appl_custom_body
+  (scoped_name) @attribute)
+
+(op_dcl
+  (identifier) @function.method)
+
+(type_declarator
+  (simple_type_spec) @type)
+
+(type_declarator
+  (any_declarators) @variable.member)
+
+(param_dcl
+  (simple_declarator) @variable.parameter)
+
+(raises_expr
+  "raises" @keyword.exception
+  (scoped_name
+    (identifier) @type))
+
+(param_dcl
+  (param_attribute) @keyword.modifier)
+
+(preproc_call
+  directive: (preproc_directive) @keyword.directive
+  argument: (_)? @constant)
+
+(module_dcl
+  (identifier) @module)
+
+(struct_def
+  (identifier) @type
+  parent: (scoped_name)? @type)
+
+(enum_dcl
+  (enumerator
+    (identifier) @constant))
+
+(annotation_dcl
+  (identifier) @type)
+
+(struct_forward_dcl
+  (identifier) @type)
+
+(bitmask_dcl
+  (identifier) @type)
+
+(bitset_dcl
+  (identifier) @type
+  (scoped_name)* @type)
+
+(enum_dcl
+  (identifier) @type)
+
+(union_forward_dcl
+  (identifier) @type)
+
+(interface_forward_dcl
+  (identifier) @type)
+
+(interface_header
+  (identifier) @type)
+
+(interface_inheritance_spec
+  (interface_name) @type)
+
+(union_def
+  (identifier) @type
+  (switch_type_spec) @type)
+
+(except_dcl
+  (identifier) @type)
+
+(annotation_member_type) @type
+
+(bitfield
+  (bitfield_spec
+    "bitfield" @keyword.modifier
+    (positive_int_const) @number
+    (destination_type)? @type)
+  (identifier)* @variable.member)
+
+(bit_value) @constant
+
+(annotation_member
+  (annotation_member_type) @type
+  (simple_declarator) @property)
+
+(const_dcl
+  (const_type) @type
+  (identifier) @constant)
+
+(case_label
+  (const_expr) @constant)
+
+(simple_type_spec
+  (scoped_name
+    (identifier) @type))
+
+(annotation_appl_param
+  (identifier) @attribute)
+
+(home_header
+  (identifier) @type)
+
+(factory_dcl
+  (identifier) @type)
+
+(factory_param_dcl
+  "in" @keyword.modifier)
+
+(op_oneway_dcl
+  "oneway" @keyword.modifier
+  (identifier) @function.method)
+
+(in_param_dcl
+  "in" @keyword.modifier)
+
+(context_expr
+  "context" @keyword.modifier)
+
+(get_excep_expr
+  "getraises" @keyword.exception)
+
+(set_excep_expr
+  "setraises" @keyword.exception)
+
+(value_header
+  (identifier) @type)
+
+(value_abs_def
+  (identifier) @type)
+
+(value_forward_dcl
+  (identifier) @type)
+
+(value_box_def
+  (identifier) @type)
+
+(provides_dcl
+  (interface_type) @type
+  (identifier) @variable.member)
+
+(uses_dcl
+  (identifier) @variable.member)
+
+(component_forward_dcl
+  (identifier) @type)
+
+(component_header
+  (identifier) @type)
+
+(porttype_forward_dcl
+  (identifier) @type)
+
+(porttype_def
+  (identifier) @type)
+
+(port_dcl
+  (identifier) @variable.member)
+
+(connector_header
+  (identifier) @type)
+
+(emits_dcl
+  (identifier) @variable.member)
+
+(publishes_dcl
+  (identifier) @variable.member)
+
+(consumes_dcl
+  (identifier) @variable.member)
+
+(event_forward_dcl
+  (identifier) @type)
+
+(event_header
+  (identifier) @type)
+
+(event_abs_def
+  (identifier) @type)
+
+(template_module_dcl
+  (identifier) @type)
+
+(formal_parameter
+  (formal_parameter_type) @type
+  (identifier) @variable.member)
+
+(init_param_dcl
+  "in" @keyword.modifier
+  (simple_declarator) @variable.parameter)
+
+(finder_dcl
+  (identifier) @function.method)
+
+(member
+  identifier: (declarators) @variable.member)
+
+(factory_param_dcl
+  (simple_declarator) @variable.parameter)
+
+(element_spec
+  (declarator) @variable.member)
+
+(preproc_include
+  (keyword_include) @type
+  path: (_) @string)
+
+(system_lib_string
+  "<" @string
+  ">" @string)
+
+(extend_annotation_appl
+  "//@" @attribute
+  (annotation_appl_custom_body))
+
+(extend_annotation_appl
+  "//@" @attribute.builtin
+  (annotation_appl_builtin_body))
+
+[
+  (autoid_kind)
+  (extensibility_kind)
+  (verbatim_language)
+  (placement_kind)
+  (service_platform)
+  (try_construct_fail_action)
+  (data_representation_mask)
+] @constant
+
+(anno_name) @attribute.builtin
+
+(range_kind) @attribute.builtin
diff --git a/pack/ant/start/nvim-treesitter/queries/idl/indents.scm b/pack/ant/start/nvim-treesitter/queries/idl/indents.scm
new file mode 100644
index 0000000..2256fb7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/idl/indents.scm
@@ -0,0 +1,10 @@
+";" @indent.end
+
+"}" @indent.branch
+
+(definition) @indent.begin
+
+[
+  (preproc_define)
+  (preproc_include)
+] @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/idl/injections.scm b/pack/ant/start/nvim-treesitter/queries/idl/injections.scm
new file mode 100644
index 0000000..e4a286e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/idl/injections.scm
@@ -0,0 +1,8 @@
+((comment) @injection.content
+  (#lua-match? @injection.content "/[*\/][!*\/]<?[^a-zA-Z]")
+  (#set! injection.language "doxygen"))
+
+((comment) @injection.content
+  (#not-lua-match? @injection.content "/[*\/][!*\/]<?[^a-zA-Z]")
+  (#not-lua-match? @injection.content "//@[a-zA-Z]")
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/ini/folds.scm b/pack/ant/start/nvim-treesitter/queries/ini/folds.scm
new file mode 100644
index 0000000..911798f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ini/folds.scm
@@ -0,0 +1 @@
+(section) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/ini/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ini/highlights.scm
new file mode 100644
index 0000000..cbf958e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ini/highlights.scm
@@ -0,0 +1,16 @@
+(section_name
+  (text) @markup.heading)
+
+(comment) @comment @spell
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+"=" @operator
+
+(setting
+  (setting_name) @property)
+
+(setting_value) @string
diff --git a/pack/ant/start/nvim-treesitter/queries/ini/injections.scm b/pack/ant/start/nvim-treesitter/queries/ini/injections.scm
new file mode 100644
index 0000000..8bfeee2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ini/injections.scm
@@ -0,0 +1,3 @@
+((comment
+  (text) @injection.content)
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/inko/folds.scm b/pack/ant/start/nvim-treesitter/queries/inko/folds.scm
new file mode 100644
index 0000000..b0fbc06
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/inko/folds.scm
@@ -0,0 +1,17 @@
+[
+  (call)
+  (class)
+  (closure)
+  (define_case)
+  (define_constant)
+  (define_field)
+  (define_variable)
+  (external_function)
+  (if)
+  (import)+
+  (loop)
+  (match)
+  (method)
+  (trait)
+  (while)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/inko/highlights.scm b/pack/ant/start/nvim-treesitter/queries/inko/highlights.scm
new file mode 100644
index 0000000..589d746
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/inko/highlights.scm
@@ -0,0 +1,200 @@
+; Brackets and operators
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  ","
+  "->"
+  "."
+  ":"
+] @punctuation.delimiter
+
+[
+  "!="
+  "%"
+  "%="
+  "&"
+  "&="
+  "*"
+  "**"
+  "**="
+  "*="
+  "+"
+  "+="
+  "-"
+  "-="
+  "/"
+  "/="
+  "<"
+  "<<"
+  "<<="
+  "<="
+  "<="
+  "=="
+  ">"
+  ">="
+  ">="
+  ">>"
+  ">>="
+  ">>>"
+  ">>>="
+  "^"
+  "^="
+  "|"
+  "|="
+] @operator
+
+; Keywords
+[
+  "as"
+  "for"
+  "impl"
+  "let"
+  "mut"
+  "ref"
+  "uni"
+  "move"
+  "recover"
+] @keyword
+
+"fn" @keyword.function
+
+"import" @keyword.import
+
+[
+  "and"
+  "or"
+] @keyword.operator
+
+[
+  "class"
+  "trait"
+] @keyword.type
+
+[
+  "extern"
+  (modifier)
+  (visibility)
+] @keyword.modifier
+
+[
+  "loop"
+  "while"
+  (break)
+  (next)
+] @keyword.repeat
+
+"return" @keyword.return
+
+[
+  "throw"
+  "try"
+] @keyword.exception
+
+[
+  "case"
+  "else"
+  "if"
+  "match"
+] @keyword.conditional
+
+; Identifiers/variable references
+(identifier) @variable
+
+; Comments
+(line_comment) @comment @spell
+
+; Literals
+(self) @variable.builtin
+
+(nil) @constant.builtin
+
+[
+  (true)
+  (false)
+] @boolean
+
+(integer) @number
+
+(float) @number.float
+
+(string) @string
+
+(escape_sequence) @string.escape
+
+(interpolation
+  "${" @punctuation.special
+  "}" @punctuation.special) @none
+
+(constant) @constant
+
+; Patterns
+(integer_pattern) @number
+
+(string_pattern) @string
+
+(constant_pattern) @constant
+
+(boolean_pattern) @boolean
+
+; Types
+(generic_type
+  name: _ @type)
+
+(type) @type
+
+; Imports
+(extern_import
+  path: _ @string)
+
+(import
+  (path
+    (identifier) @module))
+
+; Classes
+(class
+  name: _ @type)
+
+(define_field
+  name: _ @variable.member)
+
+; Traits
+(trait
+  name: _ @type)
+
+; Implementations
+(implement_trait
+  class: _ @type)
+
+(reopen_class
+  name: _ @type)
+
+(bound
+  name: _ @type)
+
+; Methods
+(method
+  name: _ @function)
+
+(external_function
+  name: _ @function)
+
+(argument
+  name: _ @variable.parameter)
+
+(named_argument
+  name: _ @variable.parameter)
+
+(call
+  name: [
+    (name)
+    (constant)
+  ] @function)
+
+(field) @variable.member
diff --git a/pack/ant/start/nvim-treesitter/queries/inko/indents.scm b/pack/ant/start/nvim-treesitter/queries/inko/indents.scm
new file mode 100644
index 0000000..d2d9a57
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/inko/indents.scm
@@ -0,0 +1,41 @@
+[
+  (arguments)
+  (array)
+  (assign_field)
+  (assign_local)
+  (assign_receiver_field)
+  (binary)
+  (block)
+  (bounds)
+  (call)
+  (cast)
+  (class)
+  (class_pattern)
+  (compound_assign_field)
+  (compound_assign_local)
+  (compound_assign_receiver_field)
+  (define_constant)
+  (define_variable)
+  (grouped_expression)
+  (implement_trait)
+  (match)
+  (or_pattern)
+  (reopen_class)
+  (replace_field)
+  (replace_local)
+  (symbols)
+  (trait)
+  (tuple)
+  (tuple_pattern)
+  (type_arguments)
+] @indent.begin
+
+[
+  ")"
+  "]"
+  "}"
+] @indent.end @indent.branch
+
+(line_comment) @indent.auto
+
+(string) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/inko/injections.scm b/pack/ant/start/nvim-treesitter/queries/inko/injections.scm
new file mode 100644
index 0000000..36849c8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/inko/injections.scm
@@ -0,0 +1,2 @@
+((line_comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/inko/locals.scm b/pack/ant/start/nvim-treesitter/queries/inko/locals.scm
new file mode 100644
index 0000000..09450f5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/inko/locals.scm
@@ -0,0 +1,57 @@
+[
+  (method)
+  (block)
+] @local.scope
+
+(method
+  name: _ @local.definition.method)
+
+(external_function
+  name: _ @local.definition.function)
+
+(argument
+  name: _ @local.definition.parameter)
+
+(define_variable
+  name: _ @local.definition.var)
+
+(define_constant
+  name: _ @local.definition.constant)
+
+(define_field
+  name: _ @local.definition.field)
+
+(named_argument
+  name: _ @local.definition.parameter)
+
+(class
+  modifier: (modifier
+    "enum")
+  name: _ @local.definition.enum)
+
+(class
+  modifier: (modifier
+    "enum")
+  body: (class_body
+    (define_case
+      name: _ @local.definition.field)))
+
+(class
+  name: _ @local.definition.type)
+
+(trait
+  name: _ @local.definition.type)
+
+(import
+  (symbols
+    [
+      (identifier)
+      (constant)
+      (self)
+    ] @local.definition.import))
+
+(identifier) @local.reference
+
+(field) @local.reference
+
+(constant) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/ispc/folds.scm b/pack/ant/start/nvim-treesitter/queries/ispc/folds.scm
new file mode 100644
index 0000000..45d0ba1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ispc/folds.scm
@@ -0,0 +1,8 @@
+; inherits: c
+
+[
+  (foreach_statement)
+  (foreach_instance_statement)
+  (unmasked_statement)
+  (template_declaration)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/ispc/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ispc/highlights.scm
new file mode 100644
index 0000000..14e6142
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ispc/highlights.scm
@@ -0,0 +1,111 @@
+; inherits: c
+
+[
+  "soa"
+  "task"
+  "launch"
+  "unmasked"
+  "template"
+  "typename"
+  (sync_expression)
+] @keyword
+
+[
+  "in"
+  "new"
+  "delete"
+] @keyword.operator
+
+[
+  "cdo"
+  "cfor"
+  "cwhile"
+  "foreach"
+  "foreach_tiled"
+  "foreach_active"
+  "foreach_unique"
+] @keyword.repeat
+
+"cif" @keyword.conditional
+
+[
+  "varying"
+  "uniform"
+] @keyword.modifier
+
+"__regcall" @attribute
+
+(overload_declarator
+  name: _ @function)
+
+(foreach_statement
+  range_operator: _ @operator)
+
+(short_vector
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(soa_qualifier
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(template_argument_list
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(template_parameter_list
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(llvm_identifier) @function.builtin
+
+; built-in variables
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin
+    "programCount" "programIndex" "taskCount" "taskCount0" "taskCount1" "taskCount2" "taskIndex"
+    "taskIndex0" "taskIndex1" "taskIndex2" "threadCount" "threadIndex"))
+
+; preprocessor constants
+((identifier) @constant.builtin
+  (#any-of? @constant.builtin
+    "ISPC" "ISPC_FP16_SUPPORTED" "ISPC_FP64_SUPPORTED" "ISPC_LLVM_INTRINSICS_ENABLED"
+    "ISPC_MAJOR_VERSION" "ISPC_MINOR_VERSION" "ISPC_POINTER_SIZE" "ISPC_TARGET_AVX"
+    "ISPC_TARGET_AVX2" "ISPC_TARGET_AVX512KNL" "ISPC_TARGET_AVX512SKX" "ISPC_TARGET_AVX512SPR"
+    "ISPC_TARGET_NEON" "ISPC_TARGET_SSE2" "ISPC_TARGET_SSE4" "ISPC_UINT_IS_DEFINED" "PI"
+    "TARGET_ELEMENT_WIDTH" "TARGET_WIDTH"))
+
+; standard library built-in
+((type_identifier) @type.builtin
+  (#lua-match? @type.builtin "^RNGState"))
+
+(call_expression
+  function: (identifier) @function.builtin
+  (#any-of? @function.builtin
+    "abs" "acos" "all" "alloca" "and" "any" "aos_to_soa2" "aos_to_soa3" "aos_to_soa4" "asin"
+    "assert" "assume" "atan" "atan2" "atomic_add_global" "atomic_add_local" "atomic_and_global"
+    "atomic_and_local" "atomic_compare_exchange_global" "atomic_compare_exchange_local"
+    "atomic_max_global" "atomic_max_local" "atomic_min_global" "atomic_min_local" "atomic_or_global"
+    "atomic_or_local" "atomic_subtract_global" "atomic_subtract_local" "atomic_swap_global"
+    "atomic_swap_local" "atomic_xor_global" "atomic_xor_local" "avg_down" "avg_up" "broadcast"
+    "ceil" "clamp" "clock" "cos" "count_leading_zeros" "count_trailing_zeros" "doublebits"
+    "exclusive_scan_add" "exclusive_scan_and" "exclusive_scan_or" "exp" "extract" "fastmath"
+    "float16bits" "floatbits" "float_to_half" "float_to_half_fast" "float_to_srgb8" "floor"
+    "frandom" "frexp" "half_to_float" "half_to_float_fast" "insert" "intbits" "invoke_sycl" "isnan"
+    "ISPCAlloc" "ISPCLaunch" "ISPCSync" "lanemask" "ldexp" "log" "max" "memcpy" "memcpy64" "memmove"
+    "memmove64" "memory_barrier" "memset" "memset64" "min" "none" "num_cores" "or"
+    "packed_load_active" "packed_store_active" "packed_store_active2" "packmask" "popcnt" "pow"
+    "prefetch_l1" "prefetch_l2" "prefetch_l3" "prefetch_nt" "prefetchw_l1" "prefetchw_l2"
+    "prefetchw_l3" "print" "random" "rcp" "rcp_fast" "rdrand" "reduce_add" "reduce_equal"
+    "reduce_max" "reduce_min" "rotate" "round" "rsqrt" "rsqrt_fast" "saturating_add"
+    "saturating_div" "saturating_mul" "saturating_sub" "seed_rng" "select" "shift" "shuffle"
+    "signbits" "sign_extend" "sin" "sincos" "soa_to_aos2" "soa_to_aos3" "soa_to_aos4" "sqrt"
+    "streaming_load" "streaming_load_uniform" "streaming_store" "tan" "trunc")
+  )
diff --git a/pack/ant/start/nvim-treesitter/queries/ispc/indents.scm b/pack/ant/start/nvim-treesitter/queries/ispc/indents.scm
new file mode 100644
index 0000000..f8c04e3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ispc/indents.scm
@@ -0,0 +1,9 @@
+; inherits: c
+
+((foreach_statement
+  body: (_) @_body) @indent.begin
+  (#not-kind-eq? @_body "compound_statement"))
+
+((foreach_instance_statement
+  body: (_) @_body) @indent.begin
+  (#not-kind-eq? @_body "compound_statement"))
diff --git a/pack/ant/start/nvim-treesitter/queries/ispc/injections.scm b/pack/ant/start/nvim-treesitter/queries/ispc/injections.scm
new file mode 100644
index 0000000..a5a5208
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ispc/injections.scm
@@ -0,0 +1 @@
+; inherits: c
diff --git a/pack/ant/start/nvim-treesitter/queries/ispc/locals.scm b/pack/ant/start/nvim-treesitter/queries/ispc/locals.scm
new file mode 100644
index 0000000..985b3c9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ispc/locals.scm
@@ -0,0 +1,18 @@
+; inherits: c
+
+(reference_declarator
+  (identifier) @local.definition.var)
+
+(type_parameter_declaration
+  (type_identifier) @local.definition.type)
+
+(template_declaration) @local.scope
+
+(template_function
+  name: (identifier) @local.definition.function) @local.scope
+
+[
+  (foreach_statement)
+  (foreach_instance_statement)
+  (unmasked_statement)
+] @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/janet_simple/folds.scm b/pack/ant/start/nvim-treesitter/queries/janet_simple/folds.scm
new file mode 100644
index 0000000..e316af4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/janet_simple/folds.scm
@@ -0,0 +1,2 @@
+(source
+  (par_tup_lit) @fold)
diff --git a/pack/ant/start/nvim-treesitter/queries/janet_simple/highlights.scm b/pack/ant/start/nvim-treesitter/queries/janet_simple/highlights.scm
new file mode 100644
index 0000000..552f865
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/janet_simple/highlights.scm
@@ -0,0 +1,178 @@
+; >> Literals
+(kwd_lit) @string.special.symbol
+
+(str_lit) @string
+
+(long_str_lit) @string
+
+(buf_lit) @string
+
+(long_buf_lit) @string
+
+(num_lit) @number
+
+(bool_lit) @boolean
+
+(nil_lit) @constant.builtin
+
+(comment) @comment @spell
+
+[
+  "{"
+  "@{"
+  "}"
+  "["
+  "@["
+  "]"
+  "("
+  "@("
+  ")"
+] @punctuation.bracket
+
+; >> Symbols
+; General symbol highlighting
+(sym_lit) @variable
+
+; General function calls
+(par_tup_lit
+  .
+  (sym_lit) @function.call)
+
+(short_fn_lit
+  .
+  (sym_lit) @function.call)
+
+; Quoted symbols
+(quote_lit
+  (sym_lit) @string.special.symbol)
+
+(qq_lit
+  (sym_lit) @string.special.symbol)
+
+; Dynamic variables
+((sym_lit) @variable.builtin
+  (#lua-match? @variable.builtin "^[*].+[*]$"))
+
+; Comment
+((sym_lit) @comment
+  (#any-of? @comment "comment"))
+
+; Special forms and builtin macros
+;
+; # special forms were manually added at the beginning
+;
+; # for macros
+; (each name (all-bindings)
+;   (when-let [info (dyn (symbol name))]
+;     (when (info :macro)
+;       (print name))))
+((sym_lit) @function.macro
+  (#any-of? @function.macro
+    ; special forms
+    "break" "def" "do" "fn" "if" "quasiquote" "quote" "set" "splice" "unquote" "upscope" "var"
+    "while"
+    ; macros
+    "%=" "*=" "++" "+=" "--" "-=" "->" "->>" "-?>" "-?>>" "/=" "and" "as->" "as-macro" "as?->"
+    "assert" "case" "catseq" "chr" "comment" "compif" "comptime" "compwhen" "cond" "coro" "def-"
+    "default" "defdyn" "defer" "defmacro" "defmacro-" "defn" "defn-" "delay" "doc" "each" "eachk"
+    "eachp" "edefer" "ev/do-thread" "ev/gather" "ev/spawn" "ev/spawn-thread" "ev/with-deadline"
+    "ev/with-lock" "ev/with-rlock" "ev/with-wlock" "ffi/defbind" "ffi/defbind-alias" "fiber-fn"
+    "for" "forever" "forv" "generate" "if-let" "if-not" "if-with" "import" "juxt" "label" "let"
+    "loop" "match" "or" "prompt" "protect" "repeat" "seq" "short-fn" "tabseq" "toggle" "tracev"
+    "try" "unless" "use" "var-" "varfn" "when" "when-let" "when-with" "with" "with-dyns" "with-env"
+    "with-syms" "with-vars"
+    ; obsolete builtin macros
+    "eachy"))
+
+; All builtin functions
+;
+; (each name (all-bindings)
+;   (when-let [info (dyn (symbol name))]
+;     (when (and (nil? (info :macro))
+;                (or (function? (info :value))
+;                    (cfunction? (info :value))))
+;       (print name))))
+((sym_lit) @function.builtin
+  (#any-of? @function.builtin
+    "%" "*" "+" "-" "/" "<" "<=" "=" ">" ">="
+    ; debugging -- start janet with -d and use (debug) to see these
+    ".break" ".breakall" ".bytecode" ".clear" ".clearall" ".disasm" ".fiber" ".fn" ".frame"
+    ".locals" ".next" ".nextc" ".ppasm" ".signal" ".slot" ".slots" ".source" ".stack" ".step"
+    ; back to regularly scheduled program
+    "abstract?" "accumulate" "accumulate2" "all" "all-bindings" "all-dynamics" "any?" "apply"
+    "array" "array/clear" "array/concat" "array/ensure" "array/fill" "array/insert" "array/new"
+    "array/new-filled" "array/peek" "array/pop" "array/push" "array/remove" "array/slice"
+    "array/trim" "array/weak" "array?" "asm" "bad-compile" "bad-parse" "band" "blshift" "bnot"
+    "boolean?" "bor" "brshift" "brushift" "buffer" "buffer/bit" "buffer/bit-clear" "buffer/bit-set"
+    "buffer/bit-toggle" "buffer/blit" "buffer/clear" "buffer/fill" "buffer/format"
+    "buffer/format-at" "buffer/from-bytes" "buffer/new" "buffer/new-filled" "buffer/popn"
+    "buffer/push" "buffer/push-at" "buffer/push-byte" "buffer/push-float32" "buffer/push-float64"
+    "buffer/push-string" "buffer/push-uint16" "buffer/push-uint32" "buffer/push-uint64"
+    "buffer/push-word" "buffer/slice" "buffer/trim" "buffer?" "bundle/add" "bundle/add-directory"
+    "bundle/add-file" "bundle/install" "bundle/installed?" "bundle/list" "bundle/manifest"
+    "bundle/prune" "bundle/reinstall" "bundle/topolist" "bundle/uninstall" "bundle/update-all"
+    "bxor" "bytes?" "cancel" "cfunction?" "cli-main" "cmp" "comp" "compare" "compare<" "compare<="
+    "compare=" "compare>" "compare>=" "compile" "complement" "count" "curenv" "debug"
+    "debug/arg-stack" "debug/break" "debug/fbreak" "debug/lineage" "debug/stack" "debug/stacktrace"
+    "debug/step" "debug/unbreak" "debug/unfbreak" "debugger" "debugger-on-status" "dec" "deep-not="
+    "deep=" "defglobal" "describe" "dictionary?" "disasm" "distinct" "div" "doc*" "doc-format"
+    "doc-of" "dofile" "drop" "drop-until" "drop-while" "dyn" "eflush" "empty?" "env-lookup" "eprin"
+    "eprinf" "eprint" "eprintf" "error" "errorf" "ev/acquire-lock" "ev/acquire-rlock"
+    "ev/acquire-wlock" "ev/all-tasks" "ev/call" "ev/cancel" "ev/capacity" "ev/chan" "ev/chan-close"
+    "ev/chunk" "ev/close" "ev/count" "ev/deadline" "ev/full" "ev/give" "ev/give-supervisor" "ev/go"
+    "ev/lock" "ev/read" "ev/release-lock" "ev/release-rlock" "ev/release-wlock" "ev/rselect"
+    "ev/rwlock" "ev/select" "ev/sleep" "ev/take" "ev/thread" "ev/thread-chan" "ev/write" "eval"
+    "eval-string" "even?" "every?" "extreme" "false?" "ffi/align" "ffi/call"
+    "ffi/calling-conventions" "ffi/close" "ffi/context" "ffi/free" "ffi/jitfn" "ffi/lookup"
+    "ffi/malloc" "ffi/native" "ffi/pointer-buffer" "ffi/pointer-cfunction" "ffi/read"
+    "ffi/signature" "ffi/size" "ffi/struct" "ffi/trampoline" "ffi/write" "fiber/can-resume?"
+    "fiber/current" "fiber/getenv" "fiber/last-value" "fiber/maxstack" "fiber/new" "fiber/root"
+    "fiber/setenv" "fiber/setmaxstack" "fiber/status" "fiber?" "file/close" "file/flush"
+    "file/lines" "file/open" "file/read" "file/seek" "file/tell" "file/temp" "file/write" "filter"
+    "find" "find-index" "first" "flatten" "flatten-into" "flush" "flycheck" "freeze" "frequencies"
+    "from-pairs" "function?" "gccollect" "gcinterval" "gcsetinterval" "gensym" "get" "get-in"
+    "getline" "getproto" "group-by" "has-key?" "has-value?" "hash" "idempotent?" "identity"
+    "import*" "in" "inc" "index-of" "indexed?" "int/s64" "int/to-bytes" "int/to-number" "int/u64"
+    "int?" "interleave" "interpose" "invert" "juxt*" "keep" "keep-syntax" "keep-syntax!" "keys"
+    "keyword" "keyword/slice" "keyword?" "kvs" "last" "length" "lengthable?" "load-image" "macex"
+    "macex1" "maclintf" "make-env" "make-image" "map" "mapcat" "marshal" "math/abs" "math/acos"
+    "math/acosh" "math/asin" "math/asinh" "math/atan" "math/atan2" "math/atanh" "math/cbrt"
+    "math/ceil" "math/cos" "math/cosh" "math/erf" "math/erfc" "math/exp" "math/exp2" "math/expm1"
+    "math/floor" "math/frexp" "math/gamma" "math/gcd" "math/hypot" "math/lcm" "math/ldexp"
+    "math/log" "math/log-gamma" "math/log10" "math/log1p" "math/log2" "math/next" "math/pow"
+    "math/random" "math/rng" "math/rng-buffer" "math/rng-int" "math/rng-uniform" "math/round"
+    "math/seedrandom" "math/sin" "math/sinh" "math/sqrt" "math/tan" "math/tanh" "math/trunc" "max"
+    "max-of" "mean" "memcmp" "merge" "merge-into" "merge-module" "min" "min-of" "mod"
+    "module/add-paths" "module/expand-path" "module/find" "module/value" "nan?" "nat?" "native"
+    "neg?" "net/accept" "net/accept-loop" "net/address" "net/address-unpack" "net/chunk" "net/close"
+    "net/connect" "net/flush" "net/listen" "net/localname" "net/peername" "net/read" "net/recv-from"
+    "net/send-to" "net/server" "net/setsockopt" "net/shutdown" "net/write" "next" "nil?" "not"
+    "not=" "number?" "odd?" "one?" "os/arch" "os/cd" "os/chmod" "os/clock" "os/compiler"
+    "os/cpu-count" "os/cryptorand" "os/cwd" "os/date" "os/dir" "os/environ" "os/execute" "os/exit"
+    "os/getenv" "os/isatty" "os/link" "os/lstat" "os/mkdir" "os/mktime" "os/open" "os/perm-int"
+    "os/perm-string" "os/pipe" "os/posix-exec" "os/posix-fork" "os/proc-close" "os/proc-kill"
+    "os/proc-wait" "os/readlink" "os/realpath" "os/rename" "os/rm" "os/rmdir" "os/setenv"
+    "os/setlocale" "os/shell" "os/sigaction" "os/sleep" "os/spawn" "os/stat" "os/strftime"
+    "os/symlink" "os/time" "os/touch" "os/umask" "os/which" "pairs" "parse" "parse-all"
+    "parser/byte" "parser/clone" "parser/consume" "parser/eof" "parser/error" "parser/flush"
+    "parser/has-more" "parser/insert" "parser/new" "parser/produce" "parser/state" "parser/status"
+    "parser/where" "partial" "partition" "partition-by" "peg/compile" "peg/find" "peg/find-all"
+    "peg/match" "peg/replace" "peg/replace-all" "pos?" "postwalk" "pp" "prewalk" "prin" "prinf"
+    "print" "printf" "product" "propagate" "put" "put-in" "quit" "range" "reduce" "reduce2" "repl"
+    "require" "resume" "return" "reverse" "reverse!" "run-context" "sandbox" "scan-number" "setdyn"
+    "signal" "slice" "slurp" "some" "sort" "sort-by" "sorted" "sorted-by" "spit" "string"
+    "string/ascii-lower" "string/ascii-upper" "string/bytes" "string/check-set" "string/find"
+    "string/find-all" "string/format" "string/from-bytes" "string/has-prefix?" "string/has-suffix?"
+    "string/join" "string/repeat" "string/replace" "string/replace-all" "string/reverse"
+    "string/slice" "string/split" "string/trim" "string/triml" "string/trimr" "string?" "struct"
+    "struct/getproto" "struct/proto-flatten" "struct/to-table" "struct/with-proto" "struct?" "sum"
+    "symbol" "symbol/slice" "symbol?" "table" "table/clear" "table/clone" "table/getproto"
+    "table/new" "table/proto-flatten" "table/rawget" "table/setproto" "table/to-struct" "table/weak"
+    "table/weak-keys" "table/weak-values" "table?" "take" "take-until" "take-while" "thaw" "trace"
+    "true?" "truthy?" "tuple" "tuple/brackets" "tuple/setmap" "tuple/slice" "tuple/sourcemap"
+    "tuple/type" "tuple?" "type" "unmarshal" "untrace" "update" "update-in" "values" "varglobal"
+    "walk" "warn-compile" "xprin" "xprinf" "xprint" "xprintf" "yield" "zero?" "zipcoll"
+    ; XXX: obsolete
+    "tarray/buffer" "tarray/copy-bytes" "tarray/length" "tarray/new" "tarray/properties"
+    "tarray/slice" "tarray/swap-bytes" "thread/close" "thread/current" "thread/exit" "thread/new"
+    "thread/receive" "thread/send"))
diff --git a/pack/ant/start/nvim-treesitter/queries/janet_simple/injections.scm b/pack/ant/start/nvim-treesitter/queries/janet_simple/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/janet_simple/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/janet_simple/locals.scm b/pack/ant/start/nvim-treesitter/queries/janet_simple/locals.scm
new file mode 100644
index 0000000..e47adce
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/janet_simple/locals.scm
@@ -0,0 +1 @@
+; placeholder file to get incremental selection to work
diff --git a/pack/ant/start/nvim-treesitter/queries/java/folds.scm b/pack/ant/start/nvim-treesitter/queries/java/folds.scm
new file mode 100644
index 0000000..2cc143a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/java/folds.scm
@@ -0,0 +1,8 @@
+[
+  (block)
+  (class_body)
+  (constructor_declaration)
+  (argument_list)
+  (annotation_argument_list)
+  (import_declaration)+
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/java/highlights.scm b/pack/ant/start/nvim-treesitter/queries/java/highlights.scm
new file mode 100644
index 0000000..d29d126
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/java/highlights.scm
@@ -0,0 +1,333 @@
+; CREDITS @maxbrunsfeld (maxbrunsfeld@gmail.com)
+; Variables
+(identifier) @variable
+
+(underscore_pattern) @character.special
+
+; Methods
+(method_declaration
+  name: (identifier) @function.method)
+
+(method_invocation
+  name: (identifier) @function.method.call)
+
+(super) @function.builtin
+
+; Parameters
+(formal_parameter
+  name: (identifier) @variable.parameter)
+
+(catch_formal_parameter
+  name: (identifier) @variable.parameter)
+
+(spread_parameter
+  (variable_declarator
+    name: (identifier) @variable.parameter)) ; int... foo
+
+; Lambda parameter
+(inferred_parameters
+  (identifier) @variable.parameter) ; (x,y) -> ...
+
+(lambda_expression
+  parameters: (identifier) @variable.parameter) ; x -> ...
+
+; Operators
+[
+  "+"
+  ":"
+  "++"
+  "-"
+  "--"
+  "&"
+  "&&"
+  "|"
+  "||"
+  "!"
+  "!="
+  "=="
+  "*"
+  "/"
+  "%"
+  "<"
+  "<="
+  ">"
+  ">="
+  "="
+  "-="
+  "+="
+  "*="
+  "/="
+  "%="
+  "->"
+  "^"
+  "^="
+  "&="
+  "|="
+  "~"
+  ">>"
+  ">>>"
+  "<<"
+  "::"
+] @operator
+
+; Types
+(interface_declaration
+  name: (identifier) @type)
+
+(annotation_type_declaration
+  name: (identifier) @type)
+
+(class_declaration
+  name: (identifier) @type)
+
+(record_declaration
+  name: (identifier) @type)
+
+(enum_declaration
+  name: (identifier) @type)
+
+(constructor_declaration
+  name: (identifier) @type)
+
+(compact_constructor_declaration
+  name: (identifier) @type)
+
+(type_identifier) @type
+
+((type_identifier) @type.builtin
+  (#eq? @type.builtin "var"))
+
+((method_invocation
+  object: (identifier) @type)
+  (#lua-match? @type "^[A-Z]"))
+
+((method_reference
+  .
+  (identifier) @type)
+  (#lua-match? @type "^[A-Z]"))
+
+((field_access
+  object: (identifier) @type)
+  (#lua-match? @type "^[A-Z]"))
+
+(scoped_identifier
+  (identifier) @type
+  (#lua-match? @type "^[A-Z]"))
+
+; Fields
+(field_declaration
+  declarator: (variable_declarator
+    name: (identifier) @variable.member))
+
+(field_access
+  field: (identifier) @variable.member)
+
+[
+  (boolean_type)
+  (integral_type)
+  (floating_point_type)
+  (void_type)
+] @type.builtin
+
+; Variables
+((identifier) @constant
+  (#lua-match? @constant "^[A-Z_][A-Z%d_]+$"))
+
+(this) @variable.builtin
+
+; Annotations
+(annotation
+  "@" @attribute
+  name: (identifier) @attribute)
+
+(marker_annotation
+  "@" @attribute
+  name: (identifier) @attribute)
+
+; Literals
+(string_literal) @string
+
+(escape_sequence) @string.escape
+
+(character_literal) @character
+
+[
+  (hex_integer_literal)
+  (decimal_integer_literal)
+  (octal_integer_literal)
+  (binary_integer_literal)
+] @number
+
+[
+  (decimal_floating_point_literal)
+  (hex_floating_point_literal)
+] @number.float
+
+[
+  (true)
+  (false)
+] @boolean
+
+(null_literal) @constant.builtin
+
+; Keywords
+[
+  "assert"
+  "default"
+  "extends"
+  "implements"
+  "instanceof"
+  "@interface"
+  "permits"
+  "to"
+  "with"
+] @keyword
+
+[
+  "record"
+  "class"
+  "enum"
+  "interface"
+] @keyword.type
+
+(synchronized_statement
+  "synchronized" @keyword)
+
+[
+  "abstract"
+  "final"
+  "native"
+  "non-sealed"
+  "open"
+  "private"
+  "protected"
+  "public"
+  "sealed"
+  "static"
+  "strictfp"
+  "transitive"
+] @keyword.modifier
+
+(modifiers
+  "synchronized" @keyword.modifier)
+
+[
+  "transient"
+  "volatile"
+] @keyword.modifier
+
+[
+  "return"
+  "yield"
+] @keyword.return
+
+"new" @keyword.operator
+
+; Conditionals
+[
+  "if"
+  "else"
+  "switch"
+  "case"
+  "when"
+] @keyword.conditional
+
+(ternary_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+; Loops
+[
+  "for"
+  "while"
+  "do"
+  "continue"
+  "break"
+] @keyword.repeat
+
+; Includes
+[
+  "exports"
+  "import"
+  "module"
+  "opens"
+  "package"
+  "provides"
+  "requires"
+  "uses"
+] @keyword.import
+
+(import_declaration
+  (asterisk
+    "*" @character.special))
+
+; Punctuation
+[
+  ";"
+  "."
+  "..."
+  ","
+] @punctuation.delimiter
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+(type_arguments
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(type_parameters
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(string_interpolation
+  [
+    "\\{"
+    "}"
+  ] @punctuation.special)
+
+; Exceptions
+[
+  "throw"
+  "throws"
+  "finally"
+  "try"
+  "catch"
+] @keyword.exception
+
+; Labels
+(labeled_statement
+  (identifier) @label)
+
+; Comments
+[
+  (line_comment)
+  (block_comment)
+] @comment @spell
+
+((block_comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$"))
+
+((line_comment) @comment.documentation
+  (#lua-match? @comment.documentation "^///[^/]"))
+
+((line_comment) @comment.documentation
+  (#lua-match? @comment.documentation "^///$"))
diff --git a/pack/ant/start/nvim-treesitter/queries/java/indents.scm b/pack/ant/start/nvim-treesitter/queries/java/indents.scm
new file mode 100644
index 0000000..9e4d0a5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/java/indents.scm
@@ -0,0 +1,40 @@
+; format-ignore
+[
+  ; ... refers to the portion that this indent query will have effects on
+  (class_body)                        ; { ... } of `class X`
+  (enum_body)                         ; { ... } of `enum X`
+  (interface_body)                    ; { ... } of `interface X`
+  (constructor_body)                  ; { `modifier` X() {...} } inside `class X`
+  (annotation_type_body)              ; { ... } of `@interface X`
+  (block)                             ; { ... } that's not mentioned in this scope
+  (switch_block)                      ; { ... } in `switch X`
+  (array_initializer)                 ; [1, 2]
+  (argument_list)                     ; foo(...)
+  (formal_parameters)                 ; method foo(...)
+  (annotation_argument_list)          ; @Annotation(...)
+  (element_value_array_initializer)   ; { a, b } inside @Annotation()
+] @indent.begin
+
+(expression_statement
+  (method_invocation) @indent.begin)
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @indent.branch
+
+(annotation_argument_list
+  ")" @indent.end) ; This should be a special cased as `()` here doesn't have ending `;`
+
+"}" @indent.end
+
+(line_comment) @indent.ignore
+
+[
+  (ERROR)
+  (block_comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/java/injections.scm b/pack/ant/start/nvim-treesitter/queries/java/injections.scm
new file mode 100644
index 0000000..2ad7e5f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/java/injections.scm
@@ -0,0 +1,26 @@
+([
+  (block_comment)
+  (line_comment)
+] @injection.content
+  (#set! injection.language "comment"))
+
+((block_comment) @injection.content
+  (#lua-match? @injection.content "/[*][!<*][^a-zA-Z]")
+  (#set! injection.language "doxygen"))
+
+((method_invocation
+  name: (identifier) @_method
+  arguments: (argument_list
+    .
+    (string_literal
+      .
+      (_) @injection.content)))
+  (#any-of? @_method "format" "printf")
+  (#set! injection.language "printf"))
+
+((method_invocation
+  object: (string_literal
+    (string_fragment) @injection.content)
+  name: (identifier) @_method)
+  (#eq? @_method "formatted")
+  (#set! injection.language "printf"))
diff --git a/pack/ant/start/nvim-treesitter/queries/java/locals.scm b/pack/ant/start/nvim-treesitter/queries/java/locals.scm
new file mode 100644
index 0000000..53e9509
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/java/locals.scm
@@ -0,0 +1,100 @@
+; SCOPES
+; declarations
+(program) @local.scope
+
+(class_declaration
+  body: (_) @local.scope)
+
+(record_declaration
+  body: (_) @local.scope)
+
+(enum_declaration
+  body: (_) @local.scope)
+
+(lambda_expression) @local.scope
+
+(enhanced_for_statement) @local.scope
+
+; block
+(block) @local.scope
+
+; if/else
+(if_statement) @local.scope ; if+else
+
+(if_statement
+  consequence: (_) @local.scope) ; if body in case there are no braces
+
+(if_statement
+  alternative: (_) @local.scope) ; else body in case there are no braces
+
+; try/catch
+(try_statement) @local.scope ; covers try+catch, individual try and catch are covered by (block)
+
+(catch_clause) @local.scope ; needed because `Exception` variable
+
+; loops
+(for_statement) @local.scope ; whole for_statement because loop iterator variable
+
+(for_statement
+  ; "for" body in case there are no braces
+  body: (_) @local.scope)
+
+(do_statement
+  body: (_) @local.scope)
+
+(while_statement
+  body: (_) @local.scope)
+
+; Functions
+(constructor_declaration) @local.scope
+
+(method_declaration) @local.scope
+
+; DEFINITIONS
+(package_declaration
+  (identifier) @local.definition.namespace)
+
+(class_declaration
+  name: (identifier) @local.definition.type)
+
+(record_declaration
+  name: (identifier) @local.definition.type)
+
+(enum_declaration
+  name: (identifier) @local.definition.enum)
+
+(method_declaration
+  name: (identifier) @local.definition.method)
+
+(local_variable_declaration
+  declarator: (variable_declarator
+    name: (identifier) @local.definition.var))
+
+(enhanced_for_statement
+  ; for (var item : items) {
+  name: (identifier) @local.definition.var)
+
+(formal_parameter
+  name: (identifier) @local.definition.parameter)
+
+(catch_formal_parameter
+  name: (identifier) @local.definition.parameter)
+
+(inferred_parameters
+  (identifier) @local.definition.parameter) ; (x,y) -> ...
+
+(lambda_expression
+  parameters: (identifier) @local.definition.parameter) ; x -> ...
+
+((scoped_identifier
+  (identifier) @local.definition.import)
+  (#has-ancestor? @local.definition.import import_declaration))
+
+(field_declaration
+  declarator: (variable_declarator
+    name: (identifier) @local.definition.field))
+
+; REFERENCES
+(identifier) @local.reference
+
+(type_identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/javascript/folds.scm b/pack/ant/start/nvim-treesitter/queries/javascript/folds.scm
new file mode 100644
index 0000000..b6d9b28
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/javascript/folds.scm
@@ -0,0 +1 @@
+; inherits: ecma,jsx
diff --git a/pack/ant/start/nvim-treesitter/queries/javascript/highlights.scm b/pack/ant/start/nvim-treesitter/queries/javascript/highlights.scm
new file mode 100644
index 0000000..257a731
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/javascript/highlights.scm
@@ -0,0 +1,56 @@
+; inherits: ecma,jsx
+
+; Parameters
+(formal_parameters
+  (identifier) @variable.parameter)
+
+(formal_parameters
+  (rest_pattern
+    (identifier) @variable.parameter))
+
+; ({ a }) => null
+(formal_parameters
+  (object_pattern
+    (shorthand_property_identifier_pattern) @variable.parameter))
+
+; ({ a = b }) => null
+(formal_parameters
+  (object_pattern
+    (object_assignment_pattern
+      (shorthand_property_identifier_pattern) @variable.parameter)))
+
+; ({ a: b }) => null
+(formal_parameters
+  (object_pattern
+    (pair_pattern
+      value: (identifier) @variable.parameter)))
+
+; ([ a ]) => null
+(formal_parameters
+  (array_pattern
+    (identifier) @variable.parameter))
+
+; ({ a } = { a }) => null
+(formal_parameters
+  (assignment_pattern
+    (object_pattern
+      (shorthand_property_identifier_pattern) @variable.parameter)))
+
+; ({ a = b } = { a }) => null
+(formal_parameters
+  (assignment_pattern
+    (object_pattern
+      (object_assignment_pattern
+        (shorthand_property_identifier_pattern) @variable.parameter))))
+
+; a => null
+(arrow_function
+  parameter: (identifier) @variable.parameter)
+
+; optional parameters
+(formal_parameters
+  (assignment_pattern
+    left: (identifier) @variable.parameter))
+
+; punctuation
+(optional_chain) @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/javascript/indents.scm b/pack/ant/start/nvim-treesitter/queries/javascript/indents.scm
new file mode 100644
index 0000000..b6d9b28
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/javascript/indents.scm
@@ -0,0 +1 @@
+; inherits: ecma,jsx
diff --git a/pack/ant/start/nvim-treesitter/queries/javascript/injections.scm b/pack/ant/start/nvim-treesitter/queries/javascript/injections.scm
new file mode 100644
index 0000000..b6d9b28
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/javascript/injections.scm
@@ -0,0 +1 @@
+; inherits: ecma,jsx
diff --git a/pack/ant/start/nvim-treesitter/queries/javascript/locals.scm b/pack/ant/start/nvim-treesitter/queries/javascript/locals.scm
new file mode 100644
index 0000000..6d6846f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/javascript/locals.scm
@@ -0,0 +1,69 @@
+; inherits: ecma,jsx
+
+; Both properties are matched here.
+;
+;   class Foo {
+;     this.#bar = "baz";
+;     this.quuz = "qux";
+;   }
+(field_definition
+  property: [
+    (property_identifier)
+    (private_property_identifier)
+  ] @local.definition.var)
+
+; this.foo = "bar"
+(assignment_expression
+  left: (member_expression
+    object: (this)
+    property: (property_identifier) @local.definition.var))
+
+(formal_parameters
+  (identifier) @local.definition.parameter)
+
+; function(arg = []) {
+(formal_parameters
+  (assignment_pattern
+    left: (identifier) @local.definition.parameter))
+
+; x => x
+(arrow_function
+  parameter: (identifier) @local.definition.parameter)
+
+; ({ a }) => null
+(formal_parameters
+  (object_pattern
+    (shorthand_property_identifier_pattern) @local.definition.parameter))
+
+; ({ a: b }) => null
+(formal_parameters
+  (object_pattern
+    (pair_pattern
+      value: (identifier) @local.definition.parameter)))
+
+; ([ a ]) => null
+(formal_parameters
+  (array_pattern
+    (identifier) @local.definition.parameter))
+
+(formal_parameters
+  (rest_pattern
+    (identifier) @local.definition.parameter))
+
+; Both methods are matched here.
+;
+;   class Foo {
+;     #bar(x) { x }
+;     baz(y) { y }
+;   }
+(method_definition
+  [
+    (property_identifier)
+    (private_property_identifier)
+  ] @local.definition.function
+  (#set! definition.var.scope parent))
+
+; this.foo()
+(member_expression
+  object: (this)
+  property: (property_identifier) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/jq/highlights.scm b/pack/ant/start/nvim-treesitter/queries/jq/highlights.scm
new file mode 100644
index 0000000..5d6050f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jq/highlights.scm
@@ -0,0 +1,158 @@
+; Variables
+(variable) @variable
+
+((variable) @constant.builtin
+  (#eq? @constant.builtin "$ENV"))
+
+((variable) @constant.macro
+  (#eq? @constant.macro "$__loc__"))
+
+; Properties
+(index
+  (identifier) @property)
+
+; Labels
+(query
+  label: (variable) @label)
+
+(query
+  break_statement: (variable) @label)
+
+; Literals
+(number) @number
+
+(string) @string
+
+[
+  "true"
+  "false"
+] @boolean
+
+"null" @type.builtin
+
+; Interpolation
+[
+  "\\("
+  ")"
+] @character.special
+
+; Format
+(format) @attribute
+
+; Functions
+(funcdef
+  (identifier) @function)
+
+(funcdefargs
+  (identifier) @variable.parameter)
+
+[
+  "reduce"
+  "foreach"
+] @function.builtin
+
+((funcname) @function.call
+  .
+  "(")
+
+; jq -n 'builtins | map(split("/")[0]) | unique | .[]'
+((funcname) @function.builtin
+  (#any-of? @function.builtin
+    "IN" "INDEX" "JOIN" "abs" "acos" "acosh" "add" "all" "any" "arrays" "ascii_downcase"
+    "ascii_upcase" "asin" "asinh" "atan" "atan2" "atanh" "booleans" "bsearch" "builtins" "capture"
+    "cbrt" "ceil" "combinations" "contains" "copysign" "cos" "cosh" "debug" "del" "delpaths" "drem"
+    "empty" "endswith" "env" "erf" "erfc" "error" "exp" "exp10" "exp2" "explode" "expm1" "fabs"
+    "fdim" "finites" "first" "flatten" "floor" "fma" "fmax" "fmin" "fmod" "format" "frexp"
+    "from_entries" "fromdate" "fromdateiso8601" "fromjson" "fromstream" "gamma" "get_jq_origin"
+    "get_prog_origin" "get_search_list" "getpath" "gmtime" "group_by" "gsub" "halt" "halt_error"
+    "has" "hypot" "implode" "in" "index" "indices" "infinite" "input" "input_filename"
+    "input_line_number" "inputs" "inside" "isempty" "isfinite" "isinfinite" "isnan" "isnormal"
+    "iterables" "j0" "j1" "jn" "join" "keys" "keys_unsorted" "last" "ldexp" "length" "lgamma"
+    "lgamma_r" "limit" "localtime" "log" "log10" "log1p" "log2" "logb" "ltrimstr" "map" "map_values"
+    "match" "max" "max_by" "min" "min_by" "mktime" "modf" "modulemeta" "nan" "nearbyint" "nextafter"
+    "nexttoward" "normals" "not" "now" "nth" "nulls" "numbers" "objects" "path" "paths" "pick" "pow"
+    "pow10" "range" "recurse" "remainder" "repeat" "reverse" "rindex" "rint" "round" "rtrimstr"
+    "scalars" "scalb" "scalbln" "scan" "select" "setpath" "significand" "sin" "sinh" "sort"
+    "sort_by" "split" "splits" "sqrt" "startswith" "stderr" "strflocaltime" "strftime" "strings"
+    "strptime" "sub" "tan" "tanh" "test" "tgamma" "to_entries" "todate" "todateiso8601" "tojson"
+    "tonumber" "tostream" "tostring" "transpose" "trunc" "truncate_stream" "type" "unique"
+    "unique_by" "until" "utf8bytelength" "values" "walk" "while" "with_entries" "y0" "y1" "yn"))
+
+; Keywords
+[
+  "def"
+  "as"
+  "label"
+  "module"
+  "break"
+] @keyword
+
+[
+  "import"
+  "include"
+] @keyword.import
+
+[
+  "if"
+  "then"
+  "elif"
+  "else"
+  "end"
+] @keyword.conditional
+
+[
+  "try"
+  "catch"
+] @keyword.exception
+
+[
+  "or"
+  "and"
+] @keyword.operator
+
+; Operators
+[
+  "."
+  "=="
+  "!="
+  ">"
+  ">="
+  "<="
+  "<"
+  "="
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "+="
+  "-="
+  "*="
+  "/="
+  "%="
+  "//="
+  "|"
+  "?"
+  "//"
+  "?//"
+  (recurse) ; ".."
+] @operator
+
+; Punctuation
+[
+  ";"
+  ","
+  ":"
+] @punctuation.delimiter
+
+[
+  "["
+  "]"
+  "{"
+  "}"
+  "("
+  ")"
+] @punctuation.bracket
+
+; Comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/jq/injections.scm b/pack/ant/start/nvim-treesitter/queries/jq/injections.scm
new file mode 100644
index 0000000..f8a7a35
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jq/injections.scm
@@ -0,0 +1,23 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; test(val)
+(query
+  ((funcname) @_function
+    (#any-of? @_function "test" "match" "capture" "scan" "split" "splits" "sub" "gsub"))
+  (args
+    .
+    (query
+      (string) @injection.content
+      (#set! injection.language "regex"))))
+
+; test(regex; flags)
+(query
+  ((funcname) @_function
+    (#any-of? @_function "test" "match" "capture" "scan" "split" "splits" "sub" "gsub"))
+  (args
+    .
+    (args
+      (query
+        (string) @injection.content
+        (#set! injection.language "regex")))))
diff --git a/pack/ant/start/nvim-treesitter/queries/jq/locals.scm b/pack/ant/start/nvim-treesitter/queries/jq/locals.scm
new file mode 100644
index 0000000..0b8a099
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jq/locals.scm
@@ -0,0 +1,10 @@
+(funcdef
+  (identifier) @local.definition.function)
+
+(funcdefargs
+  (identifier) @local.definition.parameter)
+
+(funcname) @local.reference
+
+(index
+  (identifier) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/jsdoc/highlights.scm b/pack/ant/start/nvim-treesitter/queries/jsdoc/highlights.scm
new file mode 100644
index 0000000..08953a0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jsdoc/highlights.scm
@@ -0,0 +1,40 @@
+(tag_name) @keyword @nospell
+
+(type) @type @nospell
+
+[
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ":"
+  "/"
+  "."
+  "#"
+  "~"
+] @punctuation.delimiter
+
+(identifier) @variable @nospell
+
+(tag
+  (tag_name) @_name
+  (identifier) @function
+  (#any-of? @_name "@callback" "@function" "@func" "@method"))
+
+(tag
+  (tag_name) @_name
+  (identifier) @variable.parameter
+  (#any-of? @_name "@param" "@arg" "@argument"))
+
+(tag
+  (tag_name) @_name
+  (identifier) @property
+  (#any-of? @_name "@prop" "@property"))
+
+(tag
+  (tag_name) @_name
+  (identifier) @type
+  (#eq? @_name "@typedef"))
diff --git a/pack/ant/start/nvim-treesitter/queries/json/folds.scm b/pack/ant/start/nvim-treesitter/queries/json/folds.scm
new file mode 100644
index 0000000..4c2b9d3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/json/folds.scm
@@ -0,0 +1,5 @@
+[
+  (pair)
+  (object)
+  (array)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/json/highlights.scm b/pack/ant/start/nvim-treesitter/queries/json/highlights.scm
new file mode 100644
index 0000000..8591528
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/json/highlights.scm
@@ -0,0 +1,38 @@
+[
+  (true)
+  (false)
+] @boolean
+
+(null) @constant.builtin
+
+(number) @number
+
+(pair
+  key: (string) @property)
+
+(pair
+  value: (string) @string)
+
+(array
+  (string) @string)
+
+[
+  ","
+  ":"
+] @punctuation.delimiter
+
+[
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+("\"" @conceal
+  (#set! conceal ""))
+
+(escape_sequence) @string.escape
+
+((escape_sequence) @conceal
+  (#eq? @conceal "\\\"")
+  (#set! conceal "\""))
diff --git a/pack/ant/start/nvim-treesitter/queries/json/indents.scm b/pack/ant/start/nvim-treesitter/queries/json/indents.scm
new file mode 100644
index 0000000..8274ee3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/json/indents.scm
@@ -0,0 +1,9 @@
+[
+  (object)
+  (array)
+] @indent.begin
+
+[
+  "}"
+  "]"
+] @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/json/locals.scm b/pack/ant/start/nvim-treesitter/queries/json/locals.scm
new file mode 100644
index 0000000..aaeee38
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/json/locals.scm
@@ -0,0 +1,4 @@
+[
+  (object)
+  (array)
+] @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/json5/highlights.scm b/pack/ant/start/nvim-treesitter/queries/json5/highlights.scm
new file mode 100644
index 0000000..4ffe311
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/json5/highlights.scm
@@ -0,0 +1,15 @@
+[
+  (true)
+  (false)
+] @boolean
+
+(null) @constant
+
+(string) @string
+
+(number) @number
+
+(comment) @comment @spell
+
+(member
+  name: (_) @keyword)
diff --git a/pack/ant/start/nvim-treesitter/queries/json5/injections.scm b/pack/ant/start/nvim-treesitter/queries/json5/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/json5/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/jsonc/folds.scm b/pack/ant/start/nvim-treesitter/queries/jsonc/folds.scm
new file mode 100644
index 0000000..4126921
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jsonc/folds.scm
@@ -0,0 +1 @@
+; inherits: json
diff --git a/pack/ant/start/nvim-treesitter/queries/jsonc/highlights.scm b/pack/ant/start/nvim-treesitter/queries/jsonc/highlights.scm
new file mode 100644
index 0000000..e501121
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jsonc/highlights.scm
@@ -0,0 +1,3 @@
+; inherits: json
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/jsonc/indents.scm b/pack/ant/start/nvim-treesitter/queries/jsonc/indents.scm
new file mode 100644
index 0000000..3b01ca9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jsonc/indents.scm
@@ -0,0 +1,3 @@
+; inherits: json
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/jsonc/injections.scm b/pack/ant/start/nvim-treesitter/queries/jsonc/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jsonc/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/jsonc/locals.scm b/pack/ant/start/nvim-treesitter/queries/jsonc/locals.scm
new file mode 100644
index 0000000..4126921
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jsonc/locals.scm
@@ -0,0 +1 @@
+; inherits: json
diff --git a/pack/ant/start/nvim-treesitter/queries/jsonnet/folds.scm b/pack/ant/start/nvim-treesitter/queries/jsonnet/folds.scm
new file mode 100644
index 0000000..91257a7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jsonnet/folds.scm
@@ -0,0 +1,10 @@
+[
+  (field)
+  (object)
+  (array)
+  (parenthesis)
+  (bind)
+  ; (params)
+  ; (args)
+  ; (conditional)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/jsonnet/highlights.scm b/pack/ant/start/nvim-treesitter/queries/jsonnet/highlights.scm
new file mode 100644
index 0000000..1e67baa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jsonnet/highlights.scm
@@ -0,0 +1,135 @@
+(id) @variable
+
+(comment) @comment @spell
+
+; Literals
+(null) @constant.builtin
+
+(string) @string
+
+(number) @number
+
+[
+  (true)
+  (false)
+] @boolean
+
+; Keywords
+"for" @keyword.repeat
+
+"in" @keyword.operator
+
+"function" @keyword.function
+
+[
+  "if"
+  "then"
+  "else"
+] @keyword.conditional
+
+[
+  (local)
+  (tailstrict)
+  "function"
+] @keyword
+
+[
+  "assert"
+  "error"
+] @keyword.exception
+
+[
+  (dollar)
+  (self)
+  (super)
+] @variable.builtin
+
+((id) @variable.builtin
+  (#eq? @variable.builtin "std"))
+
+; Operators
+[
+  (multiplicative)
+  (additive)
+  (bitshift)
+  (comparison)
+  (equality)
+  (bitand)
+  (bitxor)
+  (bitor)
+  (and)
+  (or)
+  (unaryop)
+] @operator
+
+; Punctuation
+[
+  "["
+  "]"
+  "{"
+  "}"
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "."
+  ","
+  ";"
+  ":"
+] @punctuation.delimiter
+
+[
+  "::"
+  ":::"
+] @punctuation.special
+
+(field
+  (fieldname)
+  "+" @punctuation.special)
+
+; Imports
+[
+  (import)
+  (importstr)
+] @keyword.import
+
+; Fields
+(fieldname
+  (id) @variable.member)
+
+(fieldname
+  (string
+    (string_content) @variable.member))
+
+; Functions
+(field
+  function: (fieldname
+    (id) @function))
+
+(field
+  function: (fieldname
+    (string
+      (string_content) @function)))
+
+(param
+  identifier: (id) @variable.parameter)
+
+(bind
+  (id) @variable)
+
+(bind
+  function: (id) @function)
+
+; Function call
+(functioncall
+  (fieldaccess
+    last: (id) @function.call)?
+  (fieldaccess_super
+    (id) @function.call)?
+  (id)? @function.call
+  "("
+  (args
+    (named_argument
+      (id) @variable.parameter))?
+  ")")
diff --git a/pack/ant/start/nvim-treesitter/queries/jsonnet/injections.scm b/pack/ant/start/nvim-treesitter/queries/jsonnet/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jsonnet/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/jsonnet/locals.scm b/pack/ant/start/nvim-treesitter/queries/jsonnet/locals.scm
new file mode 100644
index 0000000..7780777
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jsonnet/locals.scm
@@ -0,0 +1,27 @@
+(parenthesis) @local.scope
+
+(anonymous_function) @local.scope
+
+(object) @local.scope
+
+(field) @local.scope
+
+(local_bind) @local.scope
+
+(field
+  function: (fieldname
+    (id) @local.definition.function)
+  (#set! definition.function.scope "parent"))
+
+(bind
+  (id) @local.definition.var)
+
+(bind
+  function: (id) @local.definition.function)
+
+(param
+  (id) @local.definition.parameter)
+
+(id) @local.reference
+
+;(fieldname (id) (#is-not? local)) ; (#is-not?) not supported yet
diff --git a/pack/ant/start/nvim-treesitter/queries/jsx/folds.scm b/pack/ant/start/nvim-treesitter/queries/jsx/folds.scm
new file mode 100644
index 0000000..93c3d9c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jsx/folds.scm
@@ -0,0 +1 @@
+(jsx_element) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/jsx/highlights.scm b/pack/ant/start/nvim-treesitter/queries/jsx/highlights.scm
new file mode 100644
index 0000000..a53b953
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jsx/highlights.scm
@@ -0,0 +1,151 @@
+(jsx_element
+  open_tag: (jsx_opening_element
+    [
+      "<"
+      ">"
+    ] @tag.delimiter))
+
+(jsx_element
+  close_tag: (jsx_closing_element
+    [
+      "</"
+      ">"
+    ] @tag.delimiter))
+
+(jsx_self_closing_element
+  [
+    "<"
+    "/>"
+  ] @tag.delimiter)
+
+(jsx_attribute
+  (property_identifier) @tag.attribute)
+
+(jsx_opening_element
+  name: (identifier) @tag.builtin)
+
+(jsx_closing_element
+  name: (identifier) @tag.builtin)
+
+(jsx_self_closing_element
+  name: (identifier) @tag.builtin)
+
+(jsx_opening_element
+  ((identifier) @tag
+    (#lua-match? @tag "^[A-Z]")))
+
+; Handle the dot operator effectively - <My.Component>
+(jsx_opening_element
+  (member_expression
+    (identifier) @tag.builtin
+    (property_identifier) @tag))
+
+(jsx_closing_element
+  ((identifier) @tag
+    (#lua-match? @tag "^[A-Z]")))
+
+; Handle the dot operator effectively - </My.Component>
+(jsx_closing_element
+  (member_expression
+    (identifier) @tag.builtin
+    (property_identifier) @tag))
+
+(jsx_self_closing_element
+  ((identifier) @tag
+    (#lua-match? @tag "^[A-Z]")))
+
+; Handle the dot operator effectively - <My.Component />
+(jsx_self_closing_element
+  (member_expression
+    (identifier) @tag.builtin
+    (property_identifier) @tag))
+
+(html_character_reference) @tag
+
+(jsx_text) @none @spell
+
+(html_character_reference) @character.special
+
+((jsx_element
+  (jsx_opening_element
+    name: (identifier) @_tag)
+  (jsx_text) @markup.heading)
+  (#eq? @_tag "title"))
+
+((jsx_element
+  (jsx_opening_element
+    name: (identifier) @_tag)
+  (jsx_text) @markup.heading.1)
+  (#eq? @_tag "h1"))
+
+((jsx_element
+  (jsx_opening_element
+    name: (identifier) @_tag)
+  (jsx_text) @markup.heading.2)
+  (#eq? @_tag "h2"))
+
+((jsx_element
+  (jsx_opening_element
+    name: (identifier) @_tag)
+  (jsx_text) @markup.heading.3)
+  (#eq? @_tag "h3"))
+
+((jsx_element
+  (jsx_opening_element
+    name: (identifier) @_tag)
+  (jsx_text) @markup.heading.4)
+  (#eq? @_tag "h4"))
+
+((jsx_element
+  (jsx_opening_element
+    name: (identifier) @_tag)
+  (jsx_text) @markup.heading.5)
+  (#eq? @_tag "h5"))
+
+((jsx_element
+  (jsx_opening_element
+    name: (identifier) @_tag)
+  (jsx_text) @markup.heading.6)
+  (#eq? @_tag "h6"))
+
+((jsx_element
+  (jsx_opening_element
+    name: (identifier) @_tag)
+  (jsx_text) @markup.strong)
+  (#any-of? @_tag "strong" "b"))
+
+((jsx_element
+  (jsx_opening_element
+    name: (identifier) @_tag)
+  (jsx_text) @markup.italic)
+  (#any-of? @_tag "em" "i"))
+
+((jsx_element
+  (jsx_opening_element
+    name: (identifier) @_tag)
+  (jsx_text) @markup.strikethrough)
+  (#any-of? @_tag "s" "del"))
+
+((jsx_element
+  (jsx_opening_element
+    name: (identifier) @_tag)
+  (jsx_text) @markup.underline)
+  (#eq? @_tag "u"))
+
+((jsx_element
+  (jsx_opening_element
+    name: (identifier) @_tag)
+  (jsx_text) @markup.raw)
+  (#any-of? @_tag "code" "kbd"))
+
+((jsx_element
+  (jsx_opening_element
+    name: (identifier) @_tag)
+  (jsx_text) @markup.link.label)
+  (#eq? @_tag "a"))
+
+((jsx_attribute
+  (property_identifier) @_attr
+  (string
+    (string_fragment) @string.special.url))
+  (#any-of? @_attr "href" "src"))
diff --git a/pack/ant/start/nvim-treesitter/queries/jsx/indents.scm b/pack/ant/start/nvim-treesitter/queries/jsx/indents.scm
new file mode 100644
index 0000000..812bc25
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jsx/indents.scm
@@ -0,0 +1,21 @@
+[
+  (jsx_element)
+  (jsx_self_closing_element)
+  (jsx_expression)
+] @indent.begin
+
+(jsx_closing_element
+  ">" @indent.end)
+
+(jsx_self_closing_element
+  "/>" @indent.end)
+
+[
+  (jsx_closing_element)
+  ">"
+] @indent.branch
+
+; <button
+; />
+(jsx_self_closing_element
+  "/>" @indent.branch)
diff --git a/pack/ant/start/nvim-treesitter/queries/jsx/injections.scm b/pack/ant/start/nvim-treesitter/queries/jsx/injections.scm
new file mode 100644
index 0000000..269ee3f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/jsx/injections.scm
@@ -0,0 +1,11 @@
+; Styled Jsx <style jsx>
+(jsx_element
+  (jsx_opening_element
+    (identifier) @_name
+    (#eq? @_name "style")
+    (jsx_attribute) @_attr
+    (#eq? @_attr "jsx"))
+  (jsx_expression
+    ((template_string) @injection.content
+      (#set! injection.language "css"))
+    (#offset! @injection.content 0 1 0 -1)))
diff --git a/pack/ant/start/nvim-treesitter/queries/julia/folds.scm b/pack/ant/start/nvim-treesitter/queries/julia/folds.scm
new file mode 100644
index 0000000..2cbdc28
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/julia/folds.scm
@@ -0,0 +1,14 @@
+[
+  (module_definition)
+  (struct_definition)
+  (macro_definition)
+  (function_definition)
+  (if_statement)
+  (try_statement)
+  (for_statement)
+  (while_statement)
+  (let_statement)
+  (quote_statement)
+  (do_clause)
+  (compound_statement)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/julia/highlights.scm b/pack/ant/start/nvim-treesitter/queries/julia/highlights.scm
new file mode 100644
index 0000000..d67c69c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/julia/highlights.scm
@@ -0,0 +1,365 @@
+; Identifiers
+(identifier) @variable
+
+; ;; If you want type highlighting based on Julia naming conventions (this might collide with mathematical notation)
+; ((identifier) @type
+;   (match? @type "^[A-Z][^_]"))  ; exception: Highlight `A_foo` sort of identifiers as variables
+(quote_expression
+  ":" @string.special.symbol
+  [
+    (identifier)
+    (operator)
+  ] @string.special.symbol)
+
+(field_expression
+  (identifier) @variable.member .)
+
+; calls
+(call_expression
+  (identifier) @function.call)
+
+(call_expression
+  (field_expression
+    (identifier) @function.call .))
+
+(broadcast_call_expression
+  (identifier) @function.call)
+
+(broadcast_call_expression
+  (field_expression
+    (identifier) @function.call .))
+
+(binary_expression
+  (_)
+  (operator) @_pipe
+  (identifier) @function.call
+  (#any-of? @_pipe "|>" ".|>"))
+
+(macro_identifier) @function.macro
+
+(macro_identifier
+  (identifier) @function.macro) ; for any one using the variable highlight
+
+(macro_definition
+  (signature
+    (call_expression
+      .
+      (identifier) @function.macro)))
+
+; Builtins
+((identifier) @function.builtin
+  (#any-of? @function.builtin
+    "_abstracttype" "_apply_iterate" "_apply_pure" "_call_in_world" "_call_in_world_total"
+    "_call_latest" "_equiv_typedef" "_expr" "_primitivetype" "_setsuper!" "_structtype" "_typebody!"
+    "_typevar" "applicable" "apply_type" "arrayref" "arrayset" "arraysize" "const_arrayref"
+    "donotdelete" "fieldtype" "get_binding_type" "getfield" "ifelse" "invoke" "isa" "isdefined"
+    "modifyfield!" "nfields" "replacefield!" "set_binding_type!" "setfield!" "sizeof" "svec"
+    "swapfield!" "throw" "tuple" "typeassert" "typeof"))
+
+; Types
+; Definitions
+(abstract_definition
+  name: (identifier) @type.definition) @keyword
+
+(primitive_definition
+  name: (identifier) @type.definition) @keyword
+
+(struct_definition
+  name: (identifier) @type)
+
+(type_clause
+  [
+    (identifier) @type
+    (field_expression
+      (identifier) @type .)
+  ])
+
+; Annotations
+(parametrized_type_expression
+  (_) @type
+  (curly_expression
+    (_) @type))
+
+(type_parameter_list
+  (identifier) @type)
+
+(typed_expression
+  (identifier) @type .)
+
+(unary_typed_expression
+  (identifier) @type .)
+
+(where_clause
+  (identifier) @type)
+
+(where_clause
+  (curly_expression
+    (_) @type))
+
+; Builtins
+; This list was generated with:
+;
+;  istype(x) = typeof(x) === DataType || typeof(x) === UnionAll
+;  get_types(m) = filter(x -> istype(Base.eval(m, x)), names(m))
+;  type_names = sort(union(get_types(Core), get_types(Base)))
+;
+((identifier) @type.builtin
+  (#any-of? @type.builtin
+    "AbstractArray" "AbstractChannel" "AbstractChar" "AbstractDict" "AbstractDisplay"
+    "AbstractFloat" "AbstractIrrational" "AbstractLock" "AbstractMatch" "AbstractMatrix"
+    "AbstractPattern" "AbstractRange" "AbstractSet" "AbstractSlices" "AbstractString"
+    "AbstractUnitRange" "AbstractVecOrMat" "AbstractVector" "Any" "ArgumentError" "Array"
+    "AssertionError" "Atomic" "BigFloat" "BigInt" "BitArray" "BitMatrix" "BitSet" "BitVector" "Bool"
+    "BoundsError" "By" "CanonicalIndexError" "CapturedException" "CartesianIndex" "CartesianIndices"
+    "Cchar" "Cdouble" "Cfloat" "Channel" "Char" "Cint" "Cintmax_t" "Clong" "Clonglong" "Cmd" "Colon"
+    "ColumnSlices" "Complex" "ComplexF16" "ComplexF32" "ComplexF64" "ComposedFunction"
+    "CompositeException" "ConcurrencyViolationError" "Condition" "Cptrdiff_t" "Cshort" "Csize_t"
+    "Cssize_t" "Cstring" "Cuchar" "Cuint" "Cuintmax_t" "Culong" "Culonglong" "Cushort" "Cvoid"
+    "Cwchar_t" "Cwstring" "DataType" "DenseArray" "DenseMatrix" "DenseVecOrMat" "DenseVector" "Dict"
+    "DimensionMismatch" "Dims" "DivideError" "DomainError" "EOFError" "Enum" "ErrorException"
+    "Exception" "ExponentialBackOff" "Expr" "Float16" "Float32" "Float64" "Function" "GlobalRef"
+    "HTML" "IO" "IOBuffer" "IOContext" "IOStream" "IdDict" "IndexCartesian" "IndexLinear"
+    "IndexStyle" "InexactError" "InitError" "Int" "Int128" "Int16" "Int32" "Int64" "Int8" "Integer"
+    "InterruptException" "InvalidStateException" "Irrational" "KeyError" "LazyString" "LinRange"
+    "LineNumberNode" "LinearIndices" "LoadError" "Lt" "MIME" "Matrix" "Method" "MethodError"
+    "Missing" "MissingException" "Module" "NTuple" "NamedTuple" "Nothing" "Number" "Ordering"
+    "OrdinalRange" "OutOfMemoryError" "OverflowError" "Pair" "ParseError" "PartialQuickSort" "Perm"
+    "PermutedDimsArray" "Pipe" "ProcessFailedException" "Ptr" "QuoteNode" "Rational" "RawFD"
+    "ReadOnlyMemoryError" "Real" "ReentrantLock" "Ref" "Regex" "RegexMatch" "Returns"
+    "ReverseOrdering" "RoundingMode" "RowSlices" "SegmentationFault" "Set" "Signed" "Slices" "Some"
+    "SpinLock" "StackFrame" "StackOverflowError" "StackTrace" "Stateful" "StepRange" "StepRangeLen"
+    "StridedArray" "StridedMatrix" "StridedVecOrMat" "StridedVector" "String" "StringIndexError"
+    "SubArray" "SubString" "SubstitutionString" "Symbol" "SystemError" "Task" "TaskFailedException"
+    "Text" "TextDisplay" "Timer" "Tmstruct" "Tuple" "Type" "TypeError" "TypeVar" "UInt" "UInt128"
+    "UInt16" "UInt32" "UInt64" "UInt8" "UndefInitializer" "UndefKeywordError" "UndefRefError"
+    "UndefVarError" "Union" "UnionAll" "UnitRange" "Unsigned" "Val" "VecElement" "VecOrMat" "Vector"
+    "VersionNumber" "WeakKeyDict" "WeakRef"))
+
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin "begin" "end")
+  (#has-ancestor? @variable.builtin index_expression))
+
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin "begin" "end")
+  (#has-ancestor? @variable.builtin range_expression))
+
+; Keywords
+[
+  "global"
+  "local"
+] @keyword
+
+(compound_statement
+  [
+    "begin"
+    "end"
+  ] @keyword)
+
+(quote_statement
+  [
+    "quote"
+    "end"
+  ] @keyword)
+
+(let_statement
+  [
+    "let"
+    "end"
+  ] @keyword)
+
+(if_statement
+  [
+    "if"
+    "end"
+  ] @keyword.conditional)
+
+(elseif_clause
+  "elseif" @keyword.conditional)
+
+(else_clause
+  "else" @keyword.conditional)
+
+(if_clause
+  "if" @keyword.conditional) ; `if` clause in comprehensions
+
+(ternary_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+(try_statement
+  [
+    "try"
+    "end"
+  ] @keyword.exception)
+
+(finally_clause
+  "finally" @keyword.exception)
+
+(catch_clause
+  "catch" @keyword.exception)
+
+(for_statement
+  [
+    "for"
+    "end"
+  ] @keyword.repeat)
+
+(while_statement
+  [
+    "while"
+    "end"
+  ] @keyword.repeat)
+
+(for_clause
+  "for" @keyword.repeat)
+
+(for_binding
+  "outer" @keyword.repeat)
+
+[
+  (break_statement)
+  (continue_statement)
+] @keyword.repeat
+
+(module_definition
+  [
+    "module"
+    "baremodule"
+    "end"
+  ] @keyword.import)
+
+(import_statement
+  [
+    "import"
+    "using"
+  ] @keyword.import)
+
+(import_alias
+  "as" @keyword.import)
+
+(export_statement
+  "export" @keyword.import)
+
+(selected_import
+  ":" @punctuation.delimiter)
+
+(struct_definition
+  [
+    "struct"
+    "end"
+  ] @keyword.type)
+
+(macro_definition
+  [
+    "macro"
+    "end"
+  ] @keyword)
+
+(function_definition
+  [
+    "function"
+    "end"
+  ] @keyword.function)
+
+(do_clause
+  [
+    "do"
+    "end"
+  ] @keyword.function)
+
+(return_statement
+  "return" @keyword.return)
+
+[
+  "const"
+  "mutable"
+] @keyword.modifier
+
+; Operators & Punctuation
+[
+  "="
+  "∈"
+  (operator)
+] @operator
+
+(adjoint_expression
+  "'" @operator)
+
+(range_expression
+  ":" @operator)
+
+((operator) @keyword.operator
+  (#any-of? @keyword.operator "in" "isa"))
+
+(for_binding
+  "in" @keyword.operator)
+
+(where_clause
+  "where" @keyword.operator)
+
+(where_expression
+  "where" @keyword.operator)
+
+[
+  ","
+  "."
+  ";"
+  "::"
+  "->"
+] @punctuation.delimiter
+
+"..." @punctuation.special
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; Literals
+(boolean_literal) @boolean
+
+(integer_literal) @number
+
+(float_literal) @number.float
+
+((identifier) @number.float
+  (#any-of? @number.float "NaN" "NaN16" "NaN32" "Inf" "Inf16" "Inf32"))
+
+((identifier) @constant.builtin
+  (#any-of? @constant.builtin "nothing" "missing"))
+
+(character_literal) @character
+
+(escape_sequence) @string.escape
+
+(string_literal) @string
+
+(prefixed_string_literal
+  prefix: (identifier) @function.macro) @string
+
+(command_literal) @string.special
+
+(prefixed_command_literal
+  prefix: (identifier) @function.macro) @string.special
+
+((string_literal) @string.documentation @spell
+  .
+  [
+    (module_definition)
+    (abstract_definition)
+    (struct_definition)
+    (function_definition)
+    (assignment)
+    (const_statement)
+  ])
+
+[
+  (line_comment)
+  (block_comment)
+] @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/julia/indents.scm b/pack/ant/start/nvim-treesitter/queries/julia/indents.scm
new file mode 100644
index 0000000..7b40f87
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/julia/indents.scm
@@ -0,0 +1,52 @@
+[
+  (struct_definition)
+  (macro_definition)
+  (function_definition)
+  (compound_statement)
+  (if_statement)
+  (try_statement)
+  (for_statement)
+  (while_statement)
+  (let_statement)
+  (quote_statement)
+  (do_clause)
+  (assignment)
+  (for_binding)
+  (call_expression)
+  (parenthesized_expression)
+  (tuple_expression)
+  (comprehension_expression)
+  (matrix_expression)
+  (vector_expression)
+] @indent.begin
+
+[
+  "end"
+  ")"
+  "]"
+  "}"
+] @indent.end
+
+[
+  "end"
+  ")"
+  "]"
+  "}"
+  (else_clause)
+  (elseif_clause)
+  (catch_clause)
+  (finally_clause)
+] @indent.branch
+
+[
+  (line_comment)
+  (block_comment)
+] @indent.ignore
+
+((argument_list) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+((curly_expression) @indent.align
+  (#set! indent.open_delimiter "{")
+  (#set! indent.close_delimiter "}"))
diff --git a/pack/ant/start/nvim-treesitter/queries/julia/injections.scm b/pack/ant/start/nvim-treesitter/queries/julia/injections.scm
new file mode 100644
index 0000000..2ed0eb4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/julia/injections.scm
@@ -0,0 +1,40 @@
+; Inject markdown in docstrings
+((string_literal) @injection.content
+  .
+  [
+    (module_definition)
+    (abstract_definition)
+    (struct_definition)
+    (function_definition)
+    (macro_definition)
+    (assignment)
+    (const_statement)
+  ]
+  (#lua-match? @injection.content "^\"\"\"")
+  (#set! injection.language "markdown")
+  (#offset! @injection.content 0 3 0 -3))
+
+; Inject comments
+([
+  (line_comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
+
+; Inject regex in r"hello\bworld"
+((prefixed_string_literal
+  prefix: (identifier) @_prefix) @injection.content
+  (#eq? @_prefix "r")
+  (#set! injection.language "regex")
+  (#offset! @injection.content 0 2 0 -1))
+
+; Inject markdown in md"**Bold** and _Italics_"
+((prefixed_string_literal
+  prefix: (identifier) @_prefix) @injection.content
+  (#eq? @_prefix "md")
+  (#set! injection.language "markdown")
+  (#offset! @injection.content 0 3 0 -1))
+
+; Inject bash in `git add --help`
+((command_literal) @injection.content
+  (#set! injection.language "bash"))
diff --git a/pack/ant/start/nvim-treesitter/queries/julia/locals.scm b/pack/ant/start/nvim-treesitter/queries/julia/locals.scm
new file mode 100644
index 0000000..767239f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/julia/locals.scm
@@ -0,0 +1,66 @@
+; Variables
+(assignment
+  (identifier) @local.definition.var)
+
+(assignment
+  (tuple_expression
+    (identifier) @local.definition.var))
+
+; let/const bindings
+(let_binding
+  (identifier) @local.definition.var)
+
+(let_binding
+  (tuple_expression
+    (identifier) @local.definition.var))
+
+; For bindings
+(for_binding
+  (identifier) @local.definition.var)
+
+(for_binding
+  (tuple_expression
+    (identifier) @local.definition.var))
+
+; Types
+(struct_definition
+  name: (identifier) @local.definition.type)
+
+(abstract_definition
+  name: (identifier) @local.definition.type)
+
+(abstract_definition
+  name: (identifier) @local.definition.type)
+
+(type_parameter_list
+  (identifier) @local.definition.type)
+
+; Module imports
+(import_statement
+  (identifier) @local.definition.import)
+
+; Function/macro definitions
+(function_definition
+  (signature
+    (call_expression
+      .
+      (identifier) @local.definition.function))) @local.scope
+
+(macro_definition
+  (signature
+    (call_expression
+      .
+      (identifier) @local.definition.function))) @local.scope
+
+(identifier) @local.reference
+
+[
+  (for_statement)
+  (while_statement)
+  (try_statement)
+  (catch_clause)
+  (finally_clause)
+  (let_statement)
+  (quote_statement)
+  (do_clause)
+] @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/just/folds.scm b/pack/ant/start/nvim-treesitter/queries/just/folds.scm
new file mode 100644
index 0000000..fea3a50
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/just/folds.scm
@@ -0,0 +1,6 @@
+([
+  (recipe)
+  (string)
+  (external_command)
+] @fold
+  (#trim! @fold))
diff --git a/pack/ant/start/nvim-treesitter/queries/just/highlights.scm b/pack/ant/start/nvim-treesitter/queries/just/highlights.scm
new file mode 100644
index 0000000..b15a857
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/just/highlights.scm
@@ -0,0 +1,133 @@
+[
+  "true"
+  "false"
+] @boolean
+
+[
+  "if"
+  "else"
+] @keyword.conditional
+
+[
+  "alias"
+  "set"
+  "shell"
+  "mod"
+] @keyword
+
+[
+  "import"
+  "export"
+] @keyword.import
+
+[
+  ":="
+  "?"
+  "=="
+  "!="
+  "=~"
+  "@"
+  "="
+  "$"
+  "*"
+  "+"
+  "&&"
+  "@-"
+  "-@"
+  "-"
+  "/"
+  ":"
+] @operator
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{{"
+  "}}"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "`"
+  "```"
+] @punctuation.special
+
+"," @punctuation.delimiter
+
+(shebang) @keyword.directive
+
+(comment) @comment @spell
+
+[
+  (string)
+  (external_command)
+] @string
+
+(escape_sequence) @string.escape
+
+(module
+  (identifier) @module)
+
+(assignment
+  (identifier) @variable)
+
+(alias
+  (identifier) @variable)
+
+(value
+  (identifier) @variable)
+
+; Recipe definitions
+(recipe_header
+  (identifier) @function)
+
+(dependency
+  (identifier) @function.call)
+
+(dependency_expression
+  (identifier) @function.call)
+
+(parameter
+  (identifier) @variable.parameter)
+
+(dependency_expression
+  (expression
+    (value
+      (identifier) @variable.parameter)))
+
+; Fallback highlighting for recipe bodies
+(recipe
+  (recipe_body) @string
+  (#set! priority 90))
+
+; Ref: https://just.systems/man/en/chapter_26.html
+;(setting (identifier) @error)
+(setting
+  (identifier) @constant.builtin
+  (#any-of? @constant.builtin
+    "allow-duplicate-recipes" "dotenv-filename" "dotenv-load" "dotenv-path" "export" "fallback"
+    "ignore-comments" "positional-arguments" "tempdir" "windows-powershell" "windows-shell"))
+
+; Ref: https://just.systems/man/en/chapter_32.html
+;(recipe (attribute (identifier) @error))
+(recipe
+  (attribute
+    (identifier) @attribute)
+  (#any-of? @attribute
+    "confirm" "linux" "macos" "no-cd" "no-exit-message" "no-quiet" "private" "unix" "windows"))
+
+; Ref: https://just.systems/man/en/chapter_31.html
+;(function_call (identifier) @error)
+(function_call
+  (identifier) @function.call
+  (#any-of? @function.call
+    "arch" "num_cpus" "os" "os_family" "env_var" "env_var_or_default" "env" "invocation_directory"
+    "invocation_directory_native" "justfile" "justfile_directory" "just_executable" "quote"
+    "replace" "replace_regex" "trim" "trim_end" "trim_end_match" "trim_end_matches" "trim_start"
+    "trim_start_match" "trim_start_matches" "capitalize" "kebabcase" "lowercamelcase" "lowercase"
+    "shoutykebabcase" "shoutysnakecase" "snakecase" "titlecase" "uppercamelcase" "uppercase"
+    "absolute_path" "extension" "file_name" "file_stem" "parent_directory" "without_extension"
+    "clean" "join" "path_exists" "error" "sha256" "sha256_file" "uuid" "semver_matches"))
diff --git a/pack/ant/start/nvim-treesitter/queries/just/indents.scm b/pack/ant/start/nvim-treesitter/queries/just/indents.scm
new file mode 100644
index 0000000..1402a0c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/just/indents.scm
@@ -0,0 +1,14 @@
+; Source: https://github.com/IndianBoy42/tree-sitter-just/blob/main/queries/just/indents.scm
+[
+  (recipe)
+  (string)
+  (external_command)
+] @indent.begin
+
+(string
+  [
+    "'''"
+    "\"\"\""
+  ] @indent.branch @indent.end)
+
+(comment) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/just/injections.scm b/pack/ant/start/nvim-treesitter/queries/just/injections.scm
new file mode 100644
index 0000000..90db6b7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/just/injections.scm
@@ -0,0 +1,44 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; The right side of =~ literals
+(regex_literal
+  (_) @injection.content
+  (#set! injection.language "regex"))
+
+; Default to bash highlighting for non-shebang recipes and commands
+(recipe
+  (recipe_body
+    !shebang) @injection.content
+  (#set! injection.include-children)
+  (#set! injection.language "bash"))
+
+(external_command
+  (command_body) @injection.content
+  (#set! injection.language "bash"))
+
+; For shebang recipes, use the shebang executable name as the language by default
+(recipe
+  (recipe_body
+    (shebang
+      (language) @injection.language)) @injection.content
+  (#not-any-of? @injection.language "python3" "nodejs" "node")
+  (#set! injection.include-children))
+
+; python3 -> python
+(recipe
+  (recipe_body
+    (shebang
+      (language) @_lang)) @injection.content
+  (#eq? @_lang "python3")
+  (#set! injection.language "python")
+  (#set! injection.include-children))
+
+; node/nodejs -> javascript
+(recipe
+  (recipe_body
+    (shebang
+      (language) @_lang)) @injection.content
+  (#any-of? @_lang "node" "nodejs")
+  (#set! injection.language "javascript")
+  (#set! injection.include-children))
diff --git a/pack/ant/start/nvim-treesitter/queries/just/locals.scm b/pack/ant/start/nvim-treesitter/queries/just/locals.scm
new file mode 100644
index 0000000..80549f3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/just/locals.scm
@@ -0,0 +1,35 @@
+; Source: https://github.com/IndianBoy42/tree-sitter-just/blob/main/queries/just/locals.scm
+; Scope
+(recipe) @local.scope
+
+; Definitions
+(alias
+  left: (identifier) @local.definition.var)
+
+(assignment
+  left: (identifier) @local.definition.var)
+
+(module
+  name: (identifier) @local.definition.namespace)
+
+(parameter
+  name: (identifier) @local.definition.var)
+
+(recipe_header
+  name: (identifier) @local.definition.function)
+
+; References
+(alias
+  right: (identifier) @local.reference)
+
+(function_call
+  name: (identifier) @local.reference)
+
+(dependency
+  name: (identifier) @local.reference)
+
+(dependency_expression
+  name: (identifier) @local.reference)
+
+(value
+  (identifier) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/kconfig/folds.scm b/pack/ant/start/nvim-treesitter/queries/kconfig/folds.scm
new file mode 100644
index 0000000..980667d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kconfig/folds.scm
@@ -0,0 +1,9 @@
+[
+  (config)
+  (menuconfig)
+  (choice)
+  (comment_entry)
+  (menu)
+  (if)
+  (help_text)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/kconfig/highlights.scm b/pack/ant/start/nvim-treesitter/queries/kconfig/highlights.scm
new file mode 100644
index 0000000..307ce1a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kconfig/highlights.scm
@@ -0,0 +1,102 @@
+"source" @keyword.import
+
+[
+  "mainmenu"
+  "config"
+  "menuconfig"
+  "choice"
+  "endchoice"
+  "comment"
+  "menu"
+  "endmenu"
+  "prompt"
+  "default"
+  "range"
+  "help"
+  (optional)
+  (modules)
+] @keyword
+
+[
+  "if"
+  "endif"
+  "depends on"
+  "select"
+  "imply"
+  "visible if"
+] @keyword.conditional
+
+[
+  "def_bool"
+  "def_tristate"
+] @keyword.function
+
+[
+  "||"
+  "&&"
+  "="
+  "!="
+  "<"
+  ">"
+  "<="
+  ">="
+  "!"
+  ":="
+  "+="
+  "?="
+] @operator
+
+[
+  "bool"
+  "tristate"
+  "int"
+  "hex"
+  "string"
+] @type.builtin
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+"," @punctuation.delimiter
+
+(macro_variable
+  [
+    "$("
+    ")"
+  ] @punctuation.special)
+
+(symbol) @variable
+
+[
+  (prompt)
+  (macro_content)
+  (text)
+] @string
+
+(config
+  name: (symbol) @constant)
+
+(menuconfig
+  name: (symbol) @constant)
+
+(choice
+  name: (symbol) @constant)
+
+((symbol) @constant
+  (#lua-match? @constant "[A-Z0-9]+"))
+
+(mainmenu
+  name: (prompt) @markup.heading)
+
+(comment_entry
+  name: (prompt) @markup.heading)
+
+(menu
+  name: (prompt) @markup.heading)
+
+(source
+  (prompt) @string.special.url)
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/kconfig/indents.scm b/pack/ant/start/nvim-treesitter/queries/kconfig/indents.scm
new file mode 100644
index 0000000..faa8360
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kconfig/indents.scm
@@ -0,0 +1,12 @@
+(help_text
+  (text) @indent.auto)
+
+[
+  (config)
+  (menuconfig)
+  (choice)
+  (comment_entry)
+  (menu)
+  (if)
+  (help_text)
+] @indent.begin
diff --git a/pack/ant/start/nvim-treesitter/queries/kconfig/injections.scm b/pack/ant/start/nvim-treesitter/queries/kconfig/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kconfig/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/kconfig/locals.scm b/pack/ant/start/nvim-treesitter/queries/kconfig/locals.scm
new file mode 100644
index 0000000..1fc1b30
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kconfig/locals.scm
@@ -0,0 +1,24 @@
+[
+  (symbol)
+  (prompt)
+] @local.reference
+
+[
+  (config)
+  (menuconfig)
+  (choice)
+  (comment_entry)
+  (menu)
+  (if)
+] @local.scope
+
+(type_definition
+  (prompt) @local.definition.var)
+
+(type_definition
+  (input_prompt
+    (prompt) @local.definition.var))
+
+(type_definition_default
+  (expression
+    (prompt) @local.definition.var))
diff --git a/pack/ant/start/nvim-treesitter/queries/kdl/folds.scm b/pack/ant/start/nvim-treesitter/queries/kdl/folds.scm
new file mode 100644
index 0000000..c96619b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kdl/folds.scm
@@ -0,0 +1,7 @@
+; Folds
+[
+  (node)
+  (node_children)
+  (string)
+  (multi_line_comment)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/kdl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/kdl/highlights.scm
new file mode 100644
index 0000000..e61361f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kdl/highlights.scm
@@ -0,0 +1,70 @@
+; Types
+(node
+  (identifier) @type)
+
+(type) @type
+
+(annotation_type) @type.builtin
+
+; Properties
+(prop
+  (identifier) @property)
+
+; Variables
+(identifier) @variable
+
+; Operators
+[
+  "="
+  "+"
+  "-"
+] @operator
+
+; Literals
+(string) @string
+
+(escape) @string.escape
+
+(number) @number
+
+(number
+  (decimal) @number.float)
+
+(number
+  (exponent) @number.float)
+
+(boolean) @boolean
+
+"null" @constant.builtin
+
+; Punctuation
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+";" @punctuation.delimiter
+
+; Comments
+[
+  (single_line_comment)
+  (multi_line_comment)
+] @comment @spell
+
+(node
+  (node_comment)
+  (#set! priority 105)) @comment
+
+(node
+  (node_field
+    (node_field_comment)
+    (#set! priority 105)) @comment)
+
+(node_children
+  (node_children_comment)
+  (#set! priority 105)) @comment
diff --git a/pack/ant/start/nvim-treesitter/queries/kdl/indents.scm b/pack/ant/start/nvim-treesitter/queries/kdl/indents.scm
new file mode 100644
index 0000000..6d16efd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kdl/indents.scm
@@ -0,0 +1,14 @@
+(node
+  (node_children) @indent.begin)
+
+"}" @indent.end
+
+[
+  "{"
+  "}"
+] @indent.branch
+
+[
+  "("
+  ")"
+] @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/kdl/injections.scm b/pack/ant/start/nvim-treesitter/queries/kdl/injections.scm
new file mode 100644
index 0000000..81d7734
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kdl/injections.scm
@@ -0,0 +1,5 @@
+([
+  (single_line_comment)
+  (multi_line_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/kdl/locals.scm b/pack/ant/start/nvim-treesitter/queries/kdl/locals.scm
new file mode 100644
index 0000000..14b0af2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kdl/locals.scm
@@ -0,0 +1,16 @@
+(document) @local.scope
+
+(node
+  (node_children) @local.scope)
+
+(node_children
+  (node) @local.scope)
+
+(identifier) @local.reference
+
+(node_field) @local.definition.field
+
+(node
+  (identifier) @local.definition.type)
+
+(type) @local.definition.type
diff --git a/pack/ant/start/nvim-treesitter/queries/kotlin/folds.scm b/pack/ant/start/nvim-treesitter/queries/kotlin/folds.scm
new file mode 100644
index 0000000..eb4becc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kotlin/folds.scm
@@ -0,0 +1,13 @@
+[
+  (import_list)
+  (when_expression)
+  (control_structure_body)
+  (lambda_literal)
+  (function_body)
+  (primary_constructor)
+  (secondary_constructor)
+  (anonymous_initializer)
+  (class_body)
+  (enum_class_body)
+  (interpolated_expression)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/kotlin/highlights.scm b/pack/ant/start/nvim-treesitter/queries/kotlin/highlights.scm
new file mode 100644
index 0000000..8eda6ef
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kotlin/highlights.scm
@@ -0,0 +1,398 @@
+; Identifiers
+(simple_identifier) @variable
+
+; `it` keyword inside lambdas
+; FIXME: This will highlight the keyword outside of lambdas since tree-sitter
+;        does not allow us to check for arbitrary nestation
+((simple_identifier) @variable.builtin
+  (#eq? @variable.builtin "it"))
+
+; `field` keyword inside property getter/setter
+; FIXME: This will highlight the keyword outside of getters and setters
+;        since tree-sitter does not allow us to check for arbitrary nestation
+((simple_identifier) @variable.builtin
+  (#eq? @variable.builtin "field"))
+
+[
+  "this"
+  "super"
+  "this@"
+  "super@"
+] @variable.builtin
+
+; NOTE: for consistency with "super@"
+(super_expression
+  "@" @variable.builtin)
+
+(class_parameter
+  (simple_identifier) @variable.member)
+
+; NOTE: temporary fix for treesitter bug that causes delay in file opening
+;(class_body
+;  (property_declaration
+;    (variable_declaration
+;      (simple_identifier) @variable.member)))
+; id_1.id_2.id_3: `id_2` and `id_3` are assumed as object properties
+(_
+  (navigation_suffix
+    (simple_identifier) @variable.member))
+
+; SCREAMING CASE identifiers are assumed to be constants
+((simple_identifier) @constant
+  (#lua-match? @constant "^[A-Z][A-Z0-9_]*$"))
+
+(_
+  (navigation_suffix
+    (simple_identifier) @constant
+    (#lua-match? @constant "^[A-Z][A-Z0-9_]*$")))
+
+(enum_entry
+  (simple_identifier) @constant)
+
+(type_identifier) @type
+
+; '?' operator, replacement for Java @Nullable
+(nullable_type) @punctuation.special
+
+(type_alias
+  (type_identifier) @type.definition)
+
+((type_identifier) @type.builtin
+  (#any-of? @type.builtin
+    "Byte" "Short" "Int" "Long" "UByte" "UShort" "UInt" "ULong" "Float" "Double" "Boolean" "Char"
+    "String" "Array" "ByteArray" "ShortArray" "IntArray" "LongArray" "UByteArray" "UShortArray"
+    "UIntArray" "ULongArray" "FloatArray" "DoubleArray" "BooleanArray" "CharArray" "Map" "Set"
+    "List" "EmptyMap" "EmptySet" "EmptyList" "MutableMap" "MutableSet" "MutableList"))
+
+(package_header
+  "package" @keyword
+  .
+  (identifier
+    (simple_identifier) @module))
+
+(import_header
+  "import" @keyword.import)
+
+(wildcard_import) @character.special
+
+; The last `simple_identifier` in a `import_header` will always either be a function
+; or a type. Classes can appear anywhere in the import path, unlike functions
+(import_header
+  (identifier
+    (simple_identifier) @type @_import)
+  (import_alias
+    (type_identifier) @type.definition)?
+  (#lua-match? @_import "^[A-Z]"))
+
+(import_header
+  (identifier
+    (simple_identifier) @function @_import .)
+  (import_alias
+    (type_identifier) @function)?
+  (#lua-match? @_import "^[a-z]"))
+
+(label) @label
+
+; Function definitions
+(function_declaration
+  (simple_identifier) @function)
+
+(getter
+  "get" @function.builtin)
+
+(setter
+  "set" @function.builtin)
+
+(primary_constructor) @constructor
+
+(secondary_constructor
+  "constructor" @constructor)
+
+(constructor_invocation
+  (user_type
+    (type_identifier) @constructor))
+
+(anonymous_initializer
+  "init" @constructor)
+
+(parameter
+  (simple_identifier) @variable.parameter)
+
+(parameter_with_optional_type
+  (simple_identifier) @variable.parameter)
+
+; lambda parameters
+(lambda_literal
+  (lambda_parameters
+    (variable_declaration
+      (simple_identifier) @variable.parameter)))
+
+; Function calls
+; function()
+(call_expression
+  .
+  (simple_identifier) @function.call)
+
+; ::function
+(callable_reference
+  .
+  (simple_identifier) @function.call)
+
+; object.function() or object.property.function()
+(call_expression
+  (navigation_expression
+    (navigation_suffix
+      (simple_identifier) @function.call) .))
+
+(call_expression
+  .
+  (simple_identifier) @function.builtin
+  (#any-of? @function.builtin
+    "arrayOf" "arrayOfNulls" "byteArrayOf" "shortArrayOf" "intArrayOf" "longArrayOf" "ubyteArrayOf"
+    "ushortArrayOf" "uintArrayOf" "ulongArrayOf" "floatArrayOf" "doubleArrayOf" "booleanArrayOf"
+    "charArrayOf" "emptyArray" "mapOf" "setOf" "listOf" "emptyMap" "emptySet" "emptyList"
+    "mutableMapOf" "mutableSetOf" "mutableListOf" "print" "println" "error" "TODO" "run"
+    "runCatching" "repeat" "lazy" "lazyOf" "enumValues" "enumValueOf" "assert" "check"
+    "checkNotNull" "require" "requireNotNull" "with" "suspend" "synchronized"))
+
+; Literals
+[
+  (line_comment)
+  (multiline_comment)
+] @comment @spell
+
+((multiline_comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$"))
+
+(shebang_line) @keyword.directive
+
+(real_literal) @number.float
+
+[
+  (integer_literal)
+  (long_literal)
+  (hex_literal)
+  (bin_literal)
+  (unsigned_literal)
+] @number
+
+[
+  (null_literal)
+  ; should be highlighted the same as booleans
+  (boolean_literal)
+] @boolean
+
+(character_literal) @character
+
+(string_literal) @string
+
+; NOTE: Escapes not allowed in multi-line strings
+(character_literal
+  (character_escape_seq) @string.escape)
+
+; There are 3 ways to define a regex
+;    - "[abc]?".toRegex()
+(call_expression
+  (navigation_expression
+    (string_literal) @string.regexp
+    (navigation_suffix
+      ((simple_identifier) @_function
+        (#eq? @_function "toRegex")))))
+
+;    - Regex("[abc]?")
+(call_expression
+  ((simple_identifier) @_function
+    (#eq? @_function "Regex"))
+  (call_suffix
+    (value_arguments
+      (value_argument
+        (string_literal) @string.regexp))))
+
+;    - Regex.fromLiteral("[abc]?")
+(call_expression
+  (navigation_expression
+    ((simple_identifier) @_class
+      (#eq? @_class "Regex"))
+    (navigation_suffix
+      ((simple_identifier) @_function
+        (#eq? @_function "fromLiteral"))))
+  (call_suffix
+    (value_arguments
+      (value_argument
+        (string_literal) @string.regexp))))
+
+; Keywords
+(type_alias
+  "typealias" @keyword)
+
+(companion_object
+  "companion" @keyword)
+
+[
+  (class_modifier)
+  (member_modifier)
+  (function_modifier)
+  (property_modifier)
+  (platform_modifier)
+  (variance_modifier)
+  (parameter_modifier)
+  (visibility_modifier)
+  (reification_modifier)
+  (inheritance_modifier)
+] @keyword.modifier
+
+[
+  "val"
+  "var"
+  ;	"typeof" ; NOTE: It is reserved for future use
+] @keyword
+
+[
+  "enum"
+  "class"
+  "object"
+  "interface"
+] @keyword.type
+
+[
+  "return"
+  "return@"
+] @keyword.return
+
+"suspend" @keyword.coroutine
+
+"fun" @keyword.function
+
+[
+  "if"
+  "else"
+  "when"
+] @keyword.conditional
+
+[
+  "for"
+  "do"
+  "while"
+  "continue"
+  "continue@"
+  "break"
+  "break@"
+] @keyword.repeat
+
+[
+  "try"
+  "catch"
+  "throw"
+  "finally"
+] @keyword.exception
+
+(annotation
+  "@" @attribute
+  (use_site_target)? @attribute)
+
+(annotation
+  (user_type
+    (type_identifier) @attribute))
+
+(annotation
+  (constructor_invocation
+    (user_type
+      (type_identifier) @attribute)))
+
+(file_annotation
+  "@" @attribute
+  "file" @attribute
+  ":" @attribute)
+
+(file_annotation
+  (user_type
+    (type_identifier) @attribute))
+
+(file_annotation
+  (constructor_invocation
+    (user_type
+      (type_identifier) @attribute)))
+
+; Operators & Punctuation
+[
+  "!"
+  "!="
+  "!=="
+  "="
+  "=="
+  "==="
+  ">"
+  ">="
+  "<"
+  "<="
+  "||"
+  "&&"
+  "+"
+  "++"
+  "+="
+  "-"
+  "--"
+  "-="
+  "*"
+  "*="
+  "/"
+  "/="
+  "%"
+  "%="
+  "?."
+  "?:"
+  "!!"
+  "is"
+  "!is"
+  "in"
+  "!in"
+  "as"
+  "as?"
+  ".."
+  "->"
+] @operator
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "."
+  ","
+  ";"
+  ":"
+  "::"
+] @punctuation.delimiter
+
+(super_expression
+  [
+    "<"
+    ">"
+  ] @punctuation.delimiter)
+
+(type_arguments
+  [
+    "<"
+    ">"
+  ] @punctuation.delimiter)
+
+(type_parameters
+  [
+    "<"
+    ">"
+  ] @punctuation.delimiter)
+
+; NOTE: `interpolated_identifier`s can be highlighted in any way
+(string_literal
+  "$" @punctuation.special
+  (interpolated_identifier) @none @variable)
+
+(string_literal
+  "${" @punctuation.special
+  (interpolated_expression) @none
+  "}" @punctuation.special)
diff --git a/pack/ant/start/nvim-treesitter/queries/kotlin/injections.scm b/pack/ant/start/nvim-treesitter/queries/kotlin/injections.scm
new file mode 100644
index 0000000..b2bc233
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kotlin/injections.scm
@@ -0,0 +1,48 @@
+([
+  (line_comment)
+  (multiline_comment)
+] @injection.content
+  (#set! injection.language "comment"))
+
+; There are 3 ways to define a regex
+;    - "[abc]?".toRegex()
+(call_expression
+  (navigation_expression
+    ((string_literal) @injection.content
+      (#set! injection.language "regex"))
+    (navigation_suffix
+      ((simple_identifier) @_function
+        (#eq? @_function "toRegex")))))
+
+;    - Regex("[abc]?")
+(call_expression
+  ((simple_identifier) @_function
+    (#eq? @_function "Regex"))
+  (call_suffix
+    (value_arguments
+      (value_argument
+        (string_literal) @injection.content
+        (#set! injection.language "regex")))))
+
+;    - Regex.fromLiteral("[abc]?")
+(call_expression
+  (navigation_expression
+    ((simple_identifier) @_class
+      (#eq? @_class "Regex"))
+    (navigation_suffix
+      ((simple_identifier) @_function
+        (#eq? @_function "fromLiteral"))))
+  (call_suffix
+    (value_arguments
+      (value_argument
+        (string_literal) @injection.content
+        (#set! injection.language "regex")))))
+
+; "pi = %.2f".format(3.14159)
+((call_expression
+  (navigation_expression
+    (string_literal) @injection.content
+    (navigation_suffix
+      (simple_identifier) @_method)))
+  (#eq? @_method "format")
+  (#set! injection.language "printf"))
diff --git a/pack/ant/start/nvim-treesitter/queries/kotlin/locals.scm b/pack/ant/start/nvim-treesitter/queries/kotlin/locals.scm
new file mode 100644
index 0000000..330803f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kotlin/locals.scm
@@ -0,0 +1,78 @@
+; Imports
+(package_header
+  .
+  (identifier) @local.definition.namespace)
+
+(import_header
+  (identifier
+    (simple_identifier) @local.definition.import .)
+  (import_alias
+    (type_identifier) @local.definition.import)?)
+
+; Functions
+(function_declaration
+  .
+  (simple_identifier) @local.definition.function
+  (#set! definition.function.scope "parent"))
+
+(class_body
+  (function_declaration
+    .
+    (simple_identifier) @local.definition.method)
+  (#set! definition.method.scope "parent"))
+
+; Variables
+(function_declaration
+  (function_value_parameters
+    (parameter
+      (simple_identifier) @local.definition.parameter)))
+
+(lambda_literal
+  (lambda_parameters
+    (variable_declaration
+      (simple_identifier) @local.definition.parameter)))
+
+; NOTE: temporary fix for treesitter bug that causes delay in file opening
+;(class_body
+;  (property_declaration
+;    (variable_declaration
+;      (simple_identifier) @local.definition.field)))
+(class_declaration
+  (primary_constructor
+    (class_parameter
+      (simple_identifier) @local.definition.field)))
+
+(enum_class_body
+  (enum_entry
+    (simple_identifier) @local.definition.field))
+
+(variable_declaration
+  (simple_identifier) @local.definition.var)
+
+; Types
+(class_declaration
+  (type_identifier) @local.definition.type
+  (#set! definition.type.scope "parent"))
+
+(type_alias
+  (type_identifier) @local.definition.type
+  (#set! definition.type.scope "parent"))
+
+; Scopes
+[
+  (if_expression)
+  (when_expression)
+  (when_entry)
+  (for_statement)
+  (while_statement)
+  (do_while_statement)
+  (lambda_literal)
+  (function_declaration)
+  (primary_constructor)
+  (secondary_constructor)
+  (anonymous_initializer)
+  (class_declaration)
+  (enum_class_body)
+  (enum_entry)
+  (interpolated_expression)
+] @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/koto/folds.scm b/pack/ant/start/nvim-treesitter/queries/koto/folds.scm
new file mode 100644
index 0000000..d20d012
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/koto/folds.scm
@@ -0,0 +1,9 @@
+[
+  (assign)
+  (comment)
+  (function)
+  (list)
+  (map)
+  (tuple)
+  (string)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/koto/highlights.scm b/pack/ant/start/nvim-treesitter/queries/koto/highlights.scm
new file mode 100644
index 0000000..021e504
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/koto/highlights.scm
@@ -0,0 +1,131 @@
+[
+  "="
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "+="
+  "-="
+  "*="
+  "/="
+  "%="
+  "=="
+  "!="
+  "<"
+  ">"
+  "<="
+  ">="
+  ".."
+  "..="
+] @operator
+
+[
+  "and"
+  "not"
+  "or"
+] @keyword.operator
+
+[
+  "return"
+  "yield"
+] @keyword.return
+
+[
+  "if"
+  "then"
+  "else"
+  "else if"
+  "match"
+  "switch"
+] @keyword.conditional
+
+[
+  (break)
+  (continue)
+  "for"
+  "in"
+  "loop"
+  "until"
+  "while"
+] @keyword.repeat
+
+[
+  "throw"
+  "try"
+  "catch"
+  "finally"
+] @keyword.exception
+
+[
+  "export"
+  "from"
+  "import"
+  "as"
+] @keyword.import
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  "|"
+] @punctuation.bracket
+
+(identifier) @variable
+
+(import_module
+  (identifier) @module)
+
+(import_item
+  (identifier) @module)
+
+(export
+  (identifier) @module)
+
+(chain
+  lookup: (identifier) @variable.member)
+
+(chain
+  start: (identifier) @function.call)
+
+[
+  (true)
+  (false)
+] @boolean
+
+(comment) @comment @spell
+
+(debug) @keyword.debug
+
+(string) @string
+
+(fill_char) @punctuation.delimiter
+
+(alignment) @operator
+
+(escape) @string.escape
+
+(null) @constant.builtin
+
+(number) @number
+
+(meta) @keyword.directive
+
+(meta
+  name: (identifier) @variable.member)
+
+(entry_inline
+  key: (identifier) @variable.member)
+
+(entry_block
+  key: (identifier) @variable.member)
+
+(self) @variable.builtin
+
+(arg
+  (identifier) @variable.parameter)
+
+(ellipsis) @variable.parameter
diff --git a/pack/ant/start/nvim-treesitter/queries/koto/injections.scm b/pack/ant/start/nvim-treesitter/queries/koto/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/koto/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/koto/locals.scm b/pack/ant/start/nvim-treesitter/queries/koto/locals.scm
new file mode 100644
index 0000000..c184874
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/koto/locals.scm
@@ -0,0 +1,28 @@
+; Scopes
+(function
+  body: (_) @local.scope)
+
+; Definitions
+(arg
+  (variable) @local.definition.parameter)
+
+(assign
+  (identifier) @local.definition.var)
+
+(for_args
+  (variable) @local.definition.var)
+
+(match_patterns
+  (variable) @local.definition.var)
+
+(import_item
+  (identifier) @local.definition.import)
+
+(entry_block
+  (identifier) @local.definition.field)
+
+(entry_inline
+  (identifier) @local.definition.field)
+
+; References
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/kusto/highlights.scm b/pack/ant/start/nvim-treesitter/queries/kusto/highlights.scm
new file mode 100644
index 0000000..5f00f75
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kusto/highlights.scm
@@ -0,0 +1,60 @@
+(identifier) @variable
+
+(let_keyword) @keyword
+
+(function_call
+  (identifier) @function.call)
+
+[
+  (type_cast_function)
+  (to_scalar_function)
+  (between_function)
+  (datatable_function)
+] @function.call
+
+(typed_parameter
+  (identifier) @variable.parameter)
+
+(function_arguments
+  (identifier) @variable.parameter)
+
+[
+  (binary_operator)
+  (compound_keywords)
+  (operator)
+  (range_operator)
+  (join_operator)
+  (sub_operator)
+  (to_operator)
+  (mv_apply_operator)
+  (sort_keyword)
+] @keyword.operator
+
+(string) @string
+
+(number) @number
+
+(bool) @boolean
+
+(null) @constant.builtin
+
+(comment) @comment @spell
+
+(type) @type
+
+(join_types) @keyword.modifier
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  ","
+  ":"
+  (pipe)
+] @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/kusto/injections.scm b/pack/ant/start/nvim-treesitter/queries/kusto/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/kusto/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/lalrpop/folds.scm b/pack/ant/start/nvim-treesitter/queries/lalrpop/folds.scm
new file mode 100644
index 0000000..beeed9b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/lalrpop/folds.scm
@@ -0,0 +1,5 @@
+[
+  (grammar_item)
+  (use)+
+  (action)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/lalrpop/highlights.scm b/pack/ant/start/nvim-treesitter/queries/lalrpop/highlights.scm
new file mode 100644
index 0000000..046d397
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/lalrpop/highlights.scm
@@ -0,0 +1,98 @@
+(comment) @comment @spell
+
+"grammar" @keyword
+
+[
+  "type"
+  "enum"
+] @keyword.type
+
+[
+  "pub"
+  "extern"
+  (mut)
+] @keyword.modifier
+
+[
+  "match"
+  "else"
+] @keyword.conditional
+
+[
+  "+"
+  "*"
+  "?"
+  ; TODO: inaccessible node
+  ; =>
+  "=>@L"
+  "=>@R"
+  "="
+  "&"
+] @operator
+
+(binding_symbol
+  name: (identifier) @variable.parameter)
+
+(annotation
+  "#" @punctuation.special)
+
+(grammar_parameter
+  (identifier) @variable.parameter)
+
+(associated_type
+  (identifier) @type)
+
+(parametrized_type
+  (path
+    (identifier) @type))
+
+(bare_symbol
+  (macro
+    (macro_id) @type.definition))
+
+(bare_symbol
+  (identifier) @type.definition)
+
+(nonterminal_name
+  (macro_id) @type.definition)
+
+(nonterminal_name
+  (identifier) @type.definition)
+
+(nonterminal
+  (type_ref) @type.builtin)
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "}"
+  "{"
+  ">"
+  "<"
+] @punctuation.bracket
+
+[
+  ";"
+  ":"
+  "::"
+  ","
+] @punctuation.delimiter
+
+(lifetime
+  "'" @keyword.modifier)
+
+(lifetime
+  (identifier) @attribute)
+
+(lifetime
+  (identifier) @attribute.builtin
+  (#any-of? @attribute.builtin "static" "_"))
+
+(string_literal) @string
+
+(regex_literal) @string
+
+(annotation
+  (id) @function.macro)
diff --git a/pack/ant/start/nvim-treesitter/queries/lalrpop/injections.scm b/pack/ant/start/nvim-treesitter/queries/lalrpop/injections.scm
new file mode 100644
index 0000000..17d0ace
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/lalrpop/injections.scm
@@ -0,0 +1,15 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+([
+  (normal_action)
+  (failible_action)
+] @injection.content
+  (#set! injection.language "rust"))
+
+((use) @injection.content
+  (#set! injection.language "rust"))
+
+((regex_literal) @injection.content
+  (#set! injection.language "regex")
+  (#offset! @injection.content 0 2 0 -1))
diff --git a/pack/ant/start/nvim-treesitter/queries/lalrpop/locals.scm b/pack/ant/start/nvim-treesitter/queries/lalrpop/locals.scm
new file mode 100644
index 0000000..ceeac96
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/lalrpop/locals.scm
@@ -0,0 +1,5 @@
+(nonterminal_name
+  (macro_id) @local.definition.function)
+
+(nonterminal_name
+  (identifier) @local.definition.function)
diff --git a/pack/ant/start/nvim-treesitter/queries/latex/folds.scm b/pack/ant/start/nvim-treesitter/queries/latex/folds.scm
new file mode 100644
index 0000000..1ee7946
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/latex/folds.scm
@@ -0,0 +1,14 @@
+[
+  (chapter)
+  (part)
+  (section)
+  (subsection)
+  (subsubsection)
+  (paragraph)
+  (subparagraph)
+  (generic_environment)
+  (math_environment)
+  (comment_environment)
+  (block_comment)
+  (displayed_equation)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/latex/highlights.scm b/pack/ant/start/nvim-treesitter/queries/latex/highlights.scm
new file mode 100644
index 0000000..c39cd1b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/latex/highlights.scm
@@ -0,0 +1,342 @@
+; General syntax
+(command_name) @function @nospell
+
+(caption
+  command: _ @function)
+
+; Turn spelling on for text
+(text) @spell
+
+; \text, \intertext, \shortintertext, ...
+(text_mode
+  command: _ @function @nospell
+  content: (curly_group
+    (_) @none @spell))
+
+; Variables, parameters
+(placeholder) @variable
+
+(key_value_pair
+  key: (_) @variable.parameter @nospell
+  value: (_))
+
+(curly_group_spec
+  (text) @variable.parameter)
+
+(brack_group_argc) @variable.parameter
+
+[
+  (operator)
+  "="
+  "_"
+  "^"
+] @operator
+
+"\\item" @punctuation.special
+
+(delimiter) @punctuation.delimiter
+
+(math_delimiter
+  left_command: _ @punctuation.delimiter
+  left_delimiter: _ @punctuation.delimiter
+  right_command: _ @punctuation.delimiter
+  right_delimiter: _ @punctuation.delimiter)
+
+[
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket ; "(" ")" has no syntactical meaning in LaTeX
+
+; General environments
+(begin
+  command: _ @module
+  name: (curly_group_text
+    (text) @label @nospell))
+
+(end
+  command: _ @module
+  name: (curly_group_text
+    (text) @label @nospell))
+
+; Definitions and references
+(new_command_definition
+  command: _ @function.macro @nospell)
+
+(old_command_definition
+  command: _ @function.macro @nospell)
+
+(let_command_definition
+  command: _ @function.macro @nospell)
+
+(environment_definition
+  command: _ @function.macro @nospell
+  name: (curly_group_text
+    (_) @label @nospell))
+
+(theorem_definition
+  command: _ @function.macro @nospell
+  name: (curly_group_text_list
+    (_) @label @nospell))
+
+(paired_delimiter_definition
+  command: _ @function.macro @nospell
+  declaration: (curly_group_command_name
+    (_) @function))
+
+(label_definition
+  command: _ @function.macro
+  name: (curly_group_text
+    (_) @markup.link @nospell))
+
+(label_reference_range
+  command: _ @function.macro
+  from: (curly_group_text
+    (_) @markup.link)
+  to: (curly_group_text
+    (_) @markup.link))
+
+(label_reference
+  command: _ @function.macro
+  names: (curly_group_text_list
+    (_) @markup.link))
+
+(label_number
+  command: _ @function.macro
+  name: (curly_group_text
+    (_) @markup.link)
+  number: (_) @markup.link)
+
+(citation
+  command: _ @function.macro @nospell
+  keys: (curly_group_text_list) @markup.link @nospell)
+
+((hyperlink
+  command: _ @function @nospell
+  uri: (curly_group_uri
+    (_) @markup.link.url @nospell)) @_hyperlink
+  (#set! @_hyperlink url @markup.link.url))
+
+(glossary_entry_definition
+  command: _ @function.macro @nospell
+  name: (curly_group_text
+    (_) @markup.link @nospell))
+
+(glossary_entry_reference
+  command: _ @function.macro
+  name: (curly_group_text
+    (_) @markup.link))
+
+(acronym_definition
+  command: _ @function.macro @nospell
+  name: (curly_group_text
+    (_) @markup.link @nospell))
+
+(acronym_reference
+  command: _ @function.macro
+  name: (curly_group_text
+    (_) @markup.link))
+
+(color_definition
+  command: _ @function.macro
+  name: (curly_group_text
+    (_) @markup.link))
+
+(color_reference
+  command: _ @function.macro
+  name: (curly_group_text
+    (_) @markup.link)?)
+
+; Sectioning
+(title_declaration
+  command: _ @module
+  options: (brack_group
+    (_) @markup.heading.1)?
+  text: (curly_group
+    (_) @markup.heading.1))
+
+(author_declaration
+  command: _ @module
+  authors: (curly_group_author_list
+    (author)+ @markup.heading.1))
+
+(chapter
+  command: _ @module
+  toc: (brack_group
+    (_) @markup.heading.2)?
+  text: (curly_group
+    (_) @markup.heading.2))
+
+(part
+  command: _ @module
+  toc: (brack_group
+    (_) @markup.heading.2)?
+  text: (curly_group
+    (_) @markup.heading.2))
+
+(section
+  command: _ @module
+  toc: (brack_group
+    (_) @markup.heading.3)?
+  text: (curly_group
+    (_) @markup.heading.3))
+
+(subsection
+  command: _ @module
+  toc: (brack_group
+    (_) @markup.heading.4)?
+  text: (curly_group
+    (_) @markup.heading.4))
+
+(subsubsection
+  command: _ @module
+  toc: (brack_group
+    (_) @markup.heading.5)?
+  text: (curly_group
+    (_) @markup.heading.5))
+
+(paragraph
+  command: _ @module
+  toc: (brack_group
+    (_) @markup.heading.6)?
+  text: (curly_group
+    (_) @markup.heading.6))
+
+(subparagraph
+  command: _ @module
+  toc: (brack_group
+    (_) @markup.heading.6)?
+  text: (curly_group
+    (_) @markup.heading.6))
+
+; Beamer frames
+(generic_environment
+  (begin
+    name: (curly_group_text
+      (text) @label)
+    (#any-of? @label "frame"))
+  .
+  (curly_group
+    (_) @markup.heading))
+
+((generic_command
+  command: (command_name) @_name
+  arg: (curly_group
+    (_) @markup.heading))
+  (#eq? @_name "\\frametitle"))
+
+((generic_command
+  command: (command_name) @_name
+  arg: (curly_group
+    (_) @markup.italic))
+  (#any-of? @_name "\\emph" "\\textit" "\\mathit"))
+
+((generic_command
+  command: (command_name) @_name
+  arg: (curly_group
+    (_) @markup.strong))
+  (#any-of? @_name "\\textbf" "\\mathbf"))
+
+(generic_command
+  (command_name) @keyword.conditional
+  (#lua-match? @keyword.conditional "^\\if[a-zA-Z@]+$"))
+
+(generic_command
+  (command_name) @keyword.conditional
+  (#any-of? @keyword.conditional "\\fi" "\\else"))
+
+; File inclusion commands
+(class_include
+  command: _ @keyword.import
+  path: (curly_group_path) @string)
+
+(package_include
+  command: _ @keyword.import
+  paths: (curly_group_path_list) @string)
+
+(latex_include
+  command: _ @keyword.import
+  path: (curly_group_path) @string.special.path)
+
+(verbatim_include
+  command: _ @keyword.import
+  path: (curly_group_path) @string.special.path)
+
+(import_include
+  command: _ @keyword.import
+  directory: (curly_group_path) @string.special.path
+  file: (curly_group_path) @string.special.path)
+
+(bibstyle_include
+  command: _ @keyword.import
+  path: (curly_group_path) @string)
+
+(bibtex_include
+  command: _ @keyword.import
+  paths: (curly_group_path_list) @string.special.path)
+
+(biblatex_include
+  "\\addbibresource" @keyword.import
+  glob: (curly_group_glob_pattern) @string.regexp)
+
+(graphics_include
+  command: _ @keyword.import
+  path: (curly_group_path) @string.special.path)
+
+(svg_include
+  command: _ @keyword.import
+  path: (curly_group_path) @string.special.path)
+
+(inkscape_include
+  command: _ @keyword.import
+  path: (curly_group_path) @string.special.path)
+
+(tikz_library_import
+  command: _ @keyword.import
+  paths: (curly_group_path_list) @string)
+
+; Turn spelling off for whole nodes
+[
+  (label_reference)
+  (label_reference_range)
+  (label_number)
+  (glossary_entry_reference)
+  (acronym_reference)
+  (color_definition)
+  (color_reference)
+  (class_include)
+  (package_include)
+  (latex_include)
+  (verbatim_include)
+  (import_include)
+  (bibstyle_include)
+  (bibtex_include)
+  (biblatex_include)
+  (graphics_include)
+  (svg_include)
+  (inkscape_include)
+  (tikz_library_import)
+] @nospell
+
+; Math
+[
+  (displayed_equation)
+  (inline_formula)
+] @markup.math @nospell
+
+(math_environment
+  (_) @markup.math)
+
+; Comments
+[
+  (line_comment)
+  (block_comment)
+  (comment_environment)
+] @comment @spell
+
+((line_comment) @keyword.directive @nospell
+  (#lua-match? @keyword.directive "^%% !TeX"))
+
+((line_comment) @keyword.directive @nospell
+  (#lua-match? @keyword.directive "^%%&"))
diff --git a/pack/ant/start/nvim-treesitter/queries/latex/injections.scm b/pack/ant/start/nvim-treesitter/queries/latex/injections.scm
new file mode 100644
index 0000000..53d808c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/latex/injections.scm
@@ -0,0 +1,36 @@
+([
+  (line_comment)
+  (block_comment)
+  (comment_environment)
+] @injection.content
+  (#set! injection.language "comment"))
+
+(pycode_environment
+  code: (source_code) @injection.content
+  (#set! injection.language "python"))
+
+(sagesilent_environment
+  code: (source_code) @injection.content
+  (#set! injection.language "python"))
+
+(sageblock_environment
+  code: (source_code) @injection.content
+  (#set! injection.language "python"))
+
+(luacode_environment
+  code: (source_code) @injection.content
+  (#set! injection.language "lua"))
+
+(asy_environment
+  code: (source_code) @injection.content
+  (#set! injection.language "c"))
+
+(asydef_environment
+  code: (source_code) @injection.content
+  (#set! injection.language "c"))
+
+(minted_environment
+  (begin
+    language: (curly_group_text
+      (text) @injection.language))
+  (source_code) @injection.content)
diff --git a/pack/ant/start/nvim-treesitter/queries/ledger/folds.scm b/pack/ant/start/nvim-treesitter/queries/ledger/folds.scm
new file mode 100644
index 0000000..8b57368
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ledger/folds.scm
@@ -0,0 +1 @@
+(xact) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/ledger/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ledger/highlights.scm
new file mode 100644
index 0000000..5198ad8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ledger/highlights.scm
@@ -0,0 +1,54 @@
+[
+  (block_comment)
+  (comment)
+  (note)
+  (test)
+] @comment @spell
+
+[
+  (quantity)
+  (negative_quantity)
+] @number
+
+[
+  (date)
+  (effective_date)
+  (time)
+  (interval)
+] @string.special
+
+[
+  (commodity)
+  (option)
+  (option_value)
+  (check_in)
+  (check_out)
+] @markup.raw
+
+(account) @variable.member
+
+"include" @keyword.import
+
+[
+  "account"
+  "alias"
+  "assert"
+  "check"
+  "commodity"
+  "comment"
+  "def"
+  "default"
+  "end"
+  "eval"
+  "format"
+  "nomarket"
+  "note"
+  "payee"
+  "test"
+  "A"
+  "Y"
+  "N"
+  "D"
+  "C"
+  "P"
+] @keyword
diff --git a/pack/ant/start/nvim-treesitter/queries/ledger/indents.scm b/pack/ant/start/nvim-treesitter/queries/ledger/indents.scm
new file mode 100644
index 0000000..9697c9c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ledger/indents.scm
@@ -0,0 +1 @@
+(journal_item) @indent.begin
diff --git a/pack/ant/start/nvim-treesitter/queries/ledger/injections.scm b/pack/ant/start/nvim-treesitter/queries/ledger/injections.scm
new file mode 100644
index 0000000..35fb57e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ledger/injections.scm
@@ -0,0 +1,5 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((note) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/leo/highlights.scm b/pack/ant/start/nvim-treesitter/queries/leo/highlights.scm
new file mode 100644
index 0000000..4e10de0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/leo/highlights.scm
@@ -0,0 +1,206 @@
+[
+  "assert"
+  "assert_eq"
+  "assert_neq"
+  "block"
+  "console"
+  "const"
+  "let"
+  "mapping"
+  "program"
+  "self"
+  "then"
+] @keyword
+
+[
+  "record"
+  "struct"
+] @keyword.type
+
+"in" @keyword.operator
+
+[
+  "constant"
+  "private"
+  "public"
+] @keyword.modifier
+
+"self" @variable.builtin
+
+"network" @variable.builtin
+
+"async" @keyword.coroutine
+
+[
+  "finalize"
+  "function"
+  "inline"
+  "transition"
+] @keyword.function
+
+"import" @keyword.import
+
+"return" @keyword.return
+
+(return_arrow) @punctuation.delimiter
+
+"for" @keyword.repeat
+
+[
+  "else"
+  "if"
+] @keyword.conditional
+
+[
+  (ternary_if)
+  (ternary_else)
+] @keyword.conditional.ternary
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ";"
+  ","
+  "::"
+] @punctuation.delimiter
+
+[
+  "!"
+  "&&"
+  "||"
+  "=="
+  "!="
+  "<"
+  "<="
+  ">"
+  ">="
+  "&"
+  "|"
+  "^"
+  "<<"
+  ">>"
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "**"
+  "="
+  "+="
+  "-="
+  "*="
+  "/="
+  "%="
+  "**="
+  "<<="
+  ">>="
+  "&="
+  "|="
+  "^="
+  "&&="
+  "||="
+] @operator
+
+(comment) @comment @spell
+
+(boolean_literal) @boolean
+
+(constant_declaration
+  (identifier
+    (constant_identifier) @constant))
+
+(variable
+  (constant_identifier) @constant)
+
+(associated_constant) @constant
+
+(variable) @variable
+
+(program_id) @string.special
+
+;record declaration
+(record_declaration
+  (identifier) @type.definition)
+
+;struct component
+(struct_component_declaration
+  (identifier) @variable.member)
+
+(type) @type
+
+[
+  (block_height)
+  (self_address)
+  (self_caller)
+  (self_signer)
+  (network_id)
+] @constant.builtin
+
+(free_function_call
+  (locator
+    (identifier) @function))
+
+(associated_function_call
+  (named_type
+    (identifier
+      (constant_identifier) @function)))
+
+(associated_function_call
+  (identifier) @function.call)
+
+(record_type
+  (locator
+    (identifier) @variable.member))
+
+(transition_declaration
+  name: (identifier) @function.builtin)
+
+(finalizer
+  name: (identifier) @function.builtin)
+
+(free_function_call
+  (identifier) @function.call)
+
+(function_declaration
+  name: (identifier) @function)
+
+(inline_declaration
+  name: (identifier) @function.macro)
+
+(method_call
+  .
+  (_)
+  .
+  (identifier) @function.method.call)
+
+(function_parameter
+  (identifier) @variable.parameter)
+
+(struct_declaration
+  name: (identifier) @type.definition)
+
+(variable_declaration
+  (identifier) @variable)
+
+[
+  (address_literal)
+  (signature_literal)
+  ((affine_group_literal)
+    (#set! priority 101))
+  (field_literal)
+  (product_group_literal)
+  (scalar_literal)
+  (signed_literal)
+  (unsigned_literal)
+] @number
+
+(string_literal) @string
+
+(annotation) @attribute
diff --git a/pack/ant/start/nvim-treesitter/queries/leo/indents.scm b/pack/ant/start/nvim-treesitter/queries/leo/indents.scm
new file mode 100644
index 0000000..473091f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/leo/indents.scm
@@ -0,0 +1,34 @@
+[
+  (record_declaration)
+  (struct_declaration)
+  (mapping_declaration)
+  (constant_declaration)
+  (return_statement)
+  (expression_statement)
+  (variable_declaration)
+  (loop_statement)
+  (assignment_statement)
+  (assert_statement)
+  (struct_expression)
+  (array_expression)
+  (tuple_expression)
+  (parenthesized_expression)
+  (items_block)
+  (block)
+] @indent.begin
+
+; if "if" statement and conditional statement are in separate lines
+; conditional should be indented and when the conditional block
+; starts dedented
+(branch
+  (block
+    "{" @indent.end)) @indent.begin
+
+((function_parameters) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+[
+  (comment)
+  (ERROR)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/leo/injections.scm b/pack/ant/start/nvim-treesitter/queries/leo/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/leo/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/linkerscript/folds.scm b/pack/ant/start/nvim-treesitter/queries/linkerscript/folds.scm
new file mode 100644
index 0000000..0fc77b1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/linkerscript/folds.scm
@@ -0,0 +1,6 @@
+[
+  (sections_command)
+  (output_section)
+  (memory_command)
+  (phdrs_command)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/linkerscript/highlights.scm b/pack/ant/start/nvim-treesitter/queries/linkerscript/highlights.scm
new file mode 100644
index 0000000..1233016
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/linkerscript/highlights.scm
@@ -0,0 +1,173 @@
+; Keywords
+[
+  "ENTRY"
+  "SECTIONS"
+  "AT"
+  "OVERLAY"
+  "NOCROSSREFS"
+  "MEMORY"
+  "PHDRS"
+  "FILEHDR"
+] @keyword
+
+; Conditionals
+(conditional_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+; Variables
+(symbol) @variable
+
+(filename) @string.special.path
+
+; Functions
+(call_expression
+  function: (symbol) @function.call)
+
+((call_expression
+  function: (symbol) @keyword.directive)
+  (#eq? @keyword.directive "DEFINED"))
+
+((call_expression
+  function: (symbol) @function.builtin)
+  (#any-of? @function.builtin
+    "ABSOLUTE" "ALIAS" "ADDR" "ALIGN" "ALIGNOF" "BASE" "BLOCK" "CHIP" "DATA_SEGMENT_ALIGN"
+    "DATA_SEGMENT_END" "DATA_SEGMENT_RELRO_END" "END" "LENGTH" "LOADADDR" "LOG2CEIL" "MAX" "MIN"
+    "NEXT" "ORIGIN" "SEGMENT_START" "SIZEOF" "BYTE" "FILL" "LONG" "SHORT" "QUAD" "SQUAD" "WORD"))
+
+[
+  "KEEP"
+  "PROVIDE"
+  "PROVIDE_HIDDEN"
+] @function.builtin
+
+; Types
+(section_type
+  "("
+  [
+    "NOLOAD"
+    "DSECT"
+    "COPY"
+    "INFO"
+    "OVERLAY"
+  ] @type.builtin
+  ")")
+
+; Fields
+[
+  "ORIGIN"
+  "org"
+  "o"
+  "LENGTH"
+  "len"
+  "l"
+] @variable.member
+
+; Constants
+((symbol) @constant
+  (#lua-match? @constant "^[%u_][%u%d_]+$"))
+
+; Labels
+(entry_command
+  name: (symbol) @label)
+
+(output_section
+  name: (symbol) @label)
+
+(memory_command
+  name: (symbol) @label)
+
+(phdrs_command
+  name: (symbol) @label)
+
+(region
+  ">"
+  (symbol) @label)
+
+(lma_region
+  ">"
+  (symbol) @label)
+
+(phdr
+  ":"
+  (symbol) @label)
+
+([
+  (symbol)
+  (filename)
+] @label
+  (#lua-match? @label "^%."))
+
+; Exceptions
+"ASSERT" @keyword.exception
+
+[
+  "/DISCARD/"
+  "."
+] @variable.builtin
+
+; Operators
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "||"
+  "&&"
+  "|"
+  "&"
+  "=="
+  "!="
+  ">"
+  ">="
+  "<="
+  "<"
+  "<<"
+  ">>"
+  "!"
+  "~"
+  "="
+  "+="
+  "-="
+  "*="
+  "/="
+  "<<="
+  ">>="
+  "&="
+  "|="
+] @operator
+
+; Literals
+(number) @number
+
+(quoted_symbol) @string
+
+(wildcard_pattern
+  [
+    "*"
+    "["
+    "]"
+  ] @character.special)
+
+(attributes) @character.special
+
+; Punctuation
+[
+  "{"
+  "}"
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  ":"
+  ";"
+] @punctuation.delimiter
+
+">" @punctuation.special
+
+; Comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/linkerscript/indents.scm b/pack/ant/start/nvim-treesitter/queries/linkerscript/indents.scm
new file mode 100644
index 0000000..a636ba1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/linkerscript/indents.scm
@@ -0,0 +1,11 @@
+[
+  (sections_command)
+  (output_section)
+  (memory_command)
+  (phdrs_command)
+] @indent.begin
+
+[
+  "}"
+  ")"
+] @indent.branch @indent.end
diff --git a/pack/ant/start/nvim-treesitter/queries/linkerscript/injections.scm b/pack/ant/start/nvim-treesitter/queries/linkerscript/injections.scm
new file mode 100644
index 0000000..51e6d1f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/linkerscript/injections.scm
@@ -0,0 +1,2 @@
+((comment)
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/linkerscript/locals.scm b/pack/ant/start/nvim-treesitter/queries/linkerscript/locals.scm
new file mode 100644
index 0000000..6b76603
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/linkerscript/locals.scm
@@ -0,0 +1,16 @@
+; References
+[
+  (symbol)
+  (filename)
+  (quoted_symbol)
+] @local.reference
+
+; Definitions
+(output_section
+  name: (symbol) @local.definition.var)
+
+(memory_command
+  name: (symbol) @local.definition.var)
+
+(phdrs_command
+  name: (symbol) @local.definition.var)
diff --git a/pack/ant/start/nvim-treesitter/queries/liquid/highlights.scm b/pack/ant/start/nvim-treesitter/queries/liquid/highlights.scm
new file mode 100644
index 0000000..17b3d6f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/liquid/highlights.scm
@@ -0,0 +1,132 @@
+((comment) @comment @spell
+  (#set! priority 110))
+
+(raw_statement
+  (raw_content) @spell
+  (#set! priority 110))
+
+((identifier) @variable
+  (#set! priority 110))
+
+((string) @string
+  (#set! priority 110))
+
+((boolean) @boolean
+  (#set! priority 110))
+
+((number) @number
+  (#set! priority 110))
+
+(filter
+  name: (identifier) @function.call
+  (#set! priority 110))
+
+([
+  "as"
+  "assign"
+  "capture"
+  (custom_unpaired_statement)
+  "decrement"
+  "echo"
+  "endcapture"
+  "endform"
+  "endjavascript"
+  "endraw"
+  "endschema"
+  "endstyle"
+  "form"
+  "increment"
+  "javascript"
+  "layout"
+  "liquid"
+  "raw"
+  "schema"
+  "style"
+  "with"
+] @keyword
+  (#set! priority 110))
+
+([
+  "case"
+  "else"
+  "elsif"
+  "endcase"
+  "endif"
+  "endunless"
+  "if"
+  "unless"
+  "when"
+] @keyword.conditional
+  (#set! priority 110))
+
+([
+  (break_statement)
+  (continue_statement)
+  "by"
+  "cycle"
+  "endfor"
+  "endpaginate"
+  "endtablerow"
+  "for"
+  "paginate"
+  "tablerow"
+] @keyword.repeat
+  (#set! priority 110))
+
+([
+  "and"
+  "contains"
+  "in"
+  "or"
+] @keyword.operator
+  (#set! priority 110))
+
+([
+  "{{"
+  "}}"
+  "{{-"
+  "-}}"
+  "{%"
+  "%}"
+  "{%-"
+  "-%}"
+] @tag.delimiter
+  (#set! priority 110))
+
+[
+  "include"
+  "include_relative"
+  "render"
+  "section"
+  "sections"
+] @keyword.import
+
+[
+  "|"
+  ":"
+  "="
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "^"
+  "=="
+  "<"
+  "<="
+  "!="
+  ">="
+  ">"
+] @operator
+
+[
+  "]"
+  "["
+  ")"
+  "("
+] @punctuation.bracket
+
+[
+  ","
+  "."
+] @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/liquid/injections.scm b/pack/ant/start/nvim-treesitter/queries/liquid/injections.scm
new file mode 100644
index 0000000..fa74576
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/liquid/injections.scm
@@ -0,0 +1,22 @@
+((template_content) @injection.content
+  (#set! injection.language "html")
+  (#set! injection.combined))
+
+; TODO we can switch to quantifiers once neovim 0.10 becomes stable
+(javascript_statement
+  (js_content) @injection.content
+  (#set! injection.language "javascript")
+  (#set! injection.combined))
+
+(schema_statement
+  (json_content) @injection.content
+  (#set! injection.language "json")
+  (#set! injection.combined))
+
+(style_statement
+  (style_content) @injection.content
+  (#set! injection.language "css")
+  (#set! injection.combined))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/liquidsoap/folds.scm b/pack/ant/start/nvim-treesitter/queries/liquidsoap/folds.scm
new file mode 100644
index 0000000..56e4ce5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/liquidsoap/folds.scm
@@ -0,0 +1,21 @@
+[
+  (let)
+  (binding)
+  (simple_fun)
+  (def)
+  (arglist)
+  (if)
+  (if_condition)
+  (if_then)
+  (elsif_condition)
+  (elsif_then)
+  (if_else)
+  (for)
+  (for_do)
+  (while)
+  (while_do)
+  (try)
+  (try_body)
+  (try_do)
+  (block)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/liquidsoap/highlights.scm b/pack/ant/start/nvim-treesitter/queries/liquidsoap/highlights.scm
new file mode 100644
index 0000000..c5608f8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/liquidsoap/highlights.scm
@@ -0,0 +1,111 @@
+(var) @variable
+
+(op) @operator
+
+[
+  "and"
+  "or"
+  "not"
+] @keyword.operator
+
+[
+  "def"
+  "fun"
+  "def_end"
+] @keyword.function
+
+(let_decoration) @keyword.coroutine
+
+[
+  "open"
+  "begin"
+  "block_end"
+  "let"
+] @keyword
+
+[
+  "while"
+  "do"
+  "to"
+  "for"
+  "for_end"
+  "while_end"
+] @keyword.repeat
+
+[
+  "if"
+  "then"
+  "elsif"
+  "else"
+  "if_end"
+] @keyword.conditional
+
+[
+  "try"
+  "catch"
+  "try_end"
+] @keyword.exception
+
+(inline_if
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+[
+  "%ifdef"
+  "%ifndef"
+  "%ifencoder"
+  "%ifnencoder"
+  "%ifversion"
+  "%else"
+  "%endif"
+  "%argsof"
+  "%include"
+] @keyword.directive
+
+(encoder_name) @constant.builtin
+
+(anonymous_argument
+  (var) @variable.parameter)
+
+(labeled_argument
+  label: (var) @variable.parameter)
+
+"." @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+(app
+  name: (var) @function.call)
+
+(method) @function.method
+
+(method_app) @function.method.call
+
+(string) @string
+
+(string_interpolation
+  [
+    "#{"
+    "}"
+  ] @punctuation.special)
+
+(integer) @number
+
+(float) @number.float
+
+(bool) @boolean
+
+(comment) @comment @spell
+
+(regexp) @string.regexp
+
+(type) @type
diff --git a/pack/ant/start/nvim-treesitter/queries/liquidsoap/indents.scm b/pack/ant/start/nvim-treesitter/queries/liquidsoap/indents.scm
new file mode 100644
index 0000000..7cb5935
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/liquidsoap/indents.scm
@@ -0,0 +1,66 @@
+[
+  "%ifdef"
+  "%ifndef"
+  "%ifencoder"
+  "%ifnencoder"
+  "%ifversion"
+  "%else"
+  "%endif"
+  "%argsof"
+  "%include"
+] @indent.zero
+
+[
+  "if"
+  "def"
+  "let"
+  "for"
+  "while"
+  "try"
+  "{"
+  "["
+  "("
+] @indent.begin
+
+(ERROR
+  "def") @indent.begin
+
+(def
+  "def_end" @indent.end)
+
+(if
+  "if_end" @indent.end)
+
+(block
+  "block_end" @indent.end)
+
+(for
+  "for_end" @indent.end)
+
+(while
+  "while_end" @indent.end)
+
+(try
+  "try_end" @indent.end)
+
+[
+  "then"
+  "do"
+  "else"
+  "elsif"
+  "catch"
+] @indent.branch
+
+[
+  "def_end"
+  "if_end"
+  "block_end"
+  "for_end"
+  "while_end"
+  "try_end"
+  "}"
+  "]"
+  ")"
+] @indent.branch @indent.end
+
+(comment) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/liquidsoap/injections.scm b/pack/ant/start/nvim-treesitter/queries/liquidsoap/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/liquidsoap/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/liquidsoap/locals.scm b/pack/ant/start/nvim-treesitter/queries/liquidsoap/locals.scm
new file mode 100644
index 0000000..995294c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/liquidsoap/locals.scm
@@ -0,0 +1,35 @@
+[
+  (anonymous_function)
+  (binding)
+  (def)
+  (let)
+] @local.scope
+
+(anonymous_argument
+  (var) @local.definition.parameter)
+
+(labeled_argument
+  label: (var) @local.definition.parameter)
+
+(binding
+  defined: (var) @local.definition.var)
+
+(def
+  defined: (var) @local.definition.var)
+
+(let
+  defined: (var) @local.definition.var)
+
+(meth_pattern
+  (var) @local.definition.var)
+
+(list_pattern
+  (var) @local.definition.var)
+
+(tuple_pattern
+  (var) @local.definition.var)
+
+(spread
+  (var) @local.definition.var)
+
+(var) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/llvm/highlights.scm b/pack/ant/start/nvim-treesitter/queries/llvm/highlights.scm
new file mode 100644
index 0000000..ea48272
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/llvm/highlights.scm
@@ -0,0 +1,180 @@
+[
+  (local_var)
+  (global_var)
+] @variable
+
+(type) @type
+
+(type_keyword) @type.builtin
+
+(type
+  [
+    (local_var)
+    (global_var)
+  ] @type)
+
+(global_type
+  (local_var) @type.definition)
+
+(argument) @variable.parameter
+
+(_
+  inst_name: _ @keyword.operator)
+
+[
+  "catch"
+  "filter"
+] @keyword.operator
+
+[
+  "to"
+  "nuw"
+  "nsw"
+  "exact"
+  "unwind"
+  "from"
+  "cleanup"
+  "swifterror"
+  "volatile"
+  "inbounds"
+  "inrange"
+] @keyword
+
+(icmp_cond) @keyword
+
+(fcmp_cond) @keyword
+
+(fast_math) @keyword
+
+(_
+  callee: _ @function)
+
+(function_header
+  name: _ @function)
+
+[
+  "declare"
+  "define"
+] @keyword.function
+
+(calling_conv) @keyword.function
+
+[
+  "target"
+  "triple"
+  "datalayout"
+  "source_filename"
+  "addrspace"
+  "blockaddress"
+  "align"
+  "syncscope"
+  "within"
+  "uselistorder"
+  "uselistorder_bb"
+  "module"
+  "asm"
+  "sideeffect"
+  "alignstack"
+  "inteldialect"
+  "unwind"
+  "type"
+  "global"
+  "constant"
+  "externally_initialized"
+  "alias"
+  "ifunc"
+  "section"
+  "comdat"
+  "any"
+  "exactmatch"
+  "largest"
+  "nodeduplicate"
+  "samesize"
+  "distinct"
+  "attributes"
+  "vscale"
+] @keyword
+
+[
+  "no_cfi"
+  (dso_local)
+  (linkage_aux)
+  (visibility)
+] @keyword.modifier
+
+[
+  "thread_local"
+  "localdynamic"
+  "initialexec"
+  "localexec"
+  (unnamed_addr)
+  (dll_storage_class)
+] @keyword.modifier
+
+(attribute_name) @attribute
+
+(function_header
+  [
+    (linkage)
+    (calling_conv)
+    (unnamed_addr)
+  ] @keyword.function)
+
+(number) @number
+
+(comment) @comment @spell
+
+(string) @string
+
+(cstring) @string
+
+(label) @label
+
+(_
+  inst_name: "ret" @keyword.return)
+
+(float) @number.float
+
+[
+  (struct_value)
+  (array_value)
+  (vector_value)
+] @constructor
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  "<"
+  ">"
+  "<{"
+  "}>"
+] @punctuation.bracket
+
+[
+  ","
+  ":"
+] @punctuation.delimiter
+
+[
+  "="
+  "|"
+  "x"
+  "..."
+] @operator
+
+[
+  "true"
+  "false"
+] @boolean
+
+[
+  "undef"
+  "poison"
+  "null"
+  "none"
+  "zeroinitializer"
+] @constant.builtin
diff --git a/pack/ant/start/nvim-treesitter/queries/llvm/injections.scm b/pack/ant/start/nvim-treesitter/queries/llvm/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/llvm/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/lua/folds.scm b/pack/ant/start/nvim-treesitter/queries/lua/folds.scm
new file mode 100644
index 0000000..9dfac3a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/lua/folds.scm
@@ -0,0 +1,12 @@
+[
+  (do_statement)
+  (while_statement)
+  (repeat_statement)
+  (if_statement)
+  (for_statement)
+  (function_declaration)
+  (function_definition)
+  (parameters)
+  (arguments)
+  (table_constructor)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/lua/highlights.scm b/pack/ant/start/nvim-treesitter/queries/lua/highlights.scm
new file mode 100644
index 0000000..79ab165
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/lua/highlights.scm
@@ -0,0 +1,265 @@
+; Keywords
+"return" @keyword.return
+
+[
+  "goto"
+  "in"
+  "local"
+] @keyword
+
+(break_statement) @keyword
+
+(do_statement
+  [
+    "do"
+    "end"
+  ] @keyword)
+
+(while_statement
+  [
+    "while"
+    "do"
+    "end"
+  ] @keyword.repeat)
+
+(repeat_statement
+  [
+    "repeat"
+    "until"
+  ] @keyword.repeat)
+
+(if_statement
+  [
+    "if"
+    "elseif"
+    "else"
+    "then"
+    "end"
+  ] @keyword.conditional)
+
+(elseif_statement
+  [
+    "elseif"
+    "then"
+    "end"
+  ] @keyword.conditional)
+
+(else_statement
+  [
+    "else"
+    "end"
+  ] @keyword.conditional)
+
+(for_statement
+  [
+    "for"
+    "do"
+    "end"
+  ] @keyword.repeat)
+
+(function_declaration
+  [
+    "function"
+    "end"
+  ] @keyword.function)
+
+(function_definition
+  [
+    "function"
+    "end"
+  ] @keyword.function)
+
+; Operators
+[
+  "and"
+  "not"
+  "or"
+] @keyword.operator
+
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "^"
+  "#"
+  "=="
+  "~="
+  "<="
+  ">="
+  "<"
+  ">"
+  "="
+  "&"
+  "~"
+  "|"
+  "<<"
+  ">>"
+  "//"
+  ".."
+] @operator
+
+; Punctuations
+[
+  ";"
+  ":"
+  "::"
+  ","
+  "."
+] @punctuation.delimiter
+
+; Brackets
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; Variables
+(identifier) @variable
+
+((identifier) @constant.builtin
+  (#eq? @constant.builtin "_VERSION"))
+
+((identifier) @variable.builtin
+  (#eq? @variable.builtin "self"))
+
+((identifier) @module.builtin
+  (#any-of? @module.builtin "_G" "debug" "io" "jit" "math" "os" "package" "string" "table" "utf8"))
+
+((identifier) @keyword.coroutine
+  (#eq? @keyword.coroutine "coroutine"))
+
+(variable_list
+  (attribute
+    "<" @punctuation.bracket
+    (identifier) @attribute
+    ">" @punctuation.bracket))
+
+; Labels
+(label_statement
+  (identifier) @label)
+
+(goto_statement
+  (identifier) @label)
+
+; Constants
+((identifier) @constant
+  (#lua-match? @constant "^[A-Z][A-Z_0-9]*$"))
+
+(nil) @constant.builtin
+
+[
+  (false)
+  (true)
+] @boolean
+
+; Tables
+(field
+  name: (identifier) @property)
+
+(dot_index_expression
+  field: (identifier) @variable.member)
+
+(table_constructor
+  [
+    "{"
+    "}"
+  ] @constructor)
+
+; Functions
+(parameters
+  (identifier) @variable.parameter)
+
+(vararg_expression) @variable.parameter.builtin
+
+(function_declaration
+  name: [
+    (identifier) @function
+    (dot_index_expression
+      field: (identifier) @function)
+  ])
+
+(function_declaration
+  name: (method_index_expression
+    method: (identifier) @function.method))
+
+(assignment_statement
+  (variable_list
+    .
+    name: [
+      (identifier) @function
+      (dot_index_expression
+        field: (identifier) @function)
+    ])
+  (expression_list
+    .
+    value: (function_definition)))
+
+(table_constructor
+  (field
+    name: (identifier) @function
+    value: (function_definition)))
+
+(function_call
+  name: [
+    (identifier) @function.call
+    (dot_index_expression
+      field: (identifier) @function.call)
+    (method_index_expression
+      method: (identifier) @function.method.call)
+  ])
+
+(function_call
+  (identifier) @function.builtin
+  (#any-of? @function.builtin
+    ; built-in functions in Lua 5.1
+    "assert" "collectgarbage" "dofile" "error" "getfenv" "getmetatable" "ipairs" "load" "loadfile"
+    "loadstring" "module" "next" "pairs" "pcall" "print" "rawequal" "rawget" "rawlen" "rawset"
+    "require" "select" "setfenv" "setmetatable" "tonumber" "tostring" "type" "unpack" "xpcall"
+    "__add" "__band" "__bnot" "__bor" "__bxor" "__call" "__concat" "__div" "__eq" "__gc" "__idiv"
+    "__index" "__le" "__len" "__lt" "__metatable" "__mod" "__mul" "__name" "__newindex" "__pairs"
+    "__pow" "__shl" "__shr" "__sub" "__tostring" "__unm"))
+
+; Others
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^[-][-][-]"))
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^[-][-](%s?)@"))
+
+(hash_bang_line) @keyword.directive
+
+(number) @number
+
+(string) @string
+
+(escape_sequence) @string.escape
+
+; string.match("123", "%d+")
+(function_call
+  (dot_index_expression
+    field: (identifier) @_method
+    (#any-of? @_method "find" "match" "gmatch" "gsub"))
+  arguments: (arguments
+    .
+    (_)
+    .
+    (string
+      content: (string_content) @string.regexp)))
+
+;("123"):match("%d+")
+(function_call
+  (method_index_expression
+    method: (identifier) @_method
+    (#any-of? @_method "find" "match" "gmatch" "gsub"))
+  arguments: (arguments
+    .
+    (string
+      content: (string_content) @string.regexp)))
diff --git a/pack/ant/start/nvim-treesitter/queries/lua/indents.scm b/pack/ant/start/nvim-treesitter/queries/lua/indents.scm
new file mode 100644
index 0000000..84303b8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/lua/indents.scm
@@ -0,0 +1,47 @@
+[
+  (function_definition)
+  (function_declaration)
+  (field)
+  (do_statement)
+  (method_index_expression)
+  (while_statement)
+  (repeat_statement)
+  (if_statement)
+  "then"
+  (for_statement)
+  (return_statement)
+  (table_constructor)
+  (arguments)
+] @indent.begin
+
+[
+  "end"
+  "}"
+  "]]"
+] @indent.end
+
+(")" @indent.end
+  (#not-has-parent? @indent.end parameters))
+
+(return_statement
+  (expression_list
+    (function_call))) @indent.dedent
+
+[
+  "end"
+  "then"
+  "until"
+  "}"
+  ")"
+  "elseif"
+  (elseif_statement)
+  "else"
+  (else_statement)
+] @indent.branch
+
+(comment) @indent.auto
+
+(string) @indent.auto
+
+(ERROR
+  "function") @indent.begin
diff --git a/pack/ant/start/nvim-treesitter/queries/lua/injections.scm b/pack/ant/start/nvim-treesitter/queries/lua/injections.scm
new file mode 100644
index 0000000..7b46f02
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/lua/injections.scm
@@ -0,0 +1,203 @@
+((function_call
+  name: [
+    (identifier) @_cdef_identifier
+    (_
+      _
+      (identifier) @_cdef_identifier)
+  ]
+  arguments: (arguments
+    (string
+      content: _ @injection.content)))
+  (#set! injection.language "c")
+  (#eq? @_cdef_identifier "cdef"))
+
+((function_call
+  name: (_) @_vimcmd_identifier
+  arguments: (arguments
+    (string
+      content: _ @injection.content)))
+  (#set! injection.language "vim")
+  (#any-of? @_vimcmd_identifier
+    "vim.cmd" "vim.api.nvim_command" "vim.api.nvim_command" "vim.api.nvim_exec2"))
+
+((function_call
+  name: (_) @_vimcmd_identifier
+  arguments: (arguments
+    (string
+      content: _ @injection.content) .))
+  (#set! injection.language "query")
+  (#any-of? @_vimcmd_identifier "vim.treesitter.query.set" "vim.treesitter.query.parse"))
+
+((function_call
+  name: (_) @_vimcmd_identifier
+  arguments: (arguments
+    .
+    (_)
+    .
+    (string
+      content: _ @_method)
+    .
+    (string
+      content: _ @injection.content)))
+  (#any-of? @_vimcmd_identifier "vim.rpcrequest" "vim.rpcnotify")
+  (#eq? @_method "nvim_exec_lua")
+  (#set! injection.language "lua"))
+
+; exec_lua [[ ... ]] in functionaltests
+((function_call
+  name: (identifier) @_function
+  arguments: (arguments
+    (string
+      content: (string_content) @injection.content)))
+  (#eq? @_function "exec_lua")
+  (#set! injection.language "lua"))
+
+; vim.api.nvim_create_autocmd("FileType", { command = "injected here" })
+(function_call
+  name: (_) @_vimcmd_identifier
+  arguments: (arguments
+    .
+    (_)
+    .
+    (table_constructor
+      (field
+        name: (identifier) @_command
+        value: (string
+          content: (_) @injection.content))) .)
+  ; limit so only 2-argument functions gets matched before pred handle
+  (#eq? @_vimcmd_identifier "vim.api.nvim_create_autocmd")
+  (#eq? @_command "command")
+  (#set! injection.language "vim"))
+
+(function_call
+  name: (_) @_user_cmd
+  arguments: (arguments
+    .
+    (_)
+    .
+    (string
+      content: (_) @injection.content)
+    .
+    (_) .)
+  (#eq? @_user_cmd "vim.api.nvim_create_user_command")
+  (#set! injection.language "vim"))
+
+(function_call
+  name: (_) @_user_cmd
+  arguments: (arguments
+    .
+    (_)
+    .
+    (_)
+    .
+    (string
+      content: (_) @injection.content)
+    .
+    (_) .)
+  ; Limiting predicate handling to only functions with 4 arguments
+  (#eq? @_user_cmd "vim.api.nvim_buf_create_user_command")
+  (#set! injection.language "vim"))
+
+; rhs highlighting for vim.keymap.set/vim.api.nvim_set_keymap/vim.api.nvim_buf_set_keymap
+; (function_call
+;   name: (_) @_map
+;   arguments:
+;     (arguments
+;       . (_)
+;       . (_)
+;       .
+;       (string
+;         content: (_) @injection.content))
+;   (#any-of? @_map "vim.api.nvim_set_keymap" "vim.keymap.set")
+;   (#set! injection.language "vim"))
+;
+; (function_call
+;   name: (_) @_map
+;   arguments:
+;     (arguments
+;       . (_)
+;       . (_)
+;       . (_)
+;       .
+;       (string
+;         content: (_) @injection.content)
+;       . (_) .)
+;   (#eq? @_map "vim.api.nvim_buf_set_keymap")
+;   (#set! injection.language "vim"))
+; highlight string as query if starts with `;; query`
+(string
+  content: _ @injection.content
+  (#lua-match? @injection.content "^%s*;+%s?query")
+  (#set! injection.language "query"))
+
+(comment
+  content: (_) @injection.content
+  (#lua-match? @injection.content "^[-][%s]*[@|]")
+  (#set! injection.language "luadoc")
+  (#offset! @injection.content 0 1 0 0))
+
+; string.match("123", "%d+")
+(function_call
+  (dot_index_expression
+    field: (identifier) @_method
+    (#any-of? @_method "find" "match" "gmatch" "gsub"))
+  arguments: (arguments
+    .
+    (_)
+    .
+    (string
+      content: (string_content) @injection.content
+      (#set! injection.language "luap")
+      (#set! injection.include-children))))
+
+;("123"):match("%d+")
+(function_call
+  (method_index_expression
+    method: (identifier) @_method
+    (#any-of? @_method "find" "match" "gmatch" "gsub"))
+  arguments: (arguments
+    .
+    (string
+      content: (string_content) @injection.content
+      (#set! injection.language "luap")
+      (#set! injection.include-children))))
+
+; string.format("pi = %.2f", 3.14159)
+((function_call
+  (dot_index_expression
+    field: (identifier) @_method)
+  arguments: (arguments
+    .
+    (string
+      (string_content) @injection.content)))
+  (#eq? @_method "format")
+  (#set! injection.language "printf"))
+
+; ("pi = %.2f"):format(3.14159)
+((function_call
+  (method_index_expression
+    table: (_
+      (string
+        (string_content) @injection.content))
+    method: (identifier) @_method))
+  (#eq? @_method "format")
+  (#set! injection.language "printf"))
+
+(comment
+  content: (_) @injection.content
+  (#set! injection.language "comment"))
+
+; vim.filetype.add({ pattern = { ["some lua pattern here"] = "filetype" } })
+((function_call
+  name: (_) @_filetypeadd_identifier
+  arguments: (arguments
+    (table_constructor
+      (field
+        name: (_) @_pattern_key
+        value: (table_constructor
+          (field
+            name: (string
+              content: _ @injection.content)))))))
+  (#set! injection.language "luap")
+  (#eq? @_filetypeadd_identifier "vim.filetype.add")
+  (#eq? @_pattern_key "pattern"))
diff --git a/pack/ant/start/nvim-treesitter/queries/lua/locals.scm b/pack/ant/start/nvim-treesitter/queries/lua/locals.scm
new file mode 100644
index 0000000..c4f36e8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/lua/locals.scm
@@ -0,0 +1,54 @@
+; Scopes
+[
+  (chunk)
+  (do_statement)
+  (while_statement)
+  (repeat_statement)
+  (if_statement)
+  (for_statement)
+  (function_declaration)
+  (function_definition)
+] @local.scope
+
+; Definitions
+(assignment_statement
+  (variable_list
+    (identifier) @local.definition.var))
+
+(assignment_statement
+  (variable_list
+    (dot_index_expression
+      .
+      (_) @local.definition.associated
+      (identifier) @local.definition.var)))
+
+((function_declaration
+  name: (identifier) @local.definition.function)
+  (#set! definition.function.scope "parent"))
+
+((function_declaration
+  name: (dot_index_expression
+    .
+    (_) @local.definition.associated
+    (identifier) @local.definition.function))
+  (#set! definition.method.scope "parent"))
+
+((function_declaration
+  name: (method_index_expression
+    .
+    (_) @local.definition.associated
+    (identifier) @local.definition.method))
+  (#set! definition.method.scope "parent"))
+
+(for_generic_clause
+  (variable_list
+    (identifier) @local.definition.var))
+
+(for_numeric_clause
+  name: (identifier) @local.definition.var)
+
+(parameters
+  (identifier) @local.definition.parameter)
+
+; References
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/luadoc/highlights.scm b/pack/ant/start/nvim-treesitter/queries/luadoc/highlights.scm
new file mode 100644
index 0000000..1649e5d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/luadoc/highlights.scm
@@ -0,0 +1,198 @@
+; Keywords
+[
+  "@module"
+  "@package"
+] @keyword.import @nospell
+
+[
+  "@class"
+  "@type"
+  "@param"
+  "@alias"
+  "@field"
+  "@generic"
+  "@vararg"
+  "@diagnostic"
+  "@cast"
+  "@deprecated"
+  "@meta"
+  "@source"
+  "@version"
+  "@operator"
+  "@nodiscard"
+  "@cast"
+  "@overload"
+  "@enum"
+  "@language"
+  "@see"
+  "@as"
+  "extends"
+  (diagnostic_identifier)
+] @keyword @nospell
+
+"@async" @keyword.coroutine @nospell
+
+(language_injection
+  "@language"
+  (identifier) @keyword @nospell)
+
+(function_type
+  [
+    "fun"
+    "function"
+  ] @keyword.function @nospell)
+
+(source_annotation
+  filename: (identifier) @string.special.path @nospell
+  extension: (identifier) @string.special.path @nospell)
+
+(version_annotation
+  version: _ @constant.builtin @nospell)
+
+"@return" @keyword.return @nospell
+
+; Qualifiers
+[
+  "public"
+  "protected"
+  "private"
+  "package"
+  "@public"
+  "@protected"
+  "@private"
+  "(exact)"
+  "(key)"
+] @keyword.modifier @nospell
+
+; Variables
+(identifier) @variable @nospell
+
+[
+  "..."
+  "self"
+] @variable.builtin @nospell
+
+; Macros
+(alias_annotation
+  (identifier) @function.macro @nospell)
+
+; Parameters
+(param_annotation
+  (identifier) @variable.parameter @nospell)
+
+(parameter
+  (identifier) @variable.parameter @nospell)
+
+; Fields
+(field_annotation
+  (identifier) @variable.member @nospell)
+
+(table_literal_type
+  field: (identifier) @variable.member @nospell)
+
+(member_type
+  [
+    "#"
+    "."
+  ]
+  .
+  (identifier) @variable.member @nospell)
+
+(member_type
+  (identifier) @module @nospell)
+
+(member_type
+  (identifier) @type @nospell .)
+
+; Types
+(table_type
+  "table" @type.builtin @nospell)
+
+(builtin_type) @type.builtin @nospell
+
+(class_annotation
+  (identifier) @type @nospell)
+
+(enum_annotation
+  (identifier) @type @nospell)
+
+((array_type
+  [
+    "["
+    "]"
+  ] @type)
+  (#set! priority 105))
+
+(type) @type
+
+; Operators
+[
+  "|"
+  "+"
+  "-"
+] @operator
+
+; Literals
+[
+  (string)
+  (literal_type)
+  "`"
+] @string
+
+(module_annotation
+  (string) @module @nospell)
+
+[
+  (number)
+  (numeric_literal_type)
+] @number
+
+; Punctuation
+[
+  "["
+  "]"
+  "[["
+  "]]"
+  "[=["
+  "]=]"
+] @punctuation.bracket
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "<"
+  ">"
+] @punctuation.bracket
+
+[
+  ","
+  "."
+  "#"
+  ":"
+] @punctuation.delimiter
+
+[
+  "@"
+  "?"
+] @punctuation.special
+
+; Comments
+(comment) @comment @spell
+
+(at_comment
+  (identifier) @type @nospell
+  (_) @comment @spell)
+
+(class_at_comment
+  (identifier) @type @nospell
+  ("extends"?
+    (identifier)? @type @nospell)
+  (_) @comment @spell)
diff --git a/pack/ant/start/nvim-treesitter/queries/luap/highlights.scm b/pack/ant/start/nvim-treesitter/queries/luap/highlights.scm
new file mode 100644
index 0000000..40d2bd3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/luap/highlights.scm
@@ -0,0 +1,45 @@
+[
+  (anchor_begin)
+  (anchor_end)
+] @punctuation.delimiter
+
+(pattern
+  (character
+    "." @variable.builtin))
+
+[
+  "["
+  "]"
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  (zero_or_more)
+  (shortest_zero_or_more)
+  (one_or_more)
+  (zero_or_one)
+] @operator
+
+(range
+  from: (character) @constant
+  "-" @operator
+  to: (character) @constant)
+
+(set
+  (character) @constant)
+
+(negated_set
+  (character) @constant)
+
+(class) @string.escape
+
+(class
+  "%" @string.regexp
+  (escape_char) @string.regexp)
+
+(negated_set
+  "^" @operator)
+
+(balanced_match
+  (character) @variable.parameter)
diff --git a/pack/ant/start/nvim-treesitter/queries/luau/folds.scm b/pack/ant/start/nvim-treesitter/queries/luau/folds.scm
new file mode 100644
index 0000000..8ddaf94
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/luau/folds.scm
@@ -0,0 +1,3 @@
+; inherits: lua
+
+(object_type) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/luau/highlights.scm b/pack/ant/start/nvim-treesitter/queries/luau/highlights.scm
new file mode 100644
index 0000000..f6f64b3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/luau/highlights.scm
@@ -0,0 +1,305 @@
+; Preproc
+(hash_bang_line) @keyword.directive
+
+; Keywords
+"return" @keyword.return
+
+"local" @keyword
+
+"type" @keyword.type
+
+"export" @keyword.import
+
+(do_statement
+  [
+    "do"
+    "end"
+  ] @keyword)
+
+(while_statement
+  [
+    "while"
+    "do"
+    "end"
+  ] @keyword.repeat)
+
+(repeat_statement
+  [
+    "repeat"
+    "until"
+  ] @keyword.repeat)
+
+[
+  (break_statement)
+  (continue_statement)
+] @keyword.repeat
+
+(if_statement
+  [
+    "if"
+    "elseif"
+    "else"
+    "then"
+    "end"
+  ] @keyword.conditional)
+
+(if_expression
+  [
+    "if"
+    "then"
+  ] @keyword.conditional)
+
+(elseif_statement
+  [
+    "elseif"
+    "then"
+    "end"
+  ] @keyword.conditional)
+
+(elseif_clause
+  [
+    "elseif"
+    "then"
+  ] @keyword.conditional)
+
+(else_statement
+  [
+    "else"
+    "end"
+  ] @keyword.conditional)
+
+(else_clause
+  "else" @keyword.conditional)
+
+(for_statement
+  [
+    "for"
+    "do"
+    "end"
+  ] @keyword.repeat)
+
+(function_declaration
+  [
+    "function"
+    "end"
+  ] @keyword.function)
+
+(function_definition
+  [
+    "function"
+    "end"
+  ] @keyword.function)
+
+; Operators
+[
+  "and"
+  "not"
+  "or"
+  "in"
+  "typeof"
+] @keyword.operator
+
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "^"
+  "#"
+  "=="
+  "~="
+  "<="
+  ">="
+  "<"
+  ">"
+  "="
+  "&"
+  "|"
+  "?"
+  "//"
+  ".."
+  "+="
+  "-="
+  "*="
+  "/="
+  "%="
+  "^="
+  "..="
+] @operator
+
+; Variables
+(identifier) @variable
+
+; Types
+(type/identifier) @type
+
+(generic_type
+  (identifier) @type)
+
+(builtin_type) @type.builtin
+
+((identifier) @type
+  (#lua-match? @type "^[A-Z]"))
+
+; Typedefs
+(type_definition
+  "type"
+  .
+  (type) @type.definition
+  "=")
+
+; Constants
+((identifier) @constant
+  (#lua-match? @constant "^[A-Z][A-Z_0-9]+$"))
+
+; Builtins
+((identifier) @constant.builtin
+  (#eq? @constant.builtin "_VERSION"))
+
+((identifier) @variable.builtin
+  (#eq? @variable.builtin "self"))
+
+"..." @variable.builtin
+
+((identifier) @module.builtin
+  (#any-of? @module.builtin "_G" "debug" "io" "jit" "math" "os" "package" "string" "table" "utf8"))
+
+((identifier) @keyword.coroutine
+  (#eq? @keyword.coroutine "coroutine"))
+
+; Tables
+(field
+  name: (identifier) @variable.member)
+
+(dot_index_expression
+  field: (identifier) @variable.member)
+
+(object_type
+  (identifier) @variable.member)
+
+(table_constructor
+  [
+    "{"
+    "}"
+  ] @constructor)
+
+; Functions
+(parameter
+  .
+  (identifier) @variable.parameter)
+
+(function_type
+  (identifier) @variable.parameter)
+
+(function_call
+  name: (identifier) @function.call)
+
+(function_declaration
+  name: (identifier) @function)
+
+(function_call
+  name: (dot_index_expression
+    field: (identifier) @function.call))
+
+(function_declaration
+  name: (dot_index_expression
+    field: (identifier) @function))
+
+(method_index_expression
+  method: (identifier) @function.method.call)
+
+(function_call
+  (identifier) @function.builtin
+  (#any-of? @function.builtin
+    ; built-in functions in Lua 5.1
+    "assert" "collectgarbage" "dofile" "error" "getfenv" "getmetatable" "ipairs" "load" "loadfile"
+    "loadstring" "module" "next" "pairs" "pcall" "print" "rawequal" "rawget" "rawlen" "rawset"
+    "require" "select" "setfenv" "setmetatable" "tonumber" "tostring" "type" "unpack" "xpcall"
+    "typeof" "__add" "__band" "__bnot" "__bor" "__bxor" "__call" "__concat" "__div" "__eq" "__gc"
+    "__idiv" "__index" "__le" "__len" "__lt" "__metatable" "__mod" "__mul" "__name" "__newindex"
+    "__pairs" "__pow" "__shl" "__shr" "__sub" "__tostring" "__unm"))
+
+; Literals
+(number) @number
+
+(string) @string
+
+(nil) @constant.builtin
+
+(vararg_expression) @variable.builtin
+
+[
+  (false)
+  (true)
+] @boolean
+
+; Punctuations
+[
+  ";"
+  ":"
+  "::"
+  ","
+  "."
+  "->"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+(variable_list
+  attribute: (attribute
+    ([
+      "<"
+      ">"
+    ] @punctuation.bracket
+      (identifier) @attribute)))
+
+(generic_type
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(generic_type_list
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+; Comments
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^[-][-][-]"))
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^[-][-](%s?)@"))
+
+; string.match("123", "%d+")
+(function_call
+  (dot_index_expression
+    field: (identifier) @_method
+    (#any-of? @_method "find" "format" "match" "gmatch" "gsub"))
+  arguments: (arguments
+    .
+    (_)
+    .
+    (string
+      content: _ @string.regexp)))
+
+; ("123"):match("%d+")
+(function_call
+  (method_index_expression
+    method: (identifier) @_method
+    (#any-of? @_method "find" "format" "match" "gmatch" "gsub"))
+  arguments: (arguments
+    .
+    (string
+      content: _ @string.regexp)))
diff --git a/pack/ant/start/nvim-treesitter/queries/luau/indents.scm b/pack/ant/start/nvim-treesitter/queries/luau/indents.scm
new file mode 100644
index 0000000..f0af4dd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/luau/indents.scm
@@ -0,0 +1,3 @@
+; inherits: lua
+
+(object_type) @indent.begin
diff --git a/pack/ant/start/nvim-treesitter/queries/luau/injections.scm b/pack/ant/start/nvim-treesitter/queries/luau/injections.scm
new file mode 100644
index 0000000..5587915
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/luau/injections.scm
@@ -0,0 +1,44 @@
+((function_call
+  name: [
+    (identifier) @_cdef_identifier
+    (_
+      _
+      (identifier) @_cdef_identifier)
+  ]
+  arguments: (arguments
+    (string
+      content: _ @injection.content)))
+  (#eq? @_cdef_identifier "cdef")
+  (#set! injection.language "c"))
+
+((comment) @injection.content
+  (#lua-match? @injection.content "[-][-][-][%s]*@")
+  (#offset! @injection.content 0 3 0 0)
+  (#set! injection.language "luadoc"))
+
+; string.match("123", "%d+")
+(function_call
+  (dot_index_expression
+    field: (identifier) @_method
+    (#any-of? @_method "find" "format" "match" "gmatch" "gsub"))
+  arguments: (arguments
+    .
+    (_)
+    .
+    (string
+      content: _ @injection.content))
+  (#set! injection.language "luap"))
+
+; ("123"):match("%d+")
+(function_call
+  (method_index_expression
+    method: (identifier) @_method
+    (#any-of? @_method "find" "format" "match" "gmatch" "gsub"))
+  arguments: (arguments
+    .
+    (string
+      content: _ @injection.content))
+  (#set! injection.language "luap"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/luau/locals.scm b/pack/ant/start/nvim-treesitter/queries/luau/locals.scm
new file mode 100644
index 0000000..d5420b4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/luau/locals.scm
@@ -0,0 +1,54 @@
+; Scopes
+[
+  (chunk)
+  (do_statement)
+  (while_statement)
+  (repeat_statement)
+  (if_statement)
+  (for_statement)
+  (function_declaration)
+  (function_definition)
+] @local.scope
+
+; References
+(identifier) @local.reference
+
+; Definitions
+(assignment_statement
+  (variable_list
+    (identifier) @local.definition.var))
+
+(assignment_statement
+  (variable_list
+    (dot_index_expression
+      .
+      (_) @local.definition.associated
+      (identifier) @local.definition.var)))
+
+((function_declaration
+  name: (identifier) @local.definition.function)
+  (#set! definition.function.scope "parent"))
+
+((function_declaration
+  name: (dot_index_expression
+    .
+    (_) @local.definition.associated
+    (identifier) @local.definition.function))
+  (#set! definition.method.scope "parent"))
+
+((function_declaration
+  name: (method_index_expression
+    .
+    (_) @local.definition.associated
+    (identifier) @local.definition.method))
+  (#set! definition.method.scope "parent"))
+
+(for_generic_clause
+  (variable_list
+    (identifier) @local.definition.var))
+
+(for_numeric_clause
+  name: (identifier) @local.definition.var)
+
+(parameter
+  (identifier) @local.definition.parameter)
diff --git a/pack/ant/start/nvim-treesitter/queries/m68k/folds.scm b/pack/ant/start/nvim-treesitter/queries/m68k/folds.scm
new file mode 100644
index 0000000..1dd8eaf
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/m68k/folds.scm
@@ -0,0 +1 @@
+(element_list) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/m68k/highlights.scm b/pack/ant/start/nvim-treesitter/queries/m68k/highlights.scm
new file mode 100644
index 0000000..72a5504
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/m68k/highlights.scm
@@ -0,0 +1,81 @@
+(symbol) @variable
+
+(label
+  name: (symbol) @label)
+
+[
+  (instruction_mnemonic)
+  (directive_mnemonic)
+] @function.builtin
+
+(include
+  (directive_mnemonic) @keyword.import)
+
+(include_bin
+  (directive_mnemonic) @keyword.import)
+
+(include_dir
+  (directive_mnemonic) @keyword.import)
+
+(size) @attribute
+
+(macro_definition
+  name: (symbol) @function.macro)
+
+(macro_call
+  name: (symbol) @function.macro)
+
+(string_literal) @string
+
+(path) @string.special.path
+
+[
+  (decimal_literal)
+  (hexadecimal_literal)
+  (octal_literal)
+  (binary_literal)
+] @number
+
+[
+  (reptn)
+  (carg)
+  (narg)
+  (macro_arg)
+] @variable.builtin
+
+[
+  (control_mnemonic)
+  (address_register)
+  (data_register)
+  (float_register)
+  (named_register)
+] @keyword
+
+(repeat
+  (control_mnemonic) @keyword.repeat)
+
+(conditional
+  (control_mnemonic) @keyword.conditional)
+
+(comment) @comment @spell
+
+[
+  (operator)
+  "="
+  "#"
+] @operator
+
+[
+  "."
+  ","
+  "/"
+  "-"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  ")+"
+] @punctuation.bracket
+
+(section) @module
diff --git a/pack/ant/start/nvim-treesitter/queries/m68k/injections.scm b/pack/ant/start/nvim-treesitter/queries/m68k/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/m68k/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/m68k/locals.scm b/pack/ant/start/nvim-treesitter/queries/m68k/locals.scm
new file mode 100644
index 0000000..54e948a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/m68k/locals.scm
@@ -0,0 +1,26 @@
+(macro_definition
+  name: (symbol) @local.definition.macro)
+
+(symbol_assignment
+  name: (symbol) @local.definition.var)
+
+(label
+  name: (symbol) @local.definition.constant)
+
+(symbol_definition
+  name: (symbol) @local.definition.constant)
+
+(offset_definition
+  name: (symbol) @local.definition.constant)
+
+(register_definition
+  name: (symbol) @local.definition.constant)
+
+(register_list_definition
+  name: (symbol) @local.definition.constant)
+
+(external_reference
+  symbols: (symbol_list
+    (symbol) @local.definition.import))
+
+(symbol) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/make/folds.scm b/pack/ant/start/nvim-treesitter/queries/make/folds.scm
new file mode 100644
index 0000000..961f4ec
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/make/folds.scm
@@ -0,0 +1,5 @@
+([
+  (conditional)
+  (rule)
+] @fold
+  (#trim! @fold))
diff --git a/pack/ant/start/nvim-treesitter/queries/make/highlights.scm b/pack/ant/start/nvim-treesitter/queries/make/highlights.scm
new file mode 100644
index 0000000..afdfbe3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/make/highlights.scm
@@ -0,0 +1,170 @@
+(comment) @comment @spell
+
+(conditional
+  (_
+    [
+      "ifeq"
+      "else"
+      "ifneq"
+      "ifdef"
+      "ifndef"
+    ] @keyword.conditional)
+  "endif" @keyword.conditional)
+
+(rule
+  (targets
+    (word) @function))
+
+(rule
+  (targets) @_target
+  (prerequisites
+    (word) @function
+    (#eq? @_target ".PHONY")))
+
+(rule
+  (targets
+    (word) @function.builtin
+    (#any-of? @function.builtin
+      ".DEFAULT" ".SUFFIXES" ".DELETE_ON_ERROR" ".EXPORT_ALL_VARIABLES" ".IGNORE" ".INTERMEDIATE"
+      ".LOW_RESOLUTION_TIME" ".NOTPARALLEL" ".ONESHELL" ".PHONY" ".POSIX" ".PRECIOUS" ".SECONDARY"
+      ".SECONDEXPANSION" ".SILENT" ".SUFFIXES")))
+
+(rule
+  [
+    "&:"
+    ":"
+    "::"
+    "|"
+  ] @operator)
+
+[
+  "export"
+  "unexport"
+] @keyword.import
+
+(override_directive
+  "override" @keyword)
+
+(include_directive
+  [
+    "include"
+    "-include"
+  ] @keyword.import
+  filenames: (list
+    (word) @string.special.path))
+
+(variable_assignment
+  name: (word) @string.special.symbol
+  [
+    "?="
+    ":="
+    "::="
+    ; ":::="
+    "+="
+    "="
+  ] @operator)
+
+(shell_assignment
+  name: (word) @string.special.symbol
+  "!=" @operator)
+
+(define_directive
+  "define" @keyword
+  name: (word) @string.special.symbol
+  [
+    "="
+    ":="
+    "::="
+    ; ":::="
+    "?="
+    "!="
+  ]? @operator
+  "endef" @keyword)
+
+(variable_assignment
+  (word) @variable.builtin
+  (#any-of? @variable.builtin
+    ".DEFAULT_GOAL" ".EXTRA_PREREQS" ".FEATURES" ".INCLUDE_DIRS" ".RECIPEPREFIX" ".SHELLFLAGS"
+    ".VARIABLES" "MAKEARGS" "MAKEFILE_LIST" "MAKEFLAGS" "MAKE_RESTARTS" "MAKE_TERMERR"
+    "MAKE_TERMOUT" "SHELL"))
+
+; Use string to match bash
+(variable_reference
+  (word) @string) @operator
+
+(shell_function
+  [
+    "$"
+    "("
+    ")"
+  ] @operator
+  "shell" @function.builtin)
+
+(function_call
+  [
+    "$"
+    "("
+    ")"
+  ] @operator)
+
+(substitution_reference
+  [
+    "$"
+    "("
+    ")"
+  ] @operator)
+
+(automatic_variable
+  "$"
+  _ @character.special
+  (#set! priority 105))
+
+(automatic_variable
+  [
+    "$"
+    "("
+    ")"
+  ] @operator
+  (#set! priority 105))
+
+(recipe_line
+  "@" @character.special)
+
+(function_call
+  [
+    "subst"
+    "patsubst"
+    "strip"
+    "findstring"
+    "filter"
+    "filter-out"
+    "sort"
+    "word"
+    "words"
+    "wordlist"
+    "firstword"
+    "lastword"
+    "dir"
+    "notdir"
+    "suffix"
+    "basename"
+    "addsuffix"
+    "addprefix"
+    "join"
+    "wildcard"
+    "realpath"
+    "abspath"
+    "error"
+    "warning"
+    "info"
+    "origin"
+    "flavor"
+    "foreach"
+    "if"
+    "or"
+    "and"
+    "call"
+    "eval"
+    "file"
+    "value"
+  ] @function.builtin)
diff --git a/pack/ant/start/nvim-treesitter/queries/make/injections.scm b/pack/ant/start/nvim-treesitter/queries/make/injections.scm
new file mode 100644
index 0000000..c9c09be
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/make/injections.scm
@@ -0,0 +1,8 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((shell_text) @injection.content
+  (#set! injection.language "bash"))
+
+((shell_command) @injection.content
+  (#set! injection.language "bash"))
diff --git a/pack/ant/start/nvim-treesitter/queries/markdown/folds.scm b/pack/ant/start/nvim-treesitter/queries/markdown/folds.scm
new file mode 100644
index 0000000..a682e20
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/markdown/folds.scm
@@ -0,0 +1,7 @@
+([
+  (fenced_code_block)
+  (indented_code_block)
+  (list)
+  (section)
+] @fold
+  (#trim! @fold))
diff --git a/pack/ant/start/nvim-treesitter/queries/markdown/highlights.scm b/pack/ant/start/nvim-treesitter/queries/markdown/highlights.scm
new file mode 100644
index 0000000..a12669c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/markdown/highlights.scm
@@ -0,0 +1,121 @@
+;From MDeiml/tree-sitter-markdown & Helix
+(setext_heading
+  (paragraph) @markup.heading.1
+  (setext_h1_underline) @markup.heading.1)
+
+(setext_heading
+  (paragraph) @markup.heading.2
+  (setext_h2_underline) @markup.heading.2)
+
+(atx_heading
+  (atx_h1_marker)) @markup.heading.1
+
+(atx_heading
+  (atx_h2_marker)) @markup.heading.2
+
+(atx_heading
+  (atx_h3_marker)) @markup.heading.3
+
+(atx_heading
+  (atx_h4_marker)) @markup.heading.4
+
+(atx_heading
+  (atx_h5_marker)) @markup.heading.5
+
+(atx_heading
+  (atx_h6_marker)) @markup.heading.6
+
+(info_string) @label
+
+(pipe_table_header
+  (pipe_table_cell) @markup.heading)
+
+(pipe_table_header
+  "|" @punctuation.special)
+
+(pipe_table_row
+  "|" @punctuation.special)
+
+(pipe_table_delimiter_row
+  "|" @punctuation.special)
+
+(pipe_table_delimiter_cell) @punctuation.special
+
+; Code blocks (conceal backticks and language annotation)
+(indented_code_block) @markup.raw.block
+
+((fenced_code_block) @markup.raw.block
+  (#set! priority 90))
+
+(fenced_code_block
+  (fenced_code_block_delimiter) @markup.raw.block
+  (#set! conceal ""))
+
+(fenced_code_block
+  (info_string
+    (language) @label
+    (#set! conceal "")))
+
+(link_destination) @markup.link.url
+
+[
+  (link_title)
+  (link_label)
+] @markup.link.label
+
+((link_label)
+  .
+  ":" @punctuation.delimiter)
+
+[
+  (list_marker_plus)
+  (list_marker_minus)
+  (list_marker_star)
+  (list_marker_dot)
+  (list_marker_parenthesis)
+] @markup.list
+
+; NOTE: The following has been commented out due to issues with spaces in the
+; list marker nodes generated by the parser. If those spaces ever get captured
+; by a different node (e.g. block_continuation) we can safely re-add these
+; conceals.
+; ;; Conceal bullet points
+; ([(list_marker_plus) (list_marker_star)]
+;   @punctuation.special
+;   (#offset! @punctuation.special 0 0 0 -1)
+;   (#set! conceal "•"))
+; ([(list_marker_plus) (list_marker_star)]
+;   @punctuation.special
+;   (#any-of? @punctuation.special "+" "*")
+;   (#set! conceal "•"))
+; ((list_marker_minus)
+;   @punctuation.special
+;   (#offset! @punctuation.special 0 0 0 -1)
+;   (#set! conceal "—"))
+; ((list_marker_minus)
+;   @punctuation.special
+;   (#eq? @punctuation.special "-")
+;   (#set! conceal "—"))
+(thematic_break) @punctuation.special
+
+(task_list_marker_unchecked) @markup.list.unchecked
+
+(task_list_marker_checked) @markup.list.checked
+
+((block_quote) @markup.quote
+  (#set! priority 90))
+
+([
+  (plus_metadata)
+  (minus_metadata)
+] @keyword.directive
+  (#set! priority 90))
+
+[
+  (block_continuation)
+  (block_quote_marker)
+] @punctuation.special
+
+(backslash_escape) @string.escape
+
+(inline) @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/markdown/indents.scm b/pack/ant/start/nvim-treesitter/queries/markdown/indents.scm
new file mode 100644
index 0000000..90c52d3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/markdown/indents.scm
@@ -0,0 +1 @@
+(list_item) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/markdown/injections.scm b/pack/ant/start/nvim-treesitter/queries/markdown/injections.scm
new file mode 100644
index 0000000..8ed2052
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/markdown/injections.scm
@@ -0,0 +1,26 @@
+(fenced_code_block
+  (info_string
+    (language) @_lang)
+  (code_fence_content) @injection.content
+  (#set-lang-from-info-string! @_lang))
+
+((html_block) @injection.content
+  (#set! injection.language "html")
+  (#set! injection.combined)
+  (#set! injection.include-children))
+
+((minus_metadata) @injection.content
+  (#set! injection.language "yaml")
+  (#offset! @injection.content 1 0 -1 0)
+  (#set! injection.include-children))
+
+((plus_metadata) @injection.content
+  (#set! injection.language "toml")
+  (#offset! @injection.content 1 0 -1 0)
+  (#set! injection.include-children))
+
+([
+  (inline)
+  (pipe_table_cell)
+] @injection.content
+  (#set! injection.language "markdown_inline"))
diff --git a/pack/ant/start/nvim-treesitter/queries/markdown_inline/highlights.scm b/pack/ant/start/nvim-treesitter/queries/markdown_inline/highlights.scm
new file mode 100644
index 0000000..5fb9e91
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/markdown_inline/highlights.scm
@@ -0,0 +1,123 @@
+; From MDeiml/tree-sitter-markdown
+(code_span) @markup.raw @nospell
+
+(emphasis) @markup.italic
+
+(strong_emphasis) @markup.strong
+
+(strikethrough) @markup.strikethrough
+
+(shortcut_link
+  (link_text) @nospell)
+
+[
+  (backslash_escape)
+  (hard_line_break)
+] @string.escape
+
+; Conceal codeblock and text style markers
+([
+  (code_span_delimiter)
+  (emphasis_delimiter)
+] @conceal
+  (#set! conceal ""))
+
+; Conceal inline links
+(inline_link
+  [
+    "["
+    "]"
+    "("
+    (link_destination)
+    ")"
+  ] @markup.link
+  (#set! conceal ""))
+
+[
+  (link_label)
+  (link_text)
+  (link_title)
+  (image_description)
+] @markup.link.label
+
+((inline_link
+  (link_destination) @_url) @_label
+  (#set! @_label url @_url))
+
+((image
+  (link_destination) @_url) @_label
+  (#set! @_label url @_url))
+
+; Conceal image links
+(image
+  [
+    "!"
+    "["
+    "]"
+    "("
+    (link_destination)
+    ")"
+  ] @markup.link
+  (#set! conceal ""))
+
+; Conceal full reference links
+(full_reference_link
+  [
+    "["
+    "]"
+    (link_label)
+  ] @markup.link
+  (#set! conceal ""))
+
+; Conceal collapsed reference links
+(collapsed_reference_link
+  [
+    "["
+    "]"
+  ] @markup.link
+  (#set! conceal ""))
+
+; Conceal shortcut links
+(shortcut_link
+  [
+    "["
+    "]"
+  ] @markup.link
+  (#set! conceal ""))
+
+[
+  (link_destination)
+  (uri_autolink)
+  (email_autolink)
+] @markup.link.url @nospell
+
+((uri_autolink) @_url
+  (#offset! @_url 0 1 0 -1)
+  (#set! @_url url @_url))
+
+(entity_reference) @nospell
+
+; Replace common HTML entities.
+((entity_reference) @character.special
+  (#eq? @character.special "&nbsp;")
+  (#set! conceal " "))
+
+((entity_reference) @character.special
+  (#eq? @character.special "&lt;")
+  (#set! conceal "<"))
+
+((entity_reference) @character.special
+  (#eq? @character.special "&gt;")
+  (#set! conceal ">"))
+
+((entity_reference) @character.special
+  (#eq? @character.special "&amp;")
+  (#set! conceal "&"))
+
+((entity_reference) @character.special
+  (#eq? @character.special "&quot;")
+  (#set! conceal "\""))
+
+((entity_reference) @character.special
+  (#any-of? @character.special "&ensp;" "&emsp;")
+  (#set! conceal " "))
diff --git a/pack/ant/start/nvim-treesitter/queries/markdown_inline/injections.scm b/pack/ant/start/nvim-treesitter/queries/markdown_inline/injections.scm
new file mode 100644
index 0000000..6448b77
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/markdown_inline/injections.scm
@@ -0,0 +1,7 @@
+((html_tag) @injection.content
+  (#set! injection.language "html")
+  (#set! injection.combined))
+
+((latex_block) @injection.content
+  (#set! injection.language "latex")
+  (#set! injection.include-children))
diff --git a/pack/ant/start/nvim-treesitter/queries/matlab/folds.scm b/pack/ant/start/nvim-treesitter/queries/matlab/folds.scm
new file mode 100644
index 0000000..83008b3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/matlab/folds.scm
@@ -0,0 +1,13 @@
+[
+  (if_statement)
+  (for_statement)
+  (while_statement)
+  (switch_statement)
+  (try_statement)
+  (function_definition)
+  (class_definition)
+  (enumeration)
+  (events)
+  (methods)
+  (properties)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/matlab/highlights.scm b/pack/ant/start/nvim-treesitter/queries/matlab/highlights.scm
new file mode 100644
index 0000000..d2ab605
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/matlab/highlights.scm
@@ -0,0 +1,216 @@
+; Includes
+((command_name) @keyword.import
+  (#eq? @keyword.import "import"))
+
+; Keywords
+[
+  "arguments"
+  "end"
+  "events"
+  "global"
+  "methods"
+  "persistent"
+  "properties"
+] @keyword
+
+"enumeration" @keyword.type
+
+(class_definition
+  [
+    "classdef"
+    "end"
+  ] @keyword.type)
+
+; Conditionals
+(if_statement
+  [
+    "if"
+    "end"
+  ] @keyword.conditional)
+
+(elseif_clause
+  "elseif" @keyword.conditional)
+
+(else_clause
+  "else" @keyword.conditional)
+
+(switch_statement
+  [
+    "switch"
+    "end"
+  ] @keyword.conditional)
+
+(case_clause
+  "case" @keyword.conditional)
+
+(otherwise_clause
+  "otherwise" @keyword.conditional)
+
+(break_statement) @keyword.conditional
+
+; Repeats
+(for_statement
+  [
+    "for"
+    "parfor"
+    "end"
+  ] @keyword.repeat)
+
+(while_statement
+  [
+    "while"
+    "end"
+  ] @keyword.repeat)
+
+(continue_statement) @keyword.repeat
+
+; Exceptions
+(try_statement
+  [
+    "try"
+    "end"
+  ] @keyword.exception)
+
+(catch_clause
+  "catch" @keyword.exception)
+
+; Variables
+(identifier) @variable
+
+; Constants
+(events
+  (identifier) @constant)
+
+(attribute
+  (identifier) @constant)
+
+"~" @constant.builtin
+
+; Fields/Properties
+(field_expression
+  field: (identifier) @variable.member)
+
+(superclass
+  "."
+  (identifier) @variable.member)
+
+(property_name
+  "."
+  (identifier) @variable.member)
+
+(property
+  name: (identifier) @variable.member)
+
+; Types
+(class_definition
+  name: (identifier) @type)
+
+(attributes
+  (identifier) @constant)
+
+(enum
+  .
+  (identifier) @type)
+
+((identifier) @type
+  (#lua-match? @type "^_*[A-Z][a-zA-Z0-9_]+$"))
+
+; Functions
+(function_definition
+  "function" @keyword.function
+  name: (identifier) @function
+  [
+    "end"
+    "endfunction"
+  ]? @keyword.function)
+
+(function_signature
+  name: (identifier) @function)
+
+(function_call
+  name: (identifier) @function.call)
+
+(handle_operator
+  (identifier) @function)
+
+(validation_functions
+  (identifier) @function)
+
+(command
+  (command_name) @function.call)
+
+(command_argument) @variable.parameter
+
+(return_statement) @keyword.return
+
+; Parameters
+(function_arguments
+  (identifier) @variable.parameter)
+
+; Punctuation
+[
+  ";"
+  ","
+  "."
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; Operators
+[
+  "+"
+  ".+"
+  "-"
+  ".*"
+  "*"
+  ".*"
+  "/"
+  "./"
+  "\\"
+  ".\\"
+  "^"
+  ".^"
+  "'"
+  ".'"
+  "|"
+  "&"
+  "?"
+  "@"
+  "<"
+  "<="
+  ">"
+  ">="
+  "=="
+  "~="
+  "="
+  "&&"
+  "||"
+  ":"
+] @operator
+
+; Literals
+(string) @string
+
+(escape_sequence) @string.escape
+
+(formatting_sequence) @string.special
+
+(number) @number
+
+(boolean) @boolean
+
+; Comments
+[
+  (comment)
+  (line_continuation)
+] @comment @spell
+
+((comment) @keyword.directive
+  (#lua-match? @keyword.directive "^%%%% "))
diff --git a/pack/ant/start/nvim-treesitter/queries/matlab/indents.scm b/pack/ant/start/nvim-treesitter/queries/matlab/indents.scm
new file mode 100644
index 0000000..c217879
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/matlab/indents.scm
@@ -0,0 +1,39 @@
+"end" @indent.end @indent.branch
+
+[
+  (if_statement)
+  (for_statement)
+  (while_statement)
+  (switch_statement)
+  (try_statement)
+  (function_definition)
+  (class_definition)
+  (enumeration)
+  (events)
+  (methods)
+  (properties)
+] @indent.begin
+
+[
+  "elseif"
+  "else"
+  "case"
+  "otherwise"
+  "catch"
+] @indent.branch
+
+((matrix
+  (row) @indent.align)
+  (#set! indent.open_delimiter "[")
+  (#set! indent.close_delimiter "]"))
+
+((cell
+  (row) @indent.align)
+  (#set! indent.open_delimiter "{")
+  (#set! indent.close_delimiter "}"))
+
+((parenthesis) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+(comment) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/matlab/injections.scm b/pack/ant/start/nvim-treesitter/queries/matlab/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/matlab/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/matlab/locals.scm b/pack/ant/start/nvim-treesitter/queries/matlab/locals.scm
new file mode 100644
index 0000000..366c820
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/matlab/locals.scm
@@ -0,0 +1,33 @@
+; References
+(identifier) @local.reference
+
+; Definitions
+(function_definition
+  name: (identifier) @local.definition.function
+  (function_arguments
+    (identifier)* @local.definition.parameter
+    (","
+      (identifier) @local.definition.parameter)*)?) @local.scope
+
+(assignment
+  left: (identifier) @local.definition.var)
+
+(multioutput_variable
+  (identifier) @local.definition.var)
+
+(iterator
+  .
+  (identifier) @local.definition.var)
+
+(lambda
+  (arguments
+    (identifier) @local.definition.parameter))
+
+(global_operator
+  (identifier) @local.definition.var)
+
+(persistent_operator
+  (identifier) @local.definition.var)
+
+(catch_clause
+  (identifier) @local.definition)
diff --git a/pack/ant/start/nvim-treesitter/queries/menhir/highlights.scm b/pack/ant/start/nvim-treesitter/queries/menhir/highlights.scm
new file mode 100644
index 0000000..022fda8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/menhir/highlights.scm
@@ -0,0 +1,73 @@
+[
+  "%parameter"
+  "%token"
+  "%type"
+  "%start"
+  "%attribute"
+  "%left"
+  "%right"
+  "%nonassoc"
+  "%public"
+  "%inline"
+  "%prec"
+] @keyword
+
+"%on_error_reduce" @keyword.exception
+
+"let" @keyword.function
+
+[
+  (equality_symbol)
+  ":"
+  "|"
+  ";"
+  ","
+] @punctuation.delimiter
+
+[
+  "="
+  "~"
+] @operator
+
+(modifier) @operator
+
+"_" @character.special
+
+[
+  "<"
+  ">"
+  "{"
+  "}"
+  "%{"
+  "%}"
+  "%%"
+] @punctuation.special
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+(old_rule
+  (symbol) @function)
+
+(new_rule
+  (lid) @function)
+
+(precedence
+  (symbol) @variable.parameter)
+
+(funcall) @function.call
+
+; Not very accurant but does a decent job
+(uid) @constant
+
+(ocaml_type) @type
+
+(ocaml) @none
+
+[
+  (comment)
+  (line_comment)
+  (ocaml_comment)
+] @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/menhir/injections.scm b/pack/ant/start/nvim-treesitter/queries/menhir/injections.scm
new file mode 100644
index 0000000..16a3f81
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/menhir/injections.scm
@@ -0,0 +1,9 @@
+([
+  (comment)
+  (line_comment)
+  (ocaml_comment)
+] @injection.content
+  (#set! injection.language "comment"))
+
+((ocaml) @injection.content
+  (#set! injection.language "ocaml"))
diff --git a/pack/ant/start/nvim-treesitter/queries/mermaid/folds.scm b/pack/ant/start/nvim-treesitter/queries/mermaid/folds.scm
new file mode 100644
index 0000000..5f28abf
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/mermaid/folds.scm
@@ -0,0 +1,10 @@
+[
+  (diagram_sequence)
+  (diagram_class)
+  (diagram_state)
+  (diagram_gantt)
+  (diagram_pie)
+  (diagram_er)
+  (diagram_flow)
+  (flow_stmt_subgraph)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/mermaid/highlights.scm b/pack/ant/start/nvim-treesitter/queries/mermaid/highlights.scm
new file mode 100644
index 0000000..2b7b563
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/mermaid/highlights.scm
@@ -0,0 +1,249 @@
+; adapted from https://github.com/monaqa/tree-sitter-mermaid
+[
+  "sequenceDiagram"
+  "classDiagram"
+  "classDiagram-v2"
+  "stateDiagram"
+  "stateDiagram-v2"
+  "gantt"
+  "pie"
+  "flowchart"
+  "erdiagram"
+  "participant"
+  "as"
+  "activate"
+  "deactivate"
+  "note "
+  "over"
+  "link"
+  "links"
+  ; "left of"
+  ; "right of"
+  "properties"
+  "details"
+  "title"
+  "loop"
+  "rect"
+  "opt"
+  "alt"
+  "else"
+  "par"
+  "and"
+  "end"
+  (sequence_stmt_autonumber)
+  (note_placement_left)
+  (note_placement_right)
+  "class"
+  "state "
+  "dateformat"
+  "inclusiveenddates"
+  "topaxis"
+  "axisformat"
+  "includes"
+  "excludes"
+  "todaymarker"
+  "title"
+  "section"
+  "direction"
+  "subgraph"
+] @keyword
+
+(comment) @comment @spell
+
+[
+  ":"
+  (sequence_signal_plus_sign)
+  (sequence_signal_minus_sign)
+  (class_visibility_public)
+  (class_visibility_private)
+  (class_visibility_protected)
+  (class_visibility_internal)
+  (state_division)
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "-->"
+  (solid_arrow)
+  (dotted_arrow)
+  (solid_open_arrow)
+  (dotted_open_arrow)
+  (solid_cross)
+  (dotted_cross)
+  (solid_point)
+  (dotted_point)
+] @operator
+
+[
+  (class_reltype_aggregation)
+  (class_reltype_extension)
+  (class_reltype_composition)
+  (class_reltype_dependency)
+  (class_linetype_solid)
+  (class_linetype_dotted)
+  "&"
+] @operator
+
+(sequence_actor) @variable.member
+
+(class_name) @variable.member
+
+(state_name) @variable.member
+
+(gantt_task_text) @variable.member
+
+[
+  (class_annotation_line)
+  (class_stmt_annotation)
+  (class_generics)
+  (state_annotation_fork)
+  (state_annotation_join)
+  (state_annotation_choice)
+] @attribute
+
+(directive) @keyword.import
+
+(pie_label) @string
+
+(pie_value) @number.float
+
+[
+  (flowchart_direction_lr)
+  (flowchart_direction_rl)
+  (flowchart_direction_tb)
+  (flowchart_direction_bt)
+] @constant
+
+(flow_vertex_id) @variable.member
+
+[
+  (flow_link_arrow)
+  (flow_link_arrow_start)
+] @operator
+
+(flow_link_arrowtext
+  "|" @punctuation.bracket)
+
+(flow_vertex_square
+  [
+    "["
+    "]"
+  ] @punctuation.bracket)
+
+(flow_vertex_circle
+  [
+    "(("
+    "))"
+  ] @punctuation.bracket)
+
+(flow_vertex_ellipse
+  [
+    "(-"
+    "-)"
+  ] @punctuation.bracket)
+
+(flow_vertex_stadium
+  [
+    "(["
+    "])"
+  ] @punctuation.bracket)
+
+(flow_vertex_subroutine
+  [
+    "[["
+    "]]"
+  ] @punctuation.bracket)
+
+(flow_vertex_rect
+  [
+    "[|"
+    "|]"
+  ] @punctuation.bracket)
+
+(flow_vertex_cylinder
+  [
+    "[("
+    ")]"
+  ] @punctuation.bracket)
+
+(flow_vertex_round
+  [
+    "("
+    ")"
+  ] @punctuation.bracket)
+
+(flow_vertex_diamond
+  [
+    "{"
+    "}"
+  ] @punctuation.bracket)
+
+(flow_vertex_hexagon
+  [
+    "{{"
+    "}}"
+  ] @punctuation.bracket)
+
+(flow_vertex_odd
+  [
+    ">"
+    "]"
+  ] @punctuation.bracket)
+
+(flow_vertex_trapezoid
+  [
+    "[/"
+    "\\]"
+  ] @punctuation.bracket)
+
+(flow_vertex_inv_trapezoid
+  [
+    "[\\"
+    "/]"
+  ] @punctuation.bracket)
+
+(flow_vertex_leanright
+  [
+    "[/"
+    "/]"
+  ] @punctuation.bracket)
+
+(flow_vertex_leanleft
+  [
+    "[\\"
+    "\\]"
+  ] @punctuation.bracket)
+
+(flow_stmt_subgraph
+  [
+    "["
+    "]"
+  ] @punctuation.bracket)
+
+[
+  (er_cardinarity_zero_or_one)
+  (er_cardinarity_zero_or_more)
+  (er_cardinarity_one_or_more)
+  (er_cardinarity_only_one)
+  (er_reltype_non_identifying)
+  (er_reltype_identifying)
+] @operator
+
+(er_entity_name) @variable.member
+
+(er_attribute_type) @type
+
+(er_attribute_name) @variable.member
+
+[
+  (er_attribute_key_type_pk)
+  (er_attribute_key_type_fk)
+] @keyword.modifier
+
+(er_attribute_comment) @string @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/mermaid/indents.scm b/pack/ant/start/nvim-treesitter/queries/mermaid/indents.scm
new file mode 100644
index 0000000..fb95bd8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/mermaid/indents.scm
@@ -0,0 +1,18 @@
+([
+  (diagram_sequence)
+  (diagram_class)
+  (diagram_state)
+  (diagram_gantt)
+  (diagram_pie)
+  (diagram_er)
+  (diagram_flow)
+  (flow_stmt_subgraph)
+] @indent.begin
+  (#set! indent.immediate 1))
+
+"end" @indent.branch
+
+[
+  (ERROR)
+  (comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/mermaid/injections.scm b/pack/ant/start/nvim-treesitter/queries/mermaid/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/mermaid/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/meson/folds.scm b/pack/ant/start/nvim-treesitter/queries/meson/folds.scm
new file mode 100644
index 0000000..386d4d3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/meson/folds.scm
@@ -0,0 +1,9 @@
+[
+  (normal_command)
+  (if_condition)
+  (if_command)
+  (else_command)
+  (elseif_command)
+  (foreach_command)
+  (list)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/meson/highlights.scm b/pack/ant/start/nvim-treesitter/queries/meson/highlights.scm
new file mode 100644
index 0000000..b00c339
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/meson/highlights.scm
@@ -0,0 +1,77 @@
+(comment) @comment @spell
+
+(number) @number
+
+(bool) @boolean
+
+(identifier) @variable
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ":"
+  ","
+  "."
+] @punctuation.delimiter
+
+[
+  "and"
+  "not"
+  "or"
+  "in"
+] @keyword.operator
+
+[
+  "="
+  "=="
+  "!="
+  "+"
+  "/"
+  "/="
+  "+="
+  "-="
+  ">"
+  ">="
+] @operator
+
+(ternaryoperator
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+[
+  "if"
+  "elif"
+  "else"
+  "endif"
+] @keyword.conditional
+
+[
+  "foreach"
+  "endforeach"
+  (keyword_break)
+  (keyword_continue)
+] @keyword.repeat
+
+(string) @string
+
+"@" @punctuation.special
+
+(normal_command
+  command: (identifier) @function)
+
+(pair
+  key: (identifier) @property)
+
+(escape_sequence) @string.escape
+
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin "meson" "host_machine" "build_machine" "target_machine"))
diff --git a/pack/ant/start/nvim-treesitter/queries/meson/indents.scm b/pack/ant/start/nvim-treesitter/queries/meson/indents.scm
new file mode 100644
index 0000000..3e27d92
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/meson/indents.scm
@@ -0,0 +1,25 @@
+[
+  (list)
+  (dictionaries)
+  (normal_command)
+  (if_condition)
+  (foreach_command)
+  (ternaryoperator)
+  (ERROR
+    "?") ; support partial ternary
+] @indent.begin
+
+[
+  ")"
+  "]"
+  "}"
+  (elseif_command)
+  (else_command)
+  "endif"
+  "endforeach"
+] @indent.branch @indent.end
+
+(expression_statement
+  object: (_)) @indent.begin
+
+(comment) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/meson/injections.scm b/pack/ant/start/nvim-treesitter/queries/meson/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/meson/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/mlir/highlights.scm b/pack/ant/start/nvim-treesitter/queries/mlir/highlights.scm
new file mode 100644
index 0000000..97a0b0d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/mlir/highlights.scm
@@ -0,0 +1,348 @@
+[
+  "ins"
+  "outs"
+  "else"
+  "do"
+  "loc"
+  "attributes"
+  "into"
+  "to"
+  "from"
+  "step"
+  "low"
+  "high"
+  "iter_args"
+  "padding_value"
+  "inner_tiles"
+  "gather_dims"
+  "scatter_dims"
+  "outer_dims_perm"
+  "inner_dims_pos"
+  "shared_outs"
+  "default"
+  (arith_cmp_predicate)
+] @keyword
+
+; format-ignore
+[
+  "module"
+  "unrealized_conversion_cast"
+
+  "func.call"
+  "call"
+  "func.call_indirect"
+  "call_indirect"
+  "func.constant"
+  "constant"
+  "func.func"
+  "func.return"
+  "return"
+
+  "llvm.func"
+  "llvm.return"
+
+  "cf.assert"
+  "cf.br"
+  "cf.cond_br"
+  "cf.switch"
+
+  "scf.condition"
+  "scf.execute_region"
+  "scf.if"
+  "scf.index_switch"
+  "scf.for"
+  "scf.forall"
+  "scf.forall.in_parallel"
+  "scf.parallel"
+  "scf.reduce"
+  "scf.reduce.return"
+  "scf.while"
+  "scf.yield"
+
+  "arith.constant"
+  "arith.addi"
+  "arith.subi"
+  "arith.divsi"
+  "arith.divui"
+  "arith.ceildivsi"
+  "arith.ceildivui"
+  "arith.floordivsi"
+  "arith.remsi"
+  "arith.remui"
+  "arith.muli"
+  "arith.mulsi_extended"
+  "arith.mului_extended"
+  "arith.andi"
+  "arith.ori"
+  "arith.xori"
+  "arith.maxsi"
+  "arith.maxui"
+  "arith.minsi"
+  "arith.minui"
+  "arith.shli"
+  "arith.shrsi"
+  "arith.shrui"
+  "arith.addui_extended"
+  "arith.addf"
+  "arith.divf"
+  "arith.maximumf"
+  "arith.minimumf"
+  "arith.mulf"
+  "arith.remf"
+  "arith.subf"
+  "arith.negf"
+  "arith.cmpi"
+  "arith.cmpf"
+  "arith.extf"
+  "arith.extsi"
+  "arith.extui"
+  "arith.fptosi"
+  "arith.fptoui"
+  "arith.index_cast"
+  "arith.index_castui"
+  "arith.sitofp"
+  "arith.uitofp"
+  "arith.bitcast"
+  "arith.truncf"
+  "arith.select"
+
+  "math.absf"
+  "math.atan"
+  "math.cbrt"
+  "math.ceil"
+  "math.cos"
+  "math.erf"
+  "math.exp"
+  "math.exp2"
+  "math.expm1"
+  "math.floor"
+  "math.log"
+  "math.log10"
+  "math.log1p"
+  "math.log2"
+  "math.round"
+  "math.roundeven"
+  "math.rsqrt"
+  "math.sin"
+  "math.sqrt"
+  "math.tan"
+  "math.tanh"
+  "math.trunc"
+  "math.absi"
+  "math.ctlz"
+  "math.cttz"
+  "math.ctpop"
+  "math.atan2"
+  "math.copysign"
+  "math.fpowi"
+  "math.powf"
+  "math.ipowi"
+  "math.fma"
+
+  "memref.alloc"
+  "memref.cast"
+  "memref.copy"
+  "memref.collapse_shape"
+  "memref.expand_shape"
+  "memref.prefetch"
+  "memref.rank"
+  "memref.realloc"
+  "memref.view"
+
+  "vector.bitcast"
+  "vector.broadcast"
+  "vector.shape_cast"
+  "vector.type_cast"
+  "vector.constant_mask"
+  "vector.create_mask"
+  "vector.extract"
+  "vector.load"
+  "vector.scalable.extract"
+  "vector.fma"
+  "vector.flat_transpose"
+  "vector.insert"
+  "vector.scalable.insert"
+  "vector.shuffle"
+  "vector.store"
+  "vector.insert_strided_slice"
+  "vector.matrix_multiply"
+  "vector.print"
+  "vector.splat"
+  "vector.transfer_read"
+  "vector.transfer_write"
+  "vector.yield"
+
+  "tensor.empty"
+  "tensor.cast"
+  "tensor.dim"
+  "tensor.collapse_shape"
+  "tensor.expand_shape"
+  "tensor.extract"
+  "tensor.insert"
+  "tensor.extract_slice"
+  "tensor.insert_slice"
+  "tensor.parallel_insert_slice"
+  "tensor.from_elements"
+  "tensor.gather"
+  "tensor.scatter"
+  "tensor.pad"
+  "tensor.reshape"
+  "tensor.splat"
+  "tensor.pack"
+  "tensor.unpack"
+  "tensor.generate"
+  "tensor.rank"
+  "tensor.yield"
+
+  "bufferization.alloc_tensor"
+  "bufferization.to_memref"
+  "bufferization.to_tensor"
+
+  "linalg.batch_matmul"
+  "linalg.batch_matmul_transpose_b"
+  "linalg.batch_matvec"
+  "linalg.batch_reduce_matmul"
+  "linalg.broadcast"
+  "linalg.conv_1d_ncw_fcw"
+  "linalg.conv_1d_nwc_wcf"
+  "linalg.conv_1d"
+  "linalg.conv_2d_nchw_fchw"
+  "linalg.conv_2d_ngchw_fgchw"
+  "linalg.conv_2d_nhwc_fhwc"
+  "linalg.conv_2d_nhwc_hwcf"
+  "linalg.conv_2d_nhwc_hwcf_q"
+  "linalg.conv_2d"
+  "linalg.conv_3d_ndhwc_dhwcf"
+  "linalg.conv_3d_ndhwc_dhwcf_q"
+  "linalg.conv_3d"
+  "linalg.copy"
+  "linalg.depthwise_conv_1d_nwc_wcm"
+  "linalg.depthwise_conv_2d_nchw_chw"
+  "linalg.depthwise_conv_2d_nhwc_hwc"
+  "linalg.depthwise_conv_2d_nhwc_hwc_q"
+  "linalg.depthwise_conv_2d_nhwc_hwcm"
+  "linalg.depthwise_conv_2d_nhwc_hwcm_q"
+  "linalg.depthwise_conv_3d_ndhwc_dhwc"
+  "linalg.depthwise_conv_3d_ndhwc_dhwcm"
+  "linalg.dot"
+  "linalg.elemwise_binary"
+  "linalg.elemwise_unary"
+  "linalg.fill"
+  "linalg.fill_rng_2d"
+  "linalg.matmul"
+  "linalg.matmul_transpose_b"
+  "linalg.matmul_unsigned"
+  "linalg.matvec"
+  "linalg.mmt4d"
+  "linalg.pooling_nchw_max"
+  "linalg.pooling_nchw_sum"
+  "linalg.pooling_ncw_max"
+  "linalg.pooling_ncw_sum"
+  "linalg.pooling_ndhwc_max"
+  "linalg.pooling_ndhwc_min"
+  "linalg.pooling_ndhwc_sum"
+  "linalg.pooling_nhwc_max"
+  "linalg.pooling_nhwc_max_unsigned"
+  "linalg.pooling_nhwc_min"
+  "linalg.pooling_nhwc_min_unsigned"
+  "linalg.pooling_nhwc_sum"
+  "linalg.pooling_nwc_max"
+  "linalg.pooling_nwc_max_unsigned"
+  "linalg.pooling_nwc_min"
+  "linalg.pooling_nwc_min_unsigned"
+  "linalg.pooling_nwc_sum"
+  "linalg.quantized_batch_matmul"
+  "linalg.quantized_matmul"
+  "linalg.vecmat"
+  "linalg.generic"
+  "linalg.index"
+  "linalg.map"
+  "linalg.yield"
+] @function.builtin
+
+(generic_operation) @function
+
+(builtin_type) @type.builtin
+
+[
+  (type_alias)
+  (dialect_type)
+  (type_alias_def)
+] @type
+
+[
+  (integer_literal)
+  (complex_literal)
+] @number
+
+(float_literal) @number.float
+
+(bool_literal) @boolean
+
+[
+  (tensor_literal)
+  (array_literal)
+  (unit_literal)
+] @constant.builtin
+
+(string_literal) @string
+
+[
+  (attribute_alias_def)
+  (attribute_alias)
+  (bare_attribute_entry)
+  (attribute)
+  (fastmath_attr)
+  (scatter_dims_attr)
+  (gather_dims_attr)
+  (outer_dims_perm_attr)
+  (inner_dims_pos_attr)
+  (inner_tiles_attr)
+  (unique_attr)
+  (nofold_attr)
+  (isWrite_attr)
+  (localityHint_attr)
+  (isDataCache_attr)
+  (restrict_attr)
+  (writable_attr)
+] @attribute
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ":"
+  ","
+] @punctuation.delimiter
+
+[
+  "="
+  "->"
+] @operator
+
+(builtin_dialect
+  name: (symbol_ref_id) @function)
+
+(func_dialect
+  name: (symbol_ref_id) @function)
+
+(llvm_dialect
+  name: (symbol_ref_id) @function)
+
+(func_arg_list
+  (value_use) @variable.parameter)
+
+(block_arg_list
+  (value_use) @variable.parameter)
+
+(caret_id) @string.special
+
+(value_use) @variable
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/mlir/injections.scm b/pack/ant/start/nvim-treesitter/queries/mlir/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/mlir/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/mlir/locals.scm b/pack/ant/start/nvim-treesitter/queries/mlir/locals.scm
new file mode 100644
index 0000000..d29351d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/mlir/locals.scm
@@ -0,0 +1,12 @@
+(region) @local.scope
+
+(func_arg_list
+  (value_use) @local.definition.var)
+
+(block_arg_list
+  (value_use) @local.definition.var)
+
+(op_result
+  (value_use) @local.definition.var)
+
+(value_use) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/muttrc/highlights.scm b/pack/ant/start/nvim-treesitter/queries/muttrc/highlights.scm
new file mode 100644
index 0000000..27754cc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/muttrc/highlights.scm
@@ -0,0 +1,55 @@
+; Comments
+(comment) @comment @spell
+
+; General
+(int) @number
+
+(string) @string
+
+[
+  (map)
+  (object)
+  (composeobject)
+  (color)
+  (attribute)
+] @string.special
+
+(quadoption) @boolean
+
+(path) @string.special.path
+
+(regex) @string.regexp
+
+(option) @variable
+
+(command_line_option) @variable.builtin
+
+((option) @variable.builtin
+  (#not-lua-match? @variable.builtin "^my_"))
+
+(command) @keyword
+
+(source_directive
+  (command) @keyword.import)
+
+(uri) @string.special.url
+
+(key_name) @constant.builtin
+
+(escape) @string.escape
+
+(function) @function.call
+
+; Literals
+[
+  "<"
+  ">"
+] @punctuation.bracket
+
+"," @punctuation.delimiter
+
+[
+  "&"
+  "?"
+  "*"
+] @character.special
diff --git a/pack/ant/start/nvim-treesitter/queries/muttrc/injections.scm b/pack/ant/start/nvim-treesitter/queries/muttrc/injections.scm
new file mode 100644
index 0000000..9c16ad1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/muttrc/injections.scm
@@ -0,0 +1,8 @@
+((regex) @injection.content
+  (#set! injection.language "regex"))
+
+((shell) @injection.content
+  (#set! injection.language "bash"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/nasm/highlights.scm b/pack/ant/start/nvim-treesitter/queries/nasm/highlights.scm
new file mode 100644
index 0000000..02506de
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nasm/highlights.scm
@@ -0,0 +1,162 @@
+; adapted from https://github.com/naclsn/tree-sitter-nasm/blob/main/queries/highlights.scm
+(word) @variable
+
+((word) @constant
+  (#lua-match? @constant "^[A-Z_][?A-Z_0-9]+$"))
+
+((word) @constant.builtin
+  (#lua-match? @constant.builtin "^__%?[A-Z_a-z0-9]+%?__$"))
+
+[
+  (line_here_token)
+  (section_here_token)
+] @variable.builtin
+
+(label
+  (word) @label)
+
+(assembl_directive_symbols
+  (word) @label)
+
+(assembl_directive_sections
+  (word) @label)
+
+(unary_expression
+  operator: _ @operator)
+
+(binary_expression
+  operator: _ @operator)
+
+"?" @constant.builtin
+
+(conditional_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+[
+  ":"
+  ","
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+(instruction_prefix) @keyword
+
+(actual_instruction
+  instruction: (word) @function.builtin)
+
+(call_syntax_expression
+  base: (word) @function.call)
+
+(size_hint) @type
+
+(struc_declaration
+  name: (word) @type)
+
+(struc_instance
+  name: (word) @type)
+
+(effective_address
+  hint: _ @type)
+
+(effective_address
+  segment: _ @constant.builtin)
+
+(register) @variable.builtin
+
+(string_literal) @string
+
+(float_literal) @number.float
+
+[
+  (packed_bcd_literal)
+  (number_literal)
+] @number
+
+[
+  (preproc_alias)
+  (preproc_multiline_macro)
+  (preproc_multiline_unmacro)
+  (preproc_rotate)
+  (preproc_pathsearch)
+  (preproc_depend)
+  (preproc_use)
+  (preproc_push)
+  (preproc_pop)
+  (preproc_repl)
+  (preproc_arg)
+  (preproc_stacksize)
+  (preproc_local)
+  (preproc_reporting)
+  (preproc_pragma)
+  (preproc_line)
+  (preproc_clear)
+] @keyword.directive
+
+(preproc_include) @keyword.import
+
+(preproc_rep_loop) @keyword.repeat
+
+(preproc_if) @keyword.conditional
+
+[
+  (preproc_def)
+  (preproc_undef)
+] @keyword.directive.define
+
+(preproc_function_def) @keyword.function
+
+[
+  (preproc_expression)
+  (preproc_arg)
+] @constant.macro
+
+(preproc_multiline_macro
+  name: (word) @function)
+
+[
+  (pseudo_instruction_dx)
+  (pseudo_instruction_resx)
+  (pseudo_instruction_incbin_command)
+  (pseudo_instruction_equ_command)
+  (pseudo_instruction_times_prefix)
+  (pseudo_instruction_alignx_macro)
+] @function
+
+[
+  (assembl_directive_target)
+  (assembl_directive_defaults)
+  (assembl_directive_sections)
+  (assembl_directive_absolute)
+  (assembl_directive_symbols)
+  (assembl_directive_common)
+  (assembl_directive_symbolfixes)
+  (assembl_directive_cpu)
+  (assembl_directive_floathandling)
+  (assembl_directive_org)
+  (assembl_directive_sectalign)
+  (assembl_directive_primitive_target)
+  (assembl_directive_primitive_defaults)
+  (assembl_directive_primitive_sections)
+  (assembl_directive_primitive_absolute)
+  (assembl_directive_primitive_symbols)
+  (assembl_directive_primitive_common)
+  (assembl_directive_primitive_symbolfixes)
+  (assembl_directive_primitive_cpu)
+  (assembl_directive_primitive_floathandling)
+  (assembl_directive_primitive_org)
+  (assembl_directive_primitive_sectalign)
+  (assembl_directive_primitive_warning)
+  (assembl_directive_primitive_map)
+] @keyword
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/nasm/injections.scm b/pack/ant/start/nvim-treesitter/queries/nasm/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nasm/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/nginx/folds.scm b/pack/ant/start/nvim-treesitter/queries/nginx/folds.scm
new file mode 100644
index 0000000..fd7d239
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nginx/folds.scm
@@ -0,0 +1 @@
+(block) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/nginx/highlights.scm b/pack/ant/start/nvim-treesitter/queries/nginx/highlights.scm
new file mode 100644
index 0000000..58fcc0b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nginx/highlights.scm
@@ -0,0 +1,59 @@
+(comment) @comment @spell
+
+(value) @variable
+
+[
+  (location_modifier)
+  "="
+] @operator
+
+[
+  (keyword)
+  "location"
+] @keyword
+
+[
+  "if"
+  "map"
+] @keyword.conditional
+
+(boolean) @boolean
+
+[
+  (auto)
+  (constant)
+  (level)
+  (connection_method)
+  (var)
+  (condition)
+] @variable.builtin
+
+[
+  (file)
+  (mask)
+] @string.special.path
+
+[
+  (string_literal)
+  (quoted_string_literal)
+] @string
+
+(directive
+  (variable
+    (keyword) @variable.parameter))
+
+(location_route) @string.special
+
+";" @punctuation.delimiter
+
+[
+  (numeric_literal)
+  (time)
+  (size)
+  (cpumask)
+] @number
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/nginx/injections.scm b/pack/ant/start/nvim-treesitter/queries/nginx/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nginx/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/nickel/highlights.scm b/pack/ant/start/nvim-treesitter/queries/nickel/highlights.scm
new file mode 100644
index 0000000..07673d7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nickel/highlights.scm
@@ -0,0 +1,74 @@
+(comment) @comment @spell
+
+[
+  "forall"
+  "in"
+  "let"
+  "default"
+  "doc"
+  "rec"
+] @keyword
+
+"fun" @keyword.function
+
+"import" @keyword.import
+
+[
+  "if"
+  "then"
+  "else"
+] @keyword.conditional
+
+"match" @keyword.conditional
+
+(types) @type
+
+"Array" @type.builtin
+
+; BUILTIN Constants
+(bool) @boolean
+
+"null" @constant.builtin
+
+(num_literal) @number
+
+(infix_op) @operator
+
+(type_atom) @type
+
+(enum_tag) @variable
+
+(chunk_literal_single) @string
+
+(chunk_literal_multi) @string
+
+(str_esc_char) @string.escape
+
+[
+  "{"
+  "}"
+  "("
+  ")"
+  "[|"
+  "|]"
+] @punctuation.bracket
+
+(multstr_start) @punctuation.bracket
+
+(multstr_end) @punctuation.bracket
+
+(interpolation_start) @punctuation.bracket
+
+(interpolation_end) @punctuation.bracket
+
+(record_field) @variable.member
+
+(builtin) @function.builtin
+
+(fun_expr
+  pats: (pattern_fun
+    (ident) @variable.parameter))
+
+(applicative
+  t1: (applicative
+    (record_operand) @function))
diff --git a/pack/ant/start/nvim-treesitter/queries/nickel/indents.scm b/pack/ant/start/nvim-treesitter/queries/nickel/indents.scm
new file mode 100644
index 0000000..8c6f740
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nickel/indents.scm
@@ -0,0 +1,13 @@
+[
+  (atom
+    (uni_record)) ; for {...}
+  (atom
+    terms: (term)) ; for [...]
+] @indent.begin
+
+[
+  "]"
+  "}"
+] @indent.end @indent.branch
+
+(comment) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/nickel/injections.scm b/pack/ant/start/nvim-treesitter/queries/nickel/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nickel/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/nim/folds.scm b/pack/ant/start/nvim-treesitter/queries/nim/folds.scm
new file mode 100644
index 0000000..fa0581a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nim/folds.scm
@@ -0,0 +1,41 @@
+[
+  (const_section)
+  (var_section)
+  (let_section)
+  (type_section)
+  (using_section)
+  (object_declaration)
+  (tuple_type)
+  (enum_declaration)
+  (case)
+  (if)
+  (when)
+  (conditional_declaration)
+  (variant_declaration)
+  (of_branch)
+  (elif_branch)
+  (else_branch)
+  (for)
+  (while)
+  (block)
+  (static_statement)
+  (pragma_statement)
+  (try)
+  (except_branch)
+  (finally_branch)
+  (do_block)
+  (call
+    (argument_list
+      (statement_list)))
+  (proc_declaration)
+  (func_declaration)
+  (method_declaration)
+  (iterator_declaration)
+  (converter_declaration)
+  (template_declaration)
+  (macro_declaration)
+  (proc_expression)
+  (func_expression)
+  (iterator_expression)
+  (concept_declaration)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/nim/highlights.scm b/pack/ant/start/nvim-treesitter/queries/nim/highlights.scm
new file mode 100644
index 0000000..722c0ab
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nim/highlights.scm
@@ -0,0 +1,926 @@
+; SPDX-FileCopyrightText: 2023 Leorize <leorize+oss@disroot.org>, aMOPel <>
+; SPDX-License-Identifier: MPL-2.0
+; SPDX-License-Identifier: Apache-2.0
+; =============================================================================
+; catch all rules
+((identifier) @variable
+  (#set! priority 99))
+
+; NOTE: we need priority, since (identifier) is most specific and we have to
+; capture nodes containing (identifier) as a whole, while overruling the
+; @variable capture.
+(type_expression) @type
+
+; NOTE: has to be after
+; ((identifier) @variable (#set! priority 99))
+; overrule identifiers in pragmas in (proc_type)s and (pragma_expression)s
+(proc_type
+  pragmas: (pragma_list) @variable)
+
+(iterator_type
+  pragmas: (pragma_list) @variable)
+
+(type_expression
+  (pragma_expression
+    right: (pragma_list) @variable))
+
+; NOTE: has to be after
+; (type_expression) @type
+; and before @keyword.directive and all literals
+; constants/enums in array construction
+(array_construction
+  (colon_expression
+    left: (_) @constant))
+
+; NOTE: has to be before literals and punctuation etc.
+; identifiers in "case" "of" branches have to be enums
+(case
+  alternative: (of_branch
+    values: (expression_list
+      (_) @constant)))
+
+; NOTE: has to be before literals and punctuation etc.
+; in variant objects with "case" "of"
+(variant_declaration
+  alternative: (of_branch
+    values: (expression_list
+      (_) @constant)))
+
+; NOTE: has to be before literals and punctuation etc.
+; =============================================================================
+; @comment               ; line and block comments
+[
+  (comment)
+  (block_comment)
+] @comment
+
+; =============================================================================
+; @comment.documentation ; comments documenting code
+(documentation_comment
+  "##" @comment.documentation)
+
+(block_documentation_comment
+  "##[" @comment.documentation
+  "]##" @comment.documentation)
+
+; NOTE: leaving content uncaptured so markdown can be injected
+; =============================================================================
+; @punctuation.delimiter ; delimiters (e.g. `;` / `.` / `,`)
+[
+  "."
+  ";"
+  ","
+  ":"
+  "="
+] @punctuation.delimiter
+
+; =============================================================================
+; @operator              ; symbolic operators (e.g. `+` / `*`)
+(operator) @operator
+
+(assignment
+  "=" @operator)
+
+; =============================================================================
+; @punctuation.bracket   ; brackets (e.g. `()` / `{}` / `[]`)
+[
+  "("
+  ")"
+  "["
+  "[:"
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; =============================================================================
+; @keyword.directive               ; various preprocessor directives & shebangs
+[
+  "macro"
+  "template"
+] @keyword.directive
+
+(pragma_list
+  [
+    "{."
+    "}"
+    ".}"
+  ] @keyword.directive)
+
+; NOTE: has to come after @punctuation.bracket
+; =============================================================================
+; @punctuation.special   ; special symbols (e.g. `{}` in string interpolation)
+(accent_quoted
+  "`" @punctuation.special)
+
+(exported_symbol
+  "*" @punctuation.special)
+
+; dereference operator
+(bracket_expression
+  !right
+  "[" @punctuation.special
+  .
+  "]" @punctuation.special)
+
+; =============================================================================
+; @string               ; string literals
+[
+  (interpreted_string_literal)
+  (long_string_literal)
+  (raw_string_literal)
+  (generalized_string)
+] @string
+
+; injections in generalized_strings
+(generalized_string
+  (string_content) @none)
+
+; format string injection in normal strings with & prefix
+(prefix_expression
+  operator: (operator) @_string_prefix
+  .
+  (_
+    (string_content) @none)
+  (#eq? @_string_prefix "&"))
+
+; emit pragma injection
+(pragma_statement
+  (pragma_list
+    (colon_expression
+      left: (identifier) @_emit_keyword
+      (#eq? @_emit_keyword "emit")
+      right: (_
+        (string_content) @none))))
+
+; =============================================================================
+; @string.escape        ; escape sequences
+(escape_sequence) @string.escape
+
+; =============================================================================
+; @character            ; character literals
+(char_literal) @character
+
+; =============================================================================
+; @boolean              ; boolean literals
+((identifier) @boolean
+  (#any-of? @boolean "true" "false" "on" "off"))
+
+; =============================================================================
+; @number               ; numeric literals
+(integer_literal) @number
+
+(custom_numeric_literal) @number
+
+; =============================================================================
+; @number.float                ; floating-point number literals
+(float_literal) @number.float
+
+; =============================================================================
+; @function         ; function definitions
+(proc_declaration
+  name: [
+    (identifier) @function
+    (accent_quoted
+      (identifier) @function)
+    (exported_symbol
+      (identifier) @function)
+    (exported_symbol
+      (accent_quoted
+        (identifier) @function))
+  ])
+
+(func_declaration
+  name: [
+    (identifier) @function
+    (accent_quoted
+      (identifier) @function)
+    (exported_symbol
+      (identifier) @function)
+    (exported_symbol
+      (accent_quoted
+        (identifier) @function))
+  ])
+
+(iterator_declaration
+  name: [
+    (identifier) @function
+    (accent_quoted
+      (identifier) @function)
+    (exported_symbol
+      (identifier) @function)
+    (exported_symbol
+      (accent_quoted
+        (identifier) @function))
+  ])
+
+(converter_declaration
+  name: [
+    (identifier) @function
+    (accent_quoted
+      (identifier) @function)
+    (exported_symbol
+      (identifier) @function)
+    (exported_symbol
+      (accent_quoted
+        (identifier) @function))
+  ])
+
+; =============================================================================
+; @function.call    ; function calls
+(call
+  function: [
+    (identifier) @function.call
+    (accent_quoted
+      (identifier) @function.call)
+    ; generic types
+    (bracket_expression
+      left: (identifier) @function.call)
+    (bracket_expression
+      left: (accent_quoted
+        (identifier) @function.call))
+    ; dot accessor
+    (dot_expression
+      right: (identifier) @function.call)
+    (dot_expression
+      right: (accent_quoted
+        (identifier) @function.call))
+    ; both
+    (bracket_expression
+      left: (dot_expression
+        right: (identifier) @function.call))
+    (bracket_expression
+      left: (dot_expression
+        right: (accent_quoted
+          (identifier) @function.call)))
+  ])
+
+(dot_generic_call
+  function: [
+    (identifier) @function.call
+    (accent_quoted
+      (identifier) @function.call)
+  ])
+
+; generalized_string is a function call
+; `identifier"string literal"`
+; is short for
+; `identifier(r"string literal")`
+(generalized_string
+  function: [
+    (identifier) @function.call
+    (accent_quoted
+      (identifier) @function.call)
+  ])
+
+; call with leading literal
+(dot_expression
+  left: [
+    (nil_literal)
+    (integer_literal)
+    (float_literal)
+    (custom_numeric_literal)
+    (char_literal)
+    (interpreted_string_literal)
+    (long_string_literal)
+    (raw_string_literal)
+    (generalized_string)
+    (array_construction)
+    ; for sequences
+    (prefix_expression
+      operator: (operator) @_at
+      (array_construction)
+      (#eq? @_at "@"))
+    (tuple_construction)
+    (curly_construction)
+  ]
+  right: [
+    (identifier) @function.call
+    (accent_quoted
+      (identifier) @function.call)
+  ])
+
+; NOTE: will double capture as @function.call if it also has argument_list
+; function.calls in `varargs[type, routine]`
+(bracket_expression
+  left: (identifier) @_varargs
+  right: (argument_list
+    .
+    (_)
+    .
+    [
+      (identifier) @function.call
+      (accent_quoted
+        (identifier) @function.call)
+      (dot_expression
+        right: (identifier) @function.call)
+      (dot_expression
+        right: (accent_quoted
+          (identifier) @function.call))
+    ])
+  (#eq? @_varargs "varargs"))
+
+; =============================================================================
+; @function.macro   ; preprocessor macros
+(template_declaration
+  name: [
+    (identifier) @function.macro
+    (accent_quoted
+      (identifier) @function.macro)
+    (exported_symbol
+      (identifier) @function.macro)
+    (exported_symbol
+      (accent_quoted
+        (identifier) @function.macro))
+  ])
+
+(macro_declaration
+  name: [
+    (identifier) @function.macro
+    (accent_quoted
+      (identifier) @function.macro)
+    (exported_symbol
+      (identifier) @function.macro)
+    (exported_symbol
+      (accent_quoted
+        (identifier) @function.macro))
+  ])
+
+; =============================================================================
+; @function.method           ; method definitions
+(method_declaration
+  name: [
+    (identifier) @function.method
+    (accent_quoted
+      (identifier) @function.method)
+    (exported_symbol
+      (identifier) @function.method)
+    (exported_symbol
+      (accent_quoted
+        (identifier) @function.method))
+  ])
+
+; =============================================================================
+; @constructor      ; constructor calls and definitions
+(call
+  function: [
+    (identifier) @constructor
+    (accent_quoted
+      (identifier) @constructor)
+    ; generic types
+    (bracket_expression
+      left: (identifier) @constructor)
+    (bracket_expression
+      left: (accent_quoted
+        (identifier) @constructor))
+    ; dot accessor
+    (dot_expression
+      right: (identifier) @constructor)
+    (dot_expression
+      right: (accent_quoted
+        (identifier) @constructor))
+    ; both
+    (bracket_expression
+      left: (dot_expression
+        right: (identifier) @constructor))
+    (bracket_expression
+      left: (dot_expression
+        right: (accent_quoted
+          (identifier) @constructor)))
+  ]
+  (argument_list
+    (colon_expression)+))
+
+; NOTE: this cannot detect constructors with 0 arguments
+; those will be matched as @function.call instead
+; =============================================================================
+; @keyword             ; various keywords
+; unhandled but reserved keywords
+; end
+; interface
+; static expression
+; addr operator
+((call
+  function: (identifier) @keyword)
+  (#any-of? @keyword "static" "addr"))
+
+[
+  "const"
+  "let"
+  "var"
+  "concept"
+  "asm"
+  "bind"
+  "defer"
+  "do"
+  "mixin"
+  "static"
+  "tuple"
+  "block"
+  "using"
+  "discard"
+] @keyword
+
+[
+  "enum"
+  "object"
+  "type"
+] @keyword.type
+
+; =============================================================================
+; @keyword.function    ; keywords that define a function (e.g. `func` in Go, `def` in Python)
+[
+  "proc"
+  "func"
+  "method"
+  "converter"
+  "iterator"
+] @keyword.function
+
+; =============================================================================
+; @keyword.operator    ; operators that are English words (e.g. `and` / `or`)
+[
+  "and"
+  "or"
+  "xor"
+  "not"
+  "div"
+  "mod"
+  "shl"
+  "shr"
+  "from"
+  "as"
+  "of"
+  "in"
+  "notin"
+  "is"
+  "isnot"
+  "cast"
+] @keyword.operator
+
+; =============================================================================
+; @keyword.return      ; keywords like `return` and `yield`
+[
+  "return"
+  "yield"
+] @keyword.return
+
+; =============================================================================
+; @keyword.conditional         ; keywords related to conditionals (e.g. `if` / `else`)
+[
+  "if"
+  "when"
+  "case"
+  "elif"
+  "else"
+] @keyword.conditional
+
+(of_branch
+  "of" @keyword.conditional)
+
+; =============================================================================
+; @keyword.repeat              ; keywords related to loops (e.g. `for` / `while`)
+[
+  "for"
+  "while"
+  "continue"
+  "break"
+] @keyword.repeat
+
+(for
+  "in" @keyword.repeat)
+
+; =============================================================================
+; @label               ; GOTO and other labels (e.g. `label:` in C)
+(block
+  label: [
+    (identifier) @label
+    (accent_quoted
+      (identifier) @label)
+  ])
+
+; =============================================================================
+; @keyword.import             ; keywords for including modules (e.g. `import` / `from` in Python)
+[
+  "import"
+  "include"
+  "export"
+] @keyword.import
+
+(import_from_statement
+  "from" @keyword.import)
+
+(except_clause
+  "except" @keyword.import)
+
+; =============================================================================
+; @keyword.exception           ; keywords related to exceptions (e.g. `throw` / `catch`)
+[
+  "try"
+  "except"
+  "finally"
+  "raise"
+] @keyword.exception
+
+; =============================================================================
+; @type            ; type or class definitions and annotations
+; generic types when calling
+(call
+  function: (bracket_expression
+    right: (argument_list) @type))
+
+; NOTE: this also falsely matches
+; when accessing and directly call elements from an array of routines
+; eg `array_of_routines[index](arguments), but that is an uncommon case
+; dot_generic_call `v.call[:type, type]()
+(dot_generic_call
+  generic_arguments: (_) @type)
+
+; right side of `is` operator is always type
+(infix_expression
+  operator: [
+    "is"
+    "isnot"
+  ]
+  right: (_) @type)
+
+; except branch always contains types of errors
+; Eg: `except module.exception[gen_type]:`
+(except_branch
+  values: (expression_list) @type)
+
+; overrule special case in (except_branch) with "as" operator
+; `except module.exception[gen_type] as variable:`
+(except_branch
+  values: (expression_list
+    (infix_expression
+      operator: "as"
+      right: [
+        (identifier) @variable
+        (accent_quoted
+          (identifier) @variable)
+      ])))
+
+; for inline tuple types
+; `type a = tuple[a: int]`
+(tuple_type
+  "tuple" @type
+  (field_declaration_list))
+
+; NOTE: this is consistent with other generic types like `seq[int]`
+; but inconsistent with multiline tuple declaration,
+; where `tuple` is captured as @keyword
+; =============================================================================
+; @variable.parameter        ; parameters of a function
+; named parameters when calling
+; call(parameter_name=arg)
+(argument_list
+  (equal_expression
+    left: [
+      (identifier) @variable.parameter
+      (accent_quoted
+        (identifier) @variable.parameter)
+    ]))
+
+; parameters in function declaration
+(parameter_declaration_list
+  (parameter_declaration
+    (symbol_declaration_list
+      (symbol_declaration
+        name: [
+          (identifier) @variable.parameter
+          (accent_quoted
+            (identifier) @variable.parameter)
+        ]))))
+
+; NOTE: needs to be after @type
+; generic types when declaring
+(generic_parameter_list
+  (parameter_declaration
+    (symbol_declaration_list
+      (symbol_declaration
+        name: [
+          (identifier) @variable.parameter
+          (accent_quoted
+            (identifier) @variable.parameter)
+        ]))))
+
+; for loop variables
+(for
+  left: (symbol_declaration_list
+    (symbol_declaration
+      name: [
+        (identifier) @variable.parameter
+        (accent_quoted
+          (identifier) @variable.parameter)
+      ])))
+
+((tuple_deconstruct_declaration
+  (symbol_declaration
+    name: [
+      (identifier) @variable.parameter
+      (accent_quoted
+        (identifier) @variable.parameter)
+    ])) @_tuple_decons
+  (#has-ancestor? @_tuple_decons for))
+
+(concept_declaration
+  parameters: (parameter_list
+    [
+      (identifier) @variable.parameter
+      (accent_quoted
+        (identifier) @variable.parameter)
+    ]))
+
+(var_parameter
+  [
+    (identifier) @variable.parameter
+    (accent_quoted
+      (identifier) @variable.parameter)
+  ])
+
+(type_parameter
+  [
+    (identifier) @variable.parameter
+    (accent_quoted
+      (identifier) @variable.parameter)
+  ])
+
+(static_parameter
+  [
+    (identifier) @variable.parameter
+    (accent_quoted
+      (identifier) @variable.parameter)
+  ])
+
+(ref_parameter
+  [
+    (identifier) @variable.parameter
+    (accent_quoted
+      (identifier) @variable.parameter)
+  ])
+
+(pointer_parameter
+  [
+    (identifier) @variable.parameter
+    (accent_quoted
+      (identifier) @variable.parameter)
+  ])
+
+; =============================================================================
+; @type.definition ; type definitions (e.g. `typedef` in C)
+(type_section
+  (type_declaration
+    (type_symbol_declaration
+      name: [
+        (identifier) @type.definition
+        (accent_quoted
+          (identifier) @type.definition)
+        (exported_symbol
+          (identifier) @type.definition)
+        (exported_symbol
+          (accent_quoted
+            (identifier) @type.definition))
+      ])))
+
+; =============================================================================
+; @keyword.modifier  ; type qualifier keywords (e.g. `const`)
+(var_type
+  "var" @keyword.modifier)
+
+(out_type
+  "out" @keyword.modifier)
+
+(distinct_type
+  "distinct" @keyword.modifier)
+
+(ref_type
+  "ref" @keyword.modifier)
+
+(pointer_type
+  "ptr" @keyword.modifier)
+
+(var_parameter
+  "var" @keyword.modifier)
+
+(type_parameter
+  "type" @keyword.modifier)
+
+(static_parameter
+  "static" @keyword.modifier)
+
+(ref_parameter
+  "ref" @keyword.modifier)
+
+(pointer_parameter
+  "ptr" @keyword.modifier)
+
+; =============================================================================
+; @variable.member           ; object and struct fields
+; fields in object/tuple declaration
+(field_declaration
+  (symbol_declaration_list
+    (symbol_declaration
+      name: [
+        (identifier) @variable.member
+        (accent_quoted
+          (identifier) @variable.member)
+        (exported_symbol
+          (identifier) @variable.member)
+        (exported_symbol
+          (accent_quoted
+            (identifier) @variable.member))
+      ])))
+
+; fields in object construction
+(call
+  (argument_list
+    (colon_expression
+      left: [
+        (identifier) @variable.member
+        (accent_quoted
+          (identifier) @variable.member)
+      ])))
+
+; fields in tuple construction
+(tuple_construction
+  (colon_expression
+    left: [
+      (identifier) @variable.member
+      (accent_quoted
+        (identifier) @variable.member)
+    ]))
+
+(variant_declaration
+  (variant_discriminator_declaration
+    (symbol_declaration_list
+      (symbol_declaration
+        name: [
+          (identifier) @variable.member
+          (accent_quoted
+            (identifier) @variable.member)
+          (exported_symbol
+            (identifier) @variable.member)
+          (exported_symbol
+            (accent_quoted
+              (identifier) @variable.member))
+        ]))))
+
+; =============================================================================
+; @variable.builtin ; built-in variable names (e.g. `this`)
+(blank_identifier) @variable.builtin
+
+((identifier) @variable.builtin
+  (#eq? @variable.builtin "result"))
+
+; NOTE: technically needs `has-ancestor some routine declaration` but it's
+; not worth it
+; =============================================================================
+; @constant         ; constant identifiers
+; enum declaration
+(enum_field_declaration
+  (symbol_declaration
+    name: [
+      (identifier) @constant
+      (accent_quoted
+        (identifier) @constant)
+    ]))
+
+; constant declaration
+(const_section
+  (variable_declaration
+    (symbol_declaration_list
+      (symbol_declaration
+        name: [
+          (identifier) @constant
+          (accent_quoted
+            (identifier) @constant)
+          (exported_symbol
+            (identifier) @constant)
+          (exported_symbol
+            (accent_quoted
+              (identifier) @constant))
+        ]))))
+
+((tuple_deconstruct_declaration
+  (symbol_declaration
+    name: [
+      (identifier) @constant
+      (accent_quoted
+        (identifier) @constant)
+      (exported_symbol
+        (identifier) @constant)
+      (exported_symbol
+        (accent_quoted
+          (identifier) @constant))
+    ])) @_tuple_decons
+  (#has-ancestor? @_tuple_decons const_section))
+
+; constants x and y in `array[x..y, type]`
+(bracket_expression
+  left: (identifier) @_array
+  right: (argument_list
+    .
+    (infix_expression
+      right: [
+        (identifier) @constant
+        (accent_quoted
+          (identifier) @constant)
+        (dot_expression
+          right: (identifier) @constant)
+        (dot_expression
+          right: (accent_quoted
+            (identifier) @constant))
+      ]))
+  (#any-of? @_array "array" "range"))
+
+(bracket_expression
+  left: (identifier) @_array
+  right: (argument_list
+    .
+    (infix_expression
+      left: [
+        (identifier) @constant
+        (accent_quoted
+          (identifier) @constant)
+        (dot_expression
+          right: (identifier) @constant)
+        (dot_expression
+          right: (accent_quoted
+            (identifier) @constant))
+      ]))
+  (#any-of? @_array "array" "range"))
+
+; NOTE: can only do this for (infix_expression)s, since standalone identifiers
+; could be ordinal types and constants
+; =============================================================================
+; @constant.builtin ; built-in constant values
+(nil_literal) @constant.builtin
+
+; =============================================================================
+; @module        ; modules or namespaces
+(import_statement
+  (expression_list
+    (identifier) @module))
+
+(import_statement
+  (expression_list
+    (infix_expression
+      operator: "as"
+      right: (identifier) @module)))
+
+(import_statement
+  (expression_list
+    (infix_expression
+      operator: (operator) @_operator
+      right: [
+        (identifier) @module
+        (array_construction
+          (identifier) @module)
+      ]))
+  (#eq? @_operator "/"))
+
+(import_from_statement
+  module: (infix_expression
+    operator: (operator) @_operator
+    right: (identifier) @module)
+  (#eq? @_operator "/"))
+
+(export_statement
+  (expression_list
+    (identifier) @module))
+
+; =============================================================================
+; overrule things
+; left identifier in dot_expression
+(dot_expression
+  left: [
+    (identifier) @none
+    (accent_quoted
+      (identifier) @none)
+  ])
+
+; NOTE: we can't know what the left identifier is, so better leave it alone
+; for consistency
+; discard literals is like a comment
+(discard_statement
+  "discard" @comment
+  [
+    (nil_literal)
+    (integer_literal)
+    (float_literal)
+    (custom_numeric_literal)
+    (char_literal)
+    (interpreted_string_literal)
+    (long_string_literal)
+    (raw_string_literal)
+    (generalized_string)
+    (array_construction)
+    ; for sequences
+    (prefix_expression
+      operator: (operator) @_at
+      (array_construction)
+      (#eq? @_at "@"))
+    (tuple_construction)
+    (curly_construction)
+  ] @comment)
diff --git a/pack/ant/start/nvim-treesitter/queries/nim/injections.scm b/pack/ant/start/nvim-treesitter/queries/nim/injections.scm
new file mode 100644
index 0000000..da15fd8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nim/injections.scm
@@ -0,0 +1,79 @@
+; =============================================================================
+; generalized_strings
+; regex in generalized_strings
+(generalized_string
+  function: (identifier) @_string_prefix
+  .
+  (string_content) @injection.content
+  (#set! injection.language "regex")
+  (#any-of? @_string_prefix "re" "rex"))
+
+; format string in generalized_strings
+(generalized_string
+  function: (identifier) @_string_prefix
+  .
+  (string_content) @injection.content
+  (#set! injection.language "nim_format_string")
+  (#eq? @_string_prefix "fmt"))
+
+; format string in normal strings with & prefix
+(prefix_expression
+  operator: (operator) @_string_prefix
+  .
+  (_
+    (string_content) @injection.content)
+  (#set! injection.language "nim_format_string")
+  (#eq? @_string_prefix "&"))
+
+; sql in generalized_strings
+; and anything you like as long as the function name is the same as the injected language's parser
+(generalized_string
+  function: (identifier) @injection.language
+  (string_content) @injection.content
+  (#not-any-of? @injection.language "re" "rex" "fmt"))
+
+; =============================================================================
+; emit pragma
+; C / CPP / OBJC / JAVASCRIPT
+; a `#<no whitespace><language name>`
+; has to directly precede the {.emit: "<language code>".} pragma
+; eg.:
+; #objc
+; {.emit: "<objc code>".}
+; OR
+; #javascript
+; {.emit: "<javascript code>".}
+; normal strings
+((comment
+  (comment_content) @injection.language)
+  .
+  (pragma_statement
+    (pragma_list
+      (colon_expression
+        left: (identifier) @_emit_keyword
+        (#eq? @_emit_keyword "emit")
+        right: (_
+          (string_content) @injection.content)))))
+
+; =============================================================================
+; asm statement
+; works same as emit pragma, needs preceding comment with language name
+((comment
+  (comment_content) @injection.language)
+  .
+  (assembly_statement
+    (_
+      (string_content) @injection.content)))
+
+; =============================================================================
+; comments
+; NOTE: ts "comment" parser heavily impacts performance
+; markdown parser in documentation_comment
+(documentation_comment
+  (comment_content) @injection.content
+  (#set! injection.language "markdown_inline"))
+
+; markdown parser in block_documentation_comment
+(block_documentation_comment
+  (comment_content) @injection.content
+  (#set! injection.language "markdown"))
diff --git a/pack/ant/start/nvim-treesitter/queries/nim/locals.scm b/pack/ant/start/nvim-treesitter/queries/nim/locals.scm
new file mode 100644
index 0000000..d79fe72
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nim/locals.scm
@@ -0,0 +1,328 @@
+; ==============================================================================
+; @local.definition            ; various definitions
+(block
+  label: [
+    (identifier) @local.definition
+    (accent_quoted) @local.definition
+  ])
+
+; ==============================================================================
+; @local.definition.constant   ; constants
+(const_section
+  (variable_declaration
+    (symbol_declaration_list
+      (symbol_declaration
+        name: [
+          (identifier) @local.definition.constant
+          (accent_quoted) @local.definition.constant
+          (exported_symbol
+            (identifier) @local.definition.constant)
+          (exported_symbol
+            (accent_quoted) @local.definition.constant)
+        ]))
+    type: (type_expression)? @local.definition.associated))
+
+; ==============================================================================
+; @local.definition.function   ; functions
+(proc_declaration
+  name: [
+    (identifier) @local.definition.function
+    (accent_quoted) @local.definition.function
+    (exported_symbol
+      (identifier) @local.definition.function)
+    (exported_symbol
+      (accent_quoted) @local.definition.function)
+  ]
+  (#set! definition.function.scope "parent"))
+
+(func_declaration
+  name: [
+    (identifier) @local.definition.function
+    (accent_quoted) @local.definition.function
+    (exported_symbol
+      (identifier) @local.definition.function)
+    (exported_symbol
+      (accent_quoted) @local.definition.function)
+  ]
+  (#set! definition.function.scope "parent"))
+
+(iterator_declaration
+  name: [
+    (identifier) @local.definition.function
+    (accent_quoted) @local.definition.function
+    (exported_symbol
+      (identifier) @local.definition.function)
+    (exported_symbol
+      (accent_quoted) @local.definition.function)
+  ]
+  (#set! definition.function.scope "parent"))
+
+(converter_declaration
+  name: [
+    (identifier) @local.definition.function
+    (accent_quoted) @local.definition.function
+    (exported_symbol
+      (identifier) @local.definition.function)
+    (exported_symbol
+      (accent_quoted) @local.definition.function)
+  ]
+  (#set! definition.function.scope "parent"))
+
+; ==============================================================================
+; @local.definition.method     ; methods
+(method_declaration
+  name: [
+    (identifier) @local.definition.method
+    (accent_quoted) @local.definition.method
+    (exported_symbol
+      (identifier) @local.definition.method)
+    (exported_symbol
+      (accent_quoted) @local.definition.method)
+  ]
+  (#set! definition.method.scope "parent"))
+
+; ==============================================================================
+; @local.definition.var        ; variables
+(var_section
+  (variable_declaration
+    (symbol_declaration_list
+      (symbol_declaration
+        name: [
+          (identifier) @local.definition.var
+          (accent_quoted) @local.definition.var
+          (exported_symbol
+            (identifier) @local.definition.var)
+          (exported_symbol
+            (accent_quoted) @local.definition.var)
+        ]))
+    type: (type_expression)? @local.definition.associated))
+
+(let_section
+  (variable_declaration
+    (symbol_declaration_list
+      (symbol_declaration
+        name: [
+          (identifier) @local.definition.var
+          (accent_quoted) @local.definition.var
+          (exported_symbol
+            (identifier) @local.definition.var)
+          (exported_symbol
+            (accent_quoted) @local.definition.var)
+        ]))
+    type: (type_expression)? @local.definition.associated))
+
+(for
+  (symbol_declaration_list
+    (symbol_declaration
+      name: [
+        (identifier) @local.definition.var
+        (accent_quoted) @local.definition.var
+      ])))
+
+(try
+  (except_branch
+    values: (expression_list
+      (infix_expression
+        right: [
+          (identifier) @local.definition.var
+          (accent_quoted) @local.definition.var
+        ]))))
+
+; ==============================================================================
+; @local.definition.parameter  ; parameters
+(parameter_declaration
+  (symbol_declaration_list
+    (symbol_declaration
+      name: [
+        (identifier) @local.definition.parameter
+        (accent_quoted) @local.definition.parameter
+      ]))
+  type: (type_expression)? @local.definition.associated)
+
+(concept_declaration
+  parameters: (parameter_list
+    [
+      (identifier) @local.definition.parameter
+      (accent_quoted
+        (identifier) @local.definition.parameter)
+    ]))
+
+(var_parameter
+  [
+    (identifier) @local.definition.parameter
+    (accent_quoted
+      (identifier) @local.definition.parameter)
+  ])
+
+(type_parameter
+  [
+    (identifier) @local.definition.parameter
+    (accent_quoted
+      (identifier) @local.definition.parameter)
+  ])
+
+(static_parameter
+  [
+    (identifier) @local.definition.parameter
+    (accent_quoted
+      (identifier) @local.definition.parameter)
+  ])
+
+(ref_parameter
+  [
+    (identifier) @local.definition.parameter
+    (accent_quoted
+      (identifier) @local.definition.parameter)
+  ])
+
+(pointer_parameter
+  [
+    (identifier) @local.definition.parameter
+    (accent_quoted
+      (identifier) @local.definition.parameter)
+  ])
+
+; ==============================================================================
+; @local.definition.macro      ; preprocessor macros
+(template_declaration
+  name: [
+    (identifier) @local.definition.macro
+    (accent_quoted) @local.definition.macro
+    (exported_symbol
+      (identifier) @local.definition.macro)
+    (exported_symbol
+      (accent_quoted) @local.definition.macro)
+  ]
+  (#set! definition.macro.scope "parent"))
+
+(macro_declaration
+  name: [
+    (identifier) @local.definition.macro
+    (accent_quoted) @local.definition.macro
+    (exported_symbol
+      (identifier) @local.definition.macro)
+    (exported_symbol
+      (accent_quoted) @local.definition.macro)
+  ]
+  (#set! definition.macro.scope "parent"))
+
+; ==============================================================================
+; @local.definition.type       ; types or classes
+(type_declaration
+  (type_symbol_declaration
+    name: [
+      (identifier) @local.definition.type
+      (accent_quoted) @local.definition.type
+      (exported_symbol
+        (identifier) @local.definition.type)
+      (exported_symbol
+        (accent_quoted) @local.definition.type)
+    ]))
+
+; ==============================================================================
+; @local.definition.field      ; fields or properties
+; object_declaration
+; variant_declaration
+; conditional_declaration
+; tuple_type inline
+; tuple_type multiline
+(field_declaration
+  (symbol_declaration_list
+    (symbol_declaration
+      name: [
+        (identifier) @local.definition.field
+        (accent_quoted) @local.definition.field
+        (exported_symbol
+          (identifier) @local.definition.field)
+        (exported_symbol
+          (accent_quoted) @local.definition.field)
+      ]))
+  type: (type_expression)? @local.definition.associated)
+
+; ==============================================================================
+; @local.definition.enum       ; enumerations
+(enum_declaration
+  (enum_field_declaration
+    (symbol_declaration
+      name: [
+        (identifier) @local.definition.enum
+        (accent_quoted) @local.definition.enum
+      ])))
+
+; ==============================================================================
+; @local.definition.namespace  ; modules or namespaces
+; @local.definition.import     ; imported names
+(import_statement
+  (expression_list
+    (identifier) @local.definition.namespace))
+
+(import_statement
+  (expression_list
+    (infix_expression
+      operator: "as"
+      right: (identifier) @local.definition.namespace)))
+
+(import_statement
+  (expression_list
+    (infix_expression
+      operator: (operator) @_operator
+      right: [
+        (identifier) @local.definition.namespace
+        (array_construction
+          (identifier) @local.definition.namespace)
+      ]))
+  (#eq? @_operator "/"))
+
+(import_from_statement
+  module: (infix_expression
+    operator: (operator) @_operator
+    right: (identifier) @local.definition.namespace)
+  (expression_list
+    [
+      (identifier) @local.definition.import
+      (accent_quoted) @local.definition.import
+    ])
+  (#eq? @_operator "/"))
+
+; ==============================================================================
+; @local.scope                 ; scope block
+; (when)
+; NOTE: `when` does actually not create a scope
+(if
+  consequence: (statement_list) @local.scope
+  alternative: (elif_branch)* @local.scope
+  alternative: (else_branch)? @local.scope)
+
+(case
+  alternative: (of_branch)* @local.scope
+  alternative: (elif_branch)* @local.scope
+  alternative: (else_branch)? @local.scope)
+
+(try
+  body: (statement_list) @local.scope
+  (except_branch) @local.scope
+  (finally_branch)? @local.scope)
+
+[
+  (for)
+  (while)
+  (block)
+  (static_statement)
+  (proc_declaration)
+  (func_declaration)
+  (method_declaration)
+  (iterator_declaration)
+  (converter_declaration)
+  (template_declaration)
+  (macro_declaration)
+  (proc_expression)
+  (func_expression)
+  (iterator_expression)
+  (concept_declaration)
+] @local.scope
+
+; ==============================================================================
+; @local.reference             ; identifier reference
+(identifier) @local.reference
+
+(accent_quoted) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/nim_format_string/highlights.scm b/pack/ant/start/nvim-treesitter/queries/nim_format_string/highlights.scm
new file mode 100644
index 0000000..fde9e4b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nim_format_string/highlights.scm
@@ -0,0 +1,20 @@
+(string_literal)
+
+(matching_curlies
+  opening_curly: (opening_curly) @punctuation.special
+  equals: (equals)? @punctuation.special
+  closing_curly: (closing_curly) @punctuation.special)
+
+(format_specifiers
+  colon: (colon) @punctuation.delimiter
+  fill_align: (fill_align)? @keyword.conditional.ternary
+  sign: (sign)? @operator
+  hash: (hash)? @punctuation.special
+  zero: (zero)? @variable.member
+  min_width: (min_width)? @number
+  precision: (precision)? @number
+  type: (type)? @type)
+
+(matching_curlies
+  nim_expression: (nim_expression
+    escaped_curly: (escaped_curly)+ @string.escape) @none)
diff --git a/pack/ant/start/nvim-treesitter/queries/nim_format_string/injections.scm b/pack/ant/start/nvim-treesitter/queries/nim_format_string/injections.scm
new file mode 100644
index 0000000..3efbfb8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nim_format_string/injections.scm
@@ -0,0 +1,4 @@
+((matching_curlies
+  (nim_expression
+    !escaped_curly) @injection.content)
+  (#set! injection.language "nim"))
diff --git a/pack/ant/start/nvim-treesitter/queries/ninja/folds.scm b/pack/ant/start/nvim-treesitter/queries/ninja/folds.scm
new file mode 100644
index 0000000..341a8b8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ninja/folds.scm
@@ -0,0 +1 @@
+(body) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/ninja/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ninja/highlights.scm
new file mode 100644
index 0000000..8323ee9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ninja/highlights.scm
@@ -0,0 +1,101 @@
+[
+  "default"
+  "pool"
+  "rule"
+  "build"
+] @keyword
+
+[
+  "include"
+  "subninja"
+] @keyword.import
+
+":" @punctuation.delimiter
+
+[
+  "="
+  "|"
+  "||"
+  "|@"
+] @operator
+
+[
+  "$"
+  "{"
+  "}"
+] @punctuation.special
+
+;
+; Names
+; =====
+(pool
+  name: (identifier) @type)
+
+(rule
+  name: (identifier) @function)
+
+(let
+  name: (identifier) @constant)
+
+(expansion
+  (identifier) @constant)
+
+(build
+  rule: (identifier) @function)
+
+;
+; Paths and Text
+; ==============
+(path) @string.special.path
+
+(text) @string
+
+;
+; Builtins
+; ========
+(pool
+  name: (identifier) @type.builtin
+  (#any-of? @type.builtin "console"))
+
+(build
+  rule: (identifier) @function.builtin
+  (#any-of? @function.builtin "phony" "dyndep"))
+
+; Top level bindings
+; ------------------
+(manifest
+  (let
+    name: ((identifier) @constant.builtin
+      (#any-of? @constant.builtin "builddir" "ninja_required_version"))))
+
+; Rules bindings
+; -----------------
+(rule
+  (body
+    (let
+      name: (identifier) @constant.builtin
+      (#not-any-of? @constant.builtin
+        "command" "depfile" "deps" "msvc_deps_prefix" "description" "dyndep" "generator" "in"
+        "in_newline" "out" "restat" "rspfile" "rspfile_content" "pool"))))
+
+;
+; Expansion
+; ---------
+(expansion
+  (identifier) @constant.macro
+  (#any-of? @constant.macro "in" "out"))
+
+;
+; Escape sequences
+; ================
+(quote) @string.escape
+
+;
+; Others
+; ======
+[
+  (split)
+  (comment)
+] @comment
+
+(comment) @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/ninja/indents.scm b/pack/ant/start/nvim-treesitter/queries/ninja/indents.scm
new file mode 100644
index 0000000..80344cd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ninja/indents.scm
@@ -0,0 +1,5 @@
+[
+  (pool)
+  (rule)
+  (build)
+] @indent.begin
diff --git a/pack/ant/start/nvim-treesitter/queries/ninja/injections.scm b/pack/ant/start/nvim-treesitter/queries/ninja/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ninja/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/nix/folds.scm b/pack/ant/start/nvim-treesitter/queries/nix/folds.scm
new file mode 100644
index 0000000..a89a5b2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nix/folds.scm
@@ -0,0 +1,11 @@
+; Nix doesn't really have blocks, so just guess what people might want folds for
+[
+  (if_expression)
+  (with_expression)
+  (let_expression)
+  (function_expression)
+  (attrset_expression)
+  (rec_attrset_expression)
+  (list_expression)
+  (indented_string_expression)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/nix/highlights.scm b/pack/ant/start/nvim-treesitter/queries/nix/highlights.scm
new file mode 100644
index 0000000..0a0d9ac
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nix/highlights.scm
@@ -0,0 +1,207 @@
+; basic keywords
+[
+  "assert"
+  "in"
+  "inherit"
+  "let"
+  "rec"
+  "with"
+] @keyword
+
+; if/then/else
+[
+  "if"
+  "then"
+  "else"
+] @keyword.conditional
+
+; field access default (`a.b or c`)
+"or" @keyword.operator
+
+; comments
+(comment) @comment @spell
+
+; strings
+(string_fragment) @string
+
+(string_expression
+  "\"" @string)
+
+(indented_string_expression
+  "''" @string)
+
+; paths and URLs
+[
+  (path_expression)
+  (hpath_expression)
+  (spath_expression)
+] @string.special.path
+
+(uri_expression) @string.special.url
+
+; escape sequences
+(escape_sequence) @string.escape
+
+; delimiters
+[
+  "."
+  ";"
+  ":"
+  ","
+] @punctuation.delimiter
+
+; brackets
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; `?` in `{ x ? y }:`, used to set defaults for named function arguments
+(formal
+  name: (identifier) @variable.parameter
+  "?"? @operator)
+
+; `...` in `{ ... }`, used to ignore unknown named function arguments (see above)
+(ellipses) @variable.parameter.builtin
+
+; universal is the parameter of the function expression
+; `:` in `x: y`, used to separate function argument from body (see above)
+(function_expression
+  universal: (identifier) @variable.parameter
+  ":" @punctuation.special)
+
+; function calls
+(apply_expression
+  function: (variable_expression
+    name: (identifier) @function.call))
+
+; basic identifiers
+(variable_expression) @variable
+
+(variable_expression
+  name: (identifier) @keyword.import
+  (#eq? @keyword.import "import"))
+
+(variable_expression
+  name: (identifier) @boolean
+  (#any-of? @boolean "true" "false"))
+
+; builtin functions (with builtins prefix)
+(select_expression
+  expression: (variable_expression
+    name: (identifier) @_id)
+  attrpath: (attrpath
+    attr: (identifier) @function.builtin)
+  (#eq? @_id "builtins"))
+
+; builtin functions (without builtins prefix)
+(variable_expression
+  name: (identifier) @function.builtin
+  (#any-of? @function.builtin
+    ; nix eval --impure --expr 'with builtins; filter (x: !(elem x [ "abort" "import" "throw" ]) && isFunction builtins.${x}) (attrNames builtins)'
+    "add" "addErrorContext" "all" "any" "appendContext" "attrNames" "attrValues" "baseNameOf"
+    "bitAnd" "bitOr" "bitXor" "break" "catAttrs" "ceil" "compareVersions" "concatLists" "concatMap"
+    "concatStringsSep" "deepSeq" "derivation" "derivationStrict" "dirOf" "div" "elem" "elemAt"
+    "fetchGit" "fetchMercurial" "fetchTarball" "fetchTree" "fetchurl" "filter" "filterSource"
+    "findFile" "floor" "foldl'" "fromJSON" "fromTOML" "functionArgs" "genList" "genericClosure"
+    "getAttr" "getContext" "getEnv" "getFlake" "groupBy" "hasAttr" "hasContext" "hashFile"
+    "hashString" "head" "intersectAttrs" "isAttrs" "isBool" "isFloat" "isFunction" "isInt" "isList"
+    "isNull" "isPath" "isString" "length" "lessThan" "listToAttrs" "map" "mapAttrs" "match" "mul"
+    "parseDrvName" "partition" "path" "pathExists" "placeholder" "readDir" "readFile" "removeAttrs"
+    "replaceStrings" "scopedImport" "seq" "sort" "split" "splitVersion" "storePath" "stringLength"
+    "sub" "substring" "tail" "toFile" "toJSON" "toPath" "toString" "toXML" "trace" "traceVerbose"
+    "tryEval" "typeOf" "unsafeDiscardOutputDependency" "unsafeDiscardStringContext"
+    "unsafeGetAttrPos" "zipAttrsWith"
+    ; primops, `__<tab>` in `nix repl`
+    "__add" "__filter" "__isFunction" "__split" "__addErrorContext" "__filterSource" "__isInt"
+    "__splitVersion" "__all" "__findFile" "__isList" "__storeDir" "__any" "__floor" "__isPath"
+    "__storePath" "__appendContext" "__foldl'" "__isString" "__stringLength" "__attrNames"
+    "__fromJSON" "__langVersion" "__sub" "__attrValues" "__functionArgs" "__length" "__substring"
+    "__bitAnd" "__genList" "__lessThan" "__tail" "__bitOr" "__genericClosure" "__listToAttrs"
+    "__toFile" "__bitXor" "__getAttr" "__mapAttrs" "__toJSON" "__catAttrs" "__getContext" "__match"
+    "__toPath" "__ceil" "__getEnv" "__mul" "__toXML" "__compareVersions" "__getFlake" "__nixPath"
+    "__trace" "__concatLists" "__groupBy" "__nixVersion" "__traceVerbose" "__concatMap" "__hasAttr"
+    "__parseDrvName" "__tryEval" "__concatStringsSep" "__hasContext" "__partition" "__typeOf"
+    "__currentSystem" "__hashFile" "__path" "__unsafeDiscardOutputDependency" "__currentTime"
+    "__hashString" "__pathExists" "__unsafeDiscardStringContext" "__deepSeq" "__head" "__readDir"
+    "__unsafeGetAttrPos" "__div" "__intersectAttrs" "__readFile" "__zipAttrsWith" "__elem"
+    "__isAttrs" "__replaceStrings" "__elemAt" "__isBool" "__seq" "__fetchurl" "__isFloat" "__sort")
+  )
+
+; constants
+(variable_expression
+  name: (identifier) @constant.builtin
+  (#any-of? @constant.builtin
+    ; nix eval --impure --expr 'with builtins; filter (x: !(isFunction builtins.${x} || isBool builtins.${x})) (attrNames builtins)'
+    "builtins" "currentSystem" "currentTime" "langVersion" "nixPath" "nixVersion" "null" "storeDir"))
+
+; string interpolation (this was very annoying to get working properly)
+(interpolation
+  "${" @punctuation.special
+  (_)
+  "}" @punctuation.special) @none
+
+(select_expression
+  expression: (_) @_expr
+  attrpath: (attrpath
+    attr: (identifier) @variable.member)
+  (#not-eq? @_expr "builtins"))
+
+(attrset_expression
+  (binding_set
+    (binding
+      .
+      (attrpath
+        (identifier) @variable.member))))
+
+(rec_attrset_expression
+  (binding_set
+    (binding
+      .
+      (attrpath
+        (identifier) @variable.member))))
+
+; function definition
+(binding
+  attrpath: (attrpath
+    attr: (identifier) @function)
+  expression: (function_expression))
+
+; unary operators
+(unary_expression
+  operator: _ @operator)
+
+; binary operators
+(binary_expression
+  operator: _ @operator)
+
+[
+  "="
+  "@"
+  "?"
+] @operator
+
+; integers, also highlight a unary -
+[
+  (unary_expression
+    "-"
+    (integer_expression))
+  (integer_expression)
+] @number
+
+; floats, also highlight a unary -
+[
+  (unary_expression
+    "-"
+    (float_expression))
+  (float_expression)
+] @number.float
+
+; exceptions
+(variable_expression
+  name: (identifier) @keyword.exception
+  (#any-of? @keyword.exception "abort" "throw"))
diff --git a/pack/ant/start/nvim-treesitter/queries/nix/indents.scm b/pack/ant/start/nvim-treesitter/queries/nix/indents.scm
new file mode 100644
index 0000000..757511b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nix/indents.scm
@@ -0,0 +1,75 @@
+[
+  (list_expression)
+  (indented_string_expression)
+  (let_expression)
+  (if_expression)
+  (binding)
+  (parenthesized_expression)
+] @indent.begin
+
+((attrset_expression) @indent.begin
+  (#not-has-parent? @indent.begin if_expression))
+
+((rec_attrset_expression) @indent.begin
+  (#not-has-parent? @indent.begin if_expression))
+
+((binding
+  "=" @indent.begin)
+  (#set! indent.immediate 1))
+
+(binding
+  ";" @indent.end)
+
+(parenthesized_expression
+  ")" @indent.branch @indent.end)
+
+(attrset_expression
+  "}" @indent.branch @indent.end)
+
+(rec_attrset_expression
+  "}" @indent.branch @indent.end)
+
+(list_expression
+  "]" @indent.branch @indent.dedent)
+
+(indented_string_expression
+  "''" @indent.branch @indent.end .)
+
+[
+  "else"
+  "in"
+] @indent.branch
+
+(let_expression
+  body: (_) @indent.end @indent.dedent)
+
+(string_fragment) @indent.ignore @indent.auto
+
+(if_expression
+  condition: (_) @indent.auto)
+
+alternative: (if_expression) @indent.dedent
+
+(interpolation) @indent.begin @indent.dedent
+
+(interpolation
+  "}" @indent.end @indent.branch)
+
+(ERROR
+  "then" @indent.begin)
+
+(ERROR
+  "then"
+  .
+  (formals) @indent.begin)
+
+(ERROR
+  "then"
+  .
+  (formals
+    "}" @indent.branch @indent.end))
+
+(ERROR
+  "let") @indent.begin
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/nix/injections.scm b/pack/ant/start/nvim-treesitter/queries/nix/injections.scm
new file mode 100644
index 0000000..d5e8483
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nix/injections.scm
@@ -0,0 +1,190 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((comment) @injection.language
+  . ; this is to make sure only adjacent comments are accounted for the injections
+  [
+    (string_expression
+      (string_fragment) @injection.content)
+    (indented_string_expression
+      (string_fragment) @injection.content)
+  ]
+  (#gsub! @injection.language "/%*%s*([%w%p]+)%s*%*/" "%1")
+  (#set! injection.combined))
+
+; #-style Comments
+((comment) @injection.language
+  . ; this is to make sure only adjacent comments are accounted for the injections
+  [
+    (string_expression
+      (string_fragment) @injection.content)
+    (indented_string_expression
+      (string_fragment) @injection.content)
+  ]
+  (#gsub! @injection.language "#%s*([%w%p]+)%s*" "%1")
+  (#set! injection.combined))
+
+(apply_expression
+  function: (_) @_func
+  argument: [
+    (string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "regex")))
+    (indented_string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "regex")))
+  ]
+  (#match? @_func "(^|\\.)match$")
+  (#set! injection.combined))
+
+(binding
+  attrpath: (attrpath
+    (identifier) @_path)
+  expression: [
+    (string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "bash")))
+    (indented_string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "bash")))
+  ]
+  (#match? @_path "(^\\w+(Phase|Hook|Check)|(pre|post)[A-Z]\\w+|script)$"))
+
+(apply_expression
+  function: (_) @_func
+  argument: (_
+    (_)*
+    (_
+      (_)*
+      (binding
+        attrpath: (attrpath
+          (identifier) @_path)
+        expression: [
+          (string_expression
+            ((string_fragment) @injection.content
+              (#set! injection.language "bash")))
+          (indented_string_expression
+            ((string_fragment) @injection.content
+              (#set! injection.language "bash")))
+        ])))
+  (#match? @_func "(^|\\.)writeShellApplication$")
+  (#match? @_path "^text$")
+  (#set! injection.combined))
+
+(apply_expression
+  function: (apply_expression
+    function: (apply_expression
+      function: (_) @_func))
+  argument: [
+    (string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "bash")))
+    (indented_string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "bash")))
+  ]
+  (#match? @_func "(^|\\.)runCommand((No)?CC)?(Local)?$")
+  (#set! injection.combined))
+
+((apply_expression
+  function: (apply_expression
+    function: (_) @_func)
+  argument: [
+    (string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "bash")))
+    (indented_string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "bash")))
+  ])
+  (#match? @_func "(^|\\.)write(Bash|Dash|ShellScript)(Bin)?$")
+  (#set! injection.combined))
+
+((apply_expression
+  function: (apply_expression
+    function: (_) @_func)
+  argument: [
+    (string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "fish")))
+    (indented_string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "fish")))
+  ])
+  (#match? @_func "(^|\\.)writeFish(Bin)?$")
+  (#set! injection.combined))
+
+((apply_expression
+  function: (apply_expression
+    function: (apply_expression
+      function: (_) @_func))
+  argument: [
+    (string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "haskell")))
+    (indented_string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "haskell")))
+  ])
+  (#match? @_func "(^|\\.)writeHaskell(Bin)?$")
+  (#set! injection.combined))
+
+((apply_expression
+  function: (apply_expression
+    function: (apply_expression
+      function: (_) @_func))
+  argument: [
+    (string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "javascript")))
+    (indented_string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "javascript")))
+  ])
+  (#match? @_func "(^|\\.)writeJS(Bin)?$")
+  (#set! injection.combined))
+
+((apply_expression
+  function: (apply_expression
+    function: (apply_expression
+      function: (_) @_func))
+  argument: [
+    (string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "perl")))
+    (indented_string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "perl")))
+  ])
+  (#match? @_func "(^|\\.)writePerl(Bin)?$")
+  (#set! injection.combined))
+
+((apply_expression
+  function: (apply_expression
+    function: (apply_expression
+      function: (_) @_func))
+  argument: [
+    (string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "python")))
+    (indented_string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "python")))
+  ])
+  (#match? @_func "(^|\\.)write(PyPy|Python)[23](Bin)?$")
+  (#set! injection.combined))
+
+((apply_expression
+  function: (apply_expression
+    function: (apply_expression
+      function: (_) @_func))
+  argument: [
+    (string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "rust")))
+    (indented_string_expression
+      ((string_fragment) @injection.content
+        (#set! injection.language "rust")))
+  ])
+  (#match? @_func "(^|\\.)writeRust(Bin)?$")
+  (#set! injection.combined))
diff --git a/pack/ant/start/nvim-treesitter/queries/nix/locals.scm b/pack/ant/start/nvim-treesitter/queries/nix/locals.scm
new file mode 100644
index 0000000..61cab23
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nix/locals.scm
@@ -0,0 +1,34 @@
+; let bindings
+(let_expression
+  (binding_set
+    (binding
+      .
+      (attrpath) @local.definition.var))) @local.scope
+
+; rec attrsets
+(rec_attrset_expression
+  (binding_set
+    (binding
+      .
+      (attrpath) @local.definition.field))) @local.scope
+
+; functions and parameters
+(function_expression
+  .
+  [
+    (identifier) @local.definition.parameter
+    (formals
+      (formal
+        .
+        (identifier) @local.definition.parameter))
+  ]) @local.scope
+
+((formals)
+  "@"
+  (identifier) @local.definition.parameter) ; I couldn't get this to work properly inside the (function)
+
+(variable_expression
+  (identifier) @local.reference)
+
+(inherited_attrs
+  attr: (identifier) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/nqc/folds.scm b/pack/ant/start/nvim-treesitter/queries/nqc/folds.scm
new file mode 100644
index 0000000..a5a5208
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nqc/folds.scm
@@ -0,0 +1 @@
+; inherits: c
diff --git a/pack/ant/start/nvim-treesitter/queries/nqc/highlights.scm b/pack/ant/start/nvim-treesitter/queries/nqc/highlights.scm
new file mode 100644
index 0000000..0d0b770
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nqc/highlights.scm
@@ -0,0 +1,13 @@
+; inherits: c
+
+"task" @keyword.function
+
+"until" @keyword.repeat
+
+[
+  "acquire"
+  "monitor"
+  "catch"
+  "start"
+  "stop"
+] @keyword.coroutine
diff --git a/pack/ant/start/nvim-treesitter/queries/nqc/indents.scm b/pack/ant/start/nvim-treesitter/queries/nqc/indents.scm
new file mode 100644
index 0000000..a5a5208
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nqc/indents.scm
@@ -0,0 +1 @@
+; inherits: c
diff --git a/pack/ant/start/nvim-treesitter/queries/nqc/injections.scm b/pack/ant/start/nvim-treesitter/queries/nqc/injections.scm
new file mode 100644
index 0000000..a5a5208
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nqc/injections.scm
@@ -0,0 +1 @@
+; inherits: c
diff --git a/pack/ant/start/nvim-treesitter/queries/nqc/locals.scm b/pack/ant/start/nvim-treesitter/queries/nqc/locals.scm
new file mode 100644
index 0000000..a5a5208
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/nqc/locals.scm
@@ -0,0 +1 @@
+; inherits: c
diff --git a/pack/ant/start/nvim-treesitter/queries/objc/folds.scm b/pack/ant/start/nvim-treesitter/queries/objc/folds.scm
new file mode 100644
index 0000000..b922f8b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/objc/folds.scm
@@ -0,0 +1,20 @@
+; inherits: c
+
+[
+  (class_declaration)
+  (class_interface)
+  (class_implementation)
+  (protocol_declaration)
+  (property_declaration)
+  (method_declaration)
+  (struct_declaration)
+  (struct_declarator)
+  (try_statement)
+  (catch_clause)
+  (finally_clause)
+  (throw_statement)
+  (block_literal)
+  (ms_asm_block)
+  (dictionary_literal)
+  (array_literal)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/objc/highlights.scm b/pack/ant/start/nvim-treesitter/queries/objc/highlights.scm
new file mode 100644
index 0000000..0f41240
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/objc/highlights.scm
@@ -0,0 +1,268 @@
+; inherits: c
+
+; Preprocs
+(preproc_undef
+  name: (_) @constant) @keyword.directive
+
+; Includes
+(module_import
+  "@import" @keyword.import
+  path: (identifier) @module)
+
+((preproc_include
+  _ @keyword.import
+  path: (_))
+  (#any-of? @keyword.import "#include" "#import"))
+
+; Type Qualifiers
+[
+  "@optional"
+  "@required"
+  "__covariant"
+  "__contravariant"
+  (visibility_specification)
+] @keyword.modifier
+
+; Storageclasses
+[
+  "@autoreleasepool"
+  "@synthesize"
+  "@dynamic"
+  "volatile"
+  (protocol_qualifier)
+] @keyword.modifier
+
+; Keywords
+[
+  "@protocol"
+  "@interface"
+  "@implementation"
+  "@compatibility_alias"
+  "@property"
+  "@selector"
+  "@defs"
+  "availability"
+  "@end"
+] @keyword
+
+(class_declaration
+  "@" @keyword.type
+  "class" @keyword.type) ; I hate Obj-C for allowing "@ class" :)
+
+(method_definition
+  [
+    "+"
+    "-"
+  ] @keyword.function)
+
+(method_declaration
+  [
+    "+"
+    "-"
+  ] @keyword.function)
+
+[
+  "__typeof__"
+  "__typeof"
+  "typeof"
+  "in"
+] @keyword.operator
+
+[
+  "@synchronized"
+  "oneway"
+] @keyword.coroutine
+
+; Exceptions
+[
+  "@try"
+  "__try"
+  "@catch"
+  "__catch"
+  "@finally"
+  "__finally"
+  "@throw"
+] @keyword.exception
+
+; Variables
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin "self" "super"))
+
+; Functions & Methods
+[
+  "objc_bridge_related"
+  "@available"
+  "__builtin_available"
+  "va_arg"
+  "asm"
+] @function.builtin
+
+(method_definition
+  (identifier) @function.method)
+
+(method_declaration
+  (identifier) @function.method)
+
+(method_identifier
+  (identifier)? @function.method
+  ":" @function.method
+  (identifier)? @function.method)
+
+(message_expression
+  method: (identifier) @function.method.call)
+
+; Constructors
+((message_expression
+  method: (identifier) @constructor)
+  (#eq? @constructor "init"))
+
+; Attributes
+(availability_attribute_specifier
+  [
+    "CF_FORMAT_FUNCTION"
+    "NS_AVAILABLE"
+    "__IOS_AVAILABLE"
+    "NS_AVAILABLE_IOS"
+    "API_AVAILABLE"
+    "API_UNAVAILABLE"
+    "API_DEPRECATED"
+    "NS_ENUM_AVAILABLE_IOS"
+    "NS_DEPRECATED_IOS"
+    "NS_ENUM_DEPRECATED_IOS"
+    "NS_FORMAT_FUNCTION"
+    "DEPRECATED_MSG_ATTRIBUTE"
+    "__deprecated_msg"
+    "__deprecated_enum_msg"
+    "NS_SWIFT_NAME"
+    "NS_SWIFT_UNAVAILABLE"
+    "NS_EXTENSION_UNAVAILABLE_IOS"
+    "NS_CLASS_AVAILABLE_IOS"
+    "NS_CLASS_DEPRECATED_IOS"
+    "__OSX_AVAILABLE_STARTING"
+    "NS_ROOT_CLASS"
+    "NS_UNAVAILABLE"
+    "NS_REQUIRES_NIL_TERMINATION"
+    "CF_RETURNS_RETAINED"
+    "CF_RETURNS_NOT_RETAINED"
+    "DEPRECATED_ATTRIBUTE"
+    "UI_APPEARANCE_SELECTOR"
+    "UNAVAILABLE_ATTRIBUTE"
+  ]) @attribute
+
+; Macros
+(type_qualifier
+  [
+    "_Complex"
+    "_Nonnull"
+    "_Nullable"
+    "_Nullable_result"
+    "_Null_unspecified"
+    "__autoreleasing"
+    "__block"
+    "__bridge"
+    "__bridge_retained"
+    "__bridge_transfer"
+    "__complex"
+    "__kindof"
+    "__nonnull"
+    "__nullable"
+    "__ptrauth_objc_class_ro"
+    "__ptrauth_objc_isa_pointer"
+    "__ptrauth_objc_super_pointer"
+    "__strong"
+    "__thread"
+    "__unsafe_unretained"
+    "__unused"
+    "__weak"
+  ]) @function.macro
+
+[
+  "__real"
+  "__imag"
+] @function.macro
+
+((call_expression
+  function: (identifier) @function.macro)
+  (#eq? @function.macro "testassert"))
+
+; Types
+(class_declaration
+  (identifier) @type)
+
+(class_interface
+  "@interface"
+  .
+  (identifier) @type
+  superclass: _? @type
+  category: _? @module)
+
+(class_implementation
+  "@implementation"
+  .
+  (identifier) @type
+  superclass: _? @type
+  category: _? @module)
+
+(protocol_forward_declaration
+  (identifier) @type) ; @interface :(
+
+(protocol_reference_list
+  (identifier) @type) ; ^
+
+[
+  "BOOL"
+  "IMP"
+  "SEL"
+  "Class"
+  "id"
+] @type.builtin
+
+; Constants
+(property_attribute
+  (identifier) @constant
+  "="?)
+
+[
+  "__asm"
+  "__asm__"
+] @constant.macro
+
+; Properties
+(property_implementation
+  "@synthesize"
+  (identifier) @variable.member)
+
+((identifier) @variable.member
+  (#has-ancestor? @variable.member struct_declaration))
+
+; Parameters
+(method_parameter
+  ":" @function.method
+  (identifier) @variable.parameter)
+
+(method_parameter
+  declarator: (identifier) @variable.parameter)
+
+(parameter_declaration
+  declarator: (function_declarator
+    declarator: (parenthesized_declarator
+      (block_pointer_declarator
+        declarator: (identifier) @variable.parameter))))
+
+"..." @variable.parameter.builtin
+
+; Operators
+"^" @operator
+
+; Literals
+(platform) @string.special
+
+(version_number) @string.special
+
+; Punctuation
+"@" @punctuation.special
+
+[
+  "<"
+  ">"
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/objc/indents.scm b/pack/ant/start/nvim-treesitter/queries/objc/indents.scm
new file mode 100644
index 0000000..a5a5208
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/objc/indents.scm
@@ -0,0 +1 @@
+; inherits: c
diff --git a/pack/ant/start/nvim-treesitter/queries/objc/injections.scm b/pack/ant/start/nvim-treesitter/queries/objc/injections.scm
new file mode 100644
index 0000000..359420d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/objc/injections.scm
@@ -0,0 +1,10 @@
+; inherits: c
+
+; TODO(amaanq): uncomment/add when I add asm support
+; (ms_asm_block "{" _ @asm "}")
+;
+; ((asm_specifier (string_literal) @asm)
+;   (#offset! @asm 0 1 0 -1))
+;
+; ((asm_statement (string_literal) @asm)
+;   (#offset! @asm 0 1 0 -1))
diff --git a/pack/ant/start/nvim-treesitter/queries/objc/locals.scm b/pack/ant/start/nvim-treesitter/queries/objc/locals.scm
new file mode 100644
index 0000000..a5a5208
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/objc/locals.scm
@@ -0,0 +1 @@
+; inherits: c
diff --git a/pack/ant/start/nvim-treesitter/queries/objdump/highlights.scm b/pack/ant/start/nvim-treesitter/queries/objdump/highlights.scm
new file mode 100644
index 0000000..b73e188
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/objdump/highlights.scm
@@ -0,0 +1,60 @@
+(byte) @constant
+
+[
+  (hexadecimal)
+  (integer)
+  (address)
+] @number
+
+; [
+;   "file" "format"
+;   "File" "Offset:"
+;   "discriminator"
+; ] @none
+"Disassembly of section " @markup.heading
+
+(section_address) @string.special
+
+(identifier) @variable
+
+(code_location
+  (identifier) @function.call)
+
+(header
+  (identifier) @keyword)
+
+(disassembly_section_label
+  (identifier) @module)
+
+(disassembly_section
+  (identifier) @module)
+
+[
+  (file_offset)
+  (discriminator)
+] @variable.member
+
+(file_path) @string.special.path
+
+(instruction) @function
+
+(bad_instruction) @comment.warning
+
+(label) @label
+
+[
+  "<"
+  ">"
+] @punctuation.special
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "+"
+  ":"
+] @punctuation.delimiter
+
+(comment) @comment.documentation
diff --git a/pack/ant/start/nvim-treesitter/queries/objdump/injections.scm b/pack/ant/start/nvim-treesitter/queries/objdump/injections.scm
new file mode 100644
index 0000000..9fb52da
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/objdump/injections.scm
@@ -0,0 +1,6 @@
+; TODO: https://github.com/nvim-treesitter/nvim-treesitter/pull/5548#issuecomment-1773707396
+;
+; To be added once a compatible Assembly parser is merged into nvim-treesitter
+;
+; ((instruction) @injection.content
+;  (#set! injection.language "asm"))
diff --git a/pack/ant/start/nvim-treesitter/queries/ocaml/folds.scm b/pack/ant/start/nvim-treesitter/queries/ocaml/folds.scm
new file mode 100644
index 0000000..1d45dbb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ocaml/folds.scm
@@ -0,0 +1,30 @@
+[
+  (let_binding)
+  (external)
+  (type_binding)
+  (exception_definition)
+  (module_binding)
+  (module_type_definition)
+  (open_module)
+  (include_module)
+  (include_module_type)
+  (class_binding)
+  (class_type_binding)
+  (value_specification)
+  (inheritance_specification)
+  (instance_variable_specification)
+  (method_specification)
+  (inheritance_definition)
+  (instance_variable_definition)
+  (method_definition)
+  (class_initializer)
+  (match_case)
+  (attribute)
+  (item_attribute)
+  (floating_attribute)
+  (extension)
+  (item_extension)
+  (quoted_extension)
+  (quoted_item_extension)
+  (comment)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/ocaml/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ocaml/highlights.scm
new file mode 100644
index 0000000..891ff7b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ocaml/highlights.scm
@@ -0,0 +1,329 @@
+; Modules
+;--------
+[
+  (module_name)
+  (module_type_name)
+] @module
+
+; Types
+;------
+((type_constructor) @type.builtin
+  (#any-of? @type.builtin
+    "int" "char" "bytes" "string" "float" "bool" "unit" "exn" "array" "list" "option" "int32"
+    "int64" "nativeint" "format6" "lazy_t"))
+
+[
+  (class_name)
+  (class_type_name)
+  (type_constructor)
+] @type
+
+[
+  (constructor_name)
+  (tag)
+] @constructor
+
+; Variables
+;----------
+[
+  (value_name)
+  (type_variable)
+] @variable
+
+(value_pattern) @variable.parameter
+
+((value_pattern) @character.special
+  (#eq? @character.special "_"))
+
+; Functions
+;----------
+(let_binding
+  pattern: (value_name) @function
+  (parameter))
+
+(let_binding
+  pattern: (value_name) @function
+  body: [
+    (fun_expression)
+    (function_expression)
+  ])
+
+(value_specification
+  (value_name) @function)
+
+(external
+  (value_name) @function)
+
+(method_name) @function.method
+
+; Application
+;------------
+(infix_expression
+  left: (value_path
+    (value_name) @function.call)
+  operator: (concat_operator) @_operator
+  (#eq? @_operator "@@"))
+
+(infix_expression
+  operator: (rel_operator) @_operator
+  right: (value_path
+    (value_name) @function.call)
+  (#eq? @_operator "|>"))
+
+(application_expression
+  function: (value_path
+    (value_name) @function.call))
+
+((value_name) @function.builtin
+  (#any-of? @function.builtin "raise" "raise_notrace" "failwith" "invalid_arg"))
+
+; Fields
+;-------
+[
+  (field_name)
+  (instance_variable_name)
+] @variable.member
+
+; Labels
+; ------
+(label_name) @label
+
+; Constants
+;----------
+; Don't let normal parens take priority over this
+((unit) @constant.builtin
+  (#set! priority 105))
+
+(boolean) @boolean
+
+[
+  (number)
+  (signed_number)
+] @number
+
+(character) @character
+
+(string) @string
+
+(quoted_string
+  "{" @string
+  "}" @string) @string
+
+(escape_sequence) @string.escape
+
+[
+  (conversion_specification)
+  (pretty_printing_indication)
+] @string.special
+
+; Keywords
+;---------
+[
+  "and"
+  "as"
+  "assert"
+  "begin"
+  "constraint"
+  "end"
+  "external"
+  "in"
+  "inherit"
+  "initializer"
+  "let"
+  "match"
+  "method"
+  "module"
+  "new"
+  "of"
+  "sig"
+  "val"
+  "when"
+  "with"
+] @keyword
+
+[
+  "object"
+  "class"
+  "struct"
+  "type"
+] @keyword.type
+
+[
+  "lazy"
+  "mutable"
+  "nonrec"
+  "rec"
+  "private"
+  "virtual"
+] @keyword.modifier
+
+[
+  "fun"
+  "function"
+  "functor"
+] @keyword.function
+
+[
+  "if"
+  "then"
+  "else"
+] @keyword.conditional
+
+[
+  "exception"
+  "try"
+] @keyword.exception
+
+[
+  "include"
+  "open"
+] @keyword.import
+
+[
+  "for"
+  "to"
+  "downto"
+  "while"
+  "do"
+  "done"
+] @keyword.repeat
+
+; Punctuation
+;------------
+(attribute
+  [
+    "[@"
+    "]"
+  ] @punctuation.special)
+
+(item_attribute
+  [
+    "[@@"
+    "]"
+  ] @punctuation.special)
+
+(floating_attribute
+  [
+    "[@@@"
+    "]"
+  ] @punctuation.special)
+
+(extension
+  [
+    "[%"
+    "]"
+  ] @punctuation.special)
+
+(item_extension
+  [
+    "[%%"
+    "]"
+  ] @punctuation.special)
+
+(quoted_extension
+  [
+    "{%"
+    "}"
+  ] @punctuation.special)
+
+(quoted_item_extension
+  [
+    "{%%"
+    "}"
+  ] @punctuation.special)
+
+"%" @punctuation.special
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  "[|"
+  "|]"
+  "[<"
+  "[>"
+] @punctuation.bracket
+
+(object_type
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+[
+  ","
+  "."
+  ";"
+  ":"
+  "="
+  "|"
+  "~"
+  "?"
+  "+"
+  "-"
+  "!"
+  ">"
+  "&"
+  "->"
+  ";;"
+  ":>"
+  "+="
+  ":="
+  ".."
+] @punctuation.delimiter
+
+(range_pattern
+  ".." @character.special)
+
+; Operators
+;----------
+[
+  (prefix_operator)
+  (sign_operator)
+  (pow_operator)
+  (mult_operator)
+  (add_operator)
+  (concat_operator)
+  (rel_operator)
+  (and_operator)
+  (or_operator)
+  (assign_operator)
+  (hash_operator)
+  (indexing_operator)
+  (let_operator)
+  (and_operator)
+  (match_operator)
+] @operator
+
+(match_expression
+  (match_operator) @keyword)
+
+(value_definition
+  [
+    (let_operator)
+    (let_and_operator)
+  ] @keyword)
+
+[
+  "*"
+  "#"
+  "::"
+  "<-"
+] @operator
+
+; Attributes
+;-----------
+(attribute_id) @attribute
+
+; Comments
+;---------
+[
+  (comment)
+  (line_number_directive)
+  (directive)
+] @comment @spell
+
+(shebang) @keyword.directive
diff --git a/pack/ant/start/nvim-treesitter/queries/ocaml/indents.scm b/pack/ant/start/nvim-treesitter/queries/ocaml/indents.scm
new file mode 100644
index 0000000..d7f0536
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ocaml/indents.scm
@@ -0,0 +1,77 @@
+; format-ignore
+[ 
+  (let_binding)                 ; let = ...
+  (type_binding)
+
+  (external)
+  (record_declaration)          ; { foo: bar ... }
+  (structure)                   ; struct ... end
+  (signature)                   ; sig ... end
+  (value_specification)         ; val x: bar
+
+  (do_clause)                   ; do ... done
+  (match_case)
+
+  (field_expression)
+  (application_expression)
+  (parenthesized_expression)    ; ( ... )
+  (record_expression)           ; { foo = bar ... }
+  (list_expression)             ; [...;...]
+  (try_expression)              ; try ... with
+] @indent.begin
+
+; handle if-else if-else case
+(if_expression
+  condition: (_) @indent.begin)
+
+(then_clause) @indent.begin
+
+((else_clause
+  (_) @_not_if) @indent.begin
+  (#not-kind-eq? @_not_if "if_expression"))
+
+((parameter) @indent.begin
+  (#set! indent.start_at_same_line))
+
+(_
+  (ERROR) @indent.begin
+  (#set! indent.start_at_same_line))
+
+(ERROR
+  "|" @indent.begin
+  (#set! indent.start_at_same_line))
+
+(try_expression
+  "with" @indent.branch
+  [
+    (match_case) @indent.dedent
+    (match_case
+      [
+        (parenthesized_expression)
+        (list_expression)
+      ] @indent.dedent)
+  ])
+
+"}" @indent.branch @indent.end
+
+(list_expression
+  "]" @indent.branch)
+
+(parenthesized_expression
+  ")" @indent.branch)
+
+";;" @indent.end
+
+(do_clause
+  "done" @indent.end @indent.branch)
+
+(structure
+  "end" @indent.end @indent.branch)
+
+(signature
+  "end" @indent.end @indent.branch)
+
+[
+  (string)
+  (comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/ocaml/injections.scm b/pack/ant/start/nvim-treesitter/queries/ocaml/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ocaml/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/ocaml/locals.scm b/pack/ant/start/nvim-treesitter/queries/ocaml/locals.scm
new file mode 100644
index 0000000..38d3926
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ocaml/locals.scm
@@ -0,0 +1,87 @@
+; Scopes
+;-------
+[
+  (compilation_unit)
+  (structure)
+  (signature)
+  (module_binding)
+  (functor)
+  (let_binding)
+  (match_case)
+  (class_binding)
+  (class_function)
+  (method_definition)
+  (let_expression)
+  (fun_expression)
+  (for_expression)
+  (let_class_expression)
+  (object_expression)
+  (attribute_payload)
+] @local.scope
+
+; Definitions
+;------------
+(value_pattern) @local.definition.var
+
+(let_binding
+  pattern: (value_name) @local.definition.var
+  (#set! definition.var.scope "parent"))
+
+(let_binding
+  pattern: (tuple_pattern
+    (value_name) @local.definition.var)
+  (#set! definition.var.scope "parent"))
+
+(let_binding
+  pattern: (record_pattern
+    (field_pattern
+      (value_name) @local.definition.var))
+  (#set! definition.var.scope "parent"))
+
+(external
+  (value_name) @local.definition.var)
+
+(type_binding
+  (type_constructor) @local.definition.type)
+
+(abstract_type
+  (type_constructor) @local.definition.type)
+
+(method_definition
+  (method_name) @local.definition.method)
+
+(module_binding
+  (module_name) @local.definition.namespace
+  (#set! definition.namespace.scope "parent"))
+
+(module_parameter
+  (module_name) @local.definition.namespace)
+
+(module_type_definition
+  (module_type_name) @local.definition.type)
+
+; References
+;------------
+(value_path
+  .
+  (value_name) @local.reference
+  (#set! reference.kind "var"))
+
+(type_constructor_path
+  .
+  (type_constructor) @local.reference
+  (#set! reference.kind "type"))
+
+(method_invocation
+  (method_name) @local.reference
+  (#set! reference.kind "method"))
+
+(module_path
+  .
+  (module_name) @local.reference
+  (#set! reference.kind "type"))
+
+(module_type_path
+  .
+  (module_type_name) @local.reference
+  (#set! reference.kind "type"))
diff --git a/pack/ant/start/nvim-treesitter/queries/ocaml_interface/folds.scm b/pack/ant/start/nvim-treesitter/queries/ocaml_interface/folds.scm
new file mode 100644
index 0000000..6d3dfbc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ocaml_interface/folds.scm
@@ -0,0 +1 @@
+; inherits: ocaml
diff --git a/pack/ant/start/nvim-treesitter/queries/ocaml_interface/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ocaml_interface/highlights.scm
new file mode 100644
index 0000000..b623e43
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ocaml_interface/highlights.scm
@@ -0,0 +1,327 @@
+; Modules
+;--------
+[
+  (module_name)
+  (module_type_name)
+] @module
+
+; Types
+;------
+((type_constructor) @type.builtin
+  (#any-of? @type.builtin
+    "int" "char" "bytes" "string" "float" "bool" "unit" "exn" "array" "list" "option" "int32"
+    "int64" "nativeint" "format6" "lazy_t"))
+
+[
+  (class_name)
+  (class_type_name)
+  (type_constructor)
+] @type
+
+[
+  (constructor_name)
+  (tag)
+] @constructor
+
+; Variables
+;----------
+[
+  (value_name)
+  (type_variable)
+] @variable
+
+(value_pattern) @variable.parameter
+
+((value_pattern) @character.special
+  (#eq? @character.special "_"))
+
+; Functions
+;----------
+(let_binding
+  pattern: (value_name) @function
+  (parameter))
+
+(let_binding
+  pattern: (value_name) @function
+  body: [
+    (fun_expression)
+    (function_expression)
+  ])
+
+(value_specification
+  (value_name) @function)
+
+(external
+  (value_name) @function)
+
+(method_name) @function.method
+
+; Application
+;------------
+(infix_expression
+  left: (value_path
+    (value_name) @function.call)
+  operator: (concat_operator) @_operator
+  (#eq? @_operator "@@"))
+
+(infix_expression
+  operator: (rel_operator) @_operator
+  right: (value_path
+    (value_name) @function.call)
+  (#eq? @_operator "|>"))
+
+(application_expression
+  function: (value_path
+    (value_name) @function.call))
+
+((value_name) @function.builtin
+  (#any-of? @function.builtin "raise" "raise_notrace" "failwith" "invalid_arg"))
+
+; Fields
+;-------
+[
+  (field_name)
+  (instance_variable_name)
+] @variable.member
+
+; Labels
+; ------
+(label_name) @label
+
+; Constants
+;----------
+; Don't let normal parens take priority over this
+((unit) @constant.builtin
+  (#set! priority 105))
+
+(boolean) @boolean
+
+[
+  (number)
+  (signed_number)
+] @number
+
+(character) @character
+
+(string) @string
+
+(quoted_string
+  "{" @string
+  "}" @string) @string
+
+(escape_sequence) @string.escape
+
+[
+  (conversion_specification)
+  (pretty_printing_indication)
+] @string.special
+
+; Keywords
+;---------
+[
+  "and"
+  "as"
+  "assert"
+  "begin"
+  "constraint"
+  "end"
+  "external"
+  "in"
+  "inherit"
+  "initializer"
+  "let"
+  "match"
+  "method"
+  "module"
+  "new"
+  "of"
+  "sig"
+  "val"
+  "when"
+  "with"
+] @keyword
+
+[
+  "object"
+  "class"
+  "struct"
+  "type"
+] @keyword.type
+
+[
+  "lazy"
+  "mutable"
+  "nonrec"
+  "rec"
+  "private"
+  "virtual"
+] @keyword.modifier
+
+[
+  "fun"
+  "function"
+  "functor"
+] @keyword.function
+
+[
+  "if"
+  "then"
+  "else"
+] @keyword.conditional
+
+[
+  "exception"
+  "try"
+] @keyword.exception
+
+[
+  "include"
+  "open"
+] @keyword.import
+
+[
+  "for"
+  "to"
+  "downto"
+  "while"
+  "do"
+  "done"
+] @keyword.repeat
+
+; Punctuation
+;------------
+(attribute
+  [
+    "[@"
+    "]"
+  ] @punctuation.special)
+
+(item_attribute
+  [
+    "[@@"
+    "]"
+  ] @punctuation.special)
+
+(floating_attribute
+  [
+    "[@@@"
+    "]"
+  ] @punctuation.special)
+
+(extension
+  [
+    "[%"
+    "]"
+  ] @punctuation.special)
+
+(item_extension
+  [
+    "[%%"
+    "]"
+  ] @punctuation.special)
+
+(quoted_extension
+  [
+    "{%"
+    "}"
+  ] @punctuation.special)
+
+(quoted_item_extension
+  [
+    "{%%"
+    "}"
+  ] @punctuation.special)
+
+"%" @punctuation.special
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  "[|"
+  "|]"
+  "[<"
+  "[>"
+] @punctuation.bracket
+
+(object_type
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+[
+  ","
+  "."
+  ";"
+  ":"
+  "="
+  "|"
+  "~"
+  "?"
+  "+"
+  "-"
+  "!"
+  ">"
+  "&"
+  "->"
+  ";;"
+  ":>"
+  "+="
+  ":="
+  ".."
+] @punctuation.delimiter
+
+(range_pattern
+  ".." @character.special)
+
+; Operators
+;----------
+[
+  (prefix_operator)
+  (sign_operator)
+  (pow_operator)
+  (mult_operator)
+  (add_operator)
+  (concat_operator)
+  (rel_operator)
+  (and_operator)
+  (or_operator)
+  (assign_operator)
+  (hash_operator)
+  (indexing_operator)
+  (let_operator)
+  (and_operator)
+  (match_operator)
+] @operator
+
+(match_expression
+  (match_operator) @keyword)
+
+(value_definition
+  [
+    (let_operator)
+    (let_and_operator)
+  ] @keyword)
+
+[
+  "*"
+  "#"
+  "::"
+  "<-"
+] @operator
+
+; Attributes
+;-----------
+(attribute_id) @attribute
+
+; Comments
+;---------
+[
+  (comment)
+  (line_number_directive)
+  (directive)
+] @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/ocaml_interface/indents.scm b/pack/ant/start/nvim-treesitter/queries/ocaml_interface/indents.scm
new file mode 100644
index 0000000..6d3dfbc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ocaml_interface/indents.scm
@@ -0,0 +1 @@
+; inherits: ocaml
diff --git a/pack/ant/start/nvim-treesitter/queries/ocaml_interface/injections.scm b/pack/ant/start/nvim-treesitter/queries/ocaml_interface/injections.scm
new file mode 100644
index 0000000..6d3dfbc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ocaml_interface/injections.scm
@@ -0,0 +1 @@
+; inherits: ocaml
diff --git a/pack/ant/start/nvim-treesitter/queries/ocaml_interface/locals.scm b/pack/ant/start/nvim-treesitter/queries/ocaml_interface/locals.scm
new file mode 100644
index 0000000..6d3dfbc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ocaml_interface/locals.scm
@@ -0,0 +1 @@
+; inherits: ocaml
diff --git a/pack/ant/start/nvim-treesitter/queries/ocamllex/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ocamllex/highlights.scm
new file mode 100644
index 0000000..2556aa4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ocamllex/highlights.scm
@@ -0,0 +1,70 @@
+; Allow OCaml highlighter
+(ocaml) @none
+
+; Regular expressions
+(regexp_name) @variable
+
+[
+  (eof)
+  (any)
+] @constant
+
+(character) @character
+
+(string) @string
+
+(escape_sequence) @string.escape
+
+(character_set
+  "^" @punctuation.special)
+
+(character_range
+  "-" @punctuation.delimiter)
+
+(regexp_difference
+  "#" @operator)
+
+(regexp_repetition
+  [
+    "?"
+    "*"
+    "+"
+  ] @operator)
+
+(regexp_alternative
+  "|" @operator)
+
+; Rules
+(lexer_entry_name) @function
+
+(lexer_argument) @variable.parameter
+
+(lexer_entry
+  [
+    "="
+    "|"
+  ] @punctuation.delimiter)
+
+; keywords
+[
+  "and"
+  "as"
+  "let"
+  "parse"
+  "refill"
+  "rule"
+  "shortest"
+] @keyword
+
+; Punctuation
+[
+  "["
+  "]"
+  "("
+  ")"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; Misc
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/ocamllex/injections.scm b/pack/ant/start/nvim-treesitter/queries/ocamllex/injections.scm
new file mode 100644
index 0000000..ecc577d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ocamllex/injections.scm
@@ -0,0 +1,5 @@
+((ocaml) @injection.content
+  (#set! injection.language "ocaml"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/odin/folds.scm b/pack/ant/start/nvim-treesitter/queries/odin/folds.scm
new file mode 100644
index 0000000..5367cb5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/odin/folds.scm
@@ -0,0 +1,7 @@
+[
+  (declaration)
+  (statement)
+  (else_when_clause)
+  (else_if_clause)
+  (else_clause)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/odin/highlights.scm b/pack/ant/start/nvim-treesitter/queries/odin/highlights.scm
new file mode 100644
index 0000000..b7e2176
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/odin/highlights.scm
@@ -0,0 +1,350 @@
+; Preprocs
+[
+  (calling_convention)
+  (tag)
+] @keyword.directive
+
+; Includes
+[
+  "import"
+  "package"
+] @keyword.import
+
+; Keywords
+[
+  "foreign"
+  "using"
+  "defer"
+  "cast"
+  "transmute"
+  "auto_cast"
+  "map"
+  "bit_set"
+  "matrix"
+] @keyword
+
+[
+  "struct"
+  "enum"
+  "union"
+  "bit_field"
+] @keyword.type
+
+"proc" @keyword.function
+
+[
+  "return"
+  "or_return"
+] @keyword.return
+
+[
+  "distinct"
+  "dynamic"
+] @keyword.modifier
+
+; Conditionals
+[
+  "if"
+  "else"
+  "when"
+  "switch"
+  "case"
+  "where"
+  "break"
+  "or_break"
+  "or_continue"
+  (fallthrough_statement)
+] @keyword.conditional
+
+((ternary_expression
+  [
+    "?"
+    ":"
+    "if"
+    "else"
+    "when"
+  ] @keyword.conditional.ternary)
+  (#set! priority 105))
+
+; Repeats
+[
+  "for"
+  "do"
+  "continue"
+] @keyword.repeat
+
+; Variables
+(identifier) @variable
+
+; Namespaces
+(package_declaration
+  (identifier) @module)
+
+(import_declaration
+  alias: (identifier) @module)
+
+(foreign_block
+  (identifier) @module)
+
+(using_statement
+  (identifier) @module)
+
+; Parameters
+(parameter
+  (identifier) @variable.parameter
+  ":"
+  "="?
+  (identifier)? @constant)
+
+(default_parameter
+  (identifier) @variable.parameter
+  ":=")
+
+(named_type
+  (identifier) @variable.parameter)
+
+(call_expression
+  argument: (identifier) @variable.parameter
+  "=")
+
+; Functions
+(procedure_declaration
+  (identifier) @type)
+
+(procedure_declaration
+  (identifier) @function
+  (procedure
+    (block)))
+
+(procedure_declaration
+  (identifier) @function
+  (procedure
+    (uninitialized)))
+
+(overloaded_procedure_declaration
+  (identifier) @function)
+
+(call_expression
+  function: (identifier) @function.call)
+
+; Types
+(type
+  (identifier) @type)
+
+((type
+  (identifier) @type.builtin)
+  (#any-of? @type.builtin
+    "bool" "byte" "b8" "b16" "b32" "b64" "int" "i8" "i16" "i32" "i64" "i128" "uint" "u8" "u16" "u32"
+    "u64" "u128" "uintptr" "i16le" "i32le" "i64le" "i128le" "u16le" "u32le" "u64le" "u128le" "i16be"
+    "i32be" "i64be" "i128be" "u16be" "u32be" "u64be" "u128be" "float" "double" "f16" "f32" "f64"
+    "f16le" "f32le" "f64le" "f16be" "f32be" "f64be" "complex32" "complex64" "complex128"
+    "complex_float" "complex_double" "quaternion64" "quaternion128" "quaternion256" "rune" "string"
+    "cstring" "rawptr" "typeid" "any"))
+
+"..." @type.builtin
+
+(struct_declaration
+  (identifier) @type
+  "::")
+
+(enum_declaration
+  (identifier) @type
+  "::")
+
+(union_declaration
+  (identifier) @type
+  "::")
+
+(bit_field_declaration
+  (identifier) @type
+  "::")
+
+(const_declaration
+  (identifier) @type
+  "::"
+  [
+    (array_type)
+    (distinct_type)
+    (bit_set_type)
+    (pointer_type)
+  ])
+
+(struct
+  .
+  (identifier) @type)
+
+(field_type
+  .
+  (identifier) @module
+  "."
+  (identifier) @type)
+
+(bit_set_type
+  (identifier) @type
+  ";")
+
+(procedure_type
+  (parameters
+    (parameter
+      (identifier) @type)))
+
+(polymorphic_parameters
+  (identifier) @type)
+
+((identifier) @type
+  (#lua-match? @type "^[_A-Z][_a-zA-Z0-9]*$")
+  (#not-has-parent? @type parameter procedure_declaration call_expression))
+
+; Fields
+(member_expression
+  "."
+  (identifier) @variable.member)
+
+(struct_type
+  "{"
+  (identifier) @variable.member)
+
+(struct_field
+  (identifier) @variable.member
+  "="?)
+
+(field
+  (identifier) @variable.member)
+
+; Constants
+((identifier) @constant
+  (#lua-match? @constant "^_*[A-Z][A-Z0-9_]*$")
+  (#not-has-parent? @constant type parameter))
+
+(member_expression
+  .
+  "."
+  (identifier) @constant)
+
+(enum_declaration
+  "{"
+  (identifier) @constant)
+
+; Macros
+((call_expression
+  function: (identifier) @function.macro)
+  (#lua-match? @function.macro "^_*[A-Z][A-Z0-9_]*$"))
+
+; Attributes
+(attribute
+  (identifier) @attribute
+  "="?)
+
+; Labels
+(label_statement
+  (identifier) @label
+  ":")
+
+; Literals
+(number) @number
+
+(float) @number.float
+
+(string) @string
+
+(character) @character
+
+(escape_sequence) @string.escape
+
+(boolean) @boolean
+
+[
+  (uninitialized)
+  (nil)
+] @constant.builtin
+
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin "context" "self"))
+
+; Operators
+[
+  ":="
+  "="
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "%%"
+  ">"
+  ">="
+  "<"
+  "<="
+  "=="
+  "!="
+  "~="
+  "|"
+  "~"
+  "&"
+  "&~"
+  "<<"
+  ">>"
+  "||"
+  "&&"
+  "!"
+  "^"
+  ".."
+  "+="
+  "-="
+  "*="
+  "/="
+  "%="
+  "&="
+  "|="
+  "^="
+  "<<="
+  ">>="
+  "||="
+  "&&="
+  "&~="
+  "..="
+  "..<"
+  "?"
+] @operator
+
+[
+  "or_else"
+  "in"
+  "not_in"
+] @keyword.operator
+
+; Punctuation
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "::"
+  "->"
+  "."
+  ","
+  ":"
+  ";"
+] @punctuation.delimiter
+
+[
+  "@"
+  "$"
+] @punctuation.special
+
+; Comments
+[
+  (comment)
+  (block_comment)
+] @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/odin/indents.scm b/pack/ant/start/nvim-treesitter/queries/odin/indents.scm
new file mode 100644
index 0000000..9c86329
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/odin/indents.scm
@@ -0,0 +1,46 @@
+[
+  (block)
+  (enum_declaration)
+  (union_declaration)
+  (bit_field_declaration)
+  (struct_declaration)
+  (struct)
+  (parameters)
+  (tuple_type)
+  (call_expression)
+  (switch_case)
+] @indent.begin
+
+; hello(
+((identifier)
+  .
+  (ERROR
+    "(" @indent.begin))
+
+[
+  ")"
+  "]"
+] @indent.branch @indent.end
+
+; Have to do all closing brackets separately because the one for switch statements shouldn't end.
+(block
+  "}" @indent.branch @indent.end)
+
+(enum_declaration
+  "}" @indent.branch @indent.end)
+
+(union_declaration
+  "}" @indent.branch @indent.end)
+
+(struct_declaration
+  "}" @indent.branch @indent.end)
+
+(struct
+  "}" @indent.branch @indent.end)
+
+[
+  (comment)
+  (block_comment)
+  (string)
+  (ERROR)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/odin/injections.scm b/pack/ant/start/nvim-treesitter/queries/odin/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/odin/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/odin/locals.scm b/pack/ant/start/nvim-treesitter/queries/odin/locals.scm
new file mode 100644
index 0000000..3e794b2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/odin/locals.scm
@@ -0,0 +1,63 @@
+; Scopes
+[
+  (block)
+  (declaration)
+  (statement)
+] @local.scope
+
+; References
+(identifier) @local.reference
+
+; Definitions
+(package_declaration
+  (identifier) @local.definition.namespace)
+
+(import_declaration
+  alias: (identifier) @local.definition.namespace)
+
+(procedure_declaration
+  (identifier) @local.definition.function)
+
+(struct_declaration
+  (identifier) @local.definition.type
+  "::")
+
+(enum_declaration
+  (identifier) @local.definition.enum
+  "::")
+
+(union_declaration
+  (identifier) @local.definition.type
+  "::")
+
+(bit_field_declaration
+  (identifier) @local.definition.type
+  "::")
+
+(variable_declaration
+  (identifier) @local.definition.var
+  ":=")
+
+(const_declaration
+  (identifier) @local.definition.constant
+  "::")
+
+(const_type_declaration
+  (identifier) @local.definition.type
+  ":")
+
+(parameter
+  (identifier) @local.definition.parameter
+  ":"?)
+
+(default_parameter
+  (identifier) @local.definition.parameter
+  ":=")
+
+(field
+  (identifier) @local.definition.field
+  ":")
+
+(label_statement
+  (identifier) @local.definition
+  ":")
diff --git a/pack/ant/start/nvim-treesitter/queries/pascal/folds.scm b/pack/ant/start/nvim-treesitter/queries/pascal/folds.scm
new file mode 100644
index 0000000..8fcde3a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pascal/folds.scm
@@ -0,0 +1,31 @@
+[
+  (interface)
+  (implementation)
+  (initialization)
+  (finalization)
+  (if)
+  (ifElse)
+  (while)
+  (repeat)
+  (for)
+  (foreach)
+  (try)
+  (case)
+  (caseCase)
+  (asm)
+  (with)
+  (declVar)
+  (declConst)
+  (declEnum)
+  (declProcRef)
+  (declExports)
+  (declProcRef)
+  (declType)
+  (defProc)
+  (declField)
+  (declProp)
+  (comment)
+] @fold
+
+(interface
+  (declProc) @fold)
diff --git a/pack/ant/start/nvim-treesitter/queries/pascal/highlights.scm b/pack/ant/start/nvim-treesitter/queries/pascal/highlights.scm
new file mode 100644
index 0000000..d6014ee
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pascal/highlights.scm
@@ -0,0 +1,524 @@
+; -- Keywords
+[
+  (kProgram)
+  (kLibrary)
+  (kUnit)
+  (kBegin)
+  (kEnd)
+  (kAsm)
+  (kVar)
+  (kThreadvar)
+  (kConst)
+  (kConstref)
+  (kResourcestring)
+  (kOut)
+  (kType)
+  (kLabel)
+  (kExports)
+  (kProperty)
+  (kRead)
+  (kWrite)
+  (kImplements)
+  (kClass)
+  (kInterface)
+  (kObject)
+  (kRecord)
+  (kObjcclass)
+  (kObjccategory)
+  (kObjcprotocol)
+  (kArray)
+  (kFile)
+  (kString)
+  (kSet)
+  (kOf)
+  (kHelper)
+  (kInherited)
+  (kGeneric)
+  (kSpecialize)
+  (kFunction)
+  (kProcedure)
+  (kConstructor)
+  (kDestructor)
+  (kOperator)
+  (kReference)
+  (kInterface)
+  (kImplementation)
+  (kInitialization)
+  (kFinalization)
+  (kTry)
+  (kExcept)
+  (kFinally)
+  (kRaise)
+  (kOn)
+  (kCase)
+  (kWith)
+  (kGoto)
+] @keyword
+
+[
+  (kFor)
+  (kTo)
+  (kDownto)
+  (kDo)
+  (kWhile)
+  (kRepeat)
+  (kUntil)
+] @keyword.repeat
+
+[
+  (kIf)
+  (kThen)
+  (kElse)
+] @keyword.conditional
+
+[
+  (kPublished)
+  (kPublic)
+  (kProtected)
+  (kPrivate)
+  (kStrict)
+  (kRequired)
+  (kOptional)
+] @keyword.modifier
+
+[
+  (kPacked)
+  (kAbsolute)
+] @keyword.modifier
+
+(kUses) @keyword.import
+
+; -- Attributes
+[
+  (kDefault)
+  (kIndex)
+  (kNodefault)
+  (kStored)
+  (kStatic)
+  (kVirtual)
+  (kAbstract)
+  (kSealed)
+  (kDynamic)
+  (kOverride)
+  (kOverload)
+  (kReintroduce)
+  (kInline)
+  (kForward)
+  (kStdcall)
+  (kCdecl)
+  (kCppdecl)
+  (kPascal)
+  (kRegister)
+  (kMwpascal)
+  (kExternal)
+  (kName)
+  (kMessage)
+  (kDeprecated)
+  (kExperimental)
+  (kPlatform)
+  (kUnimplemented)
+  (kCvar)
+  (kExport)
+  (kFar)
+  (kNear)
+  (kSafecall)
+  (kAssembler)
+  (kNostackframe)
+  (kInterrupt)
+  (kNoreturn)
+  (kIocheck)
+  (kLocal)
+  (kHardfloat)
+  (kSoftfloat)
+  (kMs_abi_default)
+  (kMs_abi_cdecl)
+  (kSaveregisters)
+  (kSysv_abi_default)
+  (kSysv_abi_cdecl)
+  (kVectorcall)
+  (kVarargs)
+  (kWinapi)
+  (kAlias)
+  (kDelayed)
+  (rttiAttributes)
+  (procAttribute)
+] @attribute
+
+(procAttribute
+  (kPublic) @attribute)
+
+; -- Punctuation & operators
+[
+  "("
+  ")"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ";"
+  ","
+  ":"
+  (kEndDot)
+] @punctuation.delimiter
+
+".." @punctuation.special
+
+[
+  (kDot)
+  (kAdd)
+  (kSub)
+  (kMul)
+  (kFdiv)
+  (kAssign)
+  (kAssignAdd)
+  (kAssignSub)
+  (kAssignMul)
+  (kAssignDiv)
+  (kEq)
+  (kLt)
+  (kLte)
+  (kGt)
+  (kGte)
+  (kNeq)
+  (kAt)
+  (kHat)
+] @operator
+
+[
+  (kOr)
+  (kXor)
+  (kDiv)
+  (kMod)
+  (kAnd)
+  (kShl)
+  (kShr)
+  (kNot)
+  (kIs)
+  (kAs)
+  (kIn)
+] @keyword.operator
+
+; -- Builtin constants
+[
+  (kTrue)
+  (kFalse)
+] @boolean
+
+(kNil) @constant.builtin
+
+; -- Literals
+(literalNumber) @number
+
+(literalString) @string
+
+; -- Variables
+(exprBinary
+  (identifier) @variable)
+
+(exprUnary
+  (identifier) @variable)
+
+(assignment
+  (identifier) @variable)
+
+(exprBrackets
+  (identifier) @variable)
+
+(exprParens
+  (identifier) @variable)
+
+(exprDot
+  (identifier) @variable)
+
+(exprTpl
+  (identifier) @variable)
+
+(exprArgs
+  (identifier) @variable)
+
+(defaultValue
+  (identifier) @variable)
+
+; -- Comments
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^///[^/]"))
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^///$"))
+
+((comment) @comment.documentation
+  .
+  [
+    (unit)
+    (declProc)
+  ])
+
+(declTypes
+  (comment) @comment.documentation
+  .
+  (declType))
+
+(declSection
+  (comment) @comment.documentation
+  .
+  [
+    (declField)
+    (declProc)
+  ])
+
+(declEnum
+  (comment) @comment.documentation
+  .
+  (declEnumValue))
+
+(declConsts
+  (comment) @comment.documentation
+  .
+  (declConst))
+
+(declVars
+  (comment) @comment.documentation
+  .
+  (declVar))
+
+(pp) @keyword.directive
+
+; -- Type declaration
+(declType
+  name: (identifier) @type)
+
+(declType
+  name: (genericTpl
+    entity: (identifier) @type))
+
+; -- Procedure & function declarations
+; foobar
+(declProc
+  name: (identifier) @function)
+
+; foobar<t>
+(declProc
+  name: (genericTpl
+    entity: (identifier) @function))
+
+; foo.bar
+(declProc
+  name: (genericDot
+    rhs: (identifier) @function))
+
+; foo.bar<t>
+(declProc
+  name: (genericDot
+    rhs: (genericTpl
+      entity: (identifier) @function)))
+
+; Treat property declarations like functions
+(declProp
+  name: (identifier) @function)
+
+(declProp
+  getter: (identifier) @variable.member)
+
+(declProp
+  setter: (identifier) @variable.member)
+
+; -- Function parameters
+(declArg
+  name: (identifier) @variable.parameter)
+
+; -- Template parameters
+(genericArg
+  name: (identifier) @variable.parameter)
+
+(genericArg
+  type: (typeref) @type)
+
+(declProc
+  name: (genericDot
+    lhs: (identifier) @type))
+
+(declType
+  (genericDot
+    (identifier) @type))
+
+(genericDot
+  (genericTpl
+    (identifier) @type))
+
+(genericDot
+  (genericDot
+    (identifier) @type))
+
+(genericTpl
+  entity: (identifier) @type)
+
+(genericTpl
+  entity: (genericDot
+    (identifier) @type))
+
+; -- Exception parameters
+(exceptionHandler
+  variable: (identifier) @variable.parameter)
+
+; -- Type usage
+(typeref) @type
+
+; -- Constant usage
+[
+  (caseLabel)
+  (label)
+] @constant
+
+(procAttribute
+  (identifier) @constant)
+
+(procExternal
+  (identifier) @constant)
+
+; -- Variable & constant declarations
+; (This is only questionable because we cannot detect types of identifiers
+; declared in other units, so the results will be inconsistent)
+(declVar
+  name: (identifier) @variable)
+
+(declConst
+  name: (identifier) @constant)
+
+(declEnumValue
+  name: (identifier) @constant)
+
+; -- Fields
+(exprDot
+  rhs: (identifier) @variable.member)
+
+(exprDot
+  rhs: (exprDot) @variable.member)
+
+(declClass
+  (declField
+    name: (identifier) @variable.member))
+
+(declSection
+  (declField
+    name: (identifier) @variable.member))
+
+(declSection
+  (declVars
+    (declVar
+      name: (identifier) @variable.member)))
+
+(recInitializerField
+  name: (identifier) @variable.member)
+
+; ---------------------------------------------- ;;;
+; EVERYTHING BELOW THIS IS OF QUESTIONABLE VALUE ;;;
+; ---------------------------------------------- ;;;
+; -- Procedure name in calls with parentheses
+; (Pascal doesn't require parentheses for procedure calls, so this will not
+; detect all calls)
+; foobar
+(exprCall
+  entity: (identifier) @function)
+
+; foobar<t>
+(exprCall
+  entity: (exprTpl
+    entity: (identifier) @function))
+
+; foo.bar
+(exprCall
+  entity: (exprDot
+    rhs: (identifier) @function))
+
+; foo.bar<t>
+(exprCall
+  entity: (exprDot
+    rhs: (exprTpl
+      entity: (identifier) @function)))
+
+(inherited) @function
+
+; -- Heuristic for procedure/function calls without parentheses
+; (If a statement consists only of an identifier, assume it's a procedure)
+; (This will still not match all procedure calls, and also may produce false
+; positives in rare cases, but only for nonsensical code)
+(statement
+  (identifier) @function)
+
+(statement
+  (exprDot
+    rhs: (identifier) @function))
+
+(statement
+  (exprTpl
+    entity: (identifier) @function))
+
+(statement
+  (exprDot
+    rhs: (exprTpl
+      entity: (identifier) @function)))
+
+; -- Break, Continue & Exit
+; (Not ideal: ideally, there would be a way to check if these special
+; identifiers are shadowed by a local variable)
+(statement
+  ((identifier) @keyword.return
+    (#lua-match? @keyword.return "^[eE][xX][iI][tT]$")))
+
+(statement
+  (exprCall
+    entity: ((identifier) @keyword.return
+      (#lua-match? @keyword.return "^[eE][xX][iI][tT]$"))))
+
+(statement
+  ((identifier) @keyword.repeat
+    (#lua-match? @keyword.repeat "^[bB][rR][eE][aA][kK]$")))
+
+(statement
+  ((identifier) @keyword.repeat
+    (#lua-match? @keyword.repeat "^[cC][oO][nN][tT][iI][nN][uU][eE]$")))
+
+; -- Identifier type inference
+; VERY QUESTIONABLE: Highlighting of identifiers based on spelling
+(exprBinary
+  ((identifier) @constant
+    (#match? @constant "^[A-Z][A-Z0-9_]+$|^[a-z]{2,3}[A-Z].+$")))
+
+(exprUnary
+  ((identifier) @constant
+    (#match? @constant "^[A-Z][A-Z0-9_]+$|^[a-z]{2,3}[A-Z].+$")))
+
+(assignment
+  rhs: ((identifier) @constant
+    (#match? @constant "^[A-Z][A-Z0-9_]+$|^[a-z]{2,3}[A-Z].+$")))
+
+(exprBrackets
+  ((identifier) @constant
+    (#match? @constant "^[A-Z][A-Z0-9_]+$|^[a-z]{2,3}[A-Z].+$")))
+
+(exprParens
+  ((identifier) @constant
+    (#match? @constant "^[A-Z][A-Z0-9_]+$|^[a-z]{2,3}[A-Z].+$")))
+
+(exprDot
+  rhs: ((identifier) @constant
+    (#match? @constant "^[A-Z][A-Z0-9_]+$|^[a-z]{2,3}[A-Z].+$")))
+
+(exprTpl
+  args: ((identifier) @constant
+    (#match? @constant "^[A-Z][A-Z0-9_]+$|^[a-z]{2,3}[A-Z].+$")))
+
+(exprArgs
+  ((identifier) @constant
+    (#match? @constant "^[A-Z][A-Z0-9_]+$|^[a-z]{2,3}[A-Z].+$")))
+
+(declEnumValue
+  ((identifier) @constant
+    (#match? @constant "^[A-Z][A-Z0-9_]+$|^[a-z]{2,3}[A-Z].+$")))
+
+(defaultValue
+  ((identifier) @constant
+    (#match? @constant "^[A-Z][A-Z0-9_]+$|^[a-z]{2,3}[A-Z].+$")))
diff --git a/pack/ant/start/nvim-treesitter/queries/pascal/indents.scm b/pack/ant/start/nvim-treesitter/queries/pascal/indents.scm
new file mode 100644
index 0000000..879e7b8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pascal/indents.scm
@@ -0,0 +1,33 @@
+[
+  (statement)
+  (declVars)
+  (declConsts)
+  (declTypes)
+  (declProc)
+  (declArgs)
+  (declUses)
+  (declClass)
+  (exprArgs)
+  (exprSubscript)
+  (exprBrackets)
+  (exprParens)
+  (recInitializer)
+  (arrInitializer)
+  (defaultValue)
+] @indent.begin
+
+(defProc
+  (block) @indent.begin)
+
+[
+  (kEnd)
+  (kFinally)
+  (kDo)
+  (kUntil)
+  (kExcept)
+  (kElse)
+  (kThen)
+  (declSection)
+  "]"
+  ")"
+] @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/pascal/injections.scm b/pack/ant/start/nvim-treesitter/queries/pascal/injections.scm
new file mode 100644
index 0000000..f46e4b3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pascal/injections.scm
@@ -0,0 +1,7 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; There is no parser for assembly language yet. Add an injection here when we
+; have a parser.
+; ((asmBody) @injection.content
+;  (#set! injection.language "asm"))
diff --git a/pack/ant/start/nvim-treesitter/queries/pascal/locals.scm b/pack/ant/start/nvim-treesitter/queries/pascal/locals.scm
new file mode 100644
index 0000000..d74d54a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pascal/locals.scm
@@ -0,0 +1,54 @@
+(root) @local.scope
+
+(defProc) @local.scope
+
+(lambda) @local.scope
+
+(interface
+  (declProc) @local.scope)
+
+(declSection
+  (declProc) @local.scope)
+
+(declClass
+  (declProc) @local.scope)
+
+(declHelper
+  (declProc) @local.scope)
+
+(declProcRef) @local.scope
+
+(exceptionHandler) @local.scope
+
+(exceptionHandler
+  variable: (identifier) @local.definition)
+
+(declArg
+  name: (identifier) @local.definition)
+
+(declVar
+  name: (identifier) @local.definition)
+
+(declConst
+  name: (identifier) @local.definition)
+
+(declLabel
+  name: (identifier) @local.definition)
+
+(genericArg
+  name: (identifier) @local.definition)
+
+(declEnumValue
+  name: (identifier) @local.definition)
+
+(declType
+  name: (identifier) @local.definition)
+
+(declType
+  name: (genericTpl
+    entity: (identifier) @local.definition))
+
+(declProc
+  name: (identifier) @local.definition)
+
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/passwd/highlights.scm b/pack/ant/start/nvim-treesitter/queries/passwd/highlights.scm
new file mode 100644
index 0000000..51bb8fc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/passwd/highlights.scm
@@ -0,0 +1,16 @@
+(user) @module
+
+(auth) @string.special.symbol
+
+(gecos) @string
+
+(home) @string.special.path
+
+(shell) @string.special.path
+
+[
+  (gid)
+  (uid)
+] @number
+
+(separator) @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/pem/folds.scm b/pack/ant/start/nvim-treesitter/queries/pem/folds.scm
new file mode 100644
index 0000000..f0cdabd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pem/folds.scm
@@ -0,0 +1 @@
+(content) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/pem/highlights.scm b/pack/ant/start/nvim-treesitter/queries/pem/highlights.scm
new file mode 100644
index 0000000..b8dbb0f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pem/highlights.scm
@@ -0,0 +1,12 @@
+[
+  "BEGIN"
+  "END"
+] @keyword
+
+(dashes) @punctuation.delimiter
+
+(label) @label
+
+(data) @none
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/pem/injections.scm b/pack/ant/start/nvim-treesitter/queries/pem/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pem/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/perl/folds.scm b/pack/ant/start/nvim-treesitter/queries/perl/folds.scm
new file mode 100644
index 0000000..a457a0a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/perl/folds.scm
@@ -0,0 +1,36 @@
+(comment)+ @fold
+
+(pod) @fold
+
+; fold the block-typed package and class statements only
+(package_statement
+  (block)) @fold
+
+(class_statement
+  (block)) @fold
+
+[
+  (subroutine_declaration_statement)
+  (method_declaration_statement)
+  (conditional_statement)
+  (loop_statement)
+  (for_statement)
+  (cstyle_for_statement)
+  (block_statement)
+  (defer_statement)
+  (phaser_statement)
+] @fold
+
+(try_statement
+  (block) @fold)
+
+(eval_expression
+  (block) @fold)
+
+(anonymous_subroutine_expression) @fold
+
+; perhaps folks want to fold these too?
+[
+  (anonymous_array_expression)
+  (anonymous_hash_expression)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/perl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/perl/highlights.scm
new file mode 100644
index 0000000..554743b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/perl/highlights.scm
@@ -0,0 +1,309 @@
+((source_file
+  .
+  (comment) @keyword.directive @nospell)
+  (#lua-match? @keyword.directive "^#!/"))
+
+[
+  "use"
+  "no"
+  "require"
+] @keyword.import
+
+[
+  "if"
+  "elsif"
+  "unless"
+  "else"
+] @keyword.conditional
+
+(conditional_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+[
+  "while"
+  "until"
+  "for"
+  "foreach"
+] @keyword.repeat
+
+("continue" @keyword.repeat
+  (block))
+
+[
+  "try"
+  "catch"
+  "finally"
+] @keyword.exception
+
+"return" @keyword.return
+
+[
+  "sub"
+  "method"
+] @keyword.function
+
+[
+  "async"
+  "await"
+] @keyword.coroutine
+
+[
+  "map"
+  "grep"
+  "sort"
+] @function.builtin
+
+[
+  "package"
+  "class"
+  "role"
+] @keyword.import
+
+[
+  "defer"
+  "do"
+  "eval"
+  "my"
+  "our"
+  "local"
+  "dynamically"
+  "state"
+  "field"
+  "last"
+  "next"
+  "redo"
+  "goto"
+  "undef"
+] @keyword
+
+(_
+  operator: _ @operator)
+
+"\\" @operator
+
+(yadayada) @keyword.exception
+
+(phaser_statement
+  phase: _ @keyword)
+
+(class_phaser_statement
+  phase: _ @keyword)
+
+[
+  "or"
+  "xor"
+  "and"
+  "eq"
+  "equ"
+  "eqr"
+  "ne"
+  "cmp"
+  "lt"
+  "le"
+  "ge"
+  "gt"
+  "isa"
+] @keyword.operator
+
+(eof_marker) @keyword.directive
+
+(data_section) @comment
+
+(pod) @none
+
+[
+  (number)
+  (version)
+] @number
+
+(boolean) @boolean
+
+[
+  (string_literal)
+  (interpolated_string_literal)
+  (quoted_word_list)
+  (command_string)
+  (heredoc_content)
+  (replacement)
+  (transliteration_content)
+] @string
+
+[
+  (heredoc_token)
+  (command_heredoc_token)
+  (heredoc_end)
+] @label
+
+[
+  (escape_sequence)
+  (escaped_delimiter)
+] @string.escape
+
+(_
+  modifiers: _ @character.special)
+
+[
+  (quoted_regexp)
+  (match_regexp)
+  (regexp_content)
+] @string.regexp
+
+(autoquoted_bareword) @string.special
+
+(use_statement
+  (package) @type)
+
+(package_statement
+  (package) @type)
+
+(class_statement
+  (package) @type)
+
+(require_expression
+  (bareword) @type)
+
+(subroutine_declaration_statement
+  name: (bareword) @function)
+
+(method_declaration_statement
+  name: (bareword) @function)
+
+(attribute_name) @attribute
+
+(attribute_value) @string
+
+(label) @label
+
+(statement_label
+  label: _ @label)
+
+(relational_expression
+  operator: "isa"
+  right: (bareword) @type)
+
+(function_call_expression
+  (function) @function.call)
+
+(method_call_expression
+  (method) @function.method.call)
+
+(method_call_expression
+  invocant: (bareword) @type)
+
+(func0op_call_expression
+  function: _ @function.builtin)
+
+(func1op_call_expression
+  function: _ @function.builtin)
+
+; this was a regex for the CLI
+([
+  (function)
+  (expression_statement
+    (bareword))
+] @function.builtin
+  (#any-of? @function.builtin
+    "accept" "atan2" "bind" "binmode" "bless" "crypt" "chmod" "chown" "connect" "die" "dbmopen"
+    "exec" "fcntl" "flock" "formline" "getpriority" "getprotobynumber" "gethostbyaddr"
+    "getnetbyaddr" "getservbyname" "getservbyport" "getsockopt" "glob" "index" "ioctl" "join" "kill"
+    "link" "listen" "mkdir" "msgctl" "msgget" "msgrcv" "msgsend" "open" "opendir" "print" "printf"
+    "push" "pack" "pipe" "return" "rename" "rindex" "read" "recv" "reverse" "say" "select" "seek"
+    "semctl" "semget" "semop" "send" "setpgrp" "setpriority" "seekdir" "setsockopt" "shmctl"
+    "shmread" "shmwrite" "shutdown" "socket" "socketpair" "split" "sprintf" "splice" "substr"
+    "system" "symlink" "syscall" "sysopen" "sysseek" "sysread" "syswrite" "tie" "truncate" "unlink"
+    "unpack" "utime" "unshift" "vec" "warn" "waitpid"))
+
+(function) @function
+
+(_
+  "{" @punctuation.special
+  (varname)
+  "}" @punctuation.special)
+
+(varname
+  (block
+    "{" @punctuation.special
+    "}" @punctuation.special))
+
+([
+  (varname)
+  (filehandle)
+] @variable.builtin
+  (#any-of? @variable.builtin
+    "ENV" "ARGV" "INC" "ARGVOUT" "SIG" "STDIN" "STDOUT" "STDERR" "a" "b" "_"))
+
+((varname) @variable.builtin
+  ; highlights all the reserved ^ vars like ${^THINGS}
+  (#lua-match? @variable.builtin "%^"))
+
+((varname) @variable.builtin
+  ; highlights punc vars and also numeric only like $11
+  (#lua-match? @variable.builtin "^%A+$"))
+
+(scalar) @variable
+
+(scalar_deref_expression
+  [
+    "$"
+    "*"
+  ] @variable)
+
+[
+  (array)
+  (arraylen)
+] @variable
+
+(array_deref_expression
+  [
+    "@"
+    "*"
+  ] @variable)
+
+(hash) @variable
+
+(hash_deref_expression
+  [
+    "%"
+    "*"
+  ] @variable)
+
+(array_element_expression
+  array: (_) @variable)
+
+(slice_expression
+  array: (_) @variable)
+
+(keyval_expression
+  array: (_) @variable)
+
+(hash_element_expression
+  hash: (_) @variable)
+
+(slice_expression
+  hash: (_) @variable)
+
+(keyval_expression
+  hash: (_) @variable)
+
+(comment) @comment @spell
+
+[
+  "=>"
+  ","
+  ";"
+  "->"
+] @punctuation.delimiter
+
+([
+  "["
+  "]"
+  "{"
+  "}"
+  "("
+  ")"
+] @punctuation.bracket
+  ; priority hack so nvim + ts-cli behave the same
+  (#set! priority 90))
diff --git a/pack/ant/start/nvim-treesitter/queries/perl/injections.scm b/pack/ant/start/nvim-treesitter/queries/perl/injections.scm
new file mode 100644
index 0000000..48e6363
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/perl/injections.scm
@@ -0,0 +1,14 @@
+; an injections.scm file for nvim-treesitter
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((pod) @injection.content
+  (#set! injection.language "pod"))
+
+((substitution_regexp
+  (replacement) @injection.content
+  (substitution_regexp_modifiers) @_modifiers)
+  ; match if there's a single `e` in the modifiers list
+  (#lua-match? @_modifiers "e")
+  (#not-lua-match? @_modifiers "e.*e")
+  (#set! injection.language "perl"))
diff --git a/pack/ant/start/nvim-treesitter/queries/php/folds.scm b/pack/ant/start/nvim-treesitter/queries/php/folds.scm
new file mode 100644
index 0000000..f324638
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/php/folds.scm
@@ -0,0 +1 @@
+; inherits: php_only
diff --git a/pack/ant/start/nvim-treesitter/queries/php/highlights.scm b/pack/ant/start/nvim-treesitter/queries/php/highlights.scm
new file mode 100644
index 0000000..f324638
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/php/highlights.scm
@@ -0,0 +1 @@
+; inherits: php_only
diff --git a/pack/ant/start/nvim-treesitter/queries/php/indents.scm b/pack/ant/start/nvim-treesitter/queries/php/indents.scm
new file mode 100644
index 0000000..f324638
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/php/indents.scm
@@ -0,0 +1 @@
+; inherits: php_only
diff --git a/pack/ant/start/nvim-treesitter/queries/php/injections.scm b/pack/ant/start/nvim-treesitter/queries/php/injections.scm
new file mode 100644
index 0000000..3ccbb2b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/php/injections.scm
@@ -0,0 +1,5 @@
+; inherits: php_only
+
+((text) @injection.content
+  (#set! injection.language "html")
+  (#set! injection.combined))
diff --git a/pack/ant/start/nvim-treesitter/queries/php/locals.scm b/pack/ant/start/nvim-treesitter/queries/php/locals.scm
new file mode 100644
index 0000000..f324638
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/php/locals.scm
@@ -0,0 +1 @@
+; inherits: php_only
diff --git a/pack/ant/start/nvim-treesitter/queries/php_only/folds.scm b/pack/ant/start/nvim-treesitter/queries/php_only/folds.scm
new file mode 100644
index 0000000..43453b1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/php_only/folds.scm
@@ -0,0 +1,17 @@
+[
+  (if_statement)
+  (switch_statement)
+  (while_statement)
+  (do_statement)
+  (for_statement)
+  (foreach_statement)
+  (try_statement)
+  (function_definition)
+  (class_declaration)
+  (interface_declaration)
+  (trait_declaration)
+  (enum_declaration)
+  (function_static_declaration)
+  (method_declaration)
+  (namespace_use_declaration)+
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/php_only/highlights.scm b/pack/ant/start/nvim-treesitter/queries/php_only/highlights.scm
new file mode 100644
index 0000000..790bd08
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/php_only/highlights.scm
@@ -0,0 +1,436 @@
+; Keywords
+[
+  "and"
+  "as"
+  "instanceof"
+  "or"
+  "xor"
+] @keyword.operator
+
+[
+  "fn"
+  "function"
+] @keyword.function
+
+[
+  "clone"
+  "declare"
+  "default"
+  "echo"
+  "enddeclare"
+  "extends"
+  "global"
+  "goto"
+  "implements"
+  "insteadof"
+  "print"
+  "new"
+  "unset"
+] @keyword
+
+[
+  "enum"
+  "class"
+  "interface"
+  "namespace"
+  "trait"
+] @keyword.type
+
+[
+  "abstract"
+  "const"
+  "final"
+  "private"
+  "protected"
+  "public"
+  "readonly"
+  (static_modifier)
+] @keyword.modifier
+
+(function_static_declaration
+  "static" @keyword.modifier)
+
+[
+  "return"
+  "exit"
+  "yield"
+] @keyword.return
+
+(yield_expression
+  "from" @keyword.return)
+
+[
+  "case"
+  "else"
+  "elseif"
+  "endif"
+  "endswitch"
+  "if"
+  "switch"
+  "match"
+  "??"
+] @keyword.conditional
+
+[
+  "break"
+  "continue"
+  "do"
+  "endfor"
+  "endforeach"
+  "endwhile"
+  "for"
+  "foreach"
+  "while"
+] @keyword.repeat
+
+[
+  "catch"
+  "finally"
+  "throw"
+  "try"
+] @keyword.exception
+
+[
+  "include_once"
+  "include"
+  "require_once"
+  "require"
+  "use"
+] @keyword.import
+
+[
+  ","
+  ";"
+  ":"
+  "\\"
+] @punctuation.delimiter
+
+[
+  (php_tag)
+  "?>"
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  "#["
+] @punctuation.bracket
+
+[
+  "="
+  "."
+  "-"
+  "*"
+  "/"
+  "+"
+  "%"
+  "**"
+  "~"
+  "|"
+  "^"
+  "&"
+  "<<"
+  ">>"
+  "<<<"
+  "->"
+  "?->"
+  "=>"
+  "<"
+  "<="
+  ">="
+  ">"
+  "<>"
+  "<=>"
+  "=="
+  "!="
+  "==="
+  "!=="
+  "!"
+  "&&"
+  "||"
+  ".="
+  "-="
+  "+="
+  "*="
+  "/="
+  "%="
+  "**="
+  "&="
+  "|="
+  "^="
+  "<<="
+  ">>="
+  "??="
+  "--"
+  "++"
+  "@"
+  "::"
+] @operator
+
+; Variables
+(variable_name) @variable
+
+; Constants
+((name) @constant
+  (#lua-match? @constant "^_?[A-Z][A-Z%d_]*$"))
+
+((name) @constant.builtin
+  (#lua-match? @constant.builtin "^__[A-Z][A-Z%d_]+__$"))
+
+(const_declaration
+  (const_element
+    (name) @constant))
+
+; Types
+[
+  (primitive_type)
+  (cast_type)
+  (bottom_type)
+] @type.builtin
+
+(named_type
+  [
+    (name) @type
+    (qualified_name
+      (name) @type)
+  ])
+
+(named_type
+  (name) @type.builtin
+  (#any-of? @type.builtin "static" "self"))
+
+(class_declaration
+  name: (name) @type)
+
+(base_clause
+  [
+    (name) @type
+    (qualified_name
+      (name) @type)
+  ])
+
+(enum_declaration
+  name: (name) @type)
+
+(interface_declaration
+  name: (name) @type)
+
+(namespace_use_clause
+  [
+    (name) @type
+    (qualified_name
+      (name) @type)
+    alias: (name) @type.definition
+  ])
+
+(namespace_use_clause
+  type: "function"
+  [
+    (name) @function
+    (qualified_name
+      (name) @function)
+    alias: (name) @function
+  ])
+
+(namespace_use_clause
+  type: "const"
+  [
+    (name) @constant
+    (qualified_name
+      (name) @constant)
+    alias: (name) @constant
+  ])
+
+(class_interface_clause
+  [
+    (name) @type
+    (qualified_name
+      (name) @type)
+  ])
+
+(scoped_call_expression
+  scope: [
+    (name) @type
+    (qualified_name
+      (name) @type)
+  ])
+
+(class_constant_access_expression
+  .
+  [
+    (name) @type
+    (qualified_name
+      (name) @type)
+  ]
+  (name) @constant)
+
+(scoped_property_access_expression
+  scope: [
+    (name) @type
+    (qualified_name
+      (name) @type)
+  ])
+
+(scoped_property_access_expression
+  name: (variable_name) @variable.member)
+
+(trait_declaration
+  name: (name) @type)
+
+(use_declaration
+  (name) @type)
+
+(binary_expression
+  operator: "instanceof"
+  right: [
+    (name) @type
+    (qualified_name
+      (name) @type)
+  ])
+
+; Functions, methods, constructors
+(array_creation_expression
+  "array" @function.builtin)
+
+(list_literal
+  "list" @function.builtin)
+
+(exit_statement
+  "exit" @function.builtin
+  "(")
+
+(method_declaration
+  name: (name) @function.method)
+
+(function_call_expression
+  function: (qualified_name
+    (name) @function.call))
+
+(function_call_expression
+  (name) @function.call)
+
+(scoped_call_expression
+  name: (name) @function.call)
+
+(member_call_expression
+  name: (name) @function.method.call)
+
+(function_definition
+  name: (name) @function)
+
+(nullsafe_member_call_expression
+  name: (name) @function.method)
+
+(use_instead_of_clause
+  (class_constant_access_expression
+    (_)
+    (name) @function.method)
+  (name) @type)
+
+(use_as_clause
+  (class_constant_access_expression
+    (_)
+    (name) @function.method)*
+  (name) @function.method)
+
+(method_declaration
+  name: (name) @constructor
+  (#eq? @constructor "__construct"))
+
+(object_creation_expression
+  [
+    (name) @constructor
+    (qualified_name
+      (name) @constructor)
+  ])
+
+; Parameters
+(variadic_parameter
+  "..." @operator
+  name: (variable_name) @variable.parameter)
+
+(simple_parameter
+  name: (variable_name) @variable.parameter)
+
+(argument
+  (name) @variable.parameter)
+
+; Member
+(property_element
+  (variable_name) @property)
+
+(member_access_expression
+  name: (variable_name
+    (name)) @variable.member)
+
+(member_access_expression
+  name: (name) @variable.member)
+
+(nullsafe_member_access_expression
+  name: (variable_name
+    (name)) @variable.member)
+
+(nullsafe_member_access_expression
+  name: (name) @variable.member)
+
+; Variables
+(relative_scope) @variable.builtin
+
+((variable_name) @variable.builtin
+  (#eq? @variable.builtin "$this"))
+
+; Namespace
+(namespace_definition
+  name: (namespace_name
+    (name) @module))
+
+(namespace_name
+  (name) @module)
+
+; Attributes
+(attribute_list) @attribute
+
+; Conditions ( ? : )
+(conditional_expression
+  "?" @keyword.conditional.ternary
+  ":" @keyword.conditional.ternary)
+
+; Directives
+(declare_directive
+  [
+    "strict_types"
+    "ticks"
+    "encoding"
+  ] @variable.parameter)
+
+; Basic tokens
+[
+  (string)
+  (encapsed_string)
+  (heredoc_body)
+  (nowdoc_body)
+  (shell_command_expression) ; backtick operator: `ls -la`
+] @string
+
+(escape_sequence) @string.escape
+
+[
+  (heredoc_start)
+  (heredoc_end)
+] @label
+
+(nowdoc
+  "'" @label)
+
+(boolean) @boolean
+
+(null) @constant.builtin
+
+(integer) @number
+
+(float) @number.float
+
+(comment) @comment @spell
+
+(named_label_statement) @label
diff --git a/pack/ant/start/nvim-treesitter/queries/php_only/indents.scm b/pack/ant/start/nvim-treesitter/queries/php_only/indents.scm
new file mode 100644
index 0000000..1755d42
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/php_only/indents.scm
@@ -0,0 +1,68 @@
+[
+  (array_creation_expression)
+  (parenthesized_expression)
+  (compound_statement)
+  (declaration_list)
+  (member_call_expression)
+  (binary_expression)
+  (return_statement)
+  (arguments)
+  (formal_parameters)
+  (enum_declaration_list)
+  (switch_block)
+  (match_block)
+  (case_statement)
+  (default_statement)
+  (property_hook_list)
+] @indent.begin
+
+(return_statement
+  [
+    (object_creation_expression)
+    (anonymous_function)
+    (arrow_function)
+    (match_expression)
+  ]) @indent.dedent
+
+[
+  ")"
+  "}"
+  "]"
+] @indent.branch
+
+(comment) @indent.auto
+
+(arguments
+  ")" @indent.end)
+
+(formal_parameters
+  ")" @indent.end)
+
+(compound_statement
+  "}" @indent.end)
+
+(declaration_list
+  "}" @indent.end)
+
+(enum_declaration_list
+  "}" @indent.end)
+
+(return_statement
+  ";" @indent.end)
+
+(property_hook_list
+  "}" @indent.end)
+
+(ERROR
+  "(" @indent.align
+  .
+  (_)
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+(ERROR
+  "[" @indent.align
+  .
+  (_)
+  (#set! indent.open_delimiter "[")
+  (#set! indent.close_delimiter "]"))
diff --git a/pack/ant/start/nvim-treesitter/queries/php_only/injections.scm b/pack/ant/start/nvim-treesitter/queries/php_only/injections.scm
new file mode 100644
index 0000000..3681776
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/php_only/injections.scm
@@ -0,0 +1,43 @@
+((comment) @injection.content
+  (#set! injection.language "phpdoc"))
+
+(heredoc
+  (heredoc_body) @injection.content
+  (heredoc_end) @injection.language
+  (#set! injection.include-children)
+  (#downcase! @injection.language))
+
+(nowdoc
+  (nowdoc_body) @injection.content
+  (heredoc_end) @injection.language
+  (#set! injection.include-children)
+  (#downcase! @injection.language))
+
+; regex
+((function_call_expression
+  function: (_) @_preg_func_identifier
+  arguments: (arguments
+    .
+    (argument
+      (_
+        (string_content) @injection.content))))
+  (#set! injection.language "regex")
+  (#lua-match? @_preg_func_identifier "^preg_"))
+
+; bash
+((function_call_expression
+  function: (_) @_shell_func_identifier
+  arguments: (arguments
+    .
+    (argument
+      (_
+        (string_content) @injection.content))))
+  (#set! injection.language "bash")
+  (#any-of? @_shell_func_identifier
+    "shell_exec" "escapeshellarg" "escapeshellcmd" "exec" "passthru" "proc_open" "shell_exec"
+    "system"))
+
+(expression_statement
+  (shell_command_expression
+    (string_content) @injection.content)
+  (#set! injection.language "bash"))
diff --git a/pack/ant/start/nvim-treesitter/queries/php_only/locals.scm b/pack/ant/start/nvim-treesitter/queries/php_only/locals.scm
new file mode 100644
index 0000000..6739b38
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/php_only/locals.scm
@@ -0,0 +1,84 @@
+; Scopes
+;-------
+((class_declaration
+  name: (name) @local.definition.type) @local.scope
+  (#set! definition.type.scope "parent"))
+
+((method_declaration
+  name: (name) @local.definition.method) @local.scope
+  (#set! definition.method.scope "parent"))
+
+((function_definition
+  name: (name) @local.definition.function) @local.scope
+  (#set! definition.function.scope "parent"))
+
+(anonymous_function
+  (anonymous_function_use_clause
+    (variable_name
+      (name) @local.definition.var))) @local.scope
+
+; Definitions
+;------------
+(simple_parameter
+  (variable_name
+    (name) @local.definition.var))
+
+(foreach_statement
+  (pair
+    (variable_name
+      (name) @local.definition.var)))
+
+(foreach_statement
+  (variable_name
+    (name) @local.reference
+    (#set! reference.kind "var"))
+  (variable_name
+    (name) @local.definition.var))
+
+(property_declaration
+  (property_element
+    (variable_name
+      (name) @local.definition.field)))
+
+(namespace_use_clause
+  (qualified_name
+    (name) @local.definition.type))
+
+; References
+;------------
+(named_type
+  (name) @local.reference
+  (#set! reference.kind "type"))
+
+(named_type
+  (qualified_name) @local.reference
+  (#set! reference.kind "type"))
+
+(variable_name
+  (name) @local.reference
+  (#set! reference.kind "var"))
+
+(member_access_expression
+  name: (name) @local.reference
+  (#set! reference.kind "field"))
+
+(member_call_expression
+  name: (name) @local.reference
+  (#set! reference.kind "method"))
+
+(function_call_expression
+  function: (qualified_name
+    (name) @local.reference
+    (#set! reference.kind "function")))
+
+(object_creation_expression
+  (qualified_name
+    (name) @local.reference
+    (#set! reference.kind "type")))
+
+(scoped_call_expression
+  scope: (qualified_name
+    (name) @local.reference
+    (#set! reference.kind "type"))
+  name: (name) @local.reference
+  (#set! reference.kind "method"))
diff --git a/pack/ant/start/nvim-treesitter/queries/phpdoc/highlights.scm b/pack/ant/start/nvim-treesitter/queries/phpdoc/highlights.scm
new file mode 100644
index 0000000..3ebe4a6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/phpdoc/highlights.scm
@@ -0,0 +1,72 @@
+(tag_name) @attribute @nospell
+
+(tag
+  (tag_name) @_tag
+  (#eq? @_tag "@param")
+  (variable_name) @variable.parameter)
+
+(tag
+  (tag_name) @_tag
+  (#eq? @_tag "@property")
+  (variable_name) @variable.member)
+
+(tag
+  (tag_name) @_tag
+  (#eq? @_tag "@var")
+  (variable_name) @variable)
+
+(tag
+  (tag_name) @_tag
+  (#eq? @_tag "@function.method")
+  (name) @function.method)
+
+(parameter
+  (variable_name) @variable.parameter)
+
+[
+  (array_type)
+  (primitive_type)
+  (named_type)
+  (optional_type)
+] @type
+
+(union_type
+  [
+    (array_type)
+    (primitive_type)
+    (named_type)
+    (optional_type)
+  ] @type)
+
+(union_type) @nospell
+
+(variable_name) @nospell
+
+(tag
+  (description
+    (text) @none @spell))
+
+(tag
+  [
+    (author_name)
+    (version)
+  ] @none)
+
+(tag
+  (email_address) @string.special.url)
+
+(union_type
+  "|" @keyword)
+
+(variable_name
+  "$" @keyword)
+
+(tag
+  (tag_name) @_tag_name
+  [
+    "<"
+    ">"
+  ] @keyword
+  (#eq? @_tag_name "@author"))
+
+(text) @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/pioasm/highlights.scm b/pack/ant/start/nvim-treesitter/queries/pioasm/highlights.scm
new file mode 100644
index 0000000..3250059
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pioasm/highlights.scm
@@ -0,0 +1,93 @@
+[
+  (line_comment)
+  (block_comment)
+] @comment @spell
+
+(label_decl) @label
+
+(string) @string
+
+(instruction
+  opcode: _ @function.call)
+
+[
+  "pins"
+  "x"
+  "y"
+  "null"
+  "isr"
+  "osr"
+  "osre"
+  "status"
+  "pc"
+  "exec"
+] @constant.builtin
+
+(wait_source
+  [
+    "irq"
+    "gpio"
+    "pin"
+  ] @constant.builtin)
+
+(out_target
+  "pindirs" @constant.builtin)
+
+(set_target
+  "pindirs" @constant.builtin)
+
+(directive
+  "pindirs" @attribute)
+
+(condition
+  [
+    "--"
+    "!="
+  ] @operator)
+
+(expression
+  [
+    "+"
+    "-"
+    "*"
+    "/"
+    "|"
+    "&"
+    "^"
+    "::"
+  ] @operator)
+
+(not) @operator
+
+[
+  (optional)
+  (irq_modifiers)
+] @keyword.modifier
+
+[
+  "block"
+  "noblock"
+  "rel"
+] @attribute
+
+[
+  "iffull"
+  "ifempty"
+] @keyword.conditional
+
+"public" @keyword.modifier
+
+(integer) @number
+
+(directive
+  (identifier) @variable)
+
+(directive
+  (symbol_def
+    (identifier) @variable))
+
+(value
+  (identifier) @variable)
+
+(directive
+  directive: _ @keyword.directive)
diff --git a/pack/ant/start/nvim-treesitter/queries/pioasm/injections.scm b/pack/ant/start/nvim-treesitter/queries/pioasm/injections.scm
new file mode 100644
index 0000000..84d17cf
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pioasm/injections.scm
@@ -0,0 +1,15 @@
+([
+  (line_comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
+
+((code_block
+  (code_block_language) @_language
+  (code_block_body) @injection.content)
+  (#eq? @_language "c-sdk")
+  (#set! injection.language "c"))
+
+(code_block
+  (code_block_language) @injection.language
+  (code_block_body) @injection.content)
diff --git a/pack/ant/start/nvim-treesitter/queries/po/folds.scm b/pack/ant/start/nvim-treesitter/queries/po/folds.scm
new file mode 100644
index 0000000..fd1fb1e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/po/folds.scm
@@ -0,0 +1,8 @@
+[
+  (msgctxt)
+  (msgid)
+  (msgid_plural)
+  (msgstr)
+  (msgstr_plural)
+  (message)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/po/highlights.scm b/pack/ant/start/nvim-treesitter/queries/po/highlights.scm
new file mode 100644
index 0000000..0cc92e7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/po/highlights.scm
@@ -0,0 +1,32 @@
+; Keywords
+[
+  "msgctxt"
+  "msgid"
+  "msgid_plural"
+  "msgstr"
+  "msgstr_plural"
+] @keyword
+
+; Punctuation
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+; Literals
+(string) @string
+
+(escape_sequence) @string.escape
+
+(number) @number
+
+; Comments
+(comment) @comment @spell
+
+(comment
+  (reference
+    (text) @string.special.path))
+
+(comment
+  (flag
+    (text) @keyword.directive))
diff --git a/pack/ant/start/nvim-treesitter/queries/po/injections.scm b/pack/ant/start/nvim-treesitter/queries/po/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/po/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/pod/highlights.scm b/pack/ant/start/nvim-treesitter/queries/pod/highlights.scm
new file mode 100644
index 0000000..8252ac1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pod/highlights.scm
@@ -0,0 +1,76 @@
+; A highlight file for nvim-treesitter to use
+[
+  (pod_command)
+  (command)
+  (cut_command)
+] @keyword
+
+((command_paragraph
+  (command) @keyword
+  (content) @string)
+  (#set! priority 99))
+
+(command_paragraph
+  (command) @keyword
+  (#lua-match? @keyword "^=head")
+  (content) @markup.heading)
+
+(command_paragraph
+  (command) @keyword
+  (#lua-match? @keyword "^=over")
+  (content) @number)
+
+(command_paragraph
+  (command) @keyword
+  (#lua-match? @keyword "^=item")
+  (content) @none)
+
+(command_paragraph
+  (command) @keyword
+  (#lua-match? @keyword "^=encoding")
+  (content) @string.special)
+
+(verbatim_paragraph
+  (content) @markup.raw)
+
+(interior_sequence
+  (sequence_letter) @character
+  [
+    "<"
+    ">"
+  ] @punctuation.delimiter)
+
+(interior_sequence
+  (sequence_letter) @character
+  (#eq? @character "B")
+  (content) @markup.strong)
+
+(interior_sequence
+  (sequence_letter) @character
+  (#eq? @character "C")
+  (content) @markup.raw)
+
+(interior_sequence
+  (sequence_letter) @character
+  (#eq? @character "F")
+  (content) @string.special.path)
+
+(interior_sequence
+  (sequence_letter) @character
+  (#eq? @character "I")
+  (content) @markup.italic)
+
+(interior_sequence
+  (sequence_letter) @character
+  (#eq? @character "L")
+  (content) @string.special.url)
+
+(interior_sequence
+  (sequence_letter) @character
+  (#eq? @character "X")
+  (content) @markup.link)
+
+(interior_sequence
+  (sequence_letter) @character
+  (#eq? @character "E")
+  (content) @string.escape)
diff --git a/pack/ant/start/nvim-treesitter/queries/poe_filter/folds.scm b/pack/ant/start/nvim-treesitter/queries/poe_filter/folds.scm
new file mode 100644
index 0000000..fd7d239
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/poe_filter/folds.scm
@@ -0,0 +1 @@
+(block) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/poe_filter/highlights.scm b/pack/ant/start/nvim-treesitter/queries/poe_filter/highlights.scm
new file mode 100644
index 0000000..b0c715a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/poe_filter/highlights.scm
@@ -0,0 +1,52 @@
+[
+  "Show"
+  "Hide"
+  "Minimal"
+] @module
+
+[
+  "Import"
+  "Optional"
+] @keyword.import
+
+(condition
+  (name) @keyword.conditional)
+
+(action
+  (name) @keyword)
+
+(continue) @label
+
+(operator) @operator
+
+(string) @string
+
+(file) @string.special.path
+
+[
+  (quality)
+  (rarity)
+  (influence)
+  (colour)
+  (shape)
+] @constant.builtin
+
+(sockets) @variable.builtin
+
+(number) @number
+
+(boolean) @boolean
+
+[
+  (disable)
+  "Temp"
+] @constant
+
+(comment) @comment @spell
+
+"\"" @punctuation.delimiter
+
+; conceal unnecessary quotes
+("\"" @conceal
+  (#not-has-parent? @conceal string file)
+  (#set! conceal ""))
diff --git a/pack/ant/start/nvim-treesitter/queries/poe_filter/indents.scm b/pack/ant/start/nvim-treesitter/queries/poe_filter/indents.scm
new file mode 100644
index 0000000..78b7a2e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/poe_filter/indents.scm
@@ -0,0 +1,5 @@
+(block) @indent.begin
+
+(ERROR) @indent.auto
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/poe_filter/injections.scm b/pack/ant/start/nvim-treesitter/queries/poe_filter/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/poe_filter/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/pony/folds.scm b/pack/ant/start/nvim-treesitter/queries/pony/folds.scm
new file mode 100644
index 0000000..95b76eb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pony/folds.scm
@@ -0,0 +1,33 @@
+[
+  (use_statement)
+  (actor_definition)
+  (class_definition)
+  (primitive_definition)
+  (interface_definition)
+  (trait_definition)
+  (struct_definition)
+  (constructor)
+  (method)
+  (behavior)
+  (parameters)
+  (type)
+  (if_statement)
+  (iftype_statement)
+  (elseif_block)
+  (elseiftype_block)
+  (else_block)
+  (for_statement)
+  (while_statement)
+  (try_statement)
+  (with_statement)
+  (repeat_statement)
+  (recover_statement)
+  (match_statement)
+  (case_statement)
+  (parenthesized_expression)
+  (tuple_expression)
+  (array_literal)
+  (object_literal)
+  (string)
+  (block_comment)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/pony/highlights.scm b/pack/ant/start/nvim-treesitter/queries/pony/highlights.scm
new file mode 100644
index 0000000..f3d4b5d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pony/highlights.scm
@@ -0,0 +1,333 @@
+; Includes
+"use" @keyword.import
+
+; Keywords
+[
+  "primitive"
+  "embed"
+  "let"
+  "var"
+  (compile_intrinsic)
+  "as"
+  "consume"
+  "recover"
+  "object"
+  "where"
+] @keyword
+
+[
+  "class"
+  "struct"
+  "type"
+  "interface"
+  "trait"
+  "actor"
+] @keyword.type
+
+"fun" @keyword.function
+
+"be" @keyword.coroutine
+
+[
+  "in"
+  "is"
+] @keyword.operator
+
+"return" @keyword.return
+
+; Qualifiers
+[
+  "iso"
+  "trn"
+  "ref"
+  "val"
+  "box"
+  "tag"
+  "#read"
+  "#send"
+  "#share"
+  "#alias"
+  "#any"
+] @keyword.modifier
+
+; Conditionals
+[
+  "if"
+  "ifdef"
+  "iftype"
+  "then"
+  "else"
+  "elseif"
+  "match"
+] @keyword.conditional
+
+(if_statement
+  "end" @keyword.conditional)
+
+(iftype_statement
+  "end" @keyword.conditional)
+
+(match_statement
+  "end" @keyword.conditional)
+
+; Repeats
+[
+  "repeat"
+  "until"
+  "while"
+  "for"
+  "continue"
+  "do"
+  "break"
+] @keyword.repeat
+
+(do_block
+  "end" @keyword.repeat)
+
+(repeat_statement
+  "end" @keyword.repeat)
+
+; Exceptions
+[
+  "try"
+  (error)
+  "compile_error"
+] @keyword.exception
+
+(try_statement
+  "end" @keyword.exception)
+
+(recover_statement
+  "end" @keyword.exception)
+
+; Attributes
+(annotation) @attribute
+
+; Variables
+(identifier) @variable
+
+(this) @variable.builtin
+
+; Fields
+(field
+  name: (identifier) @variable.member)
+
+(member_expression
+  "."
+  (identifier) @variable.member)
+
+; Constructors
+(constructor
+  "new" @keyword.operator
+  (identifier) @constructor)
+
+; Methods
+(method
+  (identifier) @function.method)
+
+(behavior
+  (identifier) @function.method)
+
+(ffi_method
+  (identifier) @function.method)
+
+((ffi_method
+  (string) @string.special)
+  (#set! priority 105))
+
+(call_expression
+  callee: [
+    (identifier) @function.method.call
+    (ffi_identifier
+      (identifier) @function.method.call)
+    (member_expression
+      "."
+      (identifier) @function.method.call)
+  ])
+
+; Parameters
+(parameter
+  name: (identifier) @variable.parameter)
+
+(lambda_parameter
+  name: (identifier) @variable.parameter)
+
+; Types
+(type_alias
+  (identifier) @type.definition)
+
+(base_type
+  name: (identifier) @type)
+
+(generic_parameter
+  (identifier) @type)
+
+(lambda_type
+  (identifier)? @function.method)
+
+((identifier) @type
+  (#lua-match? @type "^_*[A-Z][a-zA-Z0-9_]*$"))
+
+; Operators
+(unary_expression
+  operator: [
+    "not"
+    "addressof"
+    "digestof"
+  ] @keyword.operator)
+
+(binary_expression
+  operator: [
+    "and"
+    "or"
+    "xor"
+    "is"
+    "isnt"
+  ] @keyword.operator)
+
+[
+  "="
+  "?"
+  "|"
+  "&"
+  "-~"
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "%%"
+  "<<"
+  ">>"
+  "=="
+  "!="
+  ">"
+  ">="
+  "<="
+  "<"
+  "+~"
+  "-~"
+  "*~"
+  "/~"
+  "%~"
+  "%%~"
+  "<<~"
+  ">>~"
+  "==~"
+  "!=~"
+  ">~"
+  ">=~"
+  "<=~"
+  "<~"
+  "+?"
+  "-?"
+  "*?"
+  "/?"
+  "%?"
+  "%%?"
+  "<:"
+] @operator
+
+; Literals
+(string) @string
+
+(source_file
+  (string) @string.documentation)
+
+(actor_definition
+  (string) @string.documentation)
+
+(class_definition
+  (string) @string.documentation)
+
+(primitive_definition
+  (string) @string.documentation)
+
+(interface_definition
+  (string) @string.documentation)
+
+(trait_definition
+  (string) @string.documentation)
+
+(struct_definition
+  (string) @string.documentation)
+
+(type_alias
+  (string) @string.documentation)
+
+(field
+  (string) @string.documentation)
+
+(constructor
+  [
+    (string) @string.documentation
+    (block
+      .
+      (string) @string.documentation)
+  ])
+
+(method
+  [
+    (string) @string.documentation
+    (block
+      .
+      (string) @string.documentation)
+  ])
+
+(behavior
+  [
+    (string) @string.documentation
+    (block
+      .
+      (string) @string.documentation)
+  ])
+
+(character) @character
+
+(escape_sequence) @string.escape
+
+(number) @number
+
+(float) @number.float
+
+(boolean) @boolean
+
+; Punctuation
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "."
+  ","
+  ";"
+  ":"
+  "~"
+  ".>"
+  "->"
+  "=>"
+] @punctuation.delimiter
+
+[
+  "@"
+  "!"
+  "^"
+  "..."
+] @punctuation.special
+
+; Comments
+[
+  (line_comment)
+  (block_comment)
+] @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/pony/indents.scm b/pack/ant/start/nvim-treesitter/queries/pony/indents.scm
new file mode 100644
index 0000000..3bddd29
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pony/indents.scm
@@ -0,0 +1,71 @@
+[
+  (use_statement)
+  (actor_definition)
+  (class_definition)
+  (primitive_definition)
+  (interface_definition)
+  (trait_definition)
+  (struct_definition)
+  (constructor)
+  (method)
+  (behavior)
+  (parameters)
+  (if_block)
+  (then_block)
+  (elseif_block)
+  (else_block)
+  (iftype_statement)
+  (elseiftype_block)
+  (do_block)
+  (match_statement)
+  (parenthesized_expression)
+  (tuple_expression)
+  (array_literal)
+  (object_literal)
+] @indent.begin
+
+(try_statement
+  (block) @indent.begin)
+
+(repeat_statement
+  (block) @indent.begin)
+
+(recover_statement
+  (block) @indent.begin)
+
+(return_statement
+  (block) @indent.begin)
+
+(continue_statement
+  (block) @indent.begin)
+
+(break_statement
+  (block) @indent.begin)
+
+[
+  "}"
+  "]"
+  ")"
+] @indent.end
+
+[
+  "{"
+  "}"
+] @indent.branch
+
+[
+  "["
+  "]"
+] @indent.branch
+
+[
+  "("
+  ")"
+] @indent.branch
+
+[
+  (ERROR)
+  (string)
+  (line_comment)
+  (block_comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/pony/injections.scm b/pack/ant/start/nvim-treesitter/queries/pony/injections.scm
new file mode 100644
index 0000000..3cd6aac
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pony/injections.scm
@@ -0,0 +1,5 @@
+([
+  (line_comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/pony/locals.scm b/pack/ant/start/nvim-treesitter/queries/pony/locals.scm
new file mode 100644
index 0000000..a27e501
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pony/locals.scm
@@ -0,0 +1,86 @@
+; Scopes
+[
+  (use_statement)
+  (actor_definition)
+  (class_definition)
+  (primitive_definition)
+  (interface_definition)
+  (trait_definition)
+  (struct_definition)
+  (constructor)
+  (method)
+  (behavior)
+  (if_statement)
+  (iftype_statement)
+  (elseif_block)
+  (elseiftype_block)
+  (else_block)
+  (for_statement)
+  (while_statement)
+  (try_statement)
+  (with_statement)
+  (repeat_statement)
+  (recover_statement)
+  (match_statement)
+  (case_statement)
+  (parenthesized_expression)
+  (tuple_expression)
+  (array_literal)
+  (object_literal)
+] @local.scope
+
+; References
+(identifier) @local.reference
+
+; Definitions
+(field
+  name: (identifier) @local.definition.field)
+
+(use_statement
+  (identifier) @local.definition.import)
+
+(constructor
+  (identifier) @local.definition.method)
+
+(method
+  (identifier) @local.definition.method)
+
+(behavior
+  (identifier) @local.definition.method)
+
+(actor_definition
+  (identifier) @local.definition.type)
+
+(type_alias
+  (identifier) @local.definition.type)
+
+(class_definition
+  (identifier) @local.definition.type)
+
+(primitive_definition
+  (identifier) @local.definition.type)
+
+(interface_definition
+  (identifier) @local.definition.type)
+
+(trait_definition
+  (identifier) @local.definition.type)
+
+(struct_definition
+  (identifier) @local.definition.type)
+
+(parameter
+  name: (identifier) @local.definition.parameter)
+
+(variable_declaration
+  (identifier) @local.definition.var)
+
+(for_statement
+  [
+    (identifier) @local.definition.var
+    (tuple_expression
+      (identifier) @local.definition.var)
+  ])
+
+(with_elem
+  (identifier) @local.definition.var)
diff --git a/pack/ant/start/nvim-treesitter/queries/powershell/folds.scm b/pack/ant/start/nvim-treesitter/queries/powershell/folds.scm
new file mode 100644
index 0000000..d87e3f6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/powershell/folds.scm
@@ -0,0 +1,13 @@
+[
+  (expandable_here_string_literal)
+  (verbatim_here_string_characters)
+  (function_statement)
+  (param_block)
+  (script_block_expression)
+  (statement_block)
+  (switch_body)
+  (array_expression)
+  (hash_literal_expression)
+  (class_statement)
+  (class_method_definition)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/powershell/highlights.scm b/pack/ant/start/nvim-treesitter/queries/powershell/highlights.scm
new file mode 100644
index 0000000..3885ba8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/powershell/highlights.scm
@@ -0,0 +1,334 @@
+; Punctuation
+;------------
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+(hash_literal_expression
+  [
+    "@{"
+    "}"
+  ] @punctuation.special)
+
+(array_expression
+  [
+    "@("
+    ")"
+  ] @punctuation.special)
+
+[
+  "."
+  "::"
+  ","
+  ";"
+  (empty_statement)
+  (command_argument_sep)
+] @punctuation.delimiter
+
+; Keywords
+;---------
+[
+  "if"
+  "elseif"
+  "else"
+  "switch"
+] @keyword.conditional
+
+[
+  "foreach"
+  "for"
+  "while"
+  "do"
+  "until"
+  "in"
+  "break"
+  "continue"
+] @keyword.repeat
+
+[
+  "function"
+  "filter"
+  "workflow"
+  "exit"
+  "trap"
+  "param"
+  "inlinescript"
+] @keyword.function
+
+"return" @keyword.return
+
+[
+  "class"
+  "enum"
+] @keyword.type
+
+[
+  "data"
+  (class_attribute)
+] @keyword.modifier
+
+[
+  "throw"
+  "try"
+  "catch"
+  "finally"
+] @keyword.exception
+
+[
+  "parallel"
+  "sequence"
+] @keyword.coroutine
+
+[
+  "param"
+  "dynamicparam"
+  "begin"
+  "process"
+  "end"
+] @keyword
+
+; Operators
+;----------
+[
+  "-and"
+  "-or"
+  "-xor"
+  "-band"
+  "-bor"
+  "-bxor"
+  "+"
+  "-"
+  "/"
+  "\\"
+  "%"
+  "*"
+  ".."
+  "-not"
+  "-bnot"
+  "!"
+  "="
+  "|"
+  (pre_increment_expression)
+  (pre_decrement_expression)
+  (post_increment_expression)
+  (post_decrement_expression)
+  (comparison_operator)
+  (assignement_operator)
+] @operator
+
+; Generic types
+;--------------
+(string_literal) @string
+
+(integer_literal) @number
+
+(real_literal) @number.float
+
+(variable) @variable
+
+((variable) @variable.builtin
+  (#any-of? @variable.builtin
+    "$$" "$?" "$^" "$_" "$args" "$ConsoleFileName" "$EnabledExperimentalFeatures" "$Error" "$Event"
+    "$EventArgs" "$EventSubscriber" "$ExecutionContext" "$false" "$foreach" "$HOME" "$Host" "$input"
+    "$IsCoreCLR" "$IsLinux" "$IsMacOS" "$IsWindows" "$LASTEXITCODE" "$Matches" "$MyInvocation"
+    "$NestedPromptLevel" "$null" "$PID" "$PROFILE" "$PSBoundParameters" "$PSCmdlet" "$PSCommandPath"
+    "$PSCulture" "$PSDebugContext" "$PSEdition" "$PSHOME" "$PSItem" "$PSScriptRoot" "$PSSenderInfo"
+    "$PSUICulture" "$PSVersionTable" "$PWD" "$Sender" "ShellId" "$StackTrace" "$switch" "$this"
+    "$true"))
+
+((variable) @variable.builtin
+  (#lua-match? @variable.builtin "^\$env:"))
+
+(data_name
+  (simple_name) @constant)
+
+(comment) @comment @spell
+
+((program
+  .
+  (comment) @keyword.directive)
+  (#lua-match? @keyword.directive "^#!/"))
+
+; Booleans
+;---------
+([
+  (generic_token)
+  (command_name)
+  (variable)
+  (command)
+] @boolean
+  (#any-of? @boolean "True" "False" "$true" "$false"))
+
+; switch -regex
+;--------------
+(switch_statement
+  (switch_parameters
+    (switch_parameter) @_parameter)
+  (switch_body
+    (switch_clauses
+      (switch_clause
+        (switch_clause_condition
+          (string_literal) @string.regexp))))
+  (#eq? @_parameter "-regex")
+  (#offset! @string.regexp 0 1 0 -1))
+
+; Multiline strings
+;------------------
+([
+  (verbatim_here_string_characters)
+  (expandable_here_string_literal)
+] @markup.raw.block
+  (#offset! @markup.raw.block 0 2 0 -2))
+
+; Type references and definitions
+;--------------------------------
+(type_spec
+  (type_name) @type)
+
+(class_statement
+  (simple_name) @type)
+
+(type_spec
+  (type_name) @type.builtin
+  (#any-of? @type.builtin
+    "bool" "Boolean" "System.Boolean" "char" "Char" "System.Char" "string" "String" "System.String"
+    "int" "Int32" "System.Int32" "long" "Int64" "System.Int64" "byte" "Byte" "System.Byte" "float"
+    "Single" "System.Single" "double" "Double" "System.Double" "decimal" "Decimal" "System.Decimal"
+    "array" "Array" "System.Array" "regex" "Regex" "System.Text.RegularExpressions.Regex" "ref"
+    "Management.Automation.PSReference" "System.Management.Automation.PSReference" "scriptblock"
+    "Management.Automation.ScriptBlock" "System.Management.Automation.ScriptBlock" "datetime"
+    "DateTime" "System.DateTime" "enum" "Enum" "System.Enum" "IO.DirectoryInfo"
+    "System.IO.DirectoryInfo" "IO.FileAttributes" "System.IO.FileAttributes" "IO.FileInfo"
+    "System.IO.FileInfo" "IO.Path" "System.IO.Path" "Text.RegularExpressions.RegexOptions"
+    "System.Text.RegularExpressions.RegexOptions" "Math" "System.Math" "PSObject" "System.PSObject"
+    "Object" "System.Object" "ValueType" "System.ValueType" "Hashtable"
+    "System.Collections.Hashtable" "Collections.Stack" "System.Collections.Generic.Stack"
+    "Collections.Dictionary" "System.Collections.Dictionary" "Collections.DictionaryEntry"
+    "System.Collections.DictionaryEntry" "Collections.ArrayList" "System.Collections.ArrayList"
+    "Management.Automation.SwitchParameter" "System.Management.Automation.SwitchParameter"
+    "Management.Automation.ActionPreference" "System.Management.Automation.ActionPreference"
+    "Management.Automation.ConfirmImpact" "System.Management.Automation.ConfirmImpact"
+    "Management.Automation.CommandInfo" "System.Management.Automation.CommandInfo"
+    "Management.Automation.ProviderInfo" "System.Management.Automation.ProviderInfo"
+    "Management.Automation.PSDriveInfo" "System.Management.Automation.PSDriveInfo"
+    "Management.Automation.PSVariable" "System.Management.Automation.PSVariable"
+    "Management.Automation.AliasInfo" "System.Management.Automation.AliasInfo"
+    "Management.Automation.PathInfo" "System.Management.Automation.PathInfo"
+    "Management.Automation.PathInfoStack" "System.Management.Automation.PathInfoStack"
+    "Management.Automation.ApplicationInfo" "System.Management.Automation.ApplicationInfo"
+    "Management.Automation.CmdletInfo" "System.Management.Automation.CmdletInfo"
+    "Management.Automation.ExternalScriptInfo" "System.Management.Automation.ExternalScriptInfo"
+    "Management.Automation.FunctionInfo" "System.Management.Automation.FunctionInfo"
+    "Management.Automation.CommandTypes" "System.Management.CommandTypes"
+    "Management.Automation.ScopedItemOptions" "System.Management.Automation.ScopedItemOptions"
+    "Management.Automation.PSTypeName" "System.Management.Automation.PSTypeName"
+    "Management.Automation.ParameterMetadata" "System.Management.Automation.ParameterMetadata"
+    "Management.Automation.CommandParameterSetInfo"
+    "System.Management.Automation.CommandParameterSetInfo"
+    "Management.Automation.SessionStateEntryVisibility"
+    "System.Management.Automation.SessionStateEntryVisibility" "Management.Automation.FilterInfo"
+    "System.Management.Automation.FilterInfo" "Management.Automation.ModuleType"
+    "System.Management.Automation.ModuleType" "Management.Automation.PSModuleInfo"
+    "System.Management.Automation.PSModuleInfo" "Management.Automation.PSCustomObject"
+    "System.Management.Automation.PSCustomObject" "Management.Automation.PSScriptCmdlet"
+    "System.Management.Automation.PSScriptCmdlet" "Management.Automation.ErrorRecord"
+    "System.Management.Automation.ErrorRecord" "Management.Automation.PSCredential"
+    "System.Management.Automation.PSCredential" "Management.Automation.PSMethod"
+    "System.Management.Automation.PSMethod")
+  )
+
+; Function definitions
+;---------------------
+(function_statement
+  (function_name) @function)
+
+; Classes, fields and methods definitions
+;----------------------------------------
+(class_property_definition
+  (variable) @variable.member)
+
+(class_method_definition
+  (simple_name) @function.method)
+
+(class_statement
+  (simple_name) @_class_name
+  (class_method_definition
+    (simple_name) @constructor)
+  (#eq? @constructor @_class_name))
+
+(key_expression) @property
+
+; Functions, methods calls and properties access
+;--------------------------
+(command_invokation_operator) @operator
+
+(invokation_expression
+  (member_name) @function.call)
+
+(invokation_expression
+  (member_name) @constructor
+  (#eq? @constructor "new"))
+
+(member_access
+  (member_name
+    [
+      (simple_name)
+      (variable)
+    ] @variable.member))
+
+; Commands execution
+;-------------------
+(command
+  command_name: (command_name) @function.call)
+
+(command
+  command_name: (command_name) @function.builtin
+  (#any-of? @function.builtin
+    ; Locations & Paths
+    "cd" "cd.." "cd\\" "cd~" "help" "Get-Location" "Pop-Location" "Push-Location" "Set-Location"
+    "Convert-Path" "Join-Path" "Resolve-Path" "Split-Path" "Test-Path"
+    ; Files & Directories
+    "Clear-Item" "Clear-ItemProperty" "Copy-Item" "Copy-ItemProperty" "Get-Item" "Get-ItemProperty"
+    "Get-ItemPropertyValue" "Invoke-Item" "Move-Item" "Move-ItemProperty" "New-Item"
+    "New-ItemProperty" "Remove-Item" "Remove-ItemProperty" "Rename-Item" "Rename-ItemProperty"
+    "Set-Item" "Set-ItemProperty"
+    ; Aliases
+    "New-Alias" "Get-Alias" "Set-Alias" "Remove-Alias" "Import-Alias" "Export-Alias"
+    ; Host (prompt)
+    "prompt" "cls" "echo" "Clear-Host" "Get-Host" "Out-Host" "Read-Host" "Write-Host" "Out-String"
+    ; Expressions
+    "Invoke-Expression"
+    ; Objects
+    "Compare-Object" "ForEach-Object" "Group-Object" "Measure-Object" "New-Object" "Select-Object"
+    "Sort-Object" "Tee-Object" "Where-Object"
+    ; Modules
+    "Export-ModuleMember" "Find-Module" "Get-Module" "Import-Module" "Install-Module" "New-Module"
+    "New-ModuleManifest" "Publish-Module" "Remove-Module" "Save-Module" "Test-ModuleManifest"
+    "Uninstall-Module" "Update-Module" "Update-ModuleManifest"))
+
+; Parameters and call arguments
+;------------------------------
+(command_elements
+  (generic_token) @variable.parameter)
+
+(switch_parameter) @variable.parameter.builtin
+
+(command_parameter) @variable.parameter.builtin
+
+(script_parameter
+  (variable) @variable.parameter)
+
+(class_method_parameter
+  (variable) @variable.parameter)
+
+; Document encoding
+;------------------
+((program
+  .
+  (comment) @keyword.directive @nospell)
+  (#lua-match? @keyword.directive "Encoding$"))
diff --git a/pack/ant/start/nvim-treesitter/queries/powershell/indents.scm b/pack/ant/start/nvim-treesitter/queries/powershell/indents.scm
new file mode 100644
index 0000000..3be2ed1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/powershell/indents.scm
@@ -0,0 +1,41 @@
+(function_statement
+  "}" @indent.branch) @indent.begin
+
+(param_block
+  [
+    "param"
+    "("
+    ")"
+  ] @indent.branch) @indent.begin
+
+(script_block_expression
+  "}" @indent.branch) @indent.begin
+
+(statement_block
+  "}" @indent.branch) @indent.begin
+
+(switch_body
+  "}" @indent.branch) @indent.begin
+
+(array_expression
+  ")" @indent.branch) @indent.begin
+
+(hash_literal_expression
+  "}" @indent.branch) @indent.begin
+
+(class_statement
+  "}" @indent.branch) @indent.begin
+
+(class_method_definition
+  "}" @indent.branch) @indent.begin
+
+[
+  "}"
+  ")"
+] @indent.end
+
+[
+  (comment)
+  (string_literal)
+  (ERROR)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/powershell/injections.scm b/pack/ant/start/nvim-treesitter/queries/powershell/injections.scm
new file mode 100644
index 0000000..677e8b2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/powershell/injections.scm
@@ -0,0 +1,27 @@
+; comments and block-comments
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; dynamic invocation like & "$env:ChocolateyInstall\bin\choco.exe"
+(command
+  (command_invokation_operator) @_operator
+  (command_name_expr
+    (string_literal) @injection.content)
+  (#eq? @_operator "&")
+  (#set! injection.language "powershell")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.include-children))
+
+; switch -regex
+(switch_statement
+  (switch_parameters
+    (switch_parameter) @_parameter)
+  (switch_body
+    (switch_clauses
+      (switch_clause
+        (switch_clause_condition
+          (string_literal) @injection.content))))
+  (#eq? @_parameter "-regex")
+  (#set! injection.language "regex")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.include-children))
diff --git a/pack/ant/start/nvim-treesitter/queries/powershell/locals.scm b/pack/ant/start/nvim-treesitter/queries/powershell/locals.scm
new file mode 100644
index 0000000..e984109
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/powershell/locals.scm
@@ -0,0 +1,85 @@
+; Scopes
+;-------
+(class_statement) @local.scope
+
+(class_method_definition) @local.scope
+
+(statement_block) @local.scope
+
+(function_statement) @local.scope
+
+; Definitions
+;------------
+(class_statement
+  (simple_name) @local.definition.type
+  (#set! definition.var.scope "parent"))
+
+(class_property_definition
+  (variable) @local.definition.field
+  (#set! definition.var.scope "parent"))
+
+(class_method_definition
+  (simple_name) @local.definition.method
+  (#set! definition.var.scope "parent"))
+
+(function_statement
+  (function_name) @local.definition.function
+  (#set! definition.var.scope "parent"))
+
+; function, script block parameters
+(parameter_list
+  (script_parameter
+    (attribute_list
+      (attribute
+        (type_literal
+          (type_spec) @local.definition.associated)))
+    (variable) @local.definition.parameter))
+
+; variable assignment
+(assignment_expression
+  (left_assignment_expression
+    (logical_expression
+      (bitwise_expression
+        (comparison_expression
+          (additive_expression
+            (multiplicative_expression
+              (format_expression
+                (range_expression
+                  (array_literal_expression
+                    (unary_expression
+                      (variable) @local.definition.var)))))))))))
+
+; variable with type assignment
+(assignment_expression
+  (left_assignment_expression
+    (logical_expression
+      (bitwise_expression
+        (comparison_expression
+          (additive_expression
+            (multiplicative_expression
+              (format_expression
+                (range_expression
+                  (array_literal_expression
+                    (unary_expression
+                      (expression_with_unary_operator
+                        (cast_expression
+                          (type_literal
+                            (type_spec) @local.definition.associated)
+                          (unary_expression
+                            (variable) @local.definition.var))))))))))))))
+
+; data sections
+(data_name
+  (simple_name) @local.definition.var)
+
+; References
+;-----------
+(variable) @local.reference
+
+(command_name) @local.reference
+
+(invokation_expression
+  (variable) @_variable
+  (member_name
+    (simple_name) @local.reference)
+  (#eq? @_variable "$this"))
diff --git a/pack/ant/start/nvim-treesitter/queries/printf/highlights.scm b/pack/ant/start/nvim-treesitter/queries/printf/highlights.scm
new file mode 100644
index 0000000..db5ef9a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/printf/highlights.scm
@@ -0,0 +1 @@
+(format) @character
diff --git a/pack/ant/start/nvim-treesitter/queries/prisma/folds.scm b/pack/ant/start/nvim-treesitter/queries/prisma/folds.scm
new file mode 100644
index 0000000..73be360
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/prisma/folds.scm
@@ -0,0 +1,7 @@
+[
+  (generator_declaration)
+  (datasource_declaration)
+  (model_declaration)
+  (enum_declaration)
+  (view_declaration)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/prisma/highlights.scm b/pack/ant/start/nvim-treesitter/queries/prisma/highlights.scm
new file mode 100644
index 0000000..9d2d193
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/prisma/highlights.scm
@@ -0,0 +1,47 @@
+(variable) @variable
+
+[
+  "datasource"
+  "generator"
+  "model"
+  "view"
+] @keyword
+
+[
+  "type"
+  "enum"
+] @keyword.type
+
+(comment) @comment @spell
+
+(developer_comment) @comment.documentation @spell
+
+[
+  (attribute)
+  (call_expression)
+] @function
+
+(arguments) @property
+
+(column_type) @type
+
+(enumeral) @constant
+
+(column_declaration
+  (identifier) @variable)
+
+(string) @string
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "="
+  "@"
+] @operator
diff --git a/pack/ant/start/nvim-treesitter/queries/prisma/injections.scm b/pack/ant/start/nvim-treesitter/queries/prisma/injections.scm
new file mode 100644
index 0000000..ac427dd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/prisma/injections.scm
@@ -0,0 +1,5 @@
+([
+  (comment)
+  (developer_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/problog/folds.scm b/pack/ant/start/nvim-treesitter/queries/problog/folds.scm
new file mode 100644
index 0000000..7687182
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/problog/folds.scm
@@ -0,0 +1 @@
+; inherits: prolog
diff --git a/pack/ant/start/nvim-treesitter/queries/problog/highlights.scm b/pack/ant/start/nvim-treesitter/queries/problog/highlights.scm
new file mode 100644
index 0000000..de17156
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/problog/highlights.scm
@@ -0,0 +1,4 @@
+; inherits: prolog
+
+(probability_label
+  _ @attribute)
diff --git a/pack/ant/start/nvim-treesitter/queries/problog/indents.scm b/pack/ant/start/nvim-treesitter/queries/problog/indents.scm
new file mode 100644
index 0000000..7687182
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/problog/indents.scm
@@ -0,0 +1 @@
+; inherits: prolog
diff --git a/pack/ant/start/nvim-treesitter/queries/problog/injections.scm b/pack/ant/start/nvim-treesitter/queries/problog/injections.scm
new file mode 100644
index 0000000..7687182
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/problog/injections.scm
@@ -0,0 +1 @@
+; inherits: prolog
diff --git a/pack/ant/start/nvim-treesitter/queries/prolog/folds.scm b/pack/ant/start/nvim-treesitter/queries/prolog/folds.scm
new file mode 100644
index 0000000..70a4015
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/prolog/folds.scm
@@ -0,0 +1,6 @@
+[
+  (directive_term)
+  (clause_term)
+  (arg_list)
+  (list_notation)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/prolog/highlights.scm b/pack/ant/start/nvim-treesitter/queries/prolog/highlights.scm
new file mode 100644
index 0000000..fc89b6f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/prolog/highlights.scm
@@ -0,0 +1,43 @@
+(comment) @comment @spell
+
+(atom) @constant
+
+((atom) @boolean
+  (#any-of? @boolean "true" "false"))
+
+(functional_notation
+  function: (atom) @function.call)
+
+(integer) @number
+
+(float_number) @number.float
+
+(directive_head) @operator
+
+(operator_notation
+  operator: _ @operator)
+
+[
+  (open)
+  (open_ct)
+  (close)
+  (open_list)
+  "|"
+  (close_list)
+  (open_curly)
+  (close_curly)
+] @punctuation.bracket
+
+[
+  (arg_list_separator)
+  (comma)
+  (end)
+  (list_notation_separator)
+] @punctuation.delimiter
+
+(operator_notation
+  operator: (semicolon) @punctuation.delimiter)
+
+(double_quoted_list_notation) @string
+
+(variable_term) @variable
diff --git a/pack/ant/start/nvim-treesitter/queries/prolog/indents.scm b/pack/ant/start/nvim-treesitter/queries/prolog/indents.scm
new file mode 100644
index 0000000..a7f9b03
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/prolog/indents.scm
@@ -0,0 +1,16 @@
+(directive_term) @indent.zero
+
+(clause_term) @indent.zero
+
+(functional_notation
+  (atom)
+  (open_ct) @indent.begin
+  (close) @indent.end)
+
+(list_notation
+  (open_list) @indent.begin
+  (close_list) @indent.end)
+
+(curly_bracketed_notation
+  (open_curly) @indent.begin
+  (close_curly) @indent.end)
diff --git a/pack/ant/start/nvim-treesitter/queries/prolog/injections.scm b/pack/ant/start/nvim-treesitter/queries/prolog/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/prolog/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/promql/highlights.scm b/pack/ant/start/nvim-treesitter/queries/promql/highlights.scm
new file mode 100644
index 0000000..0f58f15
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/promql/highlights.scm
@@ -0,0 +1,43 @@
+; highlights.scm
+[
+  "*"
+  "/"
+  "%"
+  "+"
+  "-"
+  ">"
+  ">="
+  "<"
+  "<="
+  "="
+  "=~"
+  "!="
+  "!~"
+] @operator
+
+[
+  "{"
+  "}"
+  "["
+  "]"
+  "("
+  ")"
+] @punctuation.bracket
+
+(float_literal) @number.float
+
+(string_literal) @string
+
+(metric_name) @type
+
+(range_selection) @type
+
+(subquery_range_selection) @type
+
+(label_name) @variable.member
+
+(label_value) @string.regexp
+
+(function_name) @function.call
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/promql/injections.scm b/pack/ant/start/nvim-treesitter/queries/promql/injections.scm
new file mode 100644
index 0000000..4e7c1b2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/promql/injections.scm
@@ -0,0 +1,6 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((label_value) @injection.content
+  (#set! injection.language "regex")
+  (#offset! @injection.content 0 1 0 -1))
diff --git a/pack/ant/start/nvim-treesitter/queries/properties/highlights.scm b/pack/ant/start/nvim-treesitter/queries/properties/highlights.scm
new file mode 100644
index 0000000..b9390be
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/properties/highlights.scm
@@ -0,0 +1,50 @@
+(comment) @comment @spell
+
+(key) @property
+
+(value) @string
+
+(value
+  (escape) @string.escape)
+
+((value) @boolean
+  (#any-of? @boolean "true" "false"))
+
+((value) @number
+  (#lua-match? @number "^%d+$"))
+
+((index) @number
+  (#lua-match? @number "^%d+$"))
+
+((substitution
+  (key) @constant)
+  (#lua-match? @constant "^[A-Z_][A-Z0-9_]*$"))
+
+(substitution
+  (key) @function
+  "::" @punctuation.special
+  (secret) @constant.macro)
+
+(property
+  [
+    "="
+    ":"
+  ] @operator)
+
+[
+  "${"
+  "}"
+] @punctuation.special
+
+(substitution
+  ":" @punctuation.special)
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "."
+  "\\"
+] @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/properties/injections.scm b/pack/ant/start/nvim-treesitter/queries/properties/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/properties/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/properties/locals.scm b/pack/ant/start/nvim-treesitter/queries/properties/locals.scm
new file mode 100644
index 0000000..91a3b9a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/properties/locals.scm
@@ -0,0 +1,5 @@
+(property
+  (key) @local.definition)
+
+(substitution
+  (key) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/proto/folds.scm b/pack/ant/start/nvim-treesitter/queries/proto/folds.scm
new file mode 100644
index 0000000..645ac18
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/proto/folds.scm
@@ -0,0 +1,5 @@
+[
+  (enum)
+  (message)
+  (service)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/proto/highlights.scm b/pack/ant/start/nvim-treesitter/queries/proto/highlights.scm
new file mode 100644
index 0000000..51f44a7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/proto/highlights.scm
@@ -0,0 +1,82 @@
+[
+  "extend"
+  "extensions"
+  "oneof"
+  "option"
+  "reserved"
+  "syntax"
+  "to"
+] @keyword
+
+[
+  "enum"
+  "service"
+  "message"
+] @keyword.type
+
+"rpc" @keyword.function
+
+"returns" @keyword.return
+
+[
+  "optional"
+  "repeated"
+  "required"
+] @keyword.modifier
+
+[
+  "package"
+  "import"
+] @keyword.import
+
+[
+  (key_type)
+  (type)
+  (message_name)
+  (enum_name)
+  (service_name)
+  (rpc_name)
+  (message_or_enum_type)
+] @type
+
+(enum_field
+  (identifier) @constant)
+
+(string) @string
+
+[
+  "\"proto3\""
+  "\"proto2\""
+] @string.special
+
+(int_lit) @number
+
+(float_lit) @number.float
+
+[
+  (true)
+  (false)
+] @boolean
+
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$"))
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  "<"
+  ">"
+] @punctuation.bracket
+
+[
+  ";"
+  ","
+] @punctuation.delimiter
+
+"=" @operator
diff --git a/pack/ant/start/nvim-treesitter/queries/proto/indents.scm b/pack/ant/start/nvim-treesitter/queries/proto/indents.scm
new file mode 100644
index 0000000..4307b2a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/proto/indents.scm
@@ -0,0 +1,11 @@
+[
+  (message_body)
+  (enum_body)
+] @indent.begin
+
+"}" @indent.end @indent.branch
+
+[
+  (ERROR)
+  (comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/proto/injections.scm b/pack/ant/start/nvim-treesitter/queries/proto/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/proto/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/prql/highlights.scm b/pack/ant/start/nvim-treesitter/queries/prql/highlights.scm
new file mode 100644
index 0000000..d24777d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/prql/highlights.scm
@@ -0,0 +1,135 @@
+[
+  (keyword_from)
+  (keyword_filter)
+  (keyword_derive)
+  (keyword_group)
+  (keyword_aggregate)
+  (keyword_sort)
+  (keyword_take)
+  (keyword_window)
+  (keyword_join)
+  (keyword_select)
+  (keyword_append)
+  (keyword_remove)
+  (keyword_intersect)
+  (keyword_rolling)
+  (keyword_rows)
+  (keyword_expanding)
+  (keyword_let)
+  (keyword_prql)
+  (keyword_from_text)
+] @keyword
+
+(keyword_loop) @keyword.repeat
+
+(keyword_case) @keyword.conditional
+
+[
+  (literal_string)
+  (f_string)
+  (s_string)
+] @string
+
+(assignment
+  alias: (field) @variable.member)
+
+alias: (identifier) @variable.member
+
+(comment) @comment @spell
+
+(function_call
+  (identifier) @function.call)
+
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "="
+  "=="
+  "<"
+  "<="
+  "!="
+  ">="
+  ">"
+  "&&"
+  "||"
+  "//"
+  "~="
+  (bang)
+] @operator
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  ","
+  "."
+  "->"
+] @punctuation.delimiter
+
+(integer) @number
+
+(decimal_number) @number.float
+
+[
+  (keyword_min)
+  (keyword_max)
+  (keyword_count)
+  (keyword_count_distinct)
+  (keyword_average)
+  (keyword_avg)
+  (keyword_sum)
+  (keyword_stddev)
+  (keyword_count)
+  (keyword_rank)
+] @function
+
+[
+  (keyword_side)
+  (keyword_format)
+] @attribute
+
+[
+  (keyword_version)
+  (keyword_target)
+] @keyword.modifier
+
+(target) @function.builtin
+
+[
+  (date)
+  (time)
+  (timestamp)
+] @string.special
+
+[
+  (keyword_left)
+  (keyword_inner)
+  (keyword_right)
+  (keyword_full)
+  (keyword_csv)
+  (keyword_json)
+] @function.method.call
+
+[
+  (keyword_true)
+  (keyword_false)
+] @boolean
+
+(function_definition
+  (keyword_let)
+  name: (identifier) @function)
+
+(parameter
+  (identifier) @variable.parameter)
+
+(variable
+  (keyword_let)
+  name: (identifier) @constant)
+
+(keyword_null) @constant.builtin
diff --git a/pack/ant/start/nvim-treesitter/queries/prql/injections.scm b/pack/ant/start/nvim-treesitter/queries/prql/injections.scm
new file mode 100644
index 0000000..e6cbeda
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/prql/injections.scm
@@ -0,0 +1,13 @@
+((s_string) @injection.content
+  (#set! injection.language "sql")
+  (#offset! @injection.content 0 2 0 -1))
+
+(from_text
+  (keyword_from_text)
+  (keyword_json)
+  (literal) @injection.content
+  (#set! injection.language "json")
+  (#offset! @injection.content 0 3 0 -3))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/psv/highlights.scm b/pack/ant/start/nvim-treesitter/queries/psv/highlights.scm
new file mode 100644
index 0000000..b7303fe
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/psv/highlights.scm
@@ -0,0 +1,3 @@
+; inherits: tsv
+
+"|" @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/pug/highlights.scm b/pack/ant/start/nvim-treesitter/queries/pug/highlights.scm
new file mode 100644
index 0000000..e32cb21
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pug/highlights.scm
@@ -0,0 +1,116 @@
+(comment) @comment @spell
+
+(tag_name) @tag
+
+((tag_name) @constant.builtin
+  ; https://www.script-example.com/html-tag-liste
+  (#any-of? @constant.builtin
+    "head" "title" "base" "link" "meta" "style" "body" "article" "section" "nav" "aside" "h1" "h2"
+    "h3" "h4" "h5" "h6" "hgroup" "header" "footer" "address" "p" "hr" "pre" "blockquote" "ol" "ul"
+    "menu" "li" "dl" "dt" "dd" "figure" "figcaption" "main" "div" "a" "em" "strong" "small" "s"
+    "cite" "q" "dfn" "abbr" "ruby" "rt" "rp" "data" "time" "code" "var" "samp" "kbd" "sub" "sup" "i"
+    "b" "u" "mark" "bdi" "bdo" "span" "br" "wbr" "ins" "del" "picture" "source" "img" "iframe"
+    "embed" "object" "param" "video" "audio" "track" "map" "area" "table" "caption" "colgroup" "col"
+    "tbody" "thead" "tfoot" "tr" "td" "th " "form" "label" "input" "button" "select" "datalist"
+    "optgroup" "option" "textarea" "output" "progress" "meter" "fieldset" "legend" "details"
+    "summary" "dialog" "script" "noscript" "template" "slot" "canvas"))
+
+(id) @constant
+
+(class) @type
+
+(doctype) @keyword.directive
+
+(content) @none
+
+(tag
+  (attributes
+    (attribute
+      (attribute_name) @tag.attribute
+      "=" @operator)))
+
+((tag
+  (attributes
+    (attribute
+      (attribute_name) @keyword)))
+  (#match? @keyword "^(:|v-bind|v-|\\@)"))
+
+(quoted_attribute_value) @string
+
+(include
+  (keyword) @keyword.import)
+
+(extends
+  (keyword) @keyword.import)
+
+(filename) @string.special.path
+
+(block_definition
+  (keyword) @keyword)
+
+(block_append
+  (keyword)+ @keyword)
+
+(block_prepend
+  (keyword)+ @keyword)
+
+(block_name) @module
+
+(conditional
+  (keyword) @keyword.conditional)
+
+(case
+  (keyword) @keyword.conditional
+  (when
+    (keyword) @keyword.conditional)+)
+
+(each
+  (keyword) @keyword.repeat)
+
+(while
+  (keyword) @keyword.repeat)
+
+(mixin_use
+  "+" @punctuation.delimiter
+  (mixin_name) @function.call)
+
+(mixin_definition
+  (keyword) @keyword.function
+  (mixin_name) @function)
+
+(mixin_attributes
+  (attribute_name) @variable.parameter)
+
+(filter
+  ":" @punctuation.delimiter
+  (filter_name) @function.method.call)
+
+(filter
+  (attributes
+    (attribute
+      (attribute_name) @variable.parameter)))
+
+[
+  "("
+  ")"
+  "#{"
+  "}"
+  ; unsupported
+  ; "!{"
+  ; "#[" "]"
+] @punctuation.bracket
+
+[
+  ","
+  "."
+  "|"
+] @punctuation.delimiter
+
+(buffered_code
+  "=" @punctuation.delimiter)
+
+(unbuffered_code
+  "-" @punctuation.delimiter)
+
+(unescaped_buffered_code
+  "!=" @punctuation.delimiter)
diff --git a/pack/ant/start/nvim-treesitter/queries/pug/injections.scm b/pack/ant/start/nvim-treesitter/queries/pug/injections.scm
new file mode 100644
index 0000000..0c01e47
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pug/injections.scm
@@ -0,0 +1,11 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((javascript) @injection.content
+  (#set! injection.language "javascript"))
+
+((attribute_name) @_attribute_name
+  (quoted_attribute_value
+    (attribute_value) @injection.content
+    (#set! injection.language "javascript"))
+  (#match? @_attribute_name "^(:|v-bind|v-|\\@)"))
diff --git a/pack/ant/start/nvim-treesitter/queries/puppet/folds.scm b/pack/ant/start/nvim-treesitter/queries/puppet/folds.scm
new file mode 100644
index 0000000..78800fe
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/puppet/folds.scm
@@ -0,0 +1,13 @@
+[
+  (block)
+  (defined_resource_type)
+  (parameter_list)
+  (attribute_type_entry)
+  (resource_declaration)
+  (selector)
+  (iterator_statement)
+  (case_statement)
+  (hash)
+  (array)
+  (comment)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/puppet/highlights.scm b/pack/ant/start/nvim-treesitter/queries/puppet/highlights.scm
new file mode 100644
index 0000000..1062193
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/puppet/highlights.scm
@@ -0,0 +1,238 @@
+; Variables
+(identifier) @variable
+
+; Includes
+"include" @keyword.import
+
+(include_statement
+  (identifier) @type)
+
+(include_statement
+  (class_identifier
+    (identifier) @type .))
+
+; Keywords
+[
+  "inherits"
+  "node"
+  "tag"
+  "require"
+] @keyword
+
+[
+  "type"
+  "class"
+] @keyword.type
+
+[
+  "define"
+  "function"
+] @keyword.function
+
+[
+  "if"
+  "elsif"
+  "else"
+  "unless"
+  "case"
+] @keyword.conditional
+
+(default_case
+  "default" @keyword.conditional)
+
+; Attributes
+(attribute
+  name: (identifier) @attribute)
+
+(attribute
+  name: (variable
+    (identifier) @attribute))
+
+; Parameters
+(lambda
+  (variable
+    (identifier) @variable.parameter))
+
+(parameter
+  (variable
+    (identifier) @variable.parameter))
+
+(function_call
+  (identifier) @variable.parameter)
+
+(iterator_statement
+  (variable) @variable.parameter)
+
+; Functions
+(function_declaration
+  "function"
+  .
+  (identifier) @function)
+
+(function_call
+  (identifier) @function.call
+  "(")
+
+(defined_resource_type
+  "define"
+  .
+  (identifier) @function)
+
+; Methods
+(function_declaration
+  "function"
+  .
+  (class_identifier
+    (identifier) @function.method .))
+
+(function_call
+  (class_identifier
+    (identifier) @function.method.call .))
+
+(defined_resource_type
+  "define"
+  .
+  (class_identifier
+    (identifier) @function.method .))
+
+(function_call
+  (field_expression
+    "."
+    (identifier) @function.method.call)
+  "(")
+
+; Types
+(type) @type
+
+(builtin_type) @type.builtin
+
+(class_definition
+  (identifier) @type)
+
+(class_definition
+  (class_identifier
+    (identifier) @type .))
+
+(class_inherits
+  (identifier) @type)
+
+(class_inherits
+  (class_identifier
+    (identifier) @type .))
+
+(resource_declaration
+  (identifier) @type)
+
+(resource_declaration
+  (class_identifier
+    (identifier) @type .))
+
+(node_definition
+  (node_name
+    (identifier) @type))
+
+((identifier) @type
+  (#lua-match? @type "^[A-Z]"))
+
+((identifier) @type.builtin
+  (#any-of? @type.builtin
+    "Boolean" "Integer" "Float" "String" "Array" "Hash" "Regexp" "Variant" "Data" "Undef" "Default"
+    "File"))
+
+; "Namespaces"
+(class_identifier
+  .
+  (identifier) @module)
+
+; Operators
+[
+  "or"
+  "and"
+  "in"
+] @keyword.operator
+
+[
+  "="
+  "+="
+  "->"
+  "~>"
+  "<<|"
+  "<|"
+  "|>"
+  "|>>"
+  "?"
+  ">"
+  ">="
+  "<="
+  "<"
+  "=="
+  "!="
+  "<<"
+  ">>"
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "=~"
+  "!~"
+] @operator
+
+; Punctuation
+[
+  "|"
+  "."
+  ","
+  ";"
+  ":"
+  "::"
+  "=>"
+] @punctuation.delimiter
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+(interpolation
+  [
+    "${"
+    "}"
+  ] @punctuation.special)
+
+[
+  "$"
+  "@"
+  "@@"
+] @punctuation.special
+
+; Literals
+(number) @number
+
+(float) @number.float
+
+(string) @string
+
+(escape_sequence) @string.escape
+
+(regex) @string.regexp
+
+(boolean) @boolean
+
+[
+  (undef)
+  (default)
+] @variable.builtin
+
+; Comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/puppet/indents.scm b/pack/ant/start/nvim-treesitter/queries/puppet/indents.scm
new file mode 100644
index 0000000..71c882f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/puppet/indents.scm
@@ -0,0 +1,23 @@
+[
+  (block)
+  (defined_resource_type)
+  (parameter_list)
+  (attribute_type_entry)
+  (resource_declaration)
+  (selector)
+  (case_statement)
+  (hash)
+  (array)
+] @indent.begin
+
+[
+  "}"
+  "]"
+  ")"
+] @indent.branch @indent.end
+
+[
+  (string)
+  (comment)
+  (ERROR)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/puppet/injections.scm b/pack/ant/start/nvim-treesitter/queries/puppet/injections.scm
new file mode 100644
index 0000000..caa10a2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/puppet/injections.scm
@@ -0,0 +1,6 @@
+((regex) @injection.content
+  (#set! injection.language "regex")
+  (#offset! @injection.content 0 1 0 -1))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/puppet/locals.scm b/pack/ant/start/nvim-treesitter/queries/puppet/locals.scm
new file mode 100644
index 0000000..f145fff
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/puppet/locals.scm
@@ -0,0 +1,64 @@
+; Scopes
+[
+  (block)
+  (defined_resource_type)
+  (parameter_list)
+  (attribute_type_entry)
+  (class_definition)
+  (node_definition)
+  (resource_declaration)
+  (selector)
+  (iterator_statement)
+  (case_statement)
+  (hash)
+  (array)
+] @local.scope
+
+; References
+[
+  (identifier)
+  (class_identifier)
+  (variable)
+] @local.reference
+
+; Definitions
+(attribute
+  [
+    (identifier)
+    (variable)
+  ] @local.definition.field)
+
+(function_declaration
+  [
+    (identifier)
+    (class_identifier)
+  ] @local.definition.function)
+
+(include_statement
+  [
+    (identifier)
+    (class_identifier)
+  ] @local.definition.import)
+
+(parameter
+  (variable) @local.definition.parameter)
+
+(class_definition
+  [
+    (identifier)
+    (class_identifier)
+  ] @local.definition.type)
+
+(node_definition
+  (node_name
+    (identifier) @local.definition.type))
+
+(resource_declaration
+  [
+    (identifier)
+    (class_identifier)
+  ] @local.definition.type)
+
+(assignment
+  .
+  (variable) @local.definition.var)
diff --git a/pack/ant/start/nvim-treesitter/queries/purescript/highlights.scm b/pack/ant/start/nvim-treesitter/queries/purescript/highlights.scm
new file mode 100644
index 0000000..02426b0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/purescript/highlights.scm
@@ -0,0 +1,196 @@
+; ----------------------------------------------------------------------------
+; Literals and comments
+[
+  (integer)
+  (exp_negation)
+] @number
+
+(exp_literal
+  (number)) @number.float
+
+(char) @character
+
+[
+  (string)
+  (triple_quote_string)
+] @string
+
+(comment) @comment @spell
+
+; ----------------------------------------------------------------------------
+; Punctuation
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  (comma)
+  ";"
+  (qualified_module) ; grabs the `.` (dot), ex: import System.IO
+  "."
+] @punctuation.delimiter
+
+; ----------------------------------------------------------------------------
+; Keywords, operators, includes
+[
+  "if"
+  "then"
+  "else"
+  "case"
+  "of"
+] @keyword.conditional
+
+[
+  "import"
+  "module"
+] @keyword.import
+
+[
+  (operator)
+  (constructor_operator)
+  (type_operator)
+  (all_names)
+  "="
+  "|"
+  "::"
+  "∷"
+  "=>"
+  "⇒"
+  "<="
+  "⇐"
+  "->"
+  "→"
+  "<-"
+  "←"
+  "\\"
+  "`"
+  "@"
+] @operator
+
+(qualified_module
+  (module) @constructor)
+
+(module) @module
+
+(qualified_type
+  (module) @module)
+
+(qualified_variable
+  (module) @module)
+
+(import
+  (module) @module)
+
+[
+  (where)
+  "let"
+  "in"
+  "instance"
+  "derive"
+  "foreign"
+  "data"
+  "as"
+  "hiding"
+  "do"
+  "ado"
+  "forall"
+  "∀"
+  "infix"
+  "infixl"
+  "infixr"
+] @keyword
+
+[
+  "type"
+  "newtype"
+  "class"
+] @keyword.type
+
+(class_instance
+  "else" @keyword)
+
+(type_role_declaration
+  "role" @keyword
+  role: (type_role) @keyword.modifier)
+
+; `_` wildcards in if-then-else and case-of expressions,
+; as well as record updates and operator sections
+[
+  "_"
+  (hole)
+] @character.special
+
+; ----------------------------------------------------------------------------
+; Functions and variables
+(variable) @variable
+
+(exp_apply
+  .
+  (exp_name
+    (variable) @function))
+
+(exp_apply
+  .
+  (exp_name
+    (qualified_variable
+      (variable) @function)))
+
+(row_field
+  (field_name) @variable.member)
+
+(record_field
+  (field_name) @variable.member)
+
+(record_accessor
+  (variable) @variable.member)
+
+(exp_record_access
+  (variable) @variable.member)
+
+(signature
+  name: (variable) @type)
+
+(kind_declaration
+  (class_name) @type)
+
+(function
+  name: (variable) @function)
+
+(foreign_import
+  (variable) @function)
+
+(class_instance
+  (instance_name) @function)
+
+(derive_declaration
+  (instance_name) @function)
+
+; true or false
+((variable) @boolean
+  (#any-of? @boolean "true" "false"))
+
+; The former one works for `tree-sitter highlight` but not in Helix/Kakoune.
+; The latter two work in Helix (but not Kakoune) and are a good compromise between not highlighting anything at all
+; as an operator and leaving it to the child nodes, and highlighting everything as an operator.
+(exp_ticked
+  (_) @operator)
+
+(exp_ticked
+  (exp_name
+    (variable) @operator))
+
+(exp_ticked
+  (exp_name
+    (qualified_variable
+      (variable) @operator)))
+
+; ----------------------------------------------------------------------------
+; Types
+(type) @type
+
+(constructor) @constructor
diff --git a/pack/ant/start/nvim-treesitter/queries/purescript/injections.scm b/pack/ant/start/nvim-treesitter/queries/purescript/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/purescript/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/purescript/locals.scm b/pack/ant/start/nvim-treesitter/queries/purescript/locals.scm
new file mode 100644
index 0000000..1626523
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/purescript/locals.scm
@@ -0,0 +1,11 @@
+(signature
+  name: (variable)) @local.definition.type
+
+(function
+  name: (variable)) @local.definition.function
+
+(pat_name
+  (variable)) @local.definition
+
+(exp_name
+  (variable)) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/pymanifest/highlights.scm b/pack/ant/start/nvim-treesitter/queries/pymanifest/highlights.scm
new file mode 100644
index 0000000..11d8b60
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pymanifest/highlights.scm
@@ -0,0 +1,25 @@
+(keyword) @keyword
+
+(dir_sep) @punctuation.delimiter
+
+(glob) @punctuation.special
+
+(linebreak) @character.special
+
+(char_sequence) @string.special
+
+(char_sequence
+  [
+    "["
+    "]"
+  ] @punctuation.bracket)
+
+(char_sequence
+  "!" @operator)
+
+(char_range
+  "-" @operator)
+
+(escaped_char) @string.escape
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/pymanifest/injections.scm b/pack/ant/start/nvim-treesitter/queries/pymanifest/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/pymanifest/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/python/folds.scm b/pack/ant/start/nvim-treesitter/queries/python/folds.scm
new file mode 100644
index 0000000..ecb9352
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/python/folds.scm
@@ -0,0 +1,28 @@
+[
+  (function_definition)
+  (class_definition)
+  (while_statement)
+  (for_statement)
+  (if_statement)
+  (with_statement)
+  (try_statement)
+  (match_statement)
+  (import_from_statement)
+  (parameters)
+  (argument_list)
+  (parenthesized_expression)
+  (generator_expression)
+  (list_comprehension)
+  (set_comprehension)
+  (dictionary_comprehension)
+  (tuple)
+  (list)
+  (set)
+  (dictionary)
+  (string)
+] @fold
+
+[
+  (import_statement)
+  (import_from_statement)
+]+ @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/python/highlights.scm b/pack/ant/start/nvim-treesitter/queries/python/highlights.scm
new file mode 100644
index 0000000..2363dc3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/python/highlights.scm
@@ -0,0 +1,441 @@
+; From tree-sitter-python licensed under MIT License
+; Copyright (c) 2016 Max Brunsfeld
+; Variables
+(identifier) @variable
+
+; Reset highlighting in f-string interpolations
+(interpolation) @none
+
+; Identifier naming conventions
+((identifier) @type
+  (#lua-match? @type "^[A-Z].*[a-z]"))
+
+((identifier) @constant
+  (#lua-match? @constant "^[A-Z][A-Z_0-9]*$"))
+
+((identifier) @constant.builtin
+  (#lua-match? @constant.builtin "^__[a-zA-Z0-9_]*__$"))
+
+((identifier) @constant.builtin
+  (#any-of? @constant.builtin
+    ; https://docs.python.org/3/library/constants.html
+    "NotImplemented" "Ellipsis" "quit" "exit" "copyright" "credits" "license"))
+
+"_" @character.special ; match wildcard
+
+((attribute
+  attribute: (identifier) @variable.member)
+  (#lua-match? @variable.member "^[%l_].*$"))
+
+((assignment
+  left: (identifier) @type.definition
+  (type
+    (identifier) @_annotation))
+  (#eq? @_annotation "TypeAlias"))
+
+((assignment
+  left: (identifier) @type.definition
+  right: (call
+    function: (identifier) @_func))
+  (#any-of? @_func "TypeVar" "NewType"))
+
+; Function calls
+(call
+  function: (identifier) @function.call)
+
+(call
+  function: (attribute
+    attribute: (identifier) @function.method.call))
+
+((call
+  function: (identifier) @constructor)
+  (#lua-match? @constructor "^%u"))
+
+((call
+  function: (attribute
+    attribute: (identifier) @constructor))
+  (#lua-match? @constructor "^%u"))
+
+; Decorators
+((decorator
+  "@" @attribute)
+  (#set! priority 101))
+
+(decorator
+  (identifier) @attribute)
+
+(decorator
+  (attribute
+    attribute: (identifier) @attribute))
+
+(decorator
+  (call
+    (identifier) @attribute))
+
+(decorator
+  (call
+    (attribute
+      attribute: (identifier) @attribute)))
+
+((decorator
+  (identifier) @attribute.builtin)
+  (#any-of? @attribute.builtin "classmethod" "property" "staticmethod"))
+
+; Builtin functions
+((call
+  function: (identifier) @function.builtin)
+  (#any-of? @function.builtin
+    "abs" "all" "any" "ascii" "bin" "bool" "breakpoint" "bytearray" "bytes" "callable" "chr"
+    "classmethod" "compile" "complex" "delattr" "dict" "dir" "divmod" "enumerate" "eval" "exec"
+    "filter" "float" "format" "frozenset" "getattr" "globals" "hasattr" "hash" "help" "hex" "id"
+    "input" "int" "isinstance" "issubclass" "iter" "len" "list" "locals" "map" "max" "memoryview"
+    "min" "next" "object" "oct" "open" "ord" "pow" "print" "property" "range" "repr" "reversed"
+    "round" "set" "setattr" "slice" "sorted" "staticmethod" "str" "sum" "super" "tuple" "type"
+    "vars" "zip" "__import__"))
+
+; Function definitions
+(function_definition
+  name: (identifier) @function)
+
+(type
+  (identifier) @type)
+
+(type
+  (subscript
+    (identifier) @type)) ; type subscript: Tuple[int]
+
+((call
+  function: (identifier) @_isinstance
+  arguments: (argument_list
+    (_)
+    (identifier) @type))
+  (#eq? @_isinstance "isinstance"))
+
+; Normal parameters
+(parameters
+  (identifier) @variable.parameter)
+
+; Lambda parameters
+(lambda_parameters
+  (identifier) @variable.parameter)
+
+(lambda_parameters
+  (tuple_pattern
+    (identifier) @variable.parameter))
+
+; Default parameters
+(keyword_argument
+  name: (identifier) @variable.parameter)
+
+; Naming parameters on call-site
+(default_parameter
+  name: (identifier) @variable.parameter)
+
+(typed_parameter
+  (identifier) @variable.parameter)
+
+(typed_default_parameter
+  name: (identifier) @variable.parameter)
+
+; Variadic parameters *args, **kwargs
+(parameters
+  (list_splat_pattern ; *args
+    (identifier) @variable.parameter))
+
+(parameters
+  (dictionary_splat_pattern ; **kwargs
+    (identifier) @variable.parameter))
+
+; Typed variadic parameters
+(parameters
+  (typed_parameter
+    (list_splat_pattern ; *args: type
+      (identifier) @variable.parameter)))
+
+(parameters
+  (typed_parameter
+    (dictionary_splat_pattern ; *kwargs: type
+      (identifier) @variable.parameter)))
+
+; Lambda parameters
+(lambda_parameters
+  (list_splat_pattern
+    (identifier) @variable.parameter))
+
+(lambda_parameters
+  (dictionary_splat_pattern
+    (identifier) @variable.parameter))
+
+; Literals
+(none) @constant.builtin
+
+[
+  (true)
+  (false)
+] @boolean
+
+((identifier) @variable.builtin
+  (#eq? @variable.builtin "self"))
+
+((identifier) @variable.builtin
+  (#eq? @variable.builtin "cls"))
+
+(integer) @number
+
+(float) @number.float
+
+(comment) @comment @spell
+
+((module
+  .
+  (comment) @keyword.directive @nospell)
+  (#lua-match? @keyword.directive "^#!/"))
+
+(string) @string
+
+[
+  (escape_sequence)
+  (escape_interpolation)
+] @string.escape
+
+; doc-strings
+(module
+  .
+  (comment)*
+  .
+  (expression_statement
+    (string
+      (string_content) @spell) @string.documentation))
+
+(class_definition
+  body: (block
+    .
+    (expression_statement
+      (string
+        (string_content) @spell) @string.documentation)))
+
+(function_definition
+  body: (block
+    .
+    (expression_statement
+      (string
+        (string_content) @spell) @string.documentation)))
+
+; Tokens
+[
+  "-"
+  "-="
+  ":="
+  "!="
+  "*"
+  "**"
+  "**="
+  "*="
+  "/"
+  "//"
+  "//="
+  "/="
+  "&"
+  "&="
+  "%"
+  "%="
+  "^"
+  "^="
+  "+"
+  "+="
+  "<"
+  "<<"
+  "<<="
+  "<="
+  "<>"
+  "="
+  "=="
+  ">"
+  ">="
+  ">>"
+  ">>="
+  "@"
+  "@="
+  "|"
+  "|="
+  "~"
+  "->"
+] @operator
+
+; Keywords
+[
+  "and"
+  "in"
+  "is"
+  "not"
+  "or"
+  "is not"
+  "not in"
+  "del"
+] @keyword.operator
+
+[
+  "def"
+  "lambda"
+] @keyword.function
+
+[
+  "assert"
+  "exec"
+  "global"
+  "nonlocal"
+  "pass"
+  "print"
+  "with"
+  "as"
+] @keyword
+
+[
+  "type"
+  "class"
+] @keyword.type
+
+[
+  "async"
+  "await"
+] @keyword.coroutine
+
+[
+  "return"
+  "yield"
+] @keyword.return
+
+(yield
+  "from" @keyword.return)
+
+(future_import_statement
+  "from" @keyword.import
+  "__future__" @constant.builtin)
+
+(import_from_statement
+  "from" @keyword.import)
+
+"import" @keyword.import
+
+(aliased_import
+  "as" @keyword.import)
+
+(wildcard_import
+  "*" @character.special)
+
+[
+  "if"
+  "elif"
+  "else"
+  "match"
+  "case"
+] @keyword.conditional
+
+[
+  "for"
+  "while"
+  "break"
+  "continue"
+] @keyword.repeat
+
+[
+  "try"
+  "except"
+  "except*"
+  "raise"
+  "finally"
+] @keyword.exception
+
+(raise_statement
+  "from" @keyword.exception)
+
+(try_statement
+  (else_clause
+    "else" @keyword.exception))
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+(interpolation
+  "{" @punctuation.special
+  "}" @punctuation.special)
+
+(type_conversion) @function.macro
+
+[
+  ","
+  "."
+  ":"
+  ";"
+  (ellipsis)
+] @punctuation.delimiter
+
+; Class definitions
+(class_definition
+  name: (identifier) @type)
+
+(class_definition
+  body: (block
+    (function_definition
+      name: (identifier) @function.method)))
+
+(class_definition
+  superclasses: (argument_list
+    (identifier) @type))
+
+((class_definition
+  body: (block
+    (expression_statement
+      (assignment
+        left: (identifier) @variable.member))))
+  (#lua-match? @variable.member "^[%l_].*$"))
+
+((class_definition
+  body: (block
+    (expression_statement
+      (assignment
+        left: (_
+          (identifier) @variable.member)))))
+  (#lua-match? @variable.member "^[%l_].*$"))
+
+((class_definition
+  (block
+    (function_definition
+      name: (identifier) @constructor)))
+  (#any-of? @constructor "__new__" "__init__"))
+
+((identifier) @type.builtin
+  (#any-of? @type.builtin
+    ; https://docs.python.org/3/library/exceptions.html
+    "BaseException" "Exception" "ArithmeticError" "BufferError" "LookupError" "AssertionError"
+    "AttributeError" "EOFError" "FloatingPointError" "GeneratorExit" "ImportError"
+    "ModuleNotFoundError" "IndexError" "KeyError" "KeyboardInterrupt" "MemoryError" "NameError"
+    "NotImplementedError" "OSError" "OverflowError" "RecursionError" "ReferenceError" "RuntimeError"
+    "StopIteration" "StopAsyncIteration" "SyntaxError" "IndentationError" "TabError" "SystemError"
+    "SystemExit" "TypeError" "UnboundLocalError" "UnicodeError" "UnicodeEncodeError"
+    "UnicodeDecodeError" "UnicodeTranslateError" "ValueError" "ZeroDivisionError" "EnvironmentError"
+    "IOError" "WindowsError" "BlockingIOError" "ChildProcessError" "ConnectionError"
+    "BrokenPipeError" "ConnectionAbortedError" "ConnectionRefusedError" "ConnectionResetError"
+    "FileExistsError" "FileNotFoundError" "InterruptedError" "IsADirectoryError"
+    "NotADirectoryError" "PermissionError" "ProcessLookupError" "TimeoutError" "Warning"
+    "UserWarning" "DeprecationWarning" "PendingDeprecationWarning" "SyntaxWarning" "RuntimeWarning"
+    "FutureWarning" "ImportWarning" "UnicodeWarning" "BytesWarning" "ResourceWarning"
+    ; https://docs.python.org/3/library/stdtypes.html
+    "bool" "int" "float" "complex" "list" "tuple" "range" "str" "bytes" "bytearray" "memoryview"
+    "set" "frozenset" "dict" "type" "object"))
+
+; Regex from the `re` module
+(call
+  function: (attribute
+    object: (identifier) @_re)
+  arguments: (argument_list
+    .
+    (string
+      (string_content) @string.regexp))
+  (#eq? @_re "re"))
diff --git a/pack/ant/start/nvim-treesitter/queries/python/indents.scm b/pack/ant/start/nvim-treesitter/queries/python/indents.scm
new file mode 100644
index 0000000..2414812
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/python/indents.scm
@@ -0,0 +1,213 @@
+[
+  (import_from_statement)
+  (generator_expression)
+  (list_comprehension)
+  (set_comprehension)
+  (dictionary_comprehension)
+  (tuple_pattern)
+  (list_pattern)
+  (binary_operator)
+  (lambda)
+  (concatenated_string)
+] @indent.begin
+
+((list) @indent.align
+  (#set! indent.open_delimiter "[")
+  (#set! indent.close_delimiter "]"))
+
+((dictionary) @indent.align
+  (#set! indent.open_delimiter "{")
+  (#set! indent.close_delimiter "}"))
+
+((set) @indent.align
+  (#set! indent.open_delimiter "{")
+  (#set! indent.close_delimiter "}"))
+
+((parenthesized_expression) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+((for_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+((if_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+((while_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+((try_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+(ERROR
+  "try"
+  .
+  ":"
+  (#set! indent.immediate 1)) @indent.begin
+
+(ERROR
+  "try"
+  .
+  ":"
+  (ERROR
+    (block
+      (expression_statement
+        (identifier) @_except) @indent.branch))
+  (#eq? @_except "except"))
+
+((function_definition) @indent.begin
+  (#set! indent.immediate 1))
+
+((class_definition) @indent.begin
+  (#set! indent.immediate 1))
+
+((with_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+((match_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+((case_clause) @indent.begin
+  (#set! indent.immediate 1))
+
+; if (cond1
+;     or cond2
+;         or cond3):
+;     pass
+;
+(if_statement
+  condition: (parenthesized_expression) @indent.align
+  (#lua-match? @indent.align "^%([^\n]")
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")")
+  (#set! indent.avoid_last_matching_next 1))
+
+; while (
+;     cond1
+;     or cond2
+;         or cond3):
+;     pass
+;
+(while_statement
+  condition: (parenthesized_expression) @indent.align
+  (#lua-match? @indent.align "[^\n ]%)$")
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")")
+  (#set! indent.avoid_last_matching_next 1))
+
+; if (
+;     cond1
+;     or cond2
+;         or cond3):
+;     pass
+;
+(if_statement
+  condition: (parenthesized_expression) @indent.align
+  (#lua-match? @indent.align "[^\n ]%)$")
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")")
+  (#set! indent.avoid_last_matching_next 1))
+
+(ERROR
+  "(" @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")")
+  .
+  (_))
+
+((argument_list) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+((parameters) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+((parameters) @indent.align
+  (#lua-match? @indent.align "[^\n ]%)$")
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")")
+  (#set! indent.avoid_last_matching_next 1))
+
+((tuple) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+(ERROR
+  "[" @indent.align
+  (#set! indent.open_delimiter "[")
+  (#set! indent.close_delimiter "]")
+  .
+  (_))
+
+(ERROR
+  "{" @indent.align
+  (#set! indent.open_delimiter "{")
+  (#set! indent.close_delimiter "}")
+  .
+  (_))
+
+[
+  (break_statement)
+  (continue_statement)
+] @indent.dedent
+
+(ERROR
+  (_) @indent.branch
+  ":"
+  .
+  (#lua-match? @indent.branch "^else"))
+
+(ERROR
+  (_) @indent.branch @indent.dedent
+  ":"
+  .
+  (#lua-match? @indent.branch "^elif"))
+
+(generator_expression
+  ")" @indent.end)
+
+(list_comprehension
+  "]" @indent.end)
+
+(set_comprehension
+  "}" @indent.end)
+
+(dictionary_comprehension
+  "}" @indent.end)
+
+(tuple_pattern
+  ")" @indent.end)
+
+(list_pattern
+  "]" @indent.end)
+
+(return_statement
+  [
+    (_) @indent.end
+    (_
+      [
+        (_)
+        ")"
+        "}"
+        "]"
+      ] @indent.end .)
+    (attribute
+      attribute: (_) @indent.end)
+    (call
+      arguments: (_
+        ")" @indent.end))
+    "return" @indent.end
+  ] .)
+
+[
+  ")"
+  "]"
+  "}"
+  (elif_clause)
+  (else_clause)
+  (except_clause)
+  (finally_clause)
+] @indent.branch
+
+(string) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/python/injections.scm b/pack/ant/start/nvim-treesitter/queries/python/injections.scm
new file mode 100644
index 0000000..bbc924b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/python/injections.scm
@@ -0,0 +1,18 @@
+(call
+  function: (attribute
+    object: (identifier) @_re)
+  arguments: (argument_list
+    .
+    (string
+      (string_content) @injection.content))
+  (#eq? @_re "re")
+  (#set! injection.language "regex"))
+
+((binary_operator
+  left: (string
+    (string_content) @injection.content)
+  operator: "%")
+  (#set! injection.language "printf"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/python/locals.scm b/pack/ant/start/nvim-treesitter/queries/python/locals.scm
new file mode 100644
index 0000000..6a9dffe
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/python/locals.scm
@@ -0,0 +1,124 @@
+; Program structure
+(module) @local.scope
+
+(class_definition
+  body: (block
+    (expression_statement
+      (assignment
+        left: (identifier) @local.definition.field)))) @local.scope
+
+(class_definition
+  body: (block
+    (expression_statement
+      (assignment
+        left: (_
+          (identifier) @local.definition.field))))) @local.scope
+
+; Imports
+(aliased_import
+  alias: (identifier) @local.definition.import)
+
+(import_statement
+  name: (dotted_name
+    (identifier) @local.definition.import))
+
+(import_from_statement
+  name: (dotted_name
+    (identifier) @local.definition.import))
+
+; Function with parameters, defines parameters
+(parameters
+  (identifier) @local.definition.parameter)
+
+(default_parameter
+  (identifier) @local.definition.parameter)
+
+(typed_parameter
+  (identifier) @local.definition.parameter)
+
+(typed_default_parameter
+  (identifier) @local.definition.parameter)
+
+; *args parameter
+(parameters
+  (list_splat_pattern
+    (identifier) @local.definition.parameter))
+
+; **kwargs parameter
+(parameters
+  (dictionary_splat_pattern
+    (identifier) @local.definition.parameter))
+
+; Function defines function and scope
+((function_definition
+  name: (identifier) @local.definition.function) @local.scope
+  (#set! definition.function.scope "parent"))
+
+((class_definition
+  name: (identifier) @local.definition.type) @local.scope
+  (#set! definition.type.scope "parent"))
+
+(class_definition
+  body: (block
+    (function_definition
+      name: (identifier) @local.definition.method)))
+
+; Loops
+; not a scope!
+(for_statement
+  left: (pattern_list
+    (identifier) @local.definition.var))
+
+(for_statement
+  left: (tuple_pattern
+    (identifier) @local.definition.var))
+
+(for_statement
+  left: (identifier) @local.definition.var)
+
+; not a scope!
+;(while_statement) @local.scope
+; for in list comprehension
+(for_in_clause
+  left: (identifier) @local.definition.var)
+
+(for_in_clause
+  left: (tuple_pattern
+    (identifier) @local.definition.var))
+
+(for_in_clause
+  left: (pattern_list
+    (identifier) @local.definition.var))
+
+(dictionary_comprehension) @local.scope
+
+(list_comprehension) @local.scope
+
+(set_comprehension) @local.scope
+
+; Assignments
+(assignment
+  left: (identifier) @local.definition.var)
+
+(assignment
+  left: (pattern_list
+    (identifier) @local.definition.var))
+
+(assignment
+  left: (tuple_pattern
+    (identifier) @local.definition.var))
+
+(assignment
+  left: (attribute
+    (identifier)
+    (identifier) @local.definition.field))
+
+; Walrus operator  x := 1
+(named_expression
+  (identifier) @local.definition.var)
+
+(as_pattern
+  alias: (as_pattern_target) @local.definition.var)
+
+; REFERENCES
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/ql/folds.scm b/pack/ant/start/nvim-treesitter/queries/ql/folds.scm
new file mode 100644
index 0000000..eb7f272
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ql/folds.scm
@@ -0,0 +1,7 @@
+[
+  (module)
+  (classlessPredicate)
+  (dataclass)
+  (charpred)
+  (memberPredicate)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/ql/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ql/highlights.scm
new file mode 100644
index 0000000..f428120
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ql/highlights.scm
@@ -0,0 +1,154 @@
+[
+  "as"
+  "by"
+  "extends"
+  "from"
+  "implies"
+  "in"
+  "module"
+  "order"
+  "select"
+  "where"
+  (predicate)
+  (result)
+  (specialId)
+] @keyword
+
+[
+  "newtype"
+  "class"
+] @keyword.type
+
+[
+  "and"
+  "not"
+  "or"
+] @keyword.operator
+
+[
+  "avg"
+  "any"
+  "count"
+  "concat"
+  "exists"
+  "max"
+  "min"
+  "instanceof"
+  "rank"
+  "sum"
+  "strictconcat"
+  "strictcount"
+  "strictsum"
+] @function.builtin
+
+"import" @keyword.import
+
+[
+  "if"
+  "then"
+  "else"
+] @keyword.conditional
+
+[
+  "forall"
+  "forex"
+] @keyword.repeat
+
+[
+  "asc"
+  "desc"
+] @keyword.modifier
+
+[
+  (true)
+  (false)
+] @boolean
+
+[
+  (this)
+  (super)
+] @variable.builtin
+
+[
+  "boolean"
+  "float"
+  "int"
+  "date"
+  "string"
+] @type.builtin
+
+(annotName) @attribute
+
+[
+  "<"
+  "<="
+  "="
+  ">"
+  ">="
+  "-"
+  "!="
+  "/"
+  "*"
+  "%"
+  "+"
+  "::"
+] @operator
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ","
+  "|"
+] @punctuation.delimiter
+
+(moduleExpr
+  (simpleId) @module)
+
+(module
+  name: (moduleName) @module)
+
+(dataclass
+  name: (className) @type)
+
+(typeExpr
+  name: (className) @type)
+
+(datatype
+  name: (className) @type.definition)
+
+(importModuleExpr
+  qualName: (simpleId) @variable)
+
+(varName) @variable
+
+(integer) @number
+
+(float) @number.float
+
+(string) @string
+
+(aritylessPredicateExpr
+  (literalId) @function)
+
+(memberPredicate
+  name: (predicateName) @function)
+
+(classlessPredicate
+  name: (predicateName) @function)
+
+(charpred
+  (className) @function)
+
+[
+  (line_comment)
+  (block_comment)
+] @comment @spell
+
+(qldoc) @comment.documentation
diff --git a/pack/ant/start/nvim-treesitter/queries/ql/indents.scm b/pack/ant/start/nvim-treesitter/queries/ql/indents.scm
new file mode 100644
index 0000000..1a4a1bd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ql/indents.scm
@@ -0,0 +1,23 @@
+[
+  (module)
+  (dataclass)
+  (classMember)
+  (classlessPredicate)
+  (quantified)
+] @indent.begin
+
+[
+  ")"
+  "}"
+] @indent.end
+
+[
+  ")"
+  "}"
+] @indent.branch
+
+[
+  (block_comment)
+  (line_comment)
+  (qldoc)
+] @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/ql/injections.scm b/pack/ant/start/nvim-treesitter/queries/ql/injections.scm
new file mode 100644
index 0000000..090116c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ql/injections.scm
@@ -0,0 +1,6 @@
+([
+  (line_comment)
+  (block_comment)
+  (qldoc)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/ql/locals.scm b/pack/ant/start/nvim-treesitter/queries/ql/locals.scm
new file mode 100644
index 0000000..2394201
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ql/locals.scm
@@ -0,0 +1,49 @@
+; SCOPES
+(module) @local.scope
+
+(dataclass) @local.scope
+
+(datatype) @local.scope
+
+; TODO does not work
+;(classMember (body)  @local.scope)
+(memberPredicate
+  (body) @local.scope)
+
+(classlessPredicate
+  (body) @local.scope)
+
+(quantified
+  (conjunction) @local.scope)
+
+(select) @local.scope
+
+; DEFINITIONS
+; module
+(module
+  name: (moduleName) @local.definition.namespace)
+
+; classes
+(dataclass
+  name: (className) @local.definition.type)
+
+(datatype
+  name: (className) @local.definition.type)
+
+; predicates
+(charpred
+  (className) @local.definition.method)
+
+(memberPredicate
+  name: (predicateName) @local.definition.method)
+
+(classlessPredicate
+  name: (predicateName) @local.definition.function)
+
+; variables
+(varDecl
+  (varName
+    (simpleId) @local.definition.var))
+
+; REFERENCES
+(simpleId) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/qmldir/highlights.scm b/pack/ant/start/nvim-treesitter/queries/qmldir/highlights.scm
new file mode 100644
index 0000000..780dbb3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/qmldir/highlights.scm
@@ -0,0 +1,20 @@
+; Preproc
+(command
+  (identifier) @keyword.directive)
+
+; Keywords
+(keyword) @keyword
+
+; Literals
+(number) @number
+
+(float) @number.float
+
+; Variables
+[
+  (identifier)
+  (unit)
+] @variable
+
+; Comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/qmldir/injections.scm b/pack/ant/start/nvim-treesitter/queries/qmldir/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/qmldir/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/qmljs/folds.scm b/pack/ant/start/nvim-treesitter/queries/qmljs/folds.scm
new file mode 100644
index 0000000..9b91799
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/qmljs/folds.scm
@@ -0,0 +1,8 @@
+[
+  (ui_object_definition)
+  (function_declaration)
+  (statement_block)
+  (if_statement)
+  (ui_binding)
+  (comment)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/qmljs/highlights.scm b/pack/ant/start/nvim-treesitter/queries/qmljs/highlights.scm
new file mode 100644
index 0000000..27f3320
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/qmljs/highlights.scm
@@ -0,0 +1,116 @@
+; inherits: ecma
+
+"pragma" @keyword.import
+
+; Annotations
+(ui_annotation
+  "@" @operator
+  type_name: [
+    (identifier) @attribute
+    (nested_identifier
+      (identifier) @attribute)
+  ])
+
+; type
+(ui_property
+  type: (type_identifier) @type)
+
+; Properties
+(ui_object_definition_binding
+  name: [
+    (identifier) @property
+    (nested_identifier
+      (identifier) @property)
+  ])
+
+(ui_binding
+  name: [
+    (identifier) @property
+    (nested_identifier
+      (identifier) @property)
+  ])
+
+; locals query appears not working unless id: <ref> isn't a parameter.
+(ui_binding
+  name: (identifier) @property
+  (#eq? @property "id")
+  value: (expression_statement
+    (identifier) @variable))
+
+(ui_property
+  name: (identifier) @property)
+
+(ui_required
+  name: (identifier) @property)
+
+(ui_list_property_type
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+; Signals
+(ui_signal
+  name: (identifier) @function)
+
+(ui_signal_parameter
+  (identifier) @variable)
+
+; ui_object_definition
+(ui_object_definition
+  type_name: (identifier) @type)
+
+(ui_object_definition
+  type_name: (nested_identifier) @type)
+
+; namespace
+(nested_identifier
+  (nested_identifier
+    (identifier) @module))
+
+; Tokens
+;-------
+[
+  "abstract"
+  "private"
+  "protected"
+  "public"
+  "default"
+  "readonly"
+  "required"
+] @keyword.modifier
+
+; from typescript
+(type_identifier) @type
+
+(predefined_type) @type.builtin
+
+(type_arguments
+  "<" @punctuation.bracket
+  ">" @punctuation.bracket)
+
+; Variables
+(required_parameter
+  (identifier) @variable)
+
+(optional_parameter
+  (identifier) @variable)
+
+; Keywords
+[
+  "on"
+  "property"
+  "signal"
+  "declare"
+  "implements"
+  "override"
+] @keyword
+
+[
+  "interface"
+  "type"
+  "enum"
+  "namespace"
+] @keyword.type
+
+"keyof" @keyword.operator
diff --git a/pack/ant/start/nvim-treesitter/queries/qmljs/injections.scm b/pack/ant/start/nvim-treesitter/queries/qmljs/injections.scm
new file mode 100644
index 0000000..04328f0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/qmljs/injections.scm
@@ -0,0 +1 @@
+; inherits: ecma
diff --git a/pack/ant/start/nvim-treesitter/queries/query/folds.scm b/pack/ant/start/nvim-treesitter/queries/query/folds.scm
new file mode 100644
index 0000000..47dd965
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/query/folds.scm
@@ -0,0 +1,6 @@
+[
+  (named_node)
+  (predicate)
+  (grouping)
+  (list)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/query/highlights.scm b/pack/ant/start/nvim-treesitter/queries/query/highlights.scm
new file mode 100644
index 0000000..f839ec9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/query/highlights.scm
@@ -0,0 +1,94 @@
+(string) @string
+
+(escape_sequence) @string.escape
+
+(capture
+  (identifier) @type)
+
+(predicate
+  name: (identifier) @function.call)
+
+(named_node
+  name: (identifier) @variable)
+
+(field_definition
+  name: (identifier) @variable.member)
+
+(negated_field
+  "!" @operator
+  (identifier) @property)
+
+(comment) @comment @spell
+
+(quantifier) @operator
+
+(predicate_type) @punctuation.special
+
+"." @operator
+
+[
+  "["
+  "]"
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  ":"
+  "/"
+] @punctuation.delimiter
+
+[
+  "@"
+  "#"
+] @punctuation.special
+
+"_" @character.special
+
+((parameters
+  (identifier) @number)
+  (#match? @number "^[-+]?[0-9]+(.[0-9]+)?$"))
+
+((program
+  .
+  (comment)*
+  .
+  (comment) @keyword.import @nospell)
+  (#lua-match? @keyword.import "^;+ *inherits *:"))
+
+((program
+  .
+  (comment)*
+  .
+  (comment) @keyword.directive @nospell)
+  (#lua-match? @keyword.directive "^;+ *extends *$"))
+
+((comment) @keyword.directive @nospell
+  (#lua-match? @keyword.directive "^;+%s*format%-ignore%s*$"))
+
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    .
+    (capture)?
+    .
+    (identifier) @property))
+  (#eq? @_name "set"))
+
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    (string
+      "\"" @string
+      "\"" @string) @string.regexp))
+  (#any-of? @_name "match" "not-match" "vim-match" "not-vim-match" "lua-match" "not-lua-match"))
+
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    (string
+      "\"" @string
+      "\"" @string) @string.regexp
+    .
+    (string) .))
+  (#any-of? @_name "gsub" "not-gsub"))
diff --git a/pack/ant/start/nvim-treesitter/queries/query/indents.scm b/pack/ant/start/nvim-treesitter/queries/query/indents.scm
new file mode 100644
index 0000000..5cea97e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/query/indents.scm
@@ -0,0 +1,25 @@
+[
+  (list)
+  (named_node)
+  (grouping)
+  (predicate)
+  "["
+] @indent.begin
+
+; ERROR node indents
+(ERROR
+  "(") @indent.begin
+
+"]" @indent.branch @indent.end
+
+[
+  ")"
+  "?"
+  "*"
+  "+"
+] @indent.end
+
+; Captures always mark the end of a node
+; Because of that, mark it as indent.end
+(capture
+  name: (identifier) @indent.end)
diff --git a/pack/ant/start/nvim-treesitter/queries/query/injections.scm b/pack/ant/start/nvim-treesitter/queries/query/injections.scm
new file mode 100644
index 0000000..759f9b2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/query/injections.scm
@@ -0,0 +1,28 @@
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    (string
+      (string_content) @injection.content)))
+  (#any-of? @_name "match" "not-match" "any-match" "vim-match" "not-vim-match" "any-vim-match")
+  (#set! injection.language "regex"))
+
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    (string
+      (string_content) @injection.content)))
+  (#any-of? @_name "lua-match" "not-lua-match" "any-lua-match")
+  (#set! injection.language "luap"))
+
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    (string
+      (string_content) @injection.content)
+    .
+    (string) .))
+  (#any-of? @_name "gsub" "not-gsub")
+  (#set! injection.language "luap"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/query/locals.scm b/pack/ant/start/nvim-treesitter/queries/query/locals.scm
new file mode 100644
index 0000000..eca196a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/query/locals.scm
@@ -0,0 +1,21 @@
+(program) @local.scope
+
+(program
+  (named_node) @local.scope)
+
+(program
+  (anonymous_node) @local.scope)
+
+(program
+  (grouping) @local.scope)
+
+(identifier) @local.reference
+
+(named_node
+  (capture) @local.definition.var)
+
+(anonymous_node
+  (capture) @local.definition.var)
+
+(grouping
+  (capture) @local.definition.var)
diff --git a/pack/ant/start/nvim-treesitter/queries/r/highlights.scm b/pack/ant/start/nvim-treesitter/queries/r/highlights.scm
new file mode 100644
index 0000000..c849dd8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/r/highlights.scm
@@ -0,0 +1,148 @@
+; Literals
+(integer) @number
+
+(float) @number.float
+
+(complex) @number
+
+(string) @string
+
+(string
+  (string_content
+    (escape_sequence) @string.escape))
+
+; Comments
+(comment) @comment @spell
+
+((program
+  .
+  (comment) @keyword.directive @nospell)
+  (#lua-match? @keyword.directive "^#!/"))
+
+; Operators
+[
+  "?"
+  ":="
+  "="
+  "<-"
+  "<<-"
+  "->"
+  "->>"
+  "~"
+  "|>"
+  "||"
+  "|"
+  "&&"
+  "&"
+  "<"
+  "<="
+  ">"
+  ">="
+  "=="
+  "!="
+  "+"
+  "-"
+  "*"
+  "/"
+  "::"
+  ":::"
+  "**"
+  "^"
+  "$"
+  "@"
+  ":"
+  "!"
+  "special"
+] @operator
+
+; Punctuation
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+  "[["
+  "]]"
+] @punctuation.bracket
+
+(comma) @punctuation.delimiter
+
+; Variables
+(identifier) @variable
+
+; Functions
+(binary_operator
+  lhs: (identifier) @function
+  operator: "<-"
+  rhs: (function_definition))
+
+(binary_operator
+  lhs: (identifier) @function
+  operator: "="
+  rhs: (function_definition))
+
+; Calls
+(call
+  function: (identifier) @function.call)
+
+(extract_operator
+  rhs: (identifier) @variable.member)
+
+function: (extract_operator
+  rhs: (identifier) @function.method.call)
+
+; Parameters
+(parameters
+  (parameter
+    name: (identifier) @variable.parameter))
+
+(arguments
+  (argument
+    name: (identifier) @variable.parameter))
+
+; Namespace
+(namespace_operator
+  lhs: (identifier) @module)
+
+(call
+  function: (namespace_operator
+    rhs: (identifier) @function))
+
+; Keywords
+(function_definition
+  name: "function" @keyword.function)
+
+(function_definition
+  name: "\\" @operator)
+
+(return) @keyword.return
+
+[
+  "if"
+  "else"
+] @keyword.conditional
+
+[
+  "while"
+  "repeat"
+  "for"
+  "in"
+  (break)
+  (next)
+] @keyword.repeat
+
+[
+  (true)
+  (false)
+] @boolean
+
+[
+  (null)
+  (inf)
+  (nan)
+  (na)
+  (dots)
+  (dot_dot_i)
+] @constant.builtin
diff --git a/pack/ant/start/nvim-treesitter/queries/r/indents.scm b/pack/ant/start/nvim-treesitter/queries/r/indents.scm
new file mode 100644
index 0000000..79dbe51
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/r/indents.scm
@@ -0,0 +1,33 @@
+[
+  (braced_expression)
+  (parenthesized_expression)
+  (call)
+  "if"
+  "else"
+  "while"
+  "repeat"
+  "for"
+] @indent.begin
+
+(binary_operator
+  rhs: (_) @_no_indent
+  (#not-kind-eq? @_no_indent function_definition)) @indent.begin
+
+[
+  "}"
+  ")"
+] @indent.branch
+
+((parameters
+  .
+  (parameter
+    name: (identifier))) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+[
+  ")"
+  "}"
+] @indent.end
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/r/injections.scm b/pack/ant/start/nvim-treesitter/queries/r/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/r/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/r/locals.scm b/pack/ant/start/nvim-treesitter/queries/r/locals.scm
new file mode 100644
index 0000000..3377552
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/r/locals.scm
@@ -0,0 +1,22 @@
+; locals.scm
+(function_definition) @local.scope
+
+(argument
+  name: (identifier) @local.definition)
+
+(parameter
+  name: (identifier) @local.definition)
+
+(binary_operator
+  lhs: (identifier) @local.definition
+  operator: "<-")
+
+(binary_operator
+  lhs: (identifier) @local.definition
+  operator: "=")
+
+(binary_operator
+  operator: "->"
+  rhs: (identifier) @local.definition)
+
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/racket/folds.scm b/pack/ant/start/nvim-treesitter/queries/racket/folds.scm
new file mode 100644
index 0000000..115809a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/racket/folds.scm
@@ -0,0 +1,2 @@
+(program
+  (list) @fold)
diff --git a/pack/ant/start/nvim-treesitter/queries/racket/highlights.scm b/pack/ant/start/nvim-treesitter/queries/racket/highlights.scm
new file mode 100644
index 0000000..9e30667
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/racket/highlights.scm
@@ -0,0 +1,685 @@
+; A highlight query can override the highlights queries before it.
+; So the order is important.
+; We should highlight general rules, then highlight special forms.
+;------------------------------------------------------------------;;
+;                         Basic highlights                         ;;
+;------------------------------------------------------------------;;
+; basic ;;
+(number) @number
+
+(character) @character
+
+(boolean) @boolean
+
+(keyword) @string.special.symbol
+
+; string ;;
+[
+  (string)
+  (here_string)
+  (byte_string)
+] @string
+
+(escape_sequence) @string.escape
+
+(regex) @string.regexp
+
+; comment ;;
+[
+  (comment)
+  (block_comment)
+  (sexp_comment)
+] @comment
+
+[
+  (comment)
+  (block_comment)
+] @spell
+
+; symbol ;;
+(symbol) @variable
+
+((symbol) @comment
+  (#lua-match? @comment "^#[cC][iIsS]$"))
+
+; extension ;;
+(extension) @keyword
+
+(lang_name) @variable.builtin
+
+; quote ;;
+(quote) @string.special.symbol
+
+; list ;;
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; procedure ;;
+(list
+  .
+  (symbol) @function)
+
+;------------------------------------------------------------------;;
+;                        Builtin highlights                        ;;
+;------------------------------------------------------------------;;
+; The following lists are generated by a racket script:
+; https://gist.github.com/6cdh/65619e761753eb4166d15185a6236040
+; Don't edit them directly.
+; keyword ;;
+(list
+  .
+  (symbol) @keyword
+  (#any-of? @keyword
+    "#%app" "#%datum" "#%declare" "#%expression" "#%module-begin" "#%plain-app" "#%plain-lambda"
+    "#%plain-module-begin" "#%printing-module-begin" "#%provide" "#%require" "#%stratified-body"
+    "#%top" "#%top-interaction" "#%variable-reference" "->" "->*" "->*m" "->d" "->dm" "->i" "->m"
+    "..." ":do-in" "==" "=>" "_" "absent" "abstract" "all-defined-out" "all-from-out" "and" "any"
+    "augment" "augment*" "augment-final" "augment-final*" "augride" "augride*" "begin"
+    "begin-for-syntax" "begin0" "case" "case->" "case->m" "case-lambda" "class" "class*"
+    "class-field-accessor" "class-field-mutator" "class/c" "class/derived" "combine-in"
+    "combine-out" "command-line" "compound-unit" "compound-unit/infer" "cond" "cons/dc" "contract"
+    "contract-out" "contract-pos/neg-doubling" "contract-struct" "contracted"
+    "current-contract-region" "define" "define-compound-unit" "define-compound-unit/infer"
+    "define-contract-struct" "define-custom-hash-types" "define-custom-set-types"
+    "define-for-syntax" "define-local-member-name" "define-logger" "define-match-expander"
+    "define-member-name" "define-module-boundary-contract" "define-namespace-anchor" "define-opt/c"
+    "define-sequence-syntax" "define-serializable-class" "define-serializable-class*"
+    "define-signature" "define-signature-form" "define-splicing-for-clause-syntax" "define-struct"
+    "define-struct/contract" "define-struct/derived" "define-syntax" "define-syntax-rule"
+    "define-syntaxes" "define-unit" "define-unit-binding" "define-unit-from-context"
+    "define-unit/contract" "define-unit/new-import-export" "define-unit/s" "define-values"
+    "define-values-for-export" "define-values-for-syntax" "define-values/invoke-unit"
+    "define-values/invoke-unit/infer" "define/augment" "define/augment-final" "define/augride"
+    "define/contract" "define/final-prop" "define/match" "define/overment" "define/override"
+    "define/override-final" "define/private" "define/public" "define/public-final" "define/pubment"
+    "define/subexpression-pos-prop" "define/subexpression-pos-prop/name" "delay" "delay/idle"
+    "delay/name" "delay/strict" "delay/sync" "delay/thread" "do" "else" "except" "except-in"
+    "except-out" "export" "extends" "failure-cont" "field" "field-bound?" "file"
+    "flat-murec-contract" "flat-rec-contract" "for" "for*" "for*/and" "for*/async" "for*/first"
+    "for*/fold" "for*/fold/derived" "for*/foldr" "for*/foldr/derived" "for*/hash" "for*/hasheq"
+    "for*/hasheqv" "for*/last" "for*/list" "for*/lists" "for*/mutable-set" "for*/mutable-seteq"
+    "for*/mutable-seteqv" "for*/or" "for*/product" "for*/set" "for*/seteq" "for*/seteqv"
+    "for*/stream" "for*/sum" "for*/vector" "for*/weak-set" "for*/weak-seteq" "for*/weak-seteqv"
+    "for-label" "for-meta" "for-space" "for-syntax" "for-template" "for/and" "for/async" "for/first"
+    "for/fold" "for/fold/derived" "for/foldr" "for/foldr/derived" "for/hash" "for/hasheq"
+    "for/hasheqv" "for/last" "for/list" "for/lists" "for/mutable-set" "for/mutable-seteq"
+    "for/mutable-seteqv" "for/or" "for/product" "for/set" "for/seteq" "for/seteqv" "for/stream"
+    "for/sum" "for/vector" "for/weak-set" "for/weak-seteq" "for/weak-seteqv" "gen:custom-write"
+    "gen:dict" "gen:equal+hash" "gen:set" "gen:stream" "generic" "get-field" "hash/dc" "if"
+    "implies" "import" "include" "include-at/relative-to" "include-at/relative-to/reader"
+    "include/reader" "inherit" "inherit-field" "inherit/inner" "inherit/super" "init" "init-depend"
+    "init-field" "init-rest" "inner" "inspect" "instantiate" "interface" "interface*"
+    "invariant-assertion" "invoke-unit" "invoke-unit/infer" "lambda" "lazy" "let" "let*"
+    "let*-values" "let-syntax" "let-syntaxes" "let-values" "let/cc" "let/ec" "letrec"
+    "letrec-syntax" "letrec-syntaxes" "letrec-syntaxes+values" "letrec-values" "lib" "link" "local"
+    "local-require" "log-debug" "log-error" "log-fatal" "log-info" "log-warning" "match" "match*"
+    "match*/derived" "match-define" "match-define-values" "match-lambda" "match-lambda*"
+    "match-lambda**" "match-let" "match-let*" "match-let*-values" "match-let-values" "match-letrec"
+    "match-letrec-values" "match/derived" "match/values" "member-name-key" "mixin" "module"
+    "module*" "module+" "nand" "new" "nor" "object-contract" "object/c" "only" "only-in"
+    "only-meta-in" "only-space-in" "open" "opt/c" "or" "overment" "overment*" "override" "override*"
+    "override-final" "override-final*" "parameterize" "parameterize*" "parameterize-break"
+    "parametric->/c" "place" "place*" "place/context" "planet" "prefix" "prefix-in" "prefix-out"
+    "private" "private*" "prompt-tag/c" "prop:dict/contract" "protect-out" "provide"
+    "provide-signature-elements" "provide/contract" "public" "public*" "public-final"
+    "public-final*" "pubment" "pubment*" "quasiquote" "quasisyntax" "quasisyntax/loc" "quote"
+    "quote-syntax" "quote-syntax/prune" "recontract-out" "recursive-contract" "relative-in" "rename"
+    "rename-in" "rename-inner" "rename-out" "rename-super" "require" "send" "send*" "send+"
+    "send-generic" "send/apply" "send/keyword-apply" "set!" "set!-values" "set-field!" "shared"
+    "stream" "stream*" "stream-cons" "stream-lazy" "struct" "struct*" "struct-copy"
+    "struct-field-index" "struct-guard/c" "struct-out" "struct/c" "struct/contract" "struct/ctc"
+    "struct/dc" "struct/derived" "submod" "super" "super-instantiate" "super-make-object"
+    "super-new" "syntax" "syntax-case" "syntax-case*" "syntax-id-rules" "syntax-rules" "syntax/loc"
+    "tag" "this" "this%" "thunk" "thunk*" "time" "unconstrained-domain->" "unit" "unit-from-context"
+    "unit/c" "unit/new-import-export" "unit/s" "unless" "unquote" "unquote-splicing" "unsyntax"
+    "unsyntax-splicing" "values/drop" "when" "with-continuation-mark" "with-contract"
+    "with-contract-continuation-mark" "with-handlers" "with-handlers*" "with-method" "with-syntax"
+    "~?" "~@" "λ")
+  )
+
+; builtin procedures
+((symbol) @function.builtin
+  (#any-of? @function.builtin
+    "*" "*list/c" "+" "-" "/" "<" "</c" "<=" "<=/c" "=" "=/c" ">" ">/c" ">=" ">=/c"
+    "abort-current-continuation" "abs" "absolute-path?" "acos" "add-between" "add1" "alarm-evt"
+    "and/c" "andmap" "angle" "any/c" "append" "append*" "append-map" "apply" "argmax" "argmin"
+    "arithmetic-shift" "arity-at-least" "arity-at-least-value" "arity-at-least?"
+    "arity-checking-wrapper" "arity-includes?" "arity=?" "arrow-contract-info"
+    "arrow-contract-info-accepts-arglist" "arrow-contract-info-chaperone-procedure"
+    "arrow-contract-info-check-first-order" "arrow-contract-info?" "asin" "assert-unreachable"
+    "assf" "assoc" "assq" "assv" "atan" "bad-number-of-results" "banner" "base->-doms/c"
+    "base->-rngs/c" "base->?" "between/c" "bitwise-and" "bitwise-bit-field" "bitwise-bit-set?"
+    "bitwise-ior" "bitwise-not" "bitwise-xor" "blame-add-car-context" "blame-add-cdr-context"
+    "blame-add-context" "blame-add-missing-party" "blame-add-nth-arg-context"
+    "blame-add-range-context" "blame-add-unknown-context" "blame-context" "blame-contract"
+    "blame-fmt->-string" "blame-missing-party?" "blame-negative" "blame-original?" "blame-positive"
+    "blame-replace-negative" "blame-replaced-negative?" "blame-source" "blame-swap" "blame-swapped?"
+    "blame-update" "blame-value" "blame?" "boolean=?" "boolean?" "bound-identifier=?" "box"
+    "box-cas!" "box-immutable" "box-immutable/c" "box/c" "box?" "break-enabled"
+    "break-parameterization?" "break-thread" "build-chaperone-contract-property"
+    "build-compound-type-name" "build-contract-property" "build-flat-contract-property" "build-list"
+    "build-path" "build-path/convention-type" "build-string" "build-vector" "byte-pregexp"
+    "byte-pregexp?" "byte-ready?" "byte-regexp" "byte-regexp?" "byte?" "bytes"
+    "bytes->immutable-bytes" "bytes->list" "bytes->path" "bytes->path-element"
+    "bytes->string/latin-1" "bytes->string/locale" "bytes->string/utf-8" "bytes-append"
+    "bytes-append*" "bytes-close-converter" "bytes-convert" "bytes-convert-end" "bytes-converter?"
+    "bytes-copy" "bytes-copy!" "bytes-environment-variable-name?" "bytes-fill!" "bytes-join"
+    "bytes-length" "bytes-no-nuls?" "bytes-open-converter" "bytes-ref" "bytes-set!"
+    "bytes-utf-8-index" "bytes-utf-8-length" "bytes-utf-8-ref" "bytes<?" "bytes=?" "bytes>?"
+    "bytes?" "caaaar" "caaadr" "caaar" "caadar" "caaddr" "caadr" "caar" "cadaar" "cadadr" "cadar"
+    "caddar" "cadddr" "caddr" "cadr" "call-in-continuation" "call-in-nested-thread"
+    "call-with-atomic-output-file" "call-with-break-parameterization"
+    "call-with-composable-continuation" "call-with-continuation-barrier"
+    "call-with-continuation-prompt" "call-with-current-continuation"
+    "call-with-default-reading-parameterization" "call-with-escape-continuation"
+    "call-with-exception-handler" "call-with-file-lock/timeout"
+    "call-with-immediate-continuation-mark" "call-with-input-bytes" "call-with-input-file"
+    "call-with-input-file*" "call-with-input-string" "call-with-output-bytes"
+    "call-with-output-file" "call-with-output-file*" "call-with-output-string"
+    "call-with-parameterization" "call-with-semaphore" "call-with-semaphore/enable-break"
+    "call-with-values" "call/cc" "call/ec" "car" "cartesian-product" "cdaaar" "cdaadr" "cdaar"
+    "cdadar" "cdaddr" "cdadr" "cdar" "cddaar" "cddadr" "cddar" "cdddar" "cddddr" "cdddr" "cddr"
+    "cdr" "ceiling" "channel-get" "channel-put" "channel-put-evt" "channel-put-evt?"
+    "channel-try-get" "channel/c" "channel?" "chaperone-box" "chaperone-channel"
+    "chaperone-continuation-mark-key" "chaperone-contract-property?" "chaperone-contract?"
+    "chaperone-evt" "chaperone-hash" "chaperone-hash-set" "chaperone-of?" "chaperone-procedure"
+    "chaperone-procedure*" "chaperone-prompt-tag" "chaperone-struct" "chaperone-struct-type"
+    "chaperone-vector" "chaperone-vector*" "chaperone?" "char->integer" "char-alphabetic?"
+    "char-blank?" "char-ci<=?" "char-ci<?" "char-ci=?" "char-ci>=?" "char-ci>?" "char-downcase"
+    "char-foldcase" "char-general-category" "char-graphic?" "char-in" "char-in/c"
+    "char-iso-control?" "char-lower-case?" "char-numeric?" "char-punctuation?" "char-ready?"
+    "char-symbolic?" "char-title-case?" "char-titlecase" "char-upcase" "char-upper-case?"
+    "char-utf-8-length" "char-whitespace?" "char<=?" "char<?" "char=?" "char>=?" "char>?" "char?"
+    "check-duplicate-identifier" "check-duplicates" "checked-procedure-check-and-extract"
+    "choice-evt" "class->interface" "class-info" "class-seal" "class-unseal" "class?" "cleanse-path"
+    "close-input-port" "close-output-port" "coerce-chaperone-contract" "coerce-chaperone-contracts"
+    "coerce-contract" "coerce-contract/f" "coerce-contracts" "coerce-flat-contract"
+    "coerce-flat-contracts" "collect-garbage" "collection-file-path" "collection-path"
+    "combinations" "combine-output" "compile" "compile-allow-set!-undefined"
+    "compile-context-preservation-enabled" "compile-enforce-module-constants" "compile-syntax"
+    "compile-target-machine?" "compiled-expression-recompile" "compiled-expression?"
+    "compiled-module-expression?" "complete-path?" "complex?" "compose" "compose1" "conjoin"
+    "conjugate" "cons" "cons/c" "cons?" "const" "continuation-mark-key/c" "continuation-mark-key?"
+    "continuation-mark-set->context" "continuation-mark-set->iterator" "continuation-mark-set->list"
+    "continuation-mark-set->list*" "continuation-mark-set-first" "continuation-mark-set?"
+    "continuation-marks" "continuation-prompt-available?" "continuation-prompt-tag?" "continuation?"
+    "contract-custom-write-property-proc" "contract-equivalent?" "contract-exercise"
+    "contract-first-order" "contract-first-order-passes?" "contract-late-neg-projection"
+    "contract-name" "contract-proc" "contract-projection" "contract-property?"
+    "contract-random-generate" "contract-random-generate-env?" "contract-random-generate-fail?"
+    "contract-random-generate-get-current-environment" "contract-random-generate-stash"
+    "contract-random-generate/choose" "contract-stronger?" "contract-struct-exercise"
+    "contract-struct-generate" "contract-struct-late-neg-projection"
+    "contract-struct-list-contract?" "contract-val-first-projection" "contract?" "convert-stream"
+    "copy-directory/files" "copy-file" "copy-port" "cos" "cosh" "count" "current-blame-format"
+    "current-break-parameterization" "current-code-inspector" "current-command-line-arguments"
+    "current-compile" "current-compile-realm" "current-compile-target-machine"
+    "current-compiled-file-roots" "current-continuation-marks" "current-custodian"
+    "current-directory" "current-directory-for-user" "current-drive" "current-environment-variables"
+    "current-error-message-adjuster" "current-error-port" "current-eval"
+    "current-evt-pseudo-random-generator" "current-force-delete-permissions" "current-future"
+    "current-gc-milliseconds" "current-get-interaction-evt" "current-get-interaction-input-port"
+    "current-inexact-milliseconds" "current-inexact-monotonic-milliseconds" "current-input-port"
+    "current-inspector" "current-library-collection-links" "current-library-collection-paths"
+    "current-load" "current-load-extension" "current-load-relative-directory"
+    "current-load/use-compiled" "current-locale" "current-logger" "current-memory-use"
+    "current-milliseconds" "current-module-declare-name" "current-module-declare-source"
+    "current-module-name-resolver" "current-module-path-for-load" "current-namespace"
+    "current-output-port" "current-parameterization" "current-plumber"
+    "current-preserved-thread-cell-values" "current-print" "current-process-milliseconds"
+    "current-prompt-read" "current-pseudo-random-generator" "current-read-interaction"
+    "current-reader-guard" "current-readtable" "current-seconds" "current-security-guard"
+    "current-subprocess-custodian-mode" "current-subprocess-keep-file-descriptors" "current-thread"
+    "current-thread-group" "current-thread-initial-stack-size" "current-write-relative-directory"
+    "curry" "curryr" "custodian-box-value" "custodian-box?" "custodian-limit-memory"
+    "custodian-managed-list" "custodian-memory-accounting-available?" "custodian-require-memory"
+    "custodian-shut-down?" "custodian-shutdown-all" "custodian?" "custom-print-quotable-accessor"
+    "custom-print-quotable?" "custom-write-accessor" "custom-write-property-proc" "custom-write?"
+    "date" "date*" "date*-nanosecond" "date*-time-zone-name" "date*?" "date-day" "date-dst?"
+    "date-hour" "date-minute" "date-month" "date-second" "date-time-zone-offset" "date-week-day"
+    "date-year" "date-year-day" "date?" "datum->syntax" "datum-intern-literal"
+    "default-continuation-prompt-tag" "degrees->radians" "delete-directory" "delete-directory/files"
+    "delete-file" "denominator" "dict->list" "dict-can-functional-set?" "dict-can-remove-keys?"
+    "dict-clear" "dict-clear!" "dict-copy" "dict-count" "dict-empty?" "dict-for-each"
+    "dict-has-key?" "dict-implements/c" "dict-implements?" "dict-iter-contract" "dict-iterate-first"
+    "dict-iterate-key" "dict-iterate-next" "dict-iterate-value" "dict-key-contract" "dict-keys"
+    "dict-map" "dict-mutable?" "dict-ref" "dict-ref!" "dict-remove" "dict-remove!" "dict-set"
+    "dict-set!" "dict-set*" "dict-set*!" "dict-update" "dict-update!" "dict-value-contract"
+    "dict-values" "dict?" "directory-exists?" "directory-list" "disjoin" "display" "display-lines"
+    "display-lines-to-file" "display-to-file" "displayln" "double-flonum?" "drop"
+    "drop-common-prefix" "drop-right" "dropf" "dropf-right" "dump-memory-stats" "dup-input-port"
+    "dup-output-port" "dynamic->*" "dynamic-get-field" "dynamic-object/c" "dynamic-place"
+    "dynamic-place*" "dynamic-require" "dynamic-require-for-syntax" "dynamic-send"
+    "dynamic-set-field!" "dynamic-wind" "eighth" "empty?" "environment-variables-copy"
+    "environment-variables-names" "environment-variables-ref" "environment-variables-set!"
+    "environment-variables?" "eof-evt" "eof-object?" "ephemeron-value" "ephemeron?" "eprintf"
+    "eq-contract-val" "eq-contract?" "eq-hash-code" "eq?" "equal-contract-val" "equal-contract?"
+    "equal-hash-code" "equal-secondary-hash-code" "equal?" "equal?/recur" "eqv-hash-code" "eqv?"
+    "error" "error-contract->adjusted-string" "error-display-handler" "error-escape-handler"
+    "error-message->adjusted-string" "error-print-context-length" "error-print-source-location"
+    "error-print-width" "error-syntax->string-handler" "error-value->string-handler" "eval"
+    "eval-jit-enabled" "eval-syntax" "even?" "evt/c" "evt?" "exact->inexact" "exact-ceiling"
+    "exact-floor" "exact-integer?" "exact-nonnegative-integer?" "exact-positive-integer?"
+    "exact-round" "exact-truncate" "exact?" "executable-yield-handler" "exit" "exit-handler" "exn"
+    "exn-continuation-marks" "exn-message" "exn:break" "exn:break-continuation" "exn:break:hang-up"
+    "exn:break:hang-up?" "exn:break:terminate" "exn:break:terminate?" "exn:break?" "exn:fail"
+    "exn:fail:contract" "exn:fail:contract:arity" "exn:fail:contract:arity?"
+    "exn:fail:contract:blame" "exn:fail:contract:blame-object" "exn:fail:contract:blame?"
+    "exn:fail:contract:continuation" "exn:fail:contract:continuation?"
+    "exn:fail:contract:divide-by-zero" "exn:fail:contract:divide-by-zero?"
+    "exn:fail:contract:non-fixnum-result" "exn:fail:contract:non-fixnum-result?"
+    "exn:fail:contract:variable" "exn:fail:contract:variable-id" "exn:fail:contract:variable?"
+    "exn:fail:contract?" "exn:fail:filesystem" "exn:fail:filesystem:errno"
+    "exn:fail:filesystem:errno-errno" "exn:fail:filesystem:errno?" "exn:fail:filesystem:exists"
+    "exn:fail:filesystem:exists?" "exn:fail:filesystem:missing-module"
+    "exn:fail:filesystem:missing-module-path" "exn:fail:filesystem:missing-module?"
+    "exn:fail:filesystem:version" "exn:fail:filesystem:version?" "exn:fail:filesystem?"
+    "exn:fail:network" "exn:fail:network:errno" "exn:fail:network:errno-errno"
+    "exn:fail:network:errno?" "exn:fail:network?" "exn:fail:object" "exn:fail:object?"
+    "exn:fail:out-of-memory" "exn:fail:out-of-memory?" "exn:fail:read" "exn:fail:read-srclocs"
+    "exn:fail:read:eof" "exn:fail:read:eof?" "exn:fail:read:non-char" "exn:fail:read:non-char?"
+    "exn:fail:read?" "exn:fail:syntax" "exn:fail:syntax-exprs" "exn:fail:syntax:missing-module"
+    "exn:fail:syntax:missing-module-path" "exn:fail:syntax:missing-module?"
+    "exn:fail:syntax:unbound" "exn:fail:syntax:unbound?" "exn:fail:syntax?" "exn:fail:unsupported"
+    "exn:fail:unsupported?" "exn:fail:user" "exn:fail:user?" "exn:fail?" "exn:misc:match?"
+    "exn:missing-module-accessor" "exn:missing-module?" "exn:srclocs-accessor" "exn:srclocs?" "exn?"
+    "exp" "expand" "expand-once" "expand-syntax" "expand-syntax-once" "expand-syntax-to-top-form"
+    "expand-to-top-form" "expand-user-path" "explode-path" "expt" "false?" "field-names" "fifth"
+    "file->bytes" "file->bytes-lines" "file->lines" "file->list" "file->string" "file->value"
+    "file-exists?" "file-name-from-path" "file-or-directory-identity"
+    "file-or-directory-modify-seconds" "file-or-directory-permissions" "file-or-directory-stat"
+    "file-or-directory-type" "file-position" "file-position*" "file-size" "file-stream-buffer-mode"
+    "file-stream-port?" "file-truncate" "filename-extension" "filesystem-change-evt"
+    "filesystem-change-evt-cancel" "filesystem-change-evt?" "filesystem-root-list" "filter"
+    "filter-map" "filter-not" "filter-read-input-port" "find-compiled-file-roots"
+    "find-executable-path" "find-files" "find-library-collection-links"
+    "find-library-collection-paths" "find-relative-path" "find-system-path" "findf" "first"
+    "first-or/c" "fixnum?" "flat-contract" "flat-contract-predicate" "flat-contract-property?"
+    "flat-contract-with-explanation" "flat-contract?" "flat-named-contract" "flatten"
+    "floating-point-bytes->real" "flonum?" "floor" "flush-output" "fold-files" "foldl" "foldr"
+    "for-each" "force" "format" "fourth" "fprintf" "free-identifier=?" "free-label-identifier=?"
+    "free-template-identifier=?" "free-transformer-identifier=?" "fsemaphore-count"
+    "fsemaphore-post" "fsemaphore-try-wait?" "fsemaphore-wait" "fsemaphore?" "future" "future?"
+    "futures-enabled?" "gcd" "generate-member-key" "generate-temporaries" "generic-set?" "generic?"
+    "gensym" "get-output-bytes" "get-output-string" "get-preference" "get/build-late-neg-projection"
+    "get/build-val-first-projection" "getenv" "global-port-print-handler" "group-by" "guard-evt"
+    "handle-evt" "handle-evt?" "has-blame?" "has-contract?" "hash" "hash->list" "hash-clear"
+    "hash-clear!" "hash-copy" "hash-copy-clear" "hash-count" "hash-empty?" "hash-ephemeron?"
+    "hash-eq?" "hash-equal?" "hash-eqv?" "hash-for-each" "hash-has-key?" "hash-iterate-first"
+    "hash-iterate-key" "hash-iterate-key+value" "hash-iterate-next" "hash-iterate-pair"
+    "hash-iterate-value" "hash-keys" "hash-keys-subset?" "hash-map" "hash-placeholder?" "hash-ref"
+    "hash-ref!" "hash-ref-key" "hash-remove" "hash-remove!" "hash-set" "hash-set!" "hash-set*"
+    "hash-set*!" "hash-strong?" "hash-update" "hash-update!" "hash-values" "hash-weak?" "hash/c"
+    "hash?" "hasheq" "hasheqv" "identifier-binding" "identifier-binding-portal-syntax"
+    "identifier-binding-symbol" "identifier-distinct-binding" "identifier-label-binding"
+    "identifier-prune-lexical-context" "identifier-prune-to-source-module"
+    "identifier-remove-from-definition-context" "identifier-template-binding"
+    "identifier-transformer-binding" "identifier?" "identity" "if/c" "imag-part" "immutable?"
+    "impersonate-box" "impersonate-channel" "impersonate-continuation-mark-key" "impersonate-hash"
+    "impersonate-hash-set" "impersonate-procedure" "impersonate-procedure*" "impersonate-prompt-tag"
+    "impersonate-struct" "impersonate-vector" "impersonate-vector*" "impersonator-contract?"
+    "impersonator-ephemeron" "impersonator-of?" "impersonator-property-accessor-procedure?"
+    "impersonator-property?" "impersonator?" "implementation?" "implementation?/c" "in-bytes"
+    "in-bytes-lines" "in-combinations" "in-cycle" "in-dict" "in-dict-keys" "in-dict-pairs"
+    "in-dict-values" "in-directory" "in-ephemeron-hash" "in-ephemeron-hash-keys"
+    "in-ephemeron-hash-pairs" "in-ephemeron-hash-values" "in-hash" "in-hash-keys" "in-hash-pairs"
+    "in-hash-values" "in-immutable-hash" "in-immutable-hash-keys" "in-immutable-hash-pairs"
+    "in-immutable-hash-values" "in-immutable-set" "in-inclusive-range" "in-indexed"
+    "in-input-port-bytes" "in-input-port-chars" "in-lines" "in-list" "in-mlist" "in-mutable-hash"
+    "in-mutable-hash-keys" "in-mutable-hash-pairs" "in-mutable-hash-values" "in-mutable-set"
+    "in-naturals" "in-parallel" "in-permutations" "in-port" "in-producer" "in-range" "in-sequences"
+    "in-set" "in-slice" "in-stream" "in-string" "in-syntax" "in-value" "in-values*-sequence"
+    "in-values-sequence" "in-vector" "in-weak-hash" "in-weak-hash-keys" "in-weak-hash-pairs"
+    "in-weak-hash-values" "in-weak-set" "inclusive-range" "index-of" "index-where" "indexes-of"
+    "indexes-where" "inexact->exact" "inexact-real?" "inexact?" "infinite?" "input-port-append"
+    "input-port?" "inspector-superior?" "inspector?" "instanceof/c" "integer->char"
+    "integer->integer-bytes" "integer-bytes->integer" "integer-in" "integer-length" "integer-sqrt"
+    "integer-sqrt/remainder" "integer?" "interface->method-names" "interface-extension?"
+    "interface?" "internal-definition-context-add-scopes"
+    "internal-definition-context-binding-identifiers" "internal-definition-context-introduce"
+    "internal-definition-context-seal" "internal-definition-context-splice-binding-identifier"
+    "internal-definition-context?" "is-a?" "is-a?/c" "keyword->string" "keyword-apply"
+    "keyword-apply/dict" "keyword<?" "keyword?" "keywords-match" "kill-thread" "last" "last-pair"
+    "lcm" "length" "liberal-define-context?" "link-exists?" "list" "list*" "list*of" "list->bytes"
+    "list->mutable-set" "list->mutable-seteq" "list->mutable-seteqv" "list->set" "list->seteq"
+    "list->seteqv" "list->string" "list->vector" "list->weak-set" "list->weak-seteq"
+    "list->weak-seteqv" "list-contract?" "list-prefix?" "list-ref" "list-set" "list-tail"
+    "list-update" "list/c" "list?" "listen-port-number?" "listof" "load" "load-extension"
+    "load-on-demand-enabled" "load-relative" "load-relative-extension" "load/cd" "load/use-compiled"
+    "local-expand" "local-expand/capture-lifts" "local-transformer-expand"
+    "local-transformer-expand/capture-lifts" "locale-string-encoding" "log" "log-all-levels"
+    "log-level-evt" "log-level?" "log-max-level" "log-message" "log-receiver?" "logger-name"
+    "logger?" "magnitude" "make-arity-at-least" "make-base-empty-namespace" "make-base-namespace"
+    "make-bytes" "make-channel" "make-chaperone-contract" "make-continuation-mark-key"
+    "make-continuation-prompt-tag" "make-contract" "make-custodian" "make-custodian-box"
+    "make-custom-hash" "make-custom-hash-types" "make-custom-set" "make-custom-set-types"
+    "make-date" "make-date*" "make-derived-parameter" "make-directory" "make-directory*"
+    "make-do-sequence" "make-empty-namespace" "make-environment-variables" "make-ephemeron"
+    "make-ephemeron-hash" "make-ephemeron-hasheq" "make-ephemeron-hasheqv" "make-exn"
+    "make-exn:break" "make-exn:break:hang-up" "make-exn:break:terminate" "make-exn:fail"
+    "make-exn:fail:contract" "make-exn:fail:contract:arity" "make-exn:fail:contract:blame"
+    "make-exn:fail:contract:continuation" "make-exn:fail:contract:divide-by-zero"
+    "make-exn:fail:contract:non-fixnum-result" "make-exn:fail:contract:variable"
+    "make-exn:fail:filesystem" "make-exn:fail:filesystem:errno" "make-exn:fail:filesystem:exists"
+    "make-exn:fail:filesystem:missing-module" "make-exn:fail:filesystem:version"
+    "make-exn:fail:network" "make-exn:fail:network:errno" "make-exn:fail:object"
+    "make-exn:fail:out-of-memory" "make-exn:fail:read" "make-exn:fail:read:eof"
+    "make-exn:fail:read:non-char" "make-exn:fail:syntax" "make-exn:fail:syntax:missing-module"
+    "make-exn:fail:syntax:unbound" "make-exn:fail:unsupported" "make-exn:fail:user"
+    "make-file-or-directory-link" "make-flat-contract" "make-fsemaphore" "make-generic"
+    "make-handle-get-preference-locked" "make-hash" "make-hash-placeholder" "make-hasheq"
+    "make-hasheq-placeholder" "make-hasheqv" "make-hasheqv-placeholder" "make-immutable-custom-hash"
+    "make-immutable-hash" "make-immutable-hasheq" "make-immutable-hasheqv"
+    "make-impersonator-property" "make-input-port" "make-input-port/read-to-peek" "make-inspector"
+    "make-interned-syntax-introducer" "make-keyword-procedure" "make-known-char-range-list"
+    "make-limited-input-port" "make-list" "make-lock-file-name" "make-log-receiver" "make-logger"
+    "make-mixin-contract" "make-mutable-custom-set" "make-none/c" "make-object" "make-output-port"
+    "make-parameter" "make-parent-directory*" "make-phantom-bytes" "make-pipe"
+    "make-pipe-with-specials" "make-placeholder" "make-plumber" "make-polar" "make-portal-syntax"
+    "make-prefab-struct" "make-primitive-class" "make-proj-contract" "make-pseudo-random-generator"
+    "make-reader-graph" "make-readtable" "make-rectangular" "make-rename-transformer"
+    "make-resolved-module-path" "make-security-guard" "make-semaphore" "make-set!-transformer"
+    "make-shared-bytes" "make-sibling-inspector" "make-special-comment" "make-srcloc" "make-string"
+    "make-struct-field-accessor" "make-struct-field-mutator" "make-struct-type"
+    "make-struct-type-property" "make-syntax-delta-introducer" "make-syntax-introducer"
+    "make-temporary-directory" "make-temporary-directory*" "make-temporary-file"
+    "make-temporary-file*" "make-tentative-pretty-print-output-port" "make-thread-cell"
+    "make-thread-group" "make-vector" "make-weak-box" "make-weak-custom-hash" "make-weak-custom-set"
+    "make-weak-hash" "make-weak-hasheq" "make-weak-hasheqv" "make-will-executor" "map"
+    "match-equality-test" "matches-arity-exactly?" "max" "mcar" "mcdr" "mcons" "member"
+    "member-name-key-hash-code" "member-name-key=?" "member-name-key?" "memf" "memory-order-acquire"
+    "memory-order-release" "memq" "memv" "merge-input" "method-in-interface?" "min"
+    "module->exports" "module->imports" "module->indirect-exports" "module->language-info"
+    "module->namespace" "module->realm" "module-compiled-cross-phase-persistent?"
+    "module-compiled-exports" "module-compiled-imports" "module-compiled-indirect-exports"
+    "module-compiled-language-info" "module-compiled-name" "module-compiled-realm"
+    "module-compiled-submodules" "module-declared?" "module-path-index-join"
+    "module-path-index-resolve" "module-path-index-split" "module-path-index-submodule"
+    "module-path-index?" "module-path?" "module-predefined?" "module-provide-protected?" "modulo"
+    "mpair?" "mutable-set" "mutable-seteq" "mutable-seteqv" "n->th" "nack-guard-evt"
+    "namespace-anchor->empty-namespace" "namespace-anchor->namespace" "namespace-anchor?"
+    "namespace-attach-module" "namespace-attach-module-declaration" "namespace-base-phase"
+    "namespace-call-with-registry-lock" "namespace-mapped-symbols" "namespace-module-identifier"
+    "namespace-module-registry" "namespace-require" "namespace-require/constant"
+    "namespace-require/copy" "namespace-require/expansion-time" "namespace-set-variable-value!"
+    "namespace-symbol->identifier" "namespace-syntax-introduce" "namespace-undefine-variable!"
+    "namespace-unprotect-module" "namespace-variable-value" "namespace?" "nan?" "natural-number/c"
+    "natural?" "negate" "negative-integer?" "negative?" "new-∀/c" "new-∃/c" "newline" "ninth"
+    "non-empty-listof" "non-empty-string?" "none/c" "nonnegative-integer?" "nonpositive-integer?"
+    "normal-case-path" "normalize-arity" "normalize-path" "normalized-arity?" "not" "not/c" "null?"
+    "number->string" "number?" "numerator" "object->vector" "object-info" "object-interface"
+    "object-method-arity-includes?" "object-name" "object-or-false=?" "object=-hash-code" "object=?"
+    "object?" "odd?" "one-of/c" "open-input-bytes" "open-input-file" "open-input-output-file"
+    "open-input-string" "open-output-bytes" "open-output-file" "open-output-nowhere"
+    "open-output-string" "or/c" "order-of-magnitude" "ormap" "output-port?" "pair?"
+    "parameter-procedure=?" "parameter/c" "parameter?" "parameterization?" "parse-command-line"
+    "partition" "path->bytes" "path->complete-path" "path->directory-path" "path->string"
+    "path-add-extension" "path-add-suffix" "path-convention-type" "path-element->bytes"
+    "path-element->string" "path-element?" "path-for-some-system?" "path-get-extension"
+    "path-has-extension?" "path-list-string->path-list" "path-only" "path-replace-extension"
+    "path-replace-suffix" "path-string?" "path<?" "path?" "pathlist-closure" "peek-byte"
+    "peek-byte-or-special" "peek-bytes" "peek-bytes!" "peek-bytes!-evt" "peek-bytes-avail!"
+    "peek-bytes-avail!*" "peek-bytes-avail!-evt" "peek-bytes-avail!/enable-break" "peek-bytes-evt"
+    "peek-char" "peek-char-or-special" "peek-string" "peek-string!" "peek-string!-evt"
+    "peek-string-evt" "peeking-input-port" "permutations" "phantom-bytes?" "pipe-content-length"
+    "place-break" "place-channel" "place-channel-get" "place-channel-put" "place-channel-put/get"
+    "place-channel?" "place-dead-evt" "place-enabled?" "place-kill" "place-location?"
+    "place-message-allowed?" "place-wait" "place?" "placeholder-get" "placeholder-set!"
+    "placeholder?" "plumber-add-flush!" "plumber-flush-all" "plumber-flush-handle-remove!"
+    "plumber-flush-handle?" "plumber?" "poll-guard-evt" "port->bytes" "port->bytes-lines"
+    "port->lines" "port->list" "port->string" "port-closed-evt" "port-closed?" "port-commit-peeked"
+    "port-count-lines!" "port-count-lines-enabled" "port-counts-lines?" "port-display-handler"
+    "port-file-identity" "port-file-unlock" "port-next-location" "port-number?" "port-print-handler"
+    "port-progress-evt" "port-provides-progress-evts?" "port-read-handler" "port-try-file-lock?"
+    "port-waiting-peer?" "port-write-handler" "port-writes-atomic?" "port-writes-special?" "port?"
+    "portal-syntax-content" "portal-syntax?" "positive-integer?" "positive?"
+    "prefab-key->struct-type" "prefab-key?" "prefab-struct-key" "preferences-lock-file-mode"
+    "pregexp" "pregexp?" "pretty-display" "pretty-format" "pretty-print"
+    "pretty-print-.-symbol-without-bars" "pretty-print-abbreviate-read-macros"
+    "pretty-print-columns" "pretty-print-current-style-table" "pretty-print-depth"
+    "pretty-print-exact-as-decimal" "pretty-print-extend-style-table" "pretty-print-handler"
+    "pretty-print-newline" "pretty-print-post-print-hook" "pretty-print-pre-print-hook"
+    "pretty-print-print-hook" "pretty-print-print-line" "pretty-print-remap-stylable"
+    "pretty-print-show-inexactness" "pretty-print-size-hook" "pretty-print-style-table?"
+    "pretty-printing" "pretty-write" "primitive-closure?" "primitive-result-arity" "primitive?"
+    "print" "print-as-expression" "print-boolean-long-form" "print-box" "print-graph"
+    "print-hash-table" "print-mpair-curly-braces" "print-pair-curly-braces"
+    "print-reader-abbreviations" "print-struct" "print-syntax-width" "print-unreadable"
+    "print-value-columns" "print-vector-length" "printable/c" "printf" "println" "procedure->method"
+    "procedure-arity" "procedure-arity-includes/c" "procedure-arity-includes?"
+    "procedure-arity-mask" "procedure-arity?" "procedure-closure-contents-eq?"
+    "procedure-extract-target" "procedure-impersonator*?" "procedure-keywords" "procedure-realm"
+    "procedure-reduce-arity" "procedure-reduce-arity-mask" "procedure-reduce-keyword-arity"
+    "procedure-reduce-keyword-arity-mask" "procedure-rename" "procedure-result-arity"
+    "procedure-specialize" "procedure-struct-type?" "procedure?" "process" "process*"
+    "process*/ports" "process/ports" "processor-count" "progress-evt?" "promise-forced?"
+    "promise-running?" "promise/c" "promise/name?" "promise?" "prop:arrow-contract-get-info"
+    "prop:arrow-contract?" "prop:orc-contract-get-subcontracts" "prop:orc-contract?"
+    "prop:recursive-contract-unroll" "prop:recursive-contract?" "proper-subset?" "property/c"
+    "pseudo-random-generator->vector" "pseudo-random-generator-vector?" "pseudo-random-generator?"
+    "put-preferences" "putenv" "quotient" "quotient/remainder" "radians->degrees" "raise"
+    "raise-argument-error" "raise-argument-error*" "raise-arguments-error" "raise-arguments-error*"
+    "raise-arity-error" "raise-arity-error*" "raise-arity-mask-error" "raise-arity-mask-error*"
+    "raise-blame-error" "raise-contract-error" "raise-mismatch-error" "raise-not-cons-blame-error"
+    "raise-range-error" "raise-range-error*" "raise-result-arity-error" "raise-result-arity-error*"
+    "raise-result-error" "raise-result-error*" "raise-syntax-error" "raise-type-error"
+    "raise-user-error" "random" "random-seed" "range" "rational?" "rationalize" "read"
+    "read-accept-bar-quote" "read-accept-box" "read-accept-compiled" "read-accept-dot"
+    "read-accept-graph" "read-accept-infix-dot" "read-accept-lang" "read-accept-quasiquote"
+    "read-accept-reader" "read-byte" "read-byte-or-special" "read-bytes" "read-bytes!"
+    "read-bytes!-evt" "read-bytes-avail!" "read-bytes-avail!*" "read-bytes-avail!-evt"
+    "read-bytes-avail!/enable-break" "read-bytes-evt" "read-bytes-line" "read-bytes-line-evt"
+    "read-case-sensitive" "read-cdot" "read-char" "read-char-or-special" "read-curly-brace-as-paren"
+    "read-curly-brace-with-tag" "read-decimal-as-inexact" "read-eval-print-loop"
+    "read-installation-configuration-table" "read-language" "read-line" "read-line-evt"
+    "read-on-demand-source" "read-single-flonum" "read-square-bracket-as-paren"
+    "read-square-bracket-with-tag" "read-string" "read-string!" "read-string!-evt" "read-string-evt"
+    "read-syntax" "read-syntax-accept-graph" "read-syntax/recursive" "read/recursive"
+    "readtable-mapping" "readtable?" "real->decimal-string" "real->double-flonum"
+    "real->floating-point-bytes" "real->single-flonum" "real-in" "real-part" "real?"
+    "reencode-input-port" "reencode-output-port" "regexp" "regexp-match" "regexp-match*"
+    "regexp-match-evt" "regexp-match-exact?" "regexp-match-peek" "regexp-match-peek-immediate"
+    "regexp-match-peek-positions" "regexp-match-peek-positions*"
+    "regexp-match-peek-positions-immediate" "regexp-match-peek-positions-immediate/end"
+    "regexp-match-peek-positions/end" "regexp-match-positions" "regexp-match-positions*"
+    "regexp-match-positions/end" "regexp-match/end" "regexp-match?" "regexp-max-lookbehind"
+    "regexp-quote" "regexp-replace" "regexp-replace*" "regexp-replace-quote" "regexp-replaces"
+    "regexp-split" "regexp-try-match" "regexp?" "relative-path?" "relocate-input-port"
+    "relocate-output-port" "remainder" "remf" "remf*" "remove" "remove*" "remove-duplicates" "remq"
+    "remq*" "remv" "remv*" "rename-contract" "rename-file-or-directory" "rename-transformer-target"
+    "rename-transformer?" "replace-evt" "reroot-path" "resolve-path" "resolved-module-path-name"
+    "resolved-module-path?" "rest" "reverse" "round" "second" "seconds->date" "security-guard?"
+    "semaphore-peek-evt" "semaphore-peek-evt?" "semaphore-post" "semaphore-try-wait?"
+    "semaphore-wait" "semaphore-wait/enable-break" "semaphore?" "sequence->list" "sequence->stream"
+    "sequence-add-between" "sequence-andmap" "sequence-append" "sequence-count" "sequence-filter"
+    "sequence-fold" "sequence-for-each" "sequence-generate" "sequence-generate*" "sequence-length"
+    "sequence-map" "sequence-ormap" "sequence-ref" "sequence-tail" "sequence/c" "sequence?" "set"
+    "set!-transformer-procedure" "set!-transformer?" "set->list" "set->stream" "set-add" "set-add!"
+    "set-box!" "set-box*!" "set-clear" "set-clear!" "set-copy" "set-copy-clear" "set-count"
+    "set-empty?" "set-eq?" "set-equal?" "set-eqv?" "set-first" "set-for-each" "set-implements/c"
+    "set-implements?" "set-intersect" "set-intersect!" "set-map" "set-mcar!" "set-mcdr!"
+    "set-member?" "set-mutable?" "set-phantom-bytes!" "set-port-next-location!" "set-remove"
+    "set-remove!" "set-rest" "set-subtract" "set-subtract!" "set-symmetric-difference"
+    "set-symmetric-difference!" "set-union" "set-union!" "set-weak?" "set/c" "set=?" "set?" "seteq"
+    "seteqv" "seventh" "sgn" "sha1-bytes" "sha224-bytes" "sha256-bytes" "shared-bytes"
+    "shell-execute" "shrink-path-wrt" "shuffle" "simple-form-path" "simplify-path" "sin"
+    "single-flonum-available?" "single-flonum?" "sinh" "sixth" "skip-projection-wrapper?" "sleep"
+    "some-system-path->string" "sort" "special-comment-value" "special-comment?"
+    "special-filter-input-port" "split-at" "split-at-right" "split-common-prefix" "split-path"
+    "splitf-at" "splitf-at-right" "sqr" "sqrt" "srcloc" "srcloc->string" "srcloc-column"
+    "srcloc-line" "srcloc-position" "srcloc-source" "srcloc-span" "srcloc?" "stop-after"
+    "stop-before" "stream->list" "stream-add-between" "stream-andmap" "stream-append" "stream-count"
+    "stream-empty?" "stream-filter" "stream-first" "stream-fold" "stream-for-each" "stream-force"
+    "stream-length" "stream-map" "stream-ormap" "stream-ref" "stream-rest" "stream-tail"
+    "stream-take" "stream/c" "stream?" "string" "string->bytes/latin-1" "string->bytes/locale"
+    "string->bytes/utf-8" "string->immutable-string" "string->keyword" "string->list"
+    "string->number" "string->path" "string->path-element" "string->some-system-path"
+    "string->symbol" "string->uninterned-symbol" "string->unreadable-symbol" "string-append"
+    "string-append*" "string-append-immutable" "string-ci<=?" "string-ci<?" "string-ci=?"
+    "string-ci>=?" "string-ci>?" "string-contains?" "string-copy" "string-copy!" "string-downcase"
+    "string-environment-variable-name?" "string-fill!" "string-foldcase" "string-join"
+    "string-len/c" "string-length" "string-locale-ci<?" "string-locale-ci=?" "string-locale-ci>?"
+    "string-locale-downcase" "string-locale-upcase" "string-locale<?" "string-locale=?"
+    "string-locale>?" "string-no-nuls?" "string-normalize-nfc" "string-normalize-nfd"
+    "string-normalize-nfkc" "string-normalize-nfkd" "string-normalize-spaces" "string-port?"
+    "string-prefix?" "string-ref" "string-replace" "string-set!" "string-split" "string-suffix?"
+    "string-titlecase" "string-trim" "string-upcase" "string-utf-8-length" "string<=?" "string<?"
+    "string=?" "string>=?" "string>?" "string?" "struct->vector" "struct-accessor-procedure?"
+    "struct-constructor-procedure?" "struct-info" "struct-mutator-procedure?"
+    "struct-predicate-procedure?" "struct-type-authentic?" "struct-type-info"
+    "struct-type-make-constructor" "struct-type-make-predicate"
+    "struct-type-property-accessor-procedure?" "struct-type-property-predicate-procedure?"
+    "struct-type-property/c" "struct-type-property?" "struct-type-sealed?" "struct-type?" "struct?"
+    "sub1" "subbytes" "subclass?" "subclass?/c" "subprocess" "subprocess-group-enabled"
+    "subprocess-kill" "subprocess-pid" "subprocess-status" "subprocess-wait" "subprocess?" "subset?"
+    "substring" "suggest/c" "symbol->string" "symbol-interned?" "symbol-unreadable?" "symbol<?"
+    "symbol=?" "symbol?" "symbols" "sync" "sync/enable-break" "sync/timeout"
+    "sync/timeout/enable-break" "syntax->datum" "syntax->list" "syntax-arm" "syntax-binding-set"
+    "syntax-binding-set->syntax" "syntax-binding-set-extend" "syntax-binding-set?" "syntax-column"
+    "syntax-debug-info" "syntax-deserialize" "syntax-disarm" "syntax-e" "syntax-line"
+    "syntax-local-apply-transformer" "syntax-local-bind-syntaxes" "syntax-local-certifier"
+    "syntax-local-context" "syntax-local-expand-expression" "syntax-local-get-shadower"
+    "syntax-local-identifier-as-binding" "syntax-local-introduce" "syntax-local-lift-context"
+    "syntax-local-lift-expression" "syntax-local-lift-module"
+    "syntax-local-lift-module-end-declaration" "syntax-local-lift-provide"
+    "syntax-local-lift-require" "syntax-local-lift-values-expression"
+    "syntax-local-make-definition-context" "syntax-local-make-delta-introducer"
+    "syntax-local-module-defined-identifiers" "syntax-local-module-exports"
+    "syntax-local-module-interned-scope-symbols" "syntax-local-module-required-identifiers"
+    "syntax-local-name" "syntax-local-phase-level" "syntax-local-submodules"
+    "syntax-local-transforming-module-provides?" "syntax-local-value" "syntax-local-value/immediate"
+    "syntax-original?" "syntax-position" "syntax-property" "syntax-property-preserved?"
+    "syntax-property-remove" "syntax-property-symbol-keys" "syntax-protect" "syntax-rearm"
+    "syntax-recertify" "syntax-serialize" "syntax-shift-phase-level" "syntax-source"
+    "syntax-source-module" "syntax-span" "syntax-taint" "syntax-tainted?" "syntax-track-origin"
+    "syntax-transforming-module-expression?" "syntax-transforming-with-lifts?"
+    "syntax-transforming?" "syntax/c" "syntax?" "system" "system*" "system*/exit-code"
+    "system-big-endian?" "system-idle-evt" "system-language+country" "system-library-subpath"
+    "system-path-convention-type" "system-type" "system/exit-code" "tail-marks-match?" "take"
+    "take-common-prefix" "take-right" "takef" "takef-right" "tan" "tanh" "tcp-abandon-port"
+    "tcp-accept" "tcp-accept-evt" "tcp-accept-ready?" "tcp-accept/enable-break" "tcp-addresses"
+    "tcp-close" "tcp-connect" "tcp-connect/enable-break" "tcp-listen" "tcp-listener?" "tcp-port?"
+    "tentative-pretty-print-port-cancel" "tentative-pretty-print-port-transfer" "tenth"
+    "terminal-port?" "third" "thread" "thread-cell-ref" "thread-cell-set!" "thread-cell-values?"
+    "thread-cell?" "thread-dead-evt" "thread-dead?" "thread-group?" "thread-receive"
+    "thread-receive-evt" "thread-resume" "thread-resume-evt" "thread-rewind-receive"
+    "thread-running?" "thread-send" "thread-suspend" "thread-suspend-evt" "thread-try-receive"
+    "thread-wait" "thread/suspend-to-kill" "thread?" "time-apply" "touch" "transplant-input-port"
+    "transplant-output-port" "truncate" "udp-addresses" "udp-bind!" "udp-bound?" "udp-close"
+    "udp-connect!" "udp-connected?" "udp-multicast-interface" "udp-multicast-join-group!"
+    "udp-multicast-leave-group!" "udp-multicast-loopback?" "udp-multicast-set-interface!"
+    "udp-multicast-set-loopback!" "udp-multicast-set-ttl!" "udp-multicast-ttl" "udp-open-socket"
+    "udp-receive!" "udp-receive!*" "udp-receive!-evt" "udp-receive!/enable-break"
+    "udp-receive-ready-evt" "udp-send" "udp-send*" "udp-send-evt" "udp-send-ready-evt" "udp-send-to"
+    "udp-send-to*" "udp-send-to-evt" "udp-send-to/enable-break" "udp-send/enable-break"
+    "udp-set-receive-buffer-size!" "udp-set-ttl!" "udp-ttl" "udp?" "unbox" "unbox*"
+    "uncaught-exception-handler" "unit?" "unquoted-printing-string" "unquoted-printing-string-value"
+    "unquoted-printing-string?" "unsupplied-arg?" "use-collection-link-paths"
+    "use-compiled-file-check" "use-compiled-file-paths" "use-user-specific-search-paths"
+    "value-blame" "value-contract" "values" "variable-reference->empty-namespace"
+    "variable-reference->module-base-phase" "variable-reference->module-declaration-inspector"
+    "variable-reference->module-path-index" "variable-reference->module-source"
+    "variable-reference->namespace" "variable-reference->phase"
+    "variable-reference->resolved-module-path" "variable-reference-constant?"
+    "variable-reference-from-unsafe?" "variable-reference?" "vector" "vector*-length" "vector*-ref"
+    "vector*-set!" "vector->immutable-vector" "vector->list" "vector->pseudo-random-generator"
+    "vector->pseudo-random-generator!" "vector->values" "vector-append" "vector-argmax"
+    "vector-argmin" "vector-cas!" "vector-copy" "vector-copy!" "vector-count" "vector-drop"
+    "vector-drop-right" "vector-empty?" "vector-fill!" "vector-filter" "vector-filter-not"
+    "vector-immutable" "vector-immutable/c" "vector-immutableof" "vector-length" "vector-map"
+    "vector-map!" "vector-member" "vector-memq" "vector-memv" "vector-ref" "vector-set!"
+    "vector-set*!" "vector-set-performance-stats!" "vector-sort" "vector-sort!" "vector-split-at"
+    "vector-split-at-right" "vector-take" "vector-take-right" "vector/c" "vector?" "vectorof"
+    "version" "void" "void?" "weak-box-value" "weak-box?" "weak-set" "weak-seteq" "weak-seteqv"
+    "will-execute" "will-executor?" "will-register" "will-try-execute" "with-input-from-bytes"
+    "with-input-from-file" "with-input-from-string" "with-output-to-bytes" "with-output-to-file"
+    "with-output-to-string" "would-be-future" "wrap-evt" "write" "write-byte" "write-bytes"
+    "write-bytes-avail" "write-bytes-avail*" "write-bytes-avail-evt"
+    "write-bytes-avail/enable-break" "write-char" "write-special" "write-special-avail*"
+    "write-special-evt" "write-string" "write-to-file" "writeln" "xor" "zero?" "~.a" "~.s" "~.v"
+    "~a" "~e" "~r" "~s" "~v"))
+
+; operators ;;
+((symbol) @operator
+  (#any-of? @operator "+" "-" "*" "/" "=" "<=" ">=" "<" ">"))
+
+; builtin variables ;;
+((symbol) @variable.builtin
+  (#any-of? @variable.builtin
+    "always-evt" "block-device-type-bits" "character-device-type-bits" "check-tail-contract"
+    "contract-continuation-mark-key" "contract-random-generate-fail" "directory-type-bits" "empty"
+    "empty-sequence" "empty-stream" "eof" "equal<%>" "error-message-adjuster-key"
+    "externalizable<%>" "failure-result/c" "false" "false/c" "fifo-type-bits" "file-type-bits"
+    "for-clause-syntax-protect" "group-execute-bit" "group-permission-bits" "group-read-bit"
+    "group-write-bit" "impersonator-prop:application-mark" "impersonator-prop:blame"
+    "impersonator-prop:contracted" "legacy-match-expander?" "match-...-nesting" "match-expander?"
+    "mixin-contract" "never-evt" "null" "object%" "other-execute-bit" "other-permission-bits"
+    "other-read-bit" "other-write-bit" "pi" "pi.f" "predicate/c" "printable<%>" "prop:arity-string"
+    "prop:arrow-contract" "prop:authentic" "prop:blame" "prop:chaperone-contract"
+    "prop:checked-procedure" "prop:contract" "prop:contracted" "prop:custom-print-quotable"
+    "prop:custom-write" "prop:dict" "prop:equal+hash" "prop:evt" "prop:exn:missing-module"
+    "prop:exn:srclocs" "prop:expansion-contexts" "prop:flat-contract" "prop:impersonator-of"
+    "prop:input-port" "prop:legacy-match-expander" "prop:liberal-define-context"
+    "prop:match-expander" "prop:object-name" "prop:orc-contract" "prop:output-port"
+    "prop:place-location" "prop:procedure" "prop:recursive-contract" "prop:rename-transformer"
+    "prop:sealed" "prop:sequence" "prop:set!-transformer" "prop:stream" "regular-file-type-bits"
+    "set-group-id-bit" "set-user-id-bit" "socket-type-bits" "sticky-bit" "struct:arity-at-least"
+    "struct:arrow-contract-info" "struct:date" "struct:date*" "struct:exn" "struct:exn:break"
+    "struct:exn:break:hang-up" "struct:exn:break:terminate" "struct:exn:fail"
+    "struct:exn:fail:contract" "struct:exn:fail:contract:arity" "struct:exn:fail:contract:blame"
+    "struct:exn:fail:contract:continuation" "struct:exn:fail:contract:divide-by-zero"
+    "struct:exn:fail:contract:non-fixnum-result" "struct:exn:fail:contract:variable"
+    "struct:exn:fail:filesystem" "struct:exn:fail:filesystem:errno"
+    "struct:exn:fail:filesystem:exists" "struct:exn:fail:filesystem:missing-module"
+    "struct:exn:fail:filesystem:version" "struct:exn:fail:network" "struct:exn:fail:network:errno"
+    "struct:exn:fail:object" "struct:exn:fail:out-of-memory" "struct:exn:fail:read"
+    "struct:exn:fail:read:eof" "struct:exn:fail:read:non-char" "struct:exn:fail:syntax"
+    "struct:exn:fail:syntax:missing-module" "struct:exn:fail:syntax:unbound"
+    "struct:exn:fail:unsupported" "struct:exn:fail:user" "struct:srcloc" "symbolic-link-type-bits"
+    "syntax-local-match-introduce" "syntax-pattern-variable?" "the-unsupplied-arg" "true"
+    "unspecified-dom" "user-execute-bit" "user-permission-bits" "user-read-bit" "user-write-bit"
+    "writable<%>"))
+
+(dot) @variable.builtin
+
+;------------------------------------------------------------------;;
+;                          Special cases                           ;;
+;------------------------------------------------------------------;;
+(list
+  "["
+  (symbol) @variable
+  "]")
+
+(list
+  .
+  (symbol) @_p
+  .
+  (list
+    (symbol) @variable)
+  (#any-of? @_p
+    "lambda" "λ" "define-values" "define-syntaxes" "define-values-for-export"
+    "define-values-for-syntax"))
+
+;------------------------------------------------------------------;;
+;                         Solve conflicts                          ;;
+;------------------------------------------------------------------;;
+; See `:h treesitter`, and search `priority`
+(list
+  .
+  (symbol) @keyword.import
+  (#eq? @keyword.import "require")
+  (#set! priority 101))
+
+(quote
+  .
+  (symbol)
+  (#set! priority 105)) @string.special.symbol
+
+((sexp_comment) @comment
+  (#set! priority 110))
diff --git a/pack/ant/start/nvim-treesitter/queries/racket/injections.scm b/pack/ant/start/nvim-treesitter/queries/racket/injections.scm
new file mode 100644
index 0000000..dc89820
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/racket/injections.scm
@@ -0,0 +1,5 @@
+([
+  (comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/ralph/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ralph/highlights.scm
new file mode 100644
index 0000000..e56ffa5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ralph/highlights.scm
@@ -0,0 +1,137 @@
+(type_identifier) @type
+
+(identifier) @variable
+
+[
+  (primitive_type)
+  (alph_token_id)
+] @type.builtin
+
+(var_declaration) @variable
+
+(struct_field
+  (identifier) @variable.member)
+
+(arg_def
+  (identifier) @variable.parameter)
+
+(event_field
+  (identifier) @variable.parameter)
+
+(struct_constructor_field
+  (identifier) @variable.parameter)
+
+[
+  (hex_num)
+  (integer)
+  (typed_num)
+] @number
+
+[
+  (bool)
+  (bytes)
+  (address)
+] @constant.builtin
+
+(func_id
+  [
+    (identifier)
+    "!"
+  ] @function)
+
+(annotation
+  [
+    "@"
+    (identifier)
+  ] @attribute)
+
+(map_def
+  (identifier) @variable.parameter)
+
+"fn" @keyword.function
+
+[
+  "Contract"
+  "TxScript"
+  "Interface"
+  "AssetScript"
+  "struct"
+  "enum"
+  "event"
+  "mapping"
+] @keyword.type
+
+[
+  "pub"
+  "Abstract"
+  (mutable)
+] @keyword.modifier
+
+[
+  "while"
+  "for"
+] @keyword.repeat
+
+"return" @keyword.return
+
+[
+  "if"
+  "else"
+] @keyword.conditional
+
+[
+  "const"
+  "let"
+  "emit"
+  "extends"
+  "embeds"
+  "implements"
+] @keyword
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "."
+  ","
+  ":"
+  ";"
+] @punctuation.delimiter
+
+[
+  "="
+  "->"
+  (op_byte_vec_add)
+  (op_add)
+  (op_sub)
+  (op_mul)
+  (op_exp)
+  (op_mod_exp)
+  (op_div)
+  (op_mod)
+  (op_mod_add)
+  (op_mod_sub)
+  (op_mod_mul)
+  (op_shl)
+  (op_shr)
+  (op_bit_and)
+  (op_xor)
+  (op_bit_or)
+  (op_eq)
+  (op_ne)
+  (op_lt)
+  (op_le)
+  (op_gt)
+  (op_ge)
+  (op_and)
+  (op_or)
+  (op_not)
+] @operator
+
+(line_comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/ralph/injections.scm b/pack/ant/start/nvim-treesitter/queries/ralph/injections.scm
new file mode 100644
index 0000000..36849c8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ralph/injections.scm
@@ -0,0 +1,2 @@
+((line_comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/rasi/folds.scm b/pack/ant/start/nvim-treesitter/queries/rasi/folds.scm
new file mode 100644
index 0000000..2fd6c9f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rasi/folds.scm
@@ -0,0 +1,5 @@
+[
+  (rule_set)
+  (list_value)
+  (distance_calc)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/rasi/highlights.scm b/pack/ant/start/nvim-treesitter/queries/rasi/highlights.scm
new file mode 100644
index 0000000..d095cef
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rasi/highlights.scm
@@ -0,0 +1,138 @@
+(comment) @comment @spell
+
+"@media" @keyword
+
+"@import" @keyword.import
+
+"@theme" @keyword.import
+
+(string_value) @string
+
+[
+  (integer_value)
+  (float_value)
+  "0"
+] @number
+
+(boolean_value) @boolean
+
+[
+  (feature_name)
+  (url_image_scale)
+  (direction)
+  (text_style_value)
+  (line_style_value)
+  (position_value)
+  (orientation_value)
+  (cursor_value)
+  "inherit"
+] @keyword
+
+(url_image
+  "url" @function.builtin)
+
+(gradient_image
+  "linear-gradient" @function.builtin)
+
+(distance_calc
+  "calc" @function.builtin)
+
+(rgb_color
+  [
+    "rgb"
+    "rgba"
+  ] @function.builtin)
+
+(hsl_color
+  [
+    "hsl"
+    "hsla"
+  ] @function.builtin)
+
+(hwb_color
+  [
+    "hwb"
+    "hwba"
+  ] @function.builtin)
+
+(cmyk_color
+  "cmyk" @function.builtin)
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+(distance_op) @operator
+
+[
+  ";"
+  ","
+  ":"
+  "."
+] @punctuation.delimiter
+
+[
+  (angle_unit)
+  (integer_distance_unit)
+  (float_distance_unit)
+] @string
+
+(percentage) @number
+
+(percentage
+  "%" @string)
+
+(global_selector) @character.special
+
+(id_selector) @constant
+
+(id_selector_view
+  [
+    "normal"
+    "selected"
+    "alternate"
+  ] @attribute)
+
+(id_selector_state
+  [
+    "normal"
+    "urgent"
+    "active"
+  ] @keyword.modifier)
+
+(hex_color) @number
+
+(hex_color
+  "#" @punctuation.special)
+
+(named_color
+  (identifier) @string.special)
+
+(named_color
+  "/" @operator)
+
+(reference_value
+  "@" @punctuation.special
+  (identifier) @variable)
+
+(reference_value
+  "var" @function.builtin
+  (identifier) @variable)
+
+(list_value
+  (identifier) @variable)
+
+(environ_value
+  "$" @punctuation.special
+  (identifier) @variable)
+
+(environ_value
+  "env" @function.builtin
+  (identifier) @variable)
+
+(property_name) @property
diff --git a/pack/ant/start/nvim-treesitter/queries/rasi/indents.scm b/pack/ant/start/nvim-treesitter/queries/rasi/indents.scm
new file mode 100644
index 0000000..849d8ae
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rasi/indents.scm
@@ -0,0 +1,6 @@
+(rule_set) @indent.begin
+
+(block
+  "}" @indent.branch)
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/rasi/injections.scm b/pack/ant/start/nvim-treesitter/queries/rasi/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rasi/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/rasi/locals.scm b/pack/ant/start/nvim-treesitter/queries/rasi/locals.scm
new file mode 100644
index 0000000..9210de6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rasi/locals.scm
@@ -0,0 +1,10 @@
+(rule_set
+  (selectors
+    (id_selector))) @local.scope
+
+(block
+  (declaration
+    (property_name) @local.definition.var))
+
+(reference_value
+  name: (identifier) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/rbs/folds.scm b/pack/ant/start/nvim-treesitter/queries/rbs/folds.scm
new file mode 100644
index 0000000..ff8e7c5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rbs/folds.scm
@@ -0,0 +1,5 @@
+[
+  (class_decl)
+  (module_decl)
+  (interface_decl)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/rbs/highlights.scm b/pack/ant/start/nvim-treesitter/queries/rbs/highlights.scm
new file mode 100644
index 0000000..1000e3b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rbs/highlights.scm
@@ -0,0 +1,143 @@
+; Use directive
+(use_clause
+  [
+    (type_name)
+    (simple_type_name)
+  ] @type)
+
+; Builtin constants and Keywords
+[
+  "true"
+  "false"
+] @boolean
+
+"nil" @constant.builtin
+
+[
+  "use"
+  "as"
+  "module"
+  "def"
+  "attr_reader"
+  "attr_writer"
+  "attr_accessor"
+  "end"
+  "alias"
+] @keyword
+
+[
+  "interface"
+  "type"
+  "class"
+] @keyword.type
+
+(class_decl
+  "end" @keyword.type)
+
+(interface_decl
+  "end" @keyword.type)
+
+"def" @keyword.function
+
+; Members of declaration
+[
+  "include"
+  "extend"
+  "prepend"
+] @function.method
+
+(visibility) @keyword.modifier
+
+(comment) @comment @spell
+
+(method_member
+  (method_name
+    [
+      (identifier)
+      (constant)
+      (operator)
+      (setter)
+    ] @function.method))
+
+[
+  (ivar_name)
+  (cvar_name)
+] @variable.member
+
+(alias_member
+  (method_name) @function)
+
+(class_name
+  (constant) @type)
+
+(module_name
+  (constant) @type)
+
+(interface_name
+  (interface) @type)
+
+(alias_name
+  (identifier) @type)
+
+(type_variable) @constant
+
+(namespace
+  (constant) @module)
+
+(builtin_type) @type.builtin
+
+(const_name
+  (constant) @constant)
+
+(global_name) @variable
+
+; Standard Arguments
+(parameter
+  (var_name) @variable.parameter)
+
+; Keyword Arguments
+(keyword) @variable.parameter
+
+; Self
+(self) @variable.builtin
+
+; Literal
+(type
+  (symbol_literal) @string.special.symbol)
+
+(type
+  (string_literal
+    (escape_sequence) @string.escape))
+
+(type
+  (string_literal) @string)
+
+(type
+  (integer_literal) @number)
+
+; Operators
+[
+  "="
+  "->"
+  "<"
+  "**"
+  "*"
+  "&"
+  "|"
+  "^"
+] @operator
+
+; Punctuation
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  ","
+  "."
+] @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/rbs/indents.scm b/pack/ant/start/nvim-treesitter/queries/rbs/indents.scm
new file mode 100644
index 0000000..f6da5b1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rbs/indents.scm
@@ -0,0 +1,24 @@
+[
+  (class_decl)
+  (module_decl)
+  (interface_decl)
+  (parameters)
+  (tuple_type)
+  (record_type)
+] @indent.begin
+
+[
+  "end"
+  ")"
+  "]"
+  "}"
+] @indent.end
+
+[
+  "end"
+  ")"
+  "}"
+  "]"
+] @indent.branch
+
+(comment) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/rbs/injections.scm b/pack/ant/start/nvim-treesitter/queries/rbs/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rbs/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/re2c/folds.scm b/pack/ant/start/nvim-treesitter/queries/re2c/folds.scm
new file mode 100644
index 0000000..b4cf5f2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/re2c/folds.scm
@@ -0,0 +1,4 @@
+[
+  (body)
+  (action)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/re2c/highlights.scm b/pack/ant/start/nvim-treesitter/queries/re2c/highlights.scm
new file mode 100644
index 0000000..c89c307
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/re2c/highlights.scm
@@ -0,0 +1,183 @@
+; Namespaces
+[
+  "re2c"
+  "re2c"
+  "local"
+  "rules"
+] @module
+
+; Includes
+[
+  "!use"
+  "!include"
+] @keyword.import
+
+; Keywords
+[
+  "flags"
+  "define"
+  "cond"
+  "label"
+  "variable"
+  "yych"
+  "state"
+  "yybm"
+  "cgoto"
+  "api"
+  "tags"
+  "indent"
+  "yyfill"
+  "eof"
+  "sentinel"
+  "condprefix"
+  "condenumprefix"
+  "startlabel"
+  "posix-captures"
+  "max"
+  "maxnmatch"
+  "mtags"
+  "stags"
+  "header"
+  "getstate"
+] @keyword
+
+[
+  "*"
+  "+"
+  "?"
+] @keyword.repeat
+
+; Constants
+[
+  "ignore"
+  "substitute"
+  "fail"
+  "default"
+  "custom"
+  "match-empty"
+  "match-none"
+  "error"
+  "functions"
+  "free-form"
+  "format"
+  "separator"
+] @constant.builtin
+
+(linedir) @constant.macro
+
+; Operators
+[
+  "="
+  "=>"
+  ":=>"
+  "/"
+  "|"
+  "\\"
+  "->"
+  "^"
+] @operator
+
+[
+  "."
+  (default)
+  (end_of_input)
+] @constant.macro
+
+(field_expression
+  "." @operator)
+
+(condition
+  (any) @constant.macro)
+
+; Names
+(name) @type
+
+(block_name) @constant
+
+(label) @label
+
+(option_name) @constant.builtin
+
+((option_name) @constant.macro
+  (#match? @constant.macro "^YY"))
+
+(field_expression
+  argument: (identifier) @variable)
+
+(field_identifier) @property
+
+; Literals
+(regex) @string.regexp
+
+[
+  (dstring) ; case   sensitive
+  (sstring) ; case insensitive
+] @string
+
+[
+  (quote)
+  (ctrl_code)
+  (code_unit)
+] @string.escape
+
+(number) @number
+
+[
+  "on"
+  "off"
+] @boolean
+
+[
+  (stag)
+  (mtag)
+] @property
+
+; Configurations
+(define
+  option: (option_name) @_yy
+  value: (dstring) @type
+  (#eq? @_yy "YYCTYPE")
+  (#offset! @type 0 1 0 -1))
+
+(set_header
+  value: (dstring) @string.special)
+
+(host_lang) @none
+
+; Punctuation
+[
+  ":"
+  ";"
+  ","
+  "-"
+] @punctuation.delimiter
+
+[
+  "{"
+  "}"
+  "["
+  "]"
+  "("
+  ")"
+  "<"
+  ">"
+] @punctuation.bracket
+
+(repetition
+  (limits
+    [
+      "{"
+      "}"
+    ] @punctuation.bracket))
+
+[
+  "!"
+  "@"
+  "#"
+] @punctuation.special
+
+; Comments and error
+[
+  (comment)
+  (ignore_block)
+] @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/re2c/indents.scm b/pack/ant/start/nvim-treesitter/queries/re2c/indents.scm
new file mode 100644
index 0000000..31ccf2a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/re2c/indents.scm
@@ -0,0 +1,11 @@
+[
+  (re2c)
+  (action)
+] @indent.begin
+
+"}" @indent.branch @indent.end
+
+[
+  (comment)
+  (linedir)
+] @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/re2c/injections.scm b/pack/ant/start/nvim-treesitter/queries/re2c/injections.scm
new file mode 100644
index 0000000..f0cb1a9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/re2c/injections.scm
@@ -0,0 +1,13 @@
+((host_lang) @injection.content
+  (#set! injection.parent))
+
+((define
+  option: (option_name) @_yy
+  value: (dstring) @injection.content)
+  (#any-of? @_yy
+    "YYPEEK" "YYSKIP" "YYBACKUP" "YYBACKUPCTX" "YYRESTORE" "YYRESTORECTX" "YYFILL" "YYSHIFT")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.parent))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/re2c/locals.scm b/pack/ant/start/nvim-treesitter/queries/re2c/locals.scm
new file mode 100644
index 0000000..eea1ede
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/re2c/locals.scm
@@ -0,0 +1 @@
+(body) @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/readline/folds.scm b/pack/ant/start/nvim-treesitter/queries/readline/folds.scm
new file mode 100644
index 0000000..57c9bc7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/readline/folds.scm
@@ -0,0 +1 @@
+(conditional_construct) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/readline/highlights.scm b/pack/ant/start/nvim-treesitter/queries/readline/highlights.scm
new file mode 100644
index 0000000..570e55b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/readline/highlights.scm
@@ -0,0 +1,69 @@
+(comment) @comment @spell
+
+"set" @keyword
+
+[
+  "$if"
+  "$else"
+  "$endif"
+] @keyword.conditional
+
+"$include" @keyword.import
+
+[
+  "="
+  "=="
+  "!="
+  ">="
+  "<="
+  ">"
+  "<"
+] @operator
+
+[
+  ":"
+  "-"
+] @punctuation.delimiter
+
+[
+  (application_name)
+  (keyname)
+  (keyseq)
+  (macro)
+  (string_value)
+  (term_name)
+] @string
+
+(file_path) @string.special.path
+
+(escape_sequence) @string.escape
+
+(symbolic_character_name) @character.special
+
+(key_literal) @character
+
+(function_name) @function
+
+[
+  (bell_variable)
+  (bool_variable)
+  (edit_mode_variable)
+  (keymap_variable)
+  (number_variable)
+  (string_variable)
+] @variable.builtin
+
+[
+  (bell_value)
+  (edit_mode_value)
+  (keymap_value)
+  "version"
+  "term"
+  "mode"
+] @constant.builtin
+
+(number_value) @number
+
+(version_number) @number.float
+
+(bool_value) @boolean
diff --git a/pack/ant/start/nvim-treesitter/queries/readline/indents.scm b/pack/ant/start/nvim-treesitter/queries/readline/indents.scm
new file mode 100644
index 0000000..d7dc674
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/readline/indents.scm
@@ -0,0 +1,11 @@
+(conditional_construct) @indent.begin
+
+(ERROR
+  "$if") @indent.begin
+
+[
+  "$else"
+  "$endif"
+] @indent.branch
+
+"$endif" @indent.end
diff --git a/pack/ant/start/nvim-treesitter/queries/readline/injections.scm b/pack/ant/start/nvim-treesitter/queries/readline/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/readline/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/regex/highlights.scm b/pack/ant/start/nvim-treesitter/queries/regex/highlights.scm
new file mode 100644
index 0000000..e529a98
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/regex/highlights.scm
@@ -0,0 +1,50 @@
+; Forked from tree-sitter-regex
+; The MIT License (MIT) Copyright (c) 2014 Max Brunsfeld
+[
+  "("
+  ")"
+  "(?"
+  "(?:"
+  "(?<"
+  ">"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+(group_name) @property
+
+; These are escaped special characters that lost their special meaning
+; -> no special highlighting
+(identity_escape) @string.regexp
+
+(class_character) @constant
+
+(decimal_digits) @number
+
+[
+  (control_letter_escape)
+  (character_class_escape)
+  (control_escape)
+  (boundary_assertion)
+  (non_boundary_assertion)
+] @string.escape
+
+[
+  "*"
+  "+"
+  "?"
+  "|"
+  "="
+  "!"
+  "-"
+] @operator
+
+[
+  (start_assertion)
+  (end_assertion)
+  ","
+] @punctuation.delimiter
+
+(any_character) @variable.builtin
diff --git a/pack/ant/start/nvim-treesitter/queries/rego/highlights.scm b/pack/ant/start/nvim-treesitter/queries/rego/highlights.scm
new file mode 100644
index 0000000..3cc3294
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rego/highlights.scm
@@ -0,0 +1,84 @@
+; highlights.scm
+[
+  (import)
+  (package)
+] @keyword.import
+
+[
+  (with)
+  (as)
+  (every)
+  (some)
+  (in)
+  (not)
+  (if)
+  (contains)
+  (else)
+  (default)
+  "null"
+] @keyword
+
+[
+  "true"
+  "false"
+] @boolean
+
+[
+  (assignment_operator)
+  (bool_operator)
+  (arith_operator)
+  (bin_operator)
+] @operator
+
+[
+  (string)
+  (raw_string)
+] @string
+
+(term
+  (ref
+    (var))) @variable
+
+(comment) @comment @spell
+
+(number) @number
+
+(expr_call
+  func_name: (fn_name
+    (var) @function .))
+
+(expr_call
+  func_arguments: (fn_args
+    (expr) @variable.parameter))
+
+(rule_args
+  (term) @variable.parameter)
+
+[
+  (open_paren)
+  (close_paren)
+  (open_bracket)
+  (close_bracket)
+  (open_curly)
+  (close_curly)
+] @punctuation.bracket
+
+(rule
+  (rule_head
+    (var) @function.method))
+
+(rule
+  (rule_head
+    (term
+      (ref
+        (var) @module)))
+  (rule_body
+    (query
+      (literal
+        (expr
+          (expr_infix
+            (expr
+              (term
+                (ref
+                  (var)) @_output))))))
+    (#eq? @_output @module)))
diff --git a/pack/ant/start/nvim-treesitter/queries/rego/injections.scm b/pack/ant/start/nvim-treesitter/queries/rego/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rego/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/requirements/highlights.scm b/pack/ant/start/nvim-treesitter/queries/requirements/highlights.scm
new file mode 100644
index 0000000..a04922a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/requirements/highlights.scm
@@ -0,0 +1,52 @@
+; packages
+(package) @variable
+
+(extras
+  (package) @variable.parameter)
+
+(path) @string.special.path
+
+(url) @string.special.url
+
+; versions
+(version_cmp) @operator
+
+(version) @number
+
+; markers
+(marker_var) @attribute
+
+(marker_op) @keyword.operator
+
+; options
+(option) @function
+
+"=" @operator
+
+; punctuation
+[
+  "["
+  "]"
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  ","
+  ";"
+  "@"
+] @punctuation.delimiter
+
+[
+  "${"
+  "}"
+] @punctuation.special
+
+; misc
+(env_var) @constant
+
+(quoted_string) @string
+
+(linebreak) @character.special
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/requirements/injections.scm b/pack/ant/start/nvim-treesitter/queries/requirements/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/requirements/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/rescript/folds.scm b/pack/ant/start/nvim-treesitter/queries/rescript/folds.scm
new file mode 100644
index 0000000..4e658a5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rescript/folds.scm
@@ -0,0 +1,12 @@
+[
+  (block)
+  (function)
+  (module_declaration)
+  (type_declaration)
+  (external_declaration)
+  (call_expression)
+  (switch_expression)
+  (parenthesized_expression)
+  (record)
+  (include_statement)+
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/rescript/highlights.scm b/pack/ant/start/nvim-treesitter/queries/rescript/highlights.scm
new file mode 100644
index 0000000..e7cba9b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rescript/highlights.scm
@@ -0,0 +1,335 @@
+(comment) @comment @spell
+
+; Identifiers
+;------------
+; Escaped identifiers like \"+."
+((value_identifier) @constant.macro
+  (#lua-match? @constant.macro "^%.*$"))
+
+(value_identifier) @variable
+
+[
+  (type_identifier)
+  (unit_type)
+  (list)
+  (list_pattern)
+] @type
+
+((type_identifier) @type.builtin
+  (#any-of? @type.builtin "int" "char" "string" "float" "bool" "unit"))
+
+[
+  (variant_identifier)
+  (polyvar_identifier)
+] @constructor
+
+(record_type_field
+  (property_identifier) @property)
+
+(record_field
+  (property_identifier) @property)
+
+(object
+  (field
+    (property_identifier) @property))
+
+(object_type
+  (field
+    (property_identifier) @property))
+
+(module_identifier) @module
+
+(member_expression
+  (property_identifier) @variable.member)
+
+(value_identifier_path
+  (module_identifier)
+  (value_identifier) @variable)
+
+(record_pattern
+  (value_identifier_path
+    (value_identifier) @variable.member))
+
+(record_pattern
+  (value_identifier) @variable)
+
+(labeled_argument
+  label: (value_identifier) @variable.parameter)
+
+; Parameters
+;----------------
+(list_pattern
+  (value_identifier) @variable.parameter)
+
+(spread_pattern
+  (value_identifier) @variable.parameter)
+
+; String literals
+;----------------
+[
+  (string)
+  (template_string)
+] @string
+
+(character) @character
+
+(escape_sequence) @string.escape
+
+; Other literals
+;---------------
+[
+  (true)
+  (false)
+] @boolean
+
+(number) @number
+
+(polyvar) @constructor
+
+(polyvar_string) @constructor
+
+; Functions
+;----------
+; parameter(s) in parens
+(parameter
+  (value_identifier) @variable.parameter)
+
+(labeled_parameter
+  (value_identifier) @variable.parameter)
+
+; single parameter with no parens
+(function
+  parameter: (value_identifier) @variable.parameter)
+
+(parameter
+  (tuple_pattern
+    (tuple_item_pattern
+      (value_identifier) @variable.parameter)))
+
+(parameter
+  (array_pattern
+    (value_identifier) @variable.parameter))
+
+(parameter
+  (record_pattern
+    (value_identifier) @variable.parameter))
+
+; function identifier in let binding
+(let_binding
+  pattern: (value_identifier) @function
+  body: (function))
+
+; function calls
+(call_expression
+  function: (value_identifier_path
+    (value_identifier) @function.method.call .))
+
+(call_expression
+  function: (value_identifier) @function.call)
+
+; highlight the right-hand side of a pipe operator as a function call
+(pipe_expression
+  (value_identifier) @function.call .)
+
+(pipe_expression
+  (value_identifier_path
+    (value_identifier) @function.method.call .) .)
+
+; Meta
+;-----
+(decorator_identifier) @attribute
+
+(extension_identifier) @keyword
+
+"%" @keyword
+
+; Misc
+;-----
+(polyvar_type_pattern
+  "#" @constructor)
+
+[
+  "include"
+  "open"
+] @keyword.import
+
+[
+  "private"
+  "mutable"
+  "rec"
+] @keyword.modifier
+
+"type" @keyword.type
+
+[
+  "and"
+  "with"
+  "as"
+] @keyword.operator
+
+[
+  "export"
+  "external"
+  "let"
+  "module"
+  "assert"
+  "await"
+  "lazy"
+  "constraint"
+] @keyword
+
+"await" @keyword.coroutine
+
+(function
+  "async" @keyword.coroutine)
+
+(module_unpack
+  "unpack" @keyword)
+
+[
+  "if"
+  "else"
+  "switch"
+  "when"
+] @keyword.conditional
+
+[
+  "exception"
+  "try"
+  "catch"
+] @keyword.exception
+
+(call_expression
+  function: (value_identifier) @keyword.exception
+  (#eq? @keyword.exception "raise"))
+
+[
+  "for"
+  "in"
+  "to"
+  "downto"
+  "while"
+] @keyword.repeat
+
+[
+  "."
+  ","
+  "|"
+  ":"
+] @punctuation.delimiter
+
+[
+  "++"
+  "+"
+  "+."
+  "-"
+  "-."
+  "*"
+  "**"
+  "*."
+  "/."
+  "<="
+  "=="
+  "==="
+  "!"
+  "!="
+  "!=="
+  ">="
+  "&&"
+  "||"
+  "="
+  ":="
+  "->"
+  "|>"
+  ":>"
+  "+="
+  "=>"
+  (uncurry)
+] @operator
+
+; Explicitly enclose these operators with binary_expression
+; to avoid confusion with JSX tag delimiters
+(binary_expression
+  [
+    "<"
+    ">"
+    "/"
+  ] @operator)
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+  "<"
+  ">"
+] @punctuation.bracket
+
+(unit
+  [
+    "("
+    ")"
+  ] @constant.builtin)
+
+(template_substitution
+  "${" @punctuation.special
+  "}" @punctuation.special) @none
+
+(polyvar_type
+  [
+    "["
+    "[>"
+    "[<"
+    "]"
+  ] @punctuation.bracket)
+
+[
+  "~"
+  "?"
+  ".."
+  "..."
+] @punctuation.special
+
+(ternary_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+; JSX
+;----------
+(jsx_identifier) @tag
+
+(jsx_element
+  open_tag: (jsx_opening_element
+    [
+      "<"
+      ">"
+    ] @tag.delimiter))
+
+(jsx_element
+  close_tag: (jsx_closing_element
+    [
+      "<"
+      "/"
+      ">"
+    ] @tag.delimiter))
+
+(jsx_self_closing_element
+  [
+    "/"
+    ">"
+    "<"
+  ] @tag.delimiter)
+
+(jsx_fragment
+  [
+    ">"
+    "<"
+    "/"
+  ] @tag.delimiter)
+
+(jsx_attribute
+  (property_identifier) @tag.attribute)
diff --git a/pack/ant/start/nvim-treesitter/queries/rescript/indents.scm b/pack/ant/start/nvim-treesitter/queries/rescript/indents.scm
new file mode 100644
index 0000000..0b635dd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rescript/indents.scm
@@ -0,0 +1,36 @@
+[
+  (block)
+  (record_type)
+  (record)
+  (parenthesized_expression)
+  (call_expression)
+  (function_type_parameters)
+  (function)
+  (switch_match)
+  (let_declaration)
+  (jsx_element)
+  (jsx_fragment)
+  (jsx_self_closing_element)
+  (object_type)
+] @indent.begin
+
+[
+  "}"
+  ")"
+  (jsx_closing_element)
+] @indent.branch @indent.end
+
+(jsx_self_closing_element
+  "/" @indent.branch
+  ">"? @indent.end)
+
+; </> is captured as 3 different anonymous nodes
+(jsx_fragment
+  "<"
+  "<" @indent.branch)
+
+(jsx_fragment
+  ">"
+  ">" @indent.end)
+
+(comment) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/rescript/injections.scm b/pack/ant/start/nvim-treesitter/queries/rescript/injections.scm
new file mode 100644
index 0000000..434404b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rescript/injections.scm
@@ -0,0 +1,33 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+(extension_expression
+  (extension_identifier) @_name
+  (#eq? @_name "re")
+  (expression_statement
+    (_) @injection.content
+    (#set! injection.language "regex")))
+
+(extension_expression
+  (extension_identifier) @_name
+  (#eq? @_name "raw")
+  (expression_statement
+    (_
+      (_) @injection.content
+      (#set! injection.language "javascript"))))
+
+(extension_expression
+  (extension_identifier) @_name
+  (#eq? @_name "graphql")
+  (expression_statement
+    (_
+      (_) @injection.content
+      (#set! injection.language "graphql"))))
+
+(extension_expression
+  (extension_identifier) @_name
+  (#eq? @_name "relay")
+  (expression_statement
+    (_
+      (_) @injection.content
+      (#set! injection.language "graphql"))))
diff --git a/pack/ant/start/nvim-treesitter/queries/rescript/locals.scm b/pack/ant/start/nvim-treesitter/queries/rescript/locals.scm
new file mode 100644
index 0000000..10a663b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rescript/locals.scm
@@ -0,0 +1,9 @@
+(switch_expression) @local.scope
+
+; Definitions
+;------------
+(type_declaration) @local.definition.type
+
+(let_binding) @local.definition.var
+
+(module_declaration) @local.definition.namespace
diff --git a/pack/ant/start/nvim-treesitter/queries/rnoweb/folds.scm b/pack/ant/start/nvim-treesitter/queries/rnoweb/folds.scm
new file mode 100644
index 0000000..893758c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rnoweb/folds.scm
@@ -0,0 +1 @@
+(rchunk) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/rnoweb/highlights.scm b/pack/ant/start/nvim-treesitter/queries/rnoweb/highlights.scm
new file mode 100644
index 0000000..81afaf1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rnoweb/highlights.scm
@@ -0,0 +1 @@
+; This file is a placeholder to enable the highlighting of injected languages.
diff --git a/pack/ant/start/nvim-treesitter/queries/rnoweb/injections.scm b/pack/ant/start/nvim-treesitter/queries/rnoweb/injections.scm
new file mode 100644
index 0000000..123cfb8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rnoweb/injections.scm
@@ -0,0 +1,12 @@
+((latex) @injection.content
+  (#set! injection.language "latex")
+  (#set! injection.combined))
+
+(rchunk
+  (renv_content) @injection.content
+  (#set! injection.language "r")
+  (#set! injection.combined))
+
+(rinline
+  (renv_content) @injection.content
+  (#set! injection.language "r"))
diff --git a/pack/ant/start/nvim-treesitter/queries/robot/folds.scm b/pack/ant/start/nvim-treesitter/queries/robot/folds.scm
new file mode 100644
index 0000000..948f8a1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/robot/folds.scm
@@ -0,0 +1,5 @@
+[
+  (section)
+  (keyword_definition)
+  (test_case_definition)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/robot/highlights.scm b/pack/ant/start/nvim-treesitter/queries/robot/highlights.scm
new file mode 100644
index 0000000..b9db024
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/robot/highlights.scm
@@ -0,0 +1,79 @@
+[
+  (comment)
+  (extra_text)
+] @comment @spell
+
+[
+  (section_header)
+  (setting_statement)
+  (keyword_setting)
+  (test_case_setting)
+] @keyword
+
+(variable_definition
+  (variable_name) @variable)
+
+(keyword_definition
+  (name) @function)
+
+(test_case_definition
+  (name) @function)
+
+(keyword_invocation
+  (keyword) @function.call)
+
+(ellipses) @punctuation.delimiter
+
+(text_chunk) @string
+
+(inline_python_expression) @string.special
+
+[
+  (scalar_variable)
+  (list_variable)
+  (dictionary_variable)
+] @variable
+
+; Control structures
+[
+  "FOR"
+  "IN"
+  "IN RANGE"
+  "IN ENUMERATE"
+  "IN ZIP"
+  (break_statement)
+  (continue_statement)
+] @keyword.repeat
+
+(for_statement
+  "END" @keyword.repeat)
+
+"WHILE" @keyword.repeat
+
+(while_statement
+  "END" @keyword.repeat)
+
+[
+  "IF"
+  "ELSE IF"
+] @keyword.conditional
+
+(if_statement
+  "END" @keyword.conditional)
+
+(if_statement
+  (else_statement
+    "ELSE" @keyword.conditional))
+
+[
+  "TRY"
+  "EXCEPT"
+  "FINALLY"
+] @keyword.exception
+
+(try_statement
+  "END" @keyword.exception)
+
+(try_statement
+  (else_statement
+    "ELSE" @keyword.exception))
diff --git a/pack/ant/start/nvim-treesitter/queries/robot/indents.scm b/pack/ant/start/nvim-treesitter/queries/robot/indents.scm
new file mode 100644
index 0000000..457fbff
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/robot/indents.scm
@@ -0,0 +1,44 @@
+(keyword_definition) @indent.begin
+
+(test_case_definition) @indent.begin
+
+(for_statement) @indent.begin
+
+(for_statement
+  "END" @indent.branch)
+
+(for_statement
+  right: (_
+    (arguments
+      (continuation
+        (ellipses) @indent.branch))))
+
+(while_statement) @indent.begin
+
+(while_statement
+  "END" @indent.branch)
+
+(if_statement) @indent.begin
+
+(if_statement
+  (elseif_statement) @indent.branch)
+
+(if_statement
+  (else_statement) @indent.branch)
+
+(if_statement
+  "END" @indent.branch)
+
+(try_statement) @indent.begin
+
+(try_statement
+  (except_statement) @indent.branch)
+
+(try_statement
+  (finally_statement) @indent.branch)
+
+(try_statement
+  (else_statement) @indent.branch)
+
+(try_statement
+  "END" @indent.branch)
diff --git a/pack/ant/start/nvim-treesitter/queries/robot/injections.scm b/pack/ant/start/nvim-treesitter/queries/robot/injections.scm
new file mode 100644
index 0000000..56e3700
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/robot/injections.scm
@@ -0,0 +1,5 @@
+([
+  (comment)
+  (extra_text)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/robots/highlights.scm b/pack/ant/start/nvim-treesitter/queries/robots/highlights.scm
new file mode 100644
index 0000000..a2c55c7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/robots/highlights.scm
@@ -0,0 +1,7 @@
+(comment) @comment @spell
+
+(directive) @property
+
+(value) @string
+
+":" @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/robots/injections.scm b/pack/ant/start/nvim-treesitter/queries/robots/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/robots/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/roc/highlights.scm b/pack/ant/start/nvim-treesitter/queries/roc/highlights.scm
new file mode 100644
index 0000000..1f950cb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/roc/highlights.scm
@@ -0,0 +1,175 @@
+;---Most generic types---
+(module) @module
+
+(identifier) @variable
+
+(concrete_type) @type
+
+;---annotations----
+(annotation_type_def
+  (annotation_pre_colon
+    (identifier) @type))
+
+(annotation_type_def
+  (annotation_pre_colon
+    (identifier) @function)
+  (function_type))
+
+;----decleration types----
+(value_declaration
+  (decl_left
+    (identifier_pattern
+      (identifier) @variable.parameter)))
+
+;---records----
+(field_name) @variable.member
+
+(record_field_pattern
+  (_
+    (identifier) @variable))
+
+;matches the second identifier and all subsequent ones
+(field_access_expr
+  (identifier) @variable.member)
+
+;----comments----
+(line_comment) @comment @spell
+
+(doc_comment) @comment.documentation @spell
+
+;-----Punctuation----
+[
+  "?"
+  (arrow)
+  (back_arrow)
+  (backslash)
+  ","
+  ":"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "|"
+  "&"
+  (operator)
+] @operator
+
+(wildcard_pattern) @character.special
+
+[
+  "if"
+  "then"
+  "else"
+] @keyword.conditional
+
+[
+  (implements)
+  (when)
+  (is)
+  "as"
+  (to)
+] @keyword
+
+;----headers-----
+[
+  "app"
+  "expect"
+  "module"
+  "package"
+  "import"
+] @keyword
+
+[
+  (import_as)
+  "imports"
+] @keyword.import
+
+(backpassing_expr
+  assignee: (identifier_pattern
+    (identifier) @variable.parameter))
+
+(value_declaration
+  (decl_left
+    (identifier_pattern
+      (identifier) @function))
+  (expr_body
+    (anon_fun_expr)))
+
+;----tags----
+(tags_type
+  (apply_type
+    (concrete_type) @constructor))
+
+[
+  (tag)
+  (opaque_tag)
+] @constructor
+
+;-----builtins----
+(variable_expr
+  (module) @module
+  (identifier) @boolean
+  (#any-of? @boolean "true" "false")
+  (#eq? @module "Bool"))
+
+"dbg" @keyword.debug
+
+;----function invocations ----
+(function_call_expr
+  caller: (variable_expr
+    (identifier) @function.call))
+
+(function_call_expr
+  caller: (field_access_expr
+    (identifier) @function.call .))
+
+(bin_op_expr
+  (operator
+    "|>") @operator
+  (variable_expr
+    (identifier) @function))
+
+;----function arguments----
+(argument_patterns
+  (identifier_pattern
+    (identifier) @variable.parameter))
+
+(argument_patterns
+  (_
+    (identifier_pattern
+      (identifier) @variable.parameter)))
+
+(argument_patterns
+  (_
+    (_
+      (identifier_pattern
+        (identifier) @variable.parameter))))
+
+;-----consts-----
+[
+  (int)
+  (uint)
+  (iint)
+  (xint)
+  (natural)
+] @number
+
+[
+  (decimal)
+  (float)
+] @number.float
+
+[
+  (string)
+  (multiline_string)
+] @string
+
+(char) @character
diff --git a/pack/ant/start/nvim-treesitter/queries/roc/injections.scm b/pack/ant/start/nvim-treesitter/queries/roc/injections.scm
new file mode 100644
index 0000000..3264783
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/roc/injections.scm
@@ -0,0 +1,5 @@
+([
+  (line_comment)
+  (doc_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/roc/locals.scm b/pack/ant/start/nvim-treesitter/queries/roc/locals.scm
new file mode 100644
index 0000000..134fe01
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/roc/locals.scm
@@ -0,0 +1,41 @@
+(expr_body) @local.scope
+
+(argument_patterns
+  (identifier_pattern
+    (identifier) @local.definition))
+
+; (argument_patterns(long_identifier)@local.definition)
+(exposes_list
+  (ident) @local.reference)
+
+(import_expr
+  (as)
+  (module) @local.definition)
+
+(opaque_type_def
+  (apply_type
+    (concrete_type) @local.definition.type))
+
+(alias_type_def
+  (apply_type
+    (concrete_type) @local.definition.type))
+
+(value_declaration
+  (decl_left
+    (identifier_pattern
+      (identifier) @local.definition.function))
+  (expr_body
+    (anon_fun_expr)))
+
+(value_declaration
+  (decl_left
+    (identifier_pattern
+      (identifier) @local.definition.var)))
+
+(identifier_pattern
+  (identifier) @local.definition)
+
+(identifier) @local.reference
+
+(tag_expr
+  (tag)) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/ron/folds.scm b/pack/ant/start/nvim-treesitter/queries/ron/folds.scm
new file mode 100644
index 0000000..ae79583
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ron/folds.scm
@@ -0,0 +1,7 @@
+[
+  (array)
+  (map)
+  (tuple)
+  (struct)
+  (block_comment)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/ron/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ron/highlights.scm
new file mode 100644
index 0000000..9650732
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ron/highlights.scm
@@ -0,0 +1,62 @@
+; Structs
+;------------
+(enum_variant) @constant
+
+(struct_entry
+  (identifier) @variable.member)
+
+(struct_entry
+  (enum_variant
+    (identifier) @constant))
+
+(struct_name
+  (identifier)) @type
+
+(unit_struct) @type.builtin
+
+; Literals
+;------------
+(string) @string
+
+(boolean) @boolean
+
+(integer) @number
+
+(float) @number.float
+
+(char) @character
+
+; Comments
+;------------
+[
+  (line_comment)
+  (block_comment)
+] @comment @spell
+
+; Punctuation
+;------------
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ","
+  ":"
+] @punctuation.delimiter
+
+"-" @operator
+
+; Special
+;------------
+(escape_sequence) @string.escape
diff --git a/pack/ant/start/nvim-treesitter/queries/ron/indents.scm b/pack/ant/start/nvim-treesitter/queries/ron/indents.scm
new file mode 100644
index 0000000..689d01f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ron/indents.scm
@@ -0,0 +1,21 @@
+[
+  (array)
+  (map)
+  (tuple)
+  (struct)
+] @indent.begin
+
+[
+  "{"
+  "}"
+] @indent.branch
+
+[
+  "("
+  ")"
+] @indent.branch
+
+[
+  "["
+  "]"
+] @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/ron/injections.scm b/pack/ant/start/nvim-treesitter/queries/ron/injections.scm
new file mode 100644
index 0000000..3cd6aac
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ron/injections.scm
@@ -0,0 +1,5 @@
+([
+  (line_comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/ron/locals.scm b/pack/ant/start/nvim-treesitter/queries/ron/locals.scm
new file mode 100644
index 0000000..81e38d5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ron/locals.scm
@@ -0,0 +1,25 @@
+(source_file) @local.scope
+
+(source_file
+  (array) @local.scope)
+
+(source_file
+  (map) @local.scope)
+
+(source_file
+  (struct) @local.scope)
+
+(source_file
+  (tuple) @local.scope)
+
+(identifier) @local.reference
+
+(struct_entry
+  (identifier) @local.definition.field)
+
+(struct_entry
+  (identifier) @local.definition.enum
+  (enum_variant))
+
+(struct
+  (struct_name) @local.definition.type)
diff --git a/pack/ant/start/nvim-treesitter/queries/rst/highlights.scm b/pack/ant/start/nvim-treesitter/queries/rst/highlights.scm
new file mode 100644
index 0000000..2d1b33e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rst/highlights.scm
@@ -0,0 +1,149 @@
+; Marks
+[
+  ".."
+  "|"
+  "--"
+  "__"
+  ":"
+  "::"
+  (transition)
+] @punctuation.special
+
+[
+  "bullet"
+  "adornment"
+] @markup.list
+
+; Resets for injection
+(doctest_block) @none
+
+; Directives
+(directive
+  name: (type) @function)
+
+(directive
+  body: (body
+    (arguments) @variable.parameter))
+
+((directive
+  name: (type) @keyword.import)
+  (#eq? @keyword.import "include"))
+
+(directive
+  name: (type) @function.builtin
+  (#any-of? @function.builtin
+    ; https://docutils.sourceforge.io/docs/ref/rst/directives.html
+    "attention" "caution" "danger" "error" "hint" "important" "note" "tip" "warning" "admonition"
+    "image" "figure" "topic" "sidebar" "line-block" "parsed-literal" "code" "math" "rubric"
+    "epigraph" "highlights" "pull-quote" "compound" "container" "table" "csv-table" "list-table"
+    "contents" "sectnum" "section-numbering" "header" "footer" "target-notes" "meta" "replace"
+    "unicode" "date" "raw" "class" "role" "default-role" "title" "restructuredtext-test-directive"))
+
+; Blocks
+[
+  (literal_block)
+  (line_block)
+] @markup.raw.block
+
+(block_quote
+  (attribution)? @markup.italic) @markup.quote
+
+(substitution_definition
+  name: (substitution) @constant)
+
+(footnote
+  name: (label) @constant)
+
+(citation
+  name: (label) @constant)
+
+(target
+  name: (name)? @markup.link.label
+  link: (_)? @markup.link)
+
+; Lists
+; Definition lists
+(list_item
+  (term) @markup.strong
+  (classifier)? @markup.italic)
+
+; Field lists
+(field
+  (field_name) @constant)
+
+; Inline markup
+(emphasis) @markup.italic
+
+(strong) @markup.strong
+
+(standalone_hyperlink) @string.special.url @nospell
+
+(role) @function
+
+((role) @function.builtin
+  (#any-of? @function.builtin
+    ; https://docutils.sourceforge.io/docs/ref/rst/roles.html
+    ":emphasis:" ":literal:" ":code:" ":math:" ":pep-reference:" ":PEP:" ":rfc-reference:" ":RFC:"
+    ":strong:" ":subscript:" ":sub:" ":superscript:" ":sup:" ":title-reference:" ":title:" ":t:"
+    ":raw:"))
+
+[
+  "interpreted_text"
+  (literal)
+] @markup.raw
+
+; Prefix role
+((interpreted_text
+  (role) @_role
+  "interpreted_text" @markup.italic)
+  (#eq? @_role ":emphasis:"))
+
+((interpreted_text
+  (role) @_role
+  "interpreted_text" @markup.strong)
+  (#eq? @_role ":strong:"))
+
+((interpreted_text
+  (role) @_role
+  "interpreted_text" @none)
+  (#eq? @_role ":math:"))
+
+; Suffix role
+((interpreted_text
+  "interpreted_text" @markup.italic
+  (role) @_role)
+  (#eq? @_role ":emphasis:"))
+
+((interpreted_text
+  "interpreted_text" @markup.strong
+  (role) @_role)
+  (#eq? @_role ":strong:"))
+
+((interpreted_text
+  "interpreted_text" @none
+  (role) @_role)
+  (#eq? @_role ":math:"))
+
+[
+  (inline_target)
+  (substitution_reference)
+  (footnote_reference)
+  (citation_reference)
+  (reference)
+] @markup.link @nospell
+
+; Others
+(title) @markup.heading
+
+(comment) @comment @spell
+
+(comment
+  "..") @comment
+
+(directive
+  name: (type) @_directive
+  body: (body
+    (content) @spell
+    (#not-any-of? @_directive "code" "code-block" "sourcecode")))
+
+(paragraph) @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/rst/injections.scm b/pack/ant/start/nvim-treesitter/queries/rst/injections.scm
new file mode 100644
index 0000000..7178de9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rst/injections.scm
@@ -0,0 +1,72 @@
+((doctest_block) @injection.content
+  (#set! injection.language "python"))
+
+; Directives with nested content without arguments nor options
+((directive
+  name: (type) @_type
+  body: (body) @injection.content)
+  (#set! injection.language "rst")
+  (#any-of? @_type
+    "attention" "caution" "danger" "error" "hint" "important" "note" "tip" "warning" "admonition"
+    "line-block" "parsed-literal" "epigraph" "highlights" "pull-quote" "compound" "header" "footer"
+    "meta" "replace"))
+
+; Directives with nested content without arguments, but with options
+((directive
+  name: (type) @_type
+  body: (body
+    (options)
+    (content) @injection.content))
+  (#set! injection.language "rst")
+  (#any-of? @_type
+    "attention" "caution" "danger" "error" "hint" "important" "note" "tip" "warning" "admonition"
+    "line-block" "parsed-literal" "compound"))
+
+; Directives with nested content with arguments and options
+((directive
+  name: (type) @_type
+  body: (body
+    (content) @injection.content))
+  (#set! injection.language "rst")
+  (#any-of? @_type
+    "figure" "topic" "sidebar" "container" "table" "list-table" "class" "role"
+    "restructuredtext-test-directive"))
+
+; Special directives
+((directive
+  name: (type) @_type
+  body: (body
+    (arguments) @injection.language
+    (content) @injection.content))
+  (#any-of? @_type "raw" "code" "code-block" "sourcecode"))
+
+((directive
+  name: (type) @_type
+  body: (body
+    (content) @injection.content))
+  (#set! injection.language "latex")
+  (#eq? @_type "math"))
+
+((directive
+  name: (type) @_type
+  body: (body
+    (content) @injection.content))
+  (#set! injection.language "csv")
+  (#eq? @_type "csv-table"))
+
+; Special roles - prefix
+((interpreted_text
+  (role) @_role
+  "interpreted_text" @injection.content)
+  (#eq? @_role ":math:")
+  (#set! injection.language "latex"))
+
+; Special roles - suffix
+((interpreted_text
+  "interpreted_text" @injection.content
+  (role) @_role)
+  (#eq? @_role ":math:")
+  (#set! injection.language "latex"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/rst/locals.scm b/pack/ant/start/nvim-treesitter/queries/rst/locals.scm
new file mode 100644
index 0000000..ce4235b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rst/locals.scm
@@ -0,0 +1,38 @@
+; Scopes
+(document) @local.scope
+
+(directive) @local.scope
+
+; Definitions
+(title) @local.definition
+
+(substitution_definition
+  name: (substitution) @local.definition)
+
+(footnote
+  name: (label) @local.definition)
+
+(citation
+  name: (label) @local.definition)
+
+(target
+  name: (name) @local.definition)
+
+; Inline targets
+(inline_target) @local.definition
+
+; The role directive can define a new role
+((directive
+  name: (type) @_type
+  body: (body
+    (arguments) @local.definition))
+  (#eq? @_type "role"))
+
+; References
+[
+  (substitution_reference)
+  (footnote_reference)
+  (citation_reference)
+  (reference)
+  (role)
+] @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/ruby/folds.scm b/pack/ant/start/nvim-treesitter/queries/ruby/folds.scm
new file mode 100644
index 0000000..3a497b3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ruby/folds.scm
@@ -0,0 +1,12 @@
+[
+  (method)
+  (singleton_method)
+  (class)
+  (module)
+  (if)
+  (else)
+  (case)
+  (do_block)
+  (singleton_class)
+  (lambda)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/ruby/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ruby/highlights.scm
new file mode 100644
index 0000000..8de0251
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ruby/highlights.scm
@@ -0,0 +1,309 @@
+; Variables
+[
+  (identifier)
+  (global_variable)
+] @variable
+
+; Keywords
+[
+  "alias"
+  "begin"
+  "do"
+  "end"
+  "ensure"
+  "module"
+  "rescue"
+  "then"
+] @keyword
+
+"class" @keyword.type
+
+[
+  "return"
+  "yield"
+] @keyword.return
+
+[
+  "and"
+  "or"
+  "in"
+  "not"
+] @keyword.operator
+
+[
+  "def"
+  "undef"
+] @keyword.function
+
+(method
+  "end" @keyword.function)
+
+[
+  "case"
+  "else"
+  "elsif"
+  "if"
+  "unless"
+  "when"
+  "then"
+] @keyword.conditional
+
+(if
+  "end" @keyword.conditional)
+
+[
+  "for"
+  "until"
+  "while"
+  "break"
+  "redo"
+  "retry"
+  "next"
+] @keyword.repeat
+
+(constant) @constant
+
+((identifier) @keyword.modifier
+  (#any-of? @keyword.modifier "private" "protected" "public"))
+
+[
+  "rescue"
+  "ensure"
+] @keyword.exception
+
+; Function calls
+"defined?" @function
+
+(call
+  receiver: (constant)? @type
+  method: [
+    (identifier)
+    (constant)
+  ] @function.call)
+
+(program
+  (call
+    (identifier) @keyword.import)
+  (#any-of? @keyword.import "require" "require_relative" "load"))
+
+; Function definitions
+(alias
+  (identifier) @function)
+
+(setter
+  (identifier) @function)
+
+(method
+  name: [
+    (identifier) @function
+    (constant) @type
+  ])
+
+(singleton_method
+  name: [
+    (identifier) @function
+    (constant) @type
+  ])
+
+(class
+  name: (constant) @type)
+
+(module
+  name: (constant) @type)
+
+(superclass
+  (constant) @type)
+
+; Identifiers
+[
+  (class_variable)
+  (instance_variable)
+] @variable.member
+
+((identifier) @constant.builtin
+  (#any-of? @constant.builtin
+    "__callee__" "__dir__" "__id__" "__method__" "__send__" "__ENCODING__" "__FILE__" "__LINE__"))
+
+((identifier) @function.builtin
+  (#any-of? @function.builtin "attr_reader" "attr_writer" "attr_accessor" "module_function"))
+
+((call
+  !receiver
+  method: (identifier) @function.builtin)
+  (#any-of? @function.builtin "include" "extend" "prepend" "refine" "using"))
+
+((identifier) @keyword.exception
+  (#any-of? @keyword.exception "raise" "fail" "catch" "throw"))
+
+((constant) @type
+  (#not-lua-match? @type "^[A-Z0-9_]+$"))
+
+[
+  (self)
+  (super)
+] @variable.builtin
+
+(method_parameters
+  (identifier) @variable.parameter)
+
+(lambda_parameters
+  (identifier) @variable.parameter)
+
+(block_parameters
+  (identifier) @variable.parameter)
+
+(splat_parameter
+  (identifier) @variable.parameter)
+
+(hash_splat_parameter
+  (identifier) @variable.parameter)
+
+(optional_parameter
+  (identifier) @variable.parameter)
+
+(destructured_parameter
+  (identifier) @variable.parameter)
+
+(block_parameter
+  (identifier) @variable.parameter)
+
+(keyword_parameter
+  (identifier) @variable.parameter)
+
+; TODO: Re-enable this once it is supported
+; ((identifier) @function
+;  (#is-not? local))
+; Literals
+[
+  (string_content)
+  (heredoc_content)
+  "\""
+  "`"
+] @string
+
+[
+  (heredoc_beginning)
+  (heredoc_end)
+] @label
+
+[
+  (bare_symbol)
+  (simple_symbol)
+  (delimited_symbol)
+  (hash_key_symbol)
+] @string.special.symbol
+
+(regex
+  (string_content) @string.regexp)
+
+(escape_sequence) @string.escape
+
+(integer) @number
+
+(float) @number.float
+
+[
+  (true)
+  (false)
+] @boolean
+
+(nil) @constant.builtin
+
+(comment) @comment @spell
+
+((program
+  .
+  (comment) @keyword.directive @nospell)
+  (#lua-match? @keyword.directive "^#!/"))
+
+(program
+  (comment)+ @comment.documentation
+  (class))
+
+(module
+  (comment)+ @comment.documentation
+  (body_statement
+    (class)))
+
+(class
+  (comment)+ @comment.documentation
+  (body_statement
+    (method)))
+
+(body_statement
+  (comment)+ @comment.documentation
+  (method))
+
+; Operators
+[
+  "!"
+  "="
+  "=="
+  "==="
+  "<=>"
+  "=>"
+  "->"
+  ">>"
+  "<<"
+  ">"
+  "<"
+  ">="
+  "<="
+  "**"
+  "*"
+  "/"
+  "%"
+  "+"
+  "-"
+  "&"
+  "|"
+  "^"
+  "&&"
+  "||"
+  "||="
+  "&&="
+  "!="
+  "%="
+  "+="
+  "-="
+  "*="
+  "/="
+  "=~"
+  "!~"
+  "?"
+  ":"
+  ".."
+  "..."
+] @operator
+
+[
+  ","
+  ";"
+  "."
+  "&."
+  "::"
+] @punctuation.delimiter
+
+(regex
+  "/" @punctuation.bracket)
+
+(pair
+  ":" @punctuation.delimiter)
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  "%w("
+  "%i("
+] @punctuation.bracket
+
+(block_parameters
+  "|" @punctuation.bracket)
+
+(interpolation
+  "#{" @punctuation.special
+  "}" @punctuation.special)
diff --git a/pack/ant/start/nvim-treesitter/queries/ruby/indents.scm b/pack/ant/start/nvim-treesitter/queries/ruby/indents.scm
new file mode 100644
index 0000000..b767329
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ruby/indents.scm
@@ -0,0 +1,43 @@
+[
+  (class)
+  (singleton_class)
+  (method)
+  (singleton_method)
+  (module)
+  (call)
+  (if)
+  (block)
+  (do_block)
+  (hash)
+  (array)
+  (argument_list)
+  (case)
+  (while)
+  (until)
+  (for)
+  (begin)
+  (unless)
+  (assignment)
+  (parenthesized_statements)
+] @indent.begin
+
+[
+  "end"
+  ")"
+  "}"
+  "]"
+] @indent.end
+
+[
+  "end"
+  ")"
+  "}"
+  "]"
+  (when)
+  (elsif)
+  (else)
+  (rescue)
+  (ensure)
+] @indent.branch
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/ruby/injections.scm b/pack/ant/start/nvim-treesitter/queries/ruby/injections.scm
new file mode 100644
index 0000000..7d8be5b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ruby/injections.scm
@@ -0,0 +1,11 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+(heredoc_body
+  (heredoc_content) @injection.content
+  (heredoc_end) @injection.language
+  (#downcase! @injection.language))
+
+(regex
+  (string_content) @injection.content
+  (#set! injection.language "regex"))
diff --git a/pack/ant/start/nvim-treesitter/queries/ruby/locals.scm b/pack/ant/start/nvim-treesitter/queries/ruby/locals.scm
new file mode 100644
index 0000000..29a67e2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ruby/locals.scm
@@ -0,0 +1,93 @@
+; The MIT License (MIT)
+;
+; Copyright (c) 2016 Rob Rix
+;
+; Permission is hereby granted, free of charge, to any person obtaining a copy
+; of this software and associated documentation files (the "Software"), to deal
+; in the Software without restriction, including without limitation the rights
+; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+; copies of the Software, and to permit persons to whom the Software is
+; furnished to do so, subject to the following conditions:
+; 
+; The above copyright notice and this permission notice shall be included in all
+; copies or substantial portions of the Software.
+; 
+; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+; SOFTWARE.
+; DECLARATIONS AND SCOPES
+(method) @local.scope
+
+(class) @local.scope
+
+[
+  (block)
+  (do_block)
+] @local.scope
+
+(identifier) @local.reference
+
+(constant) @local.reference
+
+(instance_variable) @local.reference
+
+(module
+  name: (constant) @local.definition.namespace)
+
+(class
+  name: (constant) @local.definition.type)
+
+(method
+  name: [
+    (identifier)
+    (constant)
+  ] @local.definition.function)
+
+(singleton_method
+  name: [
+    (identifier)
+    (constant)
+  ] @local.definition.function)
+
+(method_parameters
+  (identifier) @local.definition.var)
+
+(lambda_parameters
+  (identifier) @local.definition.var)
+
+(block_parameters
+  (identifier) @local.definition.var)
+
+(splat_parameter
+  (identifier) @local.definition.var)
+
+(hash_splat_parameter
+  (identifier) @local.definition.var)
+
+(optional_parameter
+  name: (identifier) @local.definition.var)
+
+(destructured_parameter
+  (identifier) @local.definition.var)
+
+(block_parameter
+  name: (identifier) @local.definition.var)
+
+(keyword_parameter
+  name: (identifier) @local.definition.var)
+
+(assignment
+  left: (_) @local.definition.var)
+
+(left_assignment_list
+  (identifier) @local.definition.var)
+
+(rest_assignment
+  (identifier) @local.definition.var)
+
+(destructured_left_assignment
+  (identifier) @local.definition.var)
diff --git a/pack/ant/start/nvim-treesitter/queries/rust/folds.scm b/pack/ant/start/nvim-treesitter/queries/rust/folds.scm
new file mode 100644
index 0000000..5429041
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rust/folds.scm
@@ -0,0 +1,25 @@
+[
+  (mod_item)
+  (foreign_mod_item)
+  (function_item)
+  (struct_item)
+  (trait_item)
+  (enum_item)
+  (impl_item)
+  (type_item)
+  (union_item)
+  (const_item)
+  (use_declaration)+
+  (let_declaration)
+  (loop_expression)
+  (for_expression)
+  (while_expression)
+  (if_expression)
+  (match_expression)
+  (call_expression)
+  (array_expression)
+  (macro_definition)
+  (macro_invocation)
+  (attribute_item)
+  (block)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/rust/highlights.scm b/pack/ant/start/nvim-treesitter/queries/rust/highlights.scm
new file mode 100644
index 0000000..c202206
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rust/highlights.scm
@@ -0,0 +1,477 @@
+; Forked from https://github.com/tree-sitter/tree-sitter-rust
+; Copyright (c) 2017 Maxim Sokolov
+; Licensed under the MIT license.
+; Identifier conventions
+(shebang) @keyword.directive
+
+(identifier) @variable
+
+((identifier) @type
+  (#lua-match? @type "^[A-Z]"))
+
+(const_item
+  name: (identifier) @constant)
+
+; Assume all-caps names are constants
+((identifier) @constant
+  (#lua-match? @constant "^[A-Z][A-Z%d_]*$"))
+
+; Other identifiers
+(type_identifier) @type
+
+(primitive_type) @type.builtin
+
+(field_identifier) @variable.member
+
+(shorthand_field_identifier) @variable.member
+
+(shorthand_field_initializer
+  (identifier) @variable.member)
+
+(mod_item
+  name: (identifier) @module)
+
+(self) @variable.builtin
+
+"_" @character.special
+
+(label
+  [
+    "'"
+    (identifier)
+  ] @label)
+
+; Function definitions
+(function_item
+  (identifier) @function)
+
+(function_signature_item
+  (identifier) @function)
+
+(parameter
+  [
+    (identifier)
+    "_"
+  ] @variable.parameter)
+
+(closure_parameters
+  (_) @variable.parameter)
+
+; Function calls
+(call_expression
+  function: (identifier) @function.call)
+
+(call_expression
+  function: (scoped_identifier
+    (identifier) @function.call .))
+
+(call_expression
+  function: (field_expression
+    field: (field_identifier) @function.call))
+
+(generic_function
+  function: (identifier) @function.call)
+
+(generic_function
+  function: (scoped_identifier
+    name: (identifier) @function.call))
+
+(generic_function
+  function: (field_expression
+    field: (field_identifier) @function.call))
+
+; Assume other uppercase names are enum constructors
+((field_identifier) @constant
+  (#lua-match? @constant "^[A-Z]"))
+
+(enum_variant
+  name: (identifier) @constant)
+
+; Assume that uppercase names in paths are types
+(scoped_identifier
+  path: (identifier) @module)
+
+(scoped_identifier
+  (scoped_identifier
+    name: (identifier) @module))
+
+(scoped_type_identifier
+  path: (identifier) @module)
+
+(scoped_type_identifier
+  path: (identifier) @type
+  (#lua-match? @type "^[A-Z]"))
+
+(scoped_type_identifier
+  (scoped_identifier
+    name: (identifier) @module))
+
+((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]"))
+
+[
+  (crate)
+  (super)
+] @module
+
+(scoped_use_list
+  path: (identifier) @module)
+
+(scoped_use_list
+  path: (scoped_identifier
+    (identifier) @module))
+
+(use_list
+  (scoped_identifier
+    (identifier) @module
+    .
+    (_)))
+
+(use_list
+  (identifier) @type
+  (#lua-match? @type "^[A-Z]"))
+
+(use_as_clause
+  alias: (identifier) @type
+  (#lua-match? @type "^[A-Z]"))
+
+; Correct enum constructors
+(call_expression
+  function: (scoped_identifier
+    "::"
+    name: (identifier) @constant)
+  (#lua-match? @constant "^[A-Z]"))
+
+; Assume uppercase names in a match arm are constants.
+((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"))
+
+; Macro definitions
+"$" @function.macro
+
+(metavariable) @function.macro
+
+(macro_definition
+  "macro_rules!" @function.macro)
+
+; Attribute macros
+(attribute_item
+  (attribute
+    (identifier) @function.macro))
+
+(inner_attribute_item
+  (attribute
+    (identifier) @function.macro))
+
+(attribute
+  (scoped_identifier
+    (identifier) @function.macro .))
+
+; Derive macros (assume all arguments are types)
+; (attribute
+;   (identifier) @_name
+;   arguments: (attribute (attribute (identifier) @type))
+;   (#eq? @_name "derive"))
+; Function-like macros
+(macro_invocation
+  macro: (identifier) @function.macro)
+
+(macro_invocation
+  macro: (scoped_identifier
+    (identifier) @function.macro .))
+
+; Literals
+(boolean_literal) @boolean
+
+(integer_literal) @number
+
+(float_literal) @number.float
+
+[
+  (raw_string_literal)
+  (string_literal)
+] @string
+
+(escape_sequence) @string.escape
+
+(char_literal) @character
+
+; Keywords
+[
+  "use"
+  "mod"
+] @keyword.import
+
+(use_as_clause
+  "as" @keyword.import)
+
+[
+  "default"
+  "impl"
+  "let"
+  "move"
+  "unsafe"
+  "where"
+] @keyword
+
+[
+  "enum"
+  "struct"
+  "union"
+  "trait"
+  "type"
+] @keyword.type
+
+[
+  "async"
+  "await"
+] @keyword.coroutine
+
+"try" @keyword.exception
+
+[
+  "ref"
+  "pub"
+  (mutable_specifier)
+  "const"
+  "static"
+  "dyn"
+  "extern"
+] @keyword.modifier
+
+(lifetime
+  "'" @keyword.modifier)
+
+(lifetime
+  (identifier) @attribute)
+
+(lifetime
+  (identifier) @attribute.builtin
+  (#any-of? @attribute.builtin "static" "_"))
+
+"fn" @keyword.function
+
+[
+  "return"
+  "yield"
+] @keyword.return
+
+(type_cast_expression
+  "as" @keyword.operator)
+
+(qualified_type
+  "as" @keyword.operator)
+
+(use_list
+  (self) @module)
+
+(scoped_use_list
+  (self) @module)
+
+(scoped_identifier
+  [
+    (crate)
+    (super)
+    (self)
+  ] @module)
+
+(visibility_modifier
+  [
+    (crate)
+    (super)
+    (self)
+  ] @module)
+
+[
+  "if"
+  "else"
+  "match"
+] @keyword.conditional
+
+[
+  "break"
+  "continue"
+  "in"
+  "loop"
+  "while"
+] @keyword.repeat
+
+"for" @keyword
+
+(for_expression
+  "for" @keyword.repeat)
+
+; Operators
+[
+  "!"
+  "!="
+  "%"
+  "%="
+  "&"
+  "&&"
+  "&="
+  "*"
+  "*="
+  "+"
+  "+="
+  "-"
+  "-="
+  ".."
+  "..="
+  "..."
+  "/"
+  "/="
+  "<"
+  "<<"
+  "<<="
+  "<="
+  "="
+  "=="
+  ">"
+  ">="
+  ">>"
+  ">>="
+  "?"
+  "@"
+  "^"
+  "^="
+  "|"
+  "|="
+  "||"
+] @operator
+
+(use_wildcard
+  "*" @character.special)
+
+(remaining_field_pattern
+  ".." @character.special)
+
+(range_pattern
+  [
+    ".."
+    "..="
+    "..."
+  ] @character.special)
+
+; Punctuation
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+(closure_parameters
+  "|" @punctuation.bracket)
+
+(type_arguments
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(type_parameters
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(bracketed_type
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(for_lifetimes
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+[
+  ","
+  "."
+  ":"
+  "::"
+  ";"
+  "->"
+  "=>"
+] @punctuation.delimiter
+
+(attribute_item
+  "#" @punctuation.special)
+
+(inner_attribute_item
+  [
+    "!"
+    "#"
+  ] @punctuation.special)
+
+(macro_invocation
+  "!" @function.macro)
+
+(never_type
+  "!" @type.builtin)
+
+(macro_invocation
+  macro: (identifier) @keyword.exception
+  "!" @keyword.exception
+  (#eq? @keyword.exception "panic"))
+
+(macro_invocation
+  macro: (identifier) @keyword.exception
+  "!" @keyword.exception
+  (#contains? @keyword.exception "assert"))
+
+(macro_invocation
+  macro: (identifier) @keyword.debug
+  "!" @keyword.debug
+  (#eq? @keyword.debug "dbg"))
+
+; Comments
+[
+  (line_comment)
+  (block_comment)
+  (outer_doc_comment_marker)
+  (inner_doc_comment_marker)
+] @comment @spell
+
+(line_comment
+  (doc_comment)) @comment.documentation
+
+(block_comment
+  (doc_comment)) @comment.documentation
diff --git a/pack/ant/start/nvim-treesitter/queries/rust/indents.scm b/pack/ant/start/nvim-treesitter/queries/rust/indents.scm
new file mode 100644
index 0000000..dfe0a38
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rust/indents.scm
@@ -0,0 +1,117 @@
+[
+  (mod_item)
+  (struct_item)
+  (enum_item)
+  (impl_item)
+  (struct_expression)
+  (struct_pattern)
+  (tuple_struct_pattern)
+  (tuple_expression)
+  (tuple_type)
+  (tuple_pattern)
+  (match_block)
+  (call_expression)
+  (assignment_expression)
+  (arguments)
+  (block)
+  (where_clause)
+  (use_list)
+  (array_expression)
+  (ordered_field_declaration_list)
+  (field_declaration_list)
+  (enum_variant_list)
+  (parameters)
+  (token_tree)
+  (token_repetition)
+  (macro_definition)
+] @indent.begin
+
+; Typing in "(" inside macro definitions breaks the tree entirely
+; Making macro_definition becoming errors
+; Offset this by adding back one indent for start of macro rules
+(ERROR
+  .
+  "macro_rules!"
+  [
+    "("
+    "{"
+    "["
+  ] @indent.begin
+  (#set! indent.immediate)
+  (#set! indent.start_at_same_line))
+
+(macro_definition
+  [
+    ")"
+    "}"
+    "]"
+  ] @indent.end)
+
+(trait_item
+  body: (_) @indent.begin)
+
+(string_literal
+  (escape_sequence)) @indent.begin
+
+(block
+  "}" @indent.end)
+
+(enum_item
+  body: (enum_variant_list
+    "}" @indent.end))
+
+(impl_item
+  body: (declaration_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))
+
+(struct_expression
+  body: (field_initializer_list
+    "}" @indent.end))
+
+(struct_pattern
+  "}" @indent.end)
+
+(tuple_struct_pattern
+  ")" @indent.end)
+
+(tuple_type
+  ")" @indent.end)
+
+(tuple_pattern
+  ")" @indent.end)
+
+(trait_item
+  body: (declaration_list
+    "}" @indent.end))
+
+(impl_item
+  (where_clause) @indent.dedent)
+
+[
+  "where"
+  ")"
+  "]"
+  "}"
+] @indent.branch
+
+(impl_item
+  (declaration_list) @indent.branch)
+
+[
+  (line_comment)
+  (string_literal)
+] @indent.ignore
+
+(raw_string_literal) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/rust/injections.scm b/pack/ant/start/nvim-treesitter/queries/rust/injections.scm
new file mode 100644
index 0000000..c8c3601
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rust/injections.scm
@@ -0,0 +1,91 @@
+(macro_invocation
+  macro: [
+    (scoped_identifier
+      name: (_) @_macro_name)
+    (identifier) @_macro_name
+  ]
+  (token_tree) @injection.content
+  (#not-eq? @_macro_name "slint")
+  (#set! injection.language "rust")
+  (#set! injection.include-children))
+
+(macro_invocation
+  macro: [
+    (scoped_identifier
+      name: (_) @_macro_name)
+    (identifier) @_macro_name
+  ]
+  (token_tree) @injection.content
+  (#eq? @_macro_name "slint")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.language "slint")
+  (#set! injection.include-children))
+
+(macro_definition
+  (macro_rule
+    left: (token_tree_pattern) @injection.content
+    (#set! injection.language "rust")))
+
+(macro_definition
+  (macro_rule
+    right: (token_tree) @injection.content
+    (#set! injection.language "rust")))
+
+([
+  (line_comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
+
+((macro_invocation
+  macro: (identifier) @injection.language
+  (token_tree) @injection.content)
+  (#any-of? @injection.language "html" "json"))
+
+(call_expression
+  function: (scoped_identifier
+    path: (identifier) @_regex
+    (#any-of? @_regex "Regex" "ByteRegexBuilder")
+    name: (identifier) @_new
+    (#eq? @_new "new"))
+  arguments: (arguments
+    (raw_string_literal) @injection.content)
+  (#set! injection.language "regex"))
+
+(call_expression
+  function: (scoped_identifier
+    path: (scoped_identifier
+      (identifier) @_regex
+      (#any-of? @_regex "Regex" "ByteRegexBuilder") .)
+    name: (identifier) @_new
+    (#eq? @_new "new"))
+  arguments: (arguments
+    (raw_string_literal) @injection.content)
+  (#set! injection.language "regex"))
+
+(call_expression
+  function: (scoped_identifier
+    path: (identifier) @_regex
+    (#any-of? @_regex "RegexSet" "RegexSetBuilder")
+    name: (identifier) @_new
+    (#eq? @_new "new"))
+  arguments: (arguments
+    (array_expression
+      (raw_string_literal) @injection.content))
+  (#set! injection.language "regex"))
+
+(call_expression
+  function: (scoped_identifier
+    path: (scoped_identifier
+      (identifier) @_regex
+      (#any-of? @_regex "RegexSet" "RegexSetBuilder") .)
+    name: (identifier) @_new
+    (#eq? @_new "new"))
+  arguments: (arguments
+    (array_expression
+      (raw_string_literal) @injection.content))
+  (#set! injection.language "regex"))
+
+((block_comment) @injection.content
+  (#match? @injection.content "/\\*!([a-zA-Z]+:)?re2c")
+  (#set! injection.language "re2c"))
diff --git a/pack/ant/start/nvim-treesitter/queries/rust/locals.scm b/pack/ant/start/nvim-treesitter/queries/rust/locals.scm
new file mode 100644
index 0000000..2b1469b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/rust/locals.scm
@@ -0,0 +1,101 @@
+; Imports
+(extern_crate_declaration
+  name: (identifier) @local.definition.import)
+
+(use_declaration
+  argument: (scoped_identifier
+    name: (identifier) @local.definition.import))
+
+(use_as_clause
+  alias: (identifier) @local.definition.import)
+
+(use_list
+  (identifier) @local.definition.import) ; use std::process::{Child, Command, Stdio};
+
+; Functions
+(function_item
+  name: (identifier) @local.definition.function)
+
+(function_item
+  name: (identifier) @local.definition.method
+  parameters: (parameters
+    (self_parameter)))
+
+; Variables
+(parameter
+  pattern: (identifier) @local.definition.var)
+
+(let_declaration
+  pattern: (identifier) @local.definition.var)
+
+(const_item
+  name: (identifier) @local.definition.var)
+
+(tuple_pattern
+  (identifier) @local.definition.var)
+
+(let_condition
+  pattern: (_
+    (identifier) @local.definition.var))
+
+(tuple_struct_pattern
+  (identifier) @local.definition.var)
+
+(closure_parameters
+  (identifier) @local.definition.var)
+
+(self_parameter
+  (self) @local.definition.var)
+
+(for_expression
+  pattern: (identifier) @local.definition.var)
+
+; Types
+(struct_item
+  name: (type_identifier) @local.definition.type)
+
+(constrained_type_parameter
+  left: (type_identifier) @local.definition.type) ; the P in  remove_file<P: AsRef<Path>>(path: P)
+
+(enum_item
+  name: (type_identifier) @local.definition.type)
+
+; Fields
+(field_declaration
+  name: (field_identifier) @local.definition.field)
+
+(enum_variant
+  name: (identifier) @local.definition.field)
+
+; References
+(identifier) @local.reference
+
+((type_identifier) @local.reference
+  (#set! reference.kind "type"))
+
+((field_identifier) @local.reference
+  (#set! reference.kind "field"))
+
+; Macros
+(macro_definition
+  name: (identifier) @local.definition.macro)
+
+; Module
+(mod_item
+  name: (identifier) @local.definition.namespace)
+
+; Scopes
+[
+  (block)
+  (function_item)
+  (closure_expression)
+  (while_expression)
+  (for_expression)
+  (loop_expression)
+  (if_expression)
+  (match_expression)
+  (match_arm)
+  (struct_item)
+  (enum_item)
+  (impl_item)
+] @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/scala/folds.scm b/pack/ant/start/nvim-treesitter/queries/scala/folds.scm
new file mode 100644
index 0000000..b0f0818
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/scala/folds.scm
@@ -0,0 +1,16 @@
+(call_expression
+  (block) @fold)
+
+[
+  (class_definition)
+  (trait_definition)
+  (object_definition)
+  (function_definition)
+  (val_definition)
+  (import_declaration)
+  (while_expression)
+  (do_while_expression)
+  (for_expression)
+  (try_expression)
+  (match_expression)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/scala/highlights.scm b/pack/ant/start/nvim-treesitter/queries/scala/highlights.scm
new file mode 100644
index 0000000..f85c502
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/scala/highlights.scm
@@ -0,0 +1,311 @@
+; CREDITS @stumash (stuart.mashaal@gmail.com)
+(class_definition
+  name: (identifier) @type)
+
+(enum_definition
+  name: (identifier) @type)
+
+(object_definition
+  name: (identifier) @type)
+
+(trait_definition
+  name: (identifier) @type)
+
+(full_enum_case
+  name: (identifier) @type)
+
+(simple_enum_case
+  name: (identifier) @type)
+
+; variables
+(class_parameter
+  name: (identifier) @variable.parameter)
+
+(self_type
+  (identifier) @variable.parameter)
+
+(interpolation
+  (identifier) @none)
+
+(interpolation
+  (block) @none)
+
+; types
+(type_definition
+  name: (type_identifier) @type.definition)
+
+(type_identifier) @type
+
+; val/var definitions/declarations
+(val_definition
+  pattern: (identifier) @variable)
+
+(var_definition
+  pattern: (identifier) @variable)
+
+(val_declaration
+  name: (identifier) @variable)
+
+(var_declaration
+  name: (identifier) @variable)
+
+; method definition
+(function_declaration
+  name: (identifier) @function.method)
+
+(function_definition
+  name: (identifier) @function.method)
+
+; imports/exports
+(import_declaration
+  path: (identifier) @module)
+
+(stable_identifier
+  (identifier) @module)
+
+((import_declaration
+  path: (identifier) @type)
+  (#lua-match? @type "^[A-Z]"))
+
+((stable_identifier
+  (identifier) @type)
+  (#lua-match? @type "^[A-Z]"))
+
+(export_declaration
+  path: (identifier) @module)
+
+(stable_identifier
+  (identifier) @module)
+
+((export_declaration
+  path: (identifier) @type)
+  (#lua-match? @type "^[A-Z]"))
+
+((stable_identifier
+  (identifier) @type)
+  (#lua-match? @type "^[A-Z]"))
+
+((namespace_selectors
+  (identifier) @type)
+  (#lua-match? @type "^[A-Z]"))
+
+; method invocation
+(call_expression
+  function: (identifier) @function.call)
+
+(call_expression
+  function: (operator_identifier) @function.call)
+
+(call_expression
+  function: (field_expression
+    field: (identifier) @function.method.call))
+
+((call_expression
+  function: (identifier) @constructor)
+  (#lua-match? @constructor "^[A-Z]"))
+
+(generic_function
+  function: (identifier) @function.call)
+
+(interpolated_string_expression
+  interpolator: (identifier) @function.call)
+
+; function definitions
+(function_definition
+  name: (identifier) @function)
+
+(parameter
+  name: (identifier) @variable.parameter)
+
+(binding
+  name: (identifier) @variable.parameter)
+
+(lambda_expression
+  parameters: (identifier) @variable.parameter)
+
+; expressions
+(field_expression
+  field: (identifier) @variable.member)
+
+(field_expression
+  value: (identifier) @type
+  (#lua-match? @type "^[A-Z]"))
+
+(infix_expression
+  operator: (identifier) @operator)
+
+(infix_expression
+  operator: (operator_identifier) @operator)
+
+(infix_type
+  operator: (operator_identifier) @operator)
+
+(infix_type
+  operator: (operator_identifier) @operator)
+
+; literals
+(boolean_literal) @boolean
+
+(integer_literal) @number
+
+(floating_point_literal) @number.float
+
+[
+  (string)
+  (interpolated_string_expression)
+] @string
+
+(character_literal) @character
+
+(interpolation
+  "$" @punctuation.special)
+
+; keywords
+(opaque_modifier) @keyword.modifier
+
+(infix_modifier) @keyword
+
+(transparent_modifier) @keyword.modifier
+
+(open_modifier) @keyword.modifier
+
+[
+  "case"
+  "extends"
+  "derives"
+  "finally"
+  ; `forSome` existential types not implemented yet
+  ; `macro` not implemented yet
+  "object"
+  "override"
+  "val"
+  "var"
+  "with"
+  "given"
+  "using"
+  "end"
+  "implicit"
+  "extension"
+  "with"
+] @keyword
+
+[
+  "enum"
+  "class"
+  "trait"
+  "type"
+] @keyword.type
+
+[
+  "abstract"
+  "final"
+  "lazy"
+  "sealed"
+  "private"
+  "protected"
+] @keyword.modifier
+
+(inline_modifier) @keyword.modifier
+
+(null_literal) @constant.builtin
+
+(wildcard
+  "_") @character.special
+
+(namespace_wildcard
+  [
+    "*"
+    "_"
+  ] @character.special)
+
+(annotation) @attribute
+
+; special keywords
+"new" @keyword.operator
+
+[
+  "else"
+  "if"
+  "match"
+  "then"
+] @keyword.conditional
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "."
+  ","
+  ":"
+] @punctuation.delimiter
+
+[
+  "do"
+  "for"
+  "while"
+  "yield"
+] @keyword.repeat
+
+"def" @keyword.function
+
+[
+  "=>"
+  "?=>"
+  "="
+  "!"
+  "<-"
+  "@"
+] @operator
+
+[
+  "import"
+  "export"
+  "package"
+] @keyword.import
+
+[
+  "try"
+  "catch"
+  "throw"
+] @keyword.exception
+
+"return" @keyword.return
+
+[
+  (comment)
+  (block_comment)
+] @comment @spell
+
+((block_comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$"))
+
+; `case` is a conditional keyword in case_block
+(case_block
+  (case_clause
+    "case" @keyword.conditional))
+
+(case_block
+  (case_clause
+    "=>" @punctuation.delimiter))
+
+(operator_identifier) @operator
+
+((identifier) @type
+  (#lua-match? @type "^[A-Z]"))
+
+((identifier) @variable.builtin
+  (#lua-match? @variable.builtin "^this$"))
+
+((identifier) @function.builtin
+  (#lua-match? @function.builtin "^super$"))
+
+; Scala CLI using directives
+(using_directive_key) @variable.parameter
+
+(using_directive_value) @string
diff --git a/pack/ant/start/nvim-treesitter/queries/scala/injections.scm b/pack/ant/start/nvim-treesitter/queries/scala/injections.scm
new file mode 100644
index 0000000..1c2fe3c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/scala/injections.scm
@@ -0,0 +1,5 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((block_comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/scala/locals.scm b/pack/ant/start/nvim-treesitter/queries/scala/locals.scm
new file mode 100644
index 0000000..7128a49
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/scala/locals.scm
@@ -0,0 +1,49 @@
+; Scopes
+[
+  (template_body)
+  (lambda_expression)
+  (function_definition)
+  (block)
+  (for_expression)
+] @local.scope
+
+; References
+(identifier) @local.reference
+
+; Definitions
+(function_declaration
+  name: (identifier) @local.definition.function)
+
+(function_definition
+  name: (identifier) @local.definition.function
+  (#set! definition.var.scope parent))
+
+(parameter
+  name: (identifier) @local.definition.parameter)
+
+(class_parameter
+  name: (identifier) @local.definition.parameter)
+
+(lambda_expression
+  parameters: (identifier) @local.definition.var)
+
+(binding
+  name: (identifier) @local.definition.var)
+
+(val_definition
+  pattern: (identifier) @local.definition.var)
+
+(var_definition
+  pattern: (identifier) @local.definition.var)
+
+(val_declaration
+  name: (identifier) @local.definition.var)
+
+(var_declaration
+  name: (identifier) @local.definition.var)
+
+(for_expression
+  enumerators: (enumerators
+    (enumerator
+      (tuple_pattern
+        (identifier) @local.definition.var))))
diff --git a/pack/ant/start/nvim-treesitter/queries/scfg/highlights.scm b/pack/ant/start/nvim-treesitter/queries/scfg/highlights.scm
new file mode 100644
index 0000000..058f3e3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/scfg/highlights.scm
@@ -0,0 +1,10 @@
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+(comment) @comment @spell
+
+(directive_name) @type
+
+(directive_params) @variable.parameter
diff --git a/pack/ant/start/nvim-treesitter/queries/scfg/injections.scm b/pack/ant/start/nvim-treesitter/queries/scfg/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/scfg/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/scheme/folds.scm b/pack/ant/start/nvim-treesitter/queries/scheme/folds.scm
new file mode 100644
index 0000000..115809a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/scheme/folds.scm
@@ -0,0 +1,2 @@
+(program
+  (list) @fold)
diff --git a/pack/ant/start/nvim-treesitter/queries/scheme/highlights.scm b/pack/ant/start/nvim-treesitter/queries/scheme/highlights.scm
new file mode 100644
index 0000000..3d41e49
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/scheme/highlights.scm
@@ -0,0 +1,161 @@
+; A highlight query can override the highlights queries before it.
+; So the order is important.
+; We should highlight general rules, then highlight special forms.
+(number) @number
+
+(character) @character
+
+(boolean) @boolean
+
+(string) @string
+
+[
+  (comment)
+  (block_comment)
+] @comment @spell
+
+; highlight for datum comment
+; copied from ../clojure/highlights.scm
+([
+  (comment)
+  (directive)
+] @comment
+  (#set! priority 105))
+
+(escape_sequence) @string.escape
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; variables
+(symbol) @variable
+
+((symbol) @variable.builtin
+  (#any-of? @variable.builtin "..." "."))
+
+; procedure
+(list
+  .
+  (symbol) @function)
+
+; special forms
+(list
+  "["
+  (symbol)+ @variable
+  "]")
+
+(list
+  .
+  (symbol) @_f
+  .
+  (list
+    (symbol) @variable)
+  (#any-of? @_f "lambda" "λ"))
+
+(list
+  .
+  (symbol) @_f
+  .
+  (list
+    (list
+      (symbol) @variable))
+  (#any-of? @_f
+    "let" "let*" "let-syntax" "let-values" "let*-values" "letrec" "letrec*" "letrec-syntax"))
+
+; operators
+((symbol) @operator
+  (#any-of? @operator "+" "-" "*" "/" "=" "<=" ">=" "<" ">"))
+
+; keyword
+((symbol) @keyword
+  (#any-of? @keyword
+    "define" "lambda" "λ" "begin" "do" "define-syntax" "and" "or" "if" "cond" "case" "when"
+    "unless" "else" "=>" "let" "let*" "let-syntax" "let-values" "let*-values" "letrec" "letrec*"
+    "letrec-syntax" "set!" "syntax-rules" "identifier-syntax" "quote" "unquote" "quote-splicing"
+    "quasiquote" "unquote-splicing" "delay" "assert" "library" "export" "import" "rename" "only"
+    "except" "prefix"))
+
+((symbol) @keyword.conditional
+  (#any-of? @keyword.conditional "if" "cond" "case" "when" "unless"))
+
+; quote
+(quote
+  "'"
+  (symbol)) @string.special.symbol
+
+(list
+  .
+  (symbol) @_f
+  (#eq? @_f "quote")) @string.special.symbol
+
+; library
+(list
+  .
+  (symbol) @_lib
+  .
+  (symbol) @module
+  (#eq? @_lib "library"))
+
+; builtin procedures
+; procedures in R5RS and R6RS but not in R6RS-lib
+((symbol) @function.builtin
+  (#any-of? @function.builtin
+    ; eq
+    "eqv?" "eq?" "equal?"
+    ; number
+    "number?" "complex?" "real?" "rational?" "integer?" "exact?" "inexact?" "zero?" "positive?"
+    "negative?" "odd?" "even?" "finite?" "infinite?" "nan?" "max" "min" "abs" "quotient" "remainder"
+    "modulo" "div" "div0" "mod" "mod0" "div-and-mod" "div0-and-mod0" "gcd" "lcm" "numerator"
+    "denominator" "floor" "ceiling" "truncate" "round" "rationalize" "exp" "log" "sin" "cos" "tan"
+    "asin" "acos" "atan" "sqrt" "expt" "exact-integer-sqrt" "make-rectangular" "make-polar"
+    "real-part" "imag-part" "magnitude" "angle" "real-valued" "rational-valued?" "integer-valued?"
+    "exact" "inexact" "exact->inexact" "inexact->exact" "number->string" "string->number"
+    ; boolean
+    "boolean?" "not" "boolean=?"
+    ; pair
+    "pair?" "cons" "car" "cdr" "caar" "cadr" "cdar" "cddr" "caaar" "caadr" "cadar" "caddr" "cdaar"
+    "cdadr" "cddar" "cdddr" "caaaar" "caaadr" "caadar" "caaddr" "cadaar" "cadadr" "caddar" "cadddr"
+    "cdaaar" "cdaadr" "cdadar" "cdaddr" "cddaar" "cddadr" "cdddar" "cddddr" "set-car!" "set-cdr!"
+    ; list
+    "null?" "list?" "list" "length" "append" "reverse" "list-tail" "list-ref" "map" "for-each"
+    "memq" "memv" "member" "assq" "assv" "assoc"
+    ; symbol
+    "symbol?" "symbol->string" "string->symbol" "symbol=?"
+    ; char
+    "char?" "char=?" "char<?" "char>?" "char<=?" "char>=?" "char-ci=?" "char-ci<?" "char-ci>?"
+    "char-ci<=?" "char-ci>=?" "char-alphabetic?" "char-numeric?" "char-whitespace?"
+    "char-upper-case?" "char-lower-case?" "char->integer" "integer->char" "char-upcase"
+    "char-downcase"
+    ; string
+    "string?" "make-string" "string" "string-length" "string-ref" "string-set!" "string=?"
+    "string-ci=?" "string<?" "string>?" "string<=?" "string>=?" "string-ci<?" "string-ci>?"
+    "string-ci<=?" "string-ci>=?" "substring" "string-append" "string->list" "list->string"
+    "string-for-each" "string-copy" "string-fill!" "string-upcase" "string-downcase"
+    ; vector
+    "vector?" "make-vector" "vector" "vector-length" "vector-ref" "vector-set!" "vector->list"
+    "list->vector" "vector-fill!" "vector-map" "vector-for-each"
+    ; bytevector
+    "bytevector?" "native-endianness" "make-bytevector" "bytevector-length" "bytevector=?"
+    "bytevector-fill!" "bytevector-copy!" "bytevector-copy"
+    ; error
+    "error" "assertion-violation"
+    ; control
+    "procedure?" "apply" "force" "call-with-current-continuation" "call/cc" "values"
+    "call-with-values" "dynamic-wind" "eval" "scheme-report-environment" "null-environment"
+    "interaction-environment"
+    ; IO
+    "call-with-input-file" "call-with-output-file" "input-port?" "output-port?" "current-input-port"
+    "current-output-port" "with-input-from-file" "with-output-to-file" "open-input-file"
+    "open-output-file" "close-input-port" "close-output-port"
+    ; input
+    "read" "read-char" "peek-char" "eof-object?" "char-ready?"
+    ; output
+    "write" "display" "newline" "write-char"
+    ; system
+    "load" "transcript-on" "transcript-off"))
diff --git a/pack/ant/start/nvim-treesitter/queries/scheme/injections.scm b/pack/ant/start/nvim-treesitter/queries/scheme/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/scheme/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/scss/folds.scm b/pack/ant/start/nvim-treesitter/queries/scss/folds.scm
new file mode 100644
index 0000000..cbe4187
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/scss/folds.scm
@@ -0,0 +1 @@
+; inherits: css
diff --git a/pack/ant/start/nvim-treesitter/queries/scss/highlights.scm b/pack/ant/start/nvim-treesitter/queries/scss/highlights.scm
new file mode 100644
index 0000000..726256f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/scss/highlights.scm
@@ -0,0 +1,87 @@
+; inherits: css
+
+[
+  "@at-root"
+  "@debug"
+  "@error"
+  "@extend"
+  "@forward"
+  "@mixin"
+  "@use"
+  "@warn"
+] @keyword
+
+"@function" @keyword.function
+
+"@return" @keyword.return
+
+"@include" @keyword.import
+
+[
+  "@while"
+  "@each"
+  "@for"
+  "from"
+  "through"
+  "in"
+] @keyword.repeat
+
+(single_line_comment) @comment @spell
+
+(function_name) @function
+
+[
+  ">="
+  "<="
+] @operator
+
+(mixin_statement
+  (name) @function)
+
+(mixin_statement
+  (parameters
+    (parameter) @variable.parameter))
+
+(function_statement
+  (name) @function)
+
+(function_statement
+  (parameters
+    (parameter) @variable.parameter))
+
+(plain_value) @string
+
+(keyword_query) @function
+
+(identifier) @variable
+
+(variable_name) @variable
+
+(each_statement
+  (key) @variable.parameter)
+
+(each_statement
+  (value) @variable.parameter)
+
+(each_statement
+  (variable_value) @variable.parameter)
+
+(for_statement
+  (variable) @variable.parameter)
+
+(for_statement
+  (_
+    (variable_value) @variable.parameter))
+
+(argument) @variable.parameter
+
+(arguments
+  (variable_value) @variable.parameter)
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+(include_statement
+  (identifier) @function)
diff --git a/pack/ant/start/nvim-treesitter/queries/scss/indents.scm b/pack/ant/start/nvim-treesitter/queries/scss/indents.scm
new file mode 100644
index 0000000..3d54a04
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/scss/indents.scm
@@ -0,0 +1,7 @@
+; inherits: css
+
+[
+  (mixin_statement)
+  (while_statement)
+  (each_statement)
+] @indent.begin
diff --git a/pack/ant/start/nvim-treesitter/queries/scss/injections.scm b/pack/ant/start/nvim-treesitter/queries/scss/injections.scm
new file mode 100644
index 0000000..c3a252a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/scss/injections.scm
@@ -0,0 +1,2 @@
+((single_line_comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/sflog/highlights.scm b/pack/ant/start/nvim-treesitter/queries/sflog/highlights.scm
new file mode 100644
index 0000000..8eeee5d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sflog/highlights.scm
@@ -0,0 +1,48 @@
+; highlights.scm
+[
+  "|"
+  "|["
+  "]"
+  "("
+  ")"
+  "|("
+  ")|"
+] @punctuation.bracket
+
+[
+  ","
+  ";"
+  ":"
+] @punctuation.delimiter
+
+"EXTERNAL" @keyword
+
+"out of" @property
+
+(number) @number
+
+(identifier) @variable
+
+(version) @string.special
+
+(anonymous_block) @string
+
+(limit) @property
+
+(time) @function
+
+(limit
+  (identifier) @string)
+
+(event_detail
+  (event_detail_value) @string)
+
+(log_level_setting
+  (component) @type)
+
+(log_level_setting
+  (log_level) @constant)
+
+(log_entry
+  (event_identifier
+    (identifier) @type))
diff --git a/pack/ant/start/nvim-treesitter/queries/slang/folds.scm b/pack/ant/start/nvim-treesitter/queries/slang/folds.scm
new file mode 100644
index 0000000..e0ae685
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/slang/folds.scm
@@ -0,0 +1,9 @@
+; inherits: hlsl
+
+[
+  (interface_specifier)
+  (extension_specifier)
+  (property_declaration)
+  (subscript_declaration)
+  (init_declaration)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/slang/highlights.scm b/pack/ant/start/nvim-treesitter/queries/slang/highlights.scm
new file mode 100644
index 0000000..166964c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/slang/highlights.scm
@@ -0,0 +1,350 @@
+; inherits: c
+
+; cpp
+((identifier) @variable.member
+  (#lua-match? @variable.member "^m_.*$"))
+
+(parameter_declaration
+  declarator: (reference_declarator) @variable.parameter)
+
+; function(Foo ...foo)
+(variadic_parameter_declaration
+  declarator: (variadic_declarator
+    (_) @variable.parameter))
+
+; int foo = 0
+(optional_parameter_declaration
+  declarator: (_) @variable.parameter)
+
+;(field_expression) @variable.parameter ;; How to highlight this?
+((field_expression
+  (field_identifier) @function.method) @_parent
+  (#has-parent? @_parent template_method function_declarator))
+
+(field_declaration
+  (field_identifier) @variable.member)
+
+(field_initializer
+  (field_identifier) @property)
+
+(function_declarator
+  declarator: (field_identifier) @function.method)
+
+(concept_definition
+  name: (identifier) @type.definition)
+
+(alias_declaration
+  name: (type_identifier) @type.definition)
+
+(namespace_identifier) @module
+
+((namespace_identifier) @type
+  (#lua-match? @type "^[%u]"))
+
+(case_statement
+  value: (qualified_identifier
+    (identifier) @constant))
+
+(using_declaration
+  .
+  "using"
+  .
+  "namespace"
+  .
+  [
+    (qualified_identifier)
+    (identifier)
+  ] @module)
+
+(destructor_name
+  (identifier) @function.method)
+
+; functions
+(function_declarator
+  (qualified_identifier
+    (identifier) @function))
+
+(function_declarator
+  (qualified_identifier
+    (qualified_identifier
+      (identifier) @function)))
+
+(function_declarator
+  (qualified_identifier
+    (qualified_identifier
+      (qualified_identifier
+        (identifier) @function))))
+
+((qualified_identifier
+  (qualified_identifier
+    (qualified_identifier
+      (qualified_identifier
+        (identifier) @function)))) @_parent
+  (#has-ancestor? @_parent function_declarator))
+
+(function_declarator
+  (template_function
+    (identifier) @function))
+
+(operator_name) @function
+
+"operator" @function
+
+"static_assert" @function.builtin
+
+(call_expression
+  (qualified_identifier
+    (identifier) @function.call))
+
+(call_expression
+  (qualified_identifier
+    (qualified_identifier
+      (identifier) @function.call)))
+
+(call_expression
+  (qualified_identifier
+    (qualified_identifier
+      (qualified_identifier
+        (identifier) @function.call))))
+
+((qualified_identifier
+  (qualified_identifier
+    (qualified_identifier
+      (qualified_identifier
+        (identifier) @function.call)))) @_parent
+  (#has-ancestor? @_parent call_expression))
+
+(call_expression
+  (template_function
+    (identifier) @function.call))
+
+(call_expression
+  (qualified_identifier
+    (template_function
+      (identifier) @function.call)))
+
+(call_expression
+  (qualified_identifier
+    (qualified_identifier
+      (template_function
+        (identifier) @function.call))))
+
+(call_expression
+  (qualified_identifier
+    (qualified_identifier
+      (qualified_identifier
+        (template_function
+          (identifier) @function.call)))))
+
+((qualified_identifier
+  (qualified_identifier
+    (qualified_identifier
+      (qualified_identifier
+        (template_function
+          (identifier) @function.call))))) @_parent
+  (#has-ancestor? @_parent call_expression))
+
+; methods
+(function_declarator
+  (template_method
+    (field_identifier) @function.method))
+
+(call_expression
+  (field_expression
+    (field_identifier) @function.method.call))
+
+; constructors
+((function_declarator
+  (qualified_identifier
+    (identifier) @constructor))
+  (#lua-match? @constructor "^%u"))
+
+((call_expression
+  function: (identifier) @constructor)
+  (#lua-match? @constructor "^%u"))
+
+((call_expression
+  function: (qualified_identifier
+    name: (identifier) @constructor))
+  (#lua-match? @constructor "^%u"))
+
+((call_expression
+  function: (field_expression
+    field: (field_identifier) @constructor))
+  (#lua-match? @constructor "^%u"))
+
+; constructing a type in an initializer list: Constructor ():  **SuperType (1)**
+((field_initializer
+  (field_identifier) @constructor
+  (argument_list))
+  (#lua-match? @constructor "^%u"))
+
+; Constants
+(this) @variable.builtin
+
+(null
+  "nullptr" @constant.builtin)
+
+(true) @boolean
+
+(false) @boolean
+
+; Literals
+(raw_string_literal) @string
+
+; Keywords
+[
+  "try"
+  "catch"
+  "noexcept"
+  "throw"
+] @keyword.exception
+
+[
+  "decltype"
+  "explicit"
+  "friend"
+  "override"
+  "using"
+  "requires"
+  "constexpr"
+] @keyword
+
+[
+  "class"
+  "namespace"
+  "template"
+  "typename"
+  "concept"
+] @keyword.type
+
+[
+  "co_await"
+  "co_yield"
+  "co_return"
+] @keyword.coroutine
+
+[
+  "public"
+  "private"
+  "protected"
+  "final"
+  "virtual"
+] @keyword.modifier
+
+[
+  "new"
+  "delete"
+  "xor"
+  "bitand"
+  "bitor"
+  "compl"
+  "not"
+  "xor_eq"
+  "and_eq"
+  "or_eq"
+  "not_eq"
+  "and"
+  "or"
+] @keyword.operator
+
+"<=>" @operator
+
+"::" @punctuation.delimiter
+
+(template_argument_list
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(template_parameter_list
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(literal_suffix) @operator
+
+; hlsl
+[
+  "in"
+  "out"
+  "inout"
+  "uniform"
+  "shared"
+  "groupshared"
+  "discard"
+  "cbuffer"
+  "row_major"
+  "column_major"
+  "globallycoherent"
+  "centroid"
+  "noperspective"
+  "nointerpolation"
+  "sample"
+  "linear"
+  "snorm"
+  "unorm"
+  "point"
+  "line"
+  "triangleadj"
+  "lineadj"
+  "triangle"
+] @keyword.modifier
+
+((identifier) @variable.builtin
+  (#lua-match? @variable.builtin "^SV_"))
+
+(hlsl_attribute) @attribute
+
+(hlsl_attribute
+  [
+    "["
+    "]"
+  ] @attribute)
+
+[
+  "var"
+  "let"
+  "This"
+] @type.builtin
+
+[
+  "interface"
+  "extension"
+  "property"
+  "associatedtype"
+  "where"
+] @keyword
+
+"__init" @constructor
+
+[
+  "__subscript"
+  "get"
+  "set"
+] @function.builtin
+
+(interface_requirements
+  (identifier) @type)
+
+(binary_expression
+  [
+    "is"
+    "as"
+  ]
+  right: (identifier) @type)
+
+[
+  "as"
+  "is"
+] @keyword.operator
+
+[
+  "__exported"
+  "import"
+] @keyword.import
+
+(property_declaration
+  (identifier) @property)
diff --git a/pack/ant/start/nvim-treesitter/queries/slang/indents.scm b/pack/ant/start/nvim-treesitter/queries/slang/indents.scm
new file mode 100644
index 0000000..6175ac5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/slang/indents.scm
@@ -0,0 +1,6 @@
+; inherits: hlsl
+
+[
+  (interface_specifier)
+  (extension_specifier)
+] @indent.begin
diff --git a/pack/ant/start/nvim-treesitter/queries/slang/injections.scm b/pack/ant/start/nvim-treesitter/queries/slang/injections.scm
new file mode 100644
index 0000000..2fd39cb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/slang/injections.scm
@@ -0,0 +1,5 @@
+((preproc_arg) @injection.content
+  (#set! injection.language "slang"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/slang/locals.scm b/pack/ant/start/nvim-treesitter/queries/slang/locals.scm
new file mode 100644
index 0000000..647bd1f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/slang/locals.scm
@@ -0,0 +1 @@
+; inherits: hlsl
diff --git a/pack/ant/start/nvim-treesitter/queries/slint/folds.scm b/pack/ant/start/nvim-treesitter/queries/slint/folds.scm
new file mode 100644
index 0000000..4c5b130
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/slint/folds.scm
@@ -0,0 +1,11 @@
+[
+  (anon_struct_block)
+  (block)
+  (callback_event)
+  (component)
+  (enum_block)
+  (function_definition)
+  (global_definition)
+  (imperative_block)
+  (struct_block)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/slint/highlights.scm b/pack/ant/start/nvim-treesitter/queries/slint/highlights.scm
new file mode 100644
index 0000000..1b56b1c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/slint/highlights.scm
@@ -0,0 +1,263 @@
+(comment) @comment @spell
+
+; Different types:
+(string_value) @string @spell
+
+(escape_sequence) @string.escape
+
+(color_value) @constant
+
+[
+  (children_identifier)
+  (easing_kind_identifier)
+] @constant.builtin
+
+(bool_value) @boolean
+
+[
+  (int_value)
+  (physical_length_value)
+] @number
+
+[
+  (angle_value)
+  (duration_value)
+  (float_value)
+  (length_value)
+  (percent_value)
+  (relative_font_size_value)
+] @number.float
+
+(purity) @keyword.modifier
+
+(function_visibility) @keyword.modifier
+
+(property_visibility) @keyword.modifier
+
+(builtin_type_identifier) @type.builtin
+
+(reference_identifier) @variable.builtin
+
+(type
+  [
+    (type_list)
+    (user_type_identifier)
+    (anon_struct_block)
+  ]) @type
+
+(user_type_identifier) @type
+
+(enum_block
+  (user_type_identifier) @constant)
+
+; Functions and callbacks
+(argument) @variable.parameter
+
+(function_call
+  name: (_) @function.call)
+
+; definitions
+(callback
+  name: (_) @function)
+
+(callback_alias
+  name: (_) @function)
+
+(callback_event
+  name: (simple_identifier) @function.call)
+
+(component
+  id: (_) @variable)
+
+(enum_definition
+  name: (_) @type)
+
+(function_definition
+  name: (_) @function)
+
+(struct_definition
+  name: (_) @type)
+
+(typed_identifier
+  type: (_) @type)
+
+; Operators
+(binary_expression
+  op: (_) @operator)
+
+(unary_expression
+  op: (_) @operator)
+
+[
+  (comparison_operator)
+  (mult_prec_operator)
+  (add_prec_operator)
+  (unary_prec_operator)
+  (assignment_prec_operator)
+] @operator
+
+[
+  ":="
+  "=>"
+  "->"
+  "<=>"
+] @operator
+
+; Punctuation
+[
+  ";"
+  "."
+  ","
+  ":"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+(property
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+; Properties, Variables and Constants:
+(component
+  id: (simple_identifier) @constant)
+
+(property
+  name: (simple_identifier) @property)
+
+(binding_alias
+  name: (simple_identifier) @property)
+
+(binding
+  name: (simple_identifier) @property)
+
+(struct_block
+  (simple_identifier) @variable.member)
+
+(anon_struct_block
+  (simple_identifier) @variable.member)
+
+(property_assignment
+  property: (simple_identifier) @property)
+
+(states_definition
+  name: (simple_identifier) @variable)
+
+(callback
+  name: (simple_identifier) @variable)
+
+(typed_identifier
+  name: (_) @variable)
+
+(simple_indexed_identifier
+  name: (simple_identifier) @variable
+  index_var: (simple_identifier) @variable)
+
+(expression
+  (simple_identifier) @variable)
+
+(member_access
+  member: (expression
+    (simple_identifier) @property))
+
+(states_definition
+  name: (simple_identifier) @constant)
+
+; Attributes:
+[
+  (linear_gradient_identifier)
+  (radial_gradient_identifier)
+  (radial_gradient_kind)
+] @attribute
+
+(image_call
+  "@image-url" @attribute)
+
+(tr
+  "@tr" @attribute)
+
+; Keywords:
+(animate_option_identifier) @keyword
+
+(export) @keyword.import
+
+(if_statement
+  "if" @keyword.conditional)
+
+(if_expr
+  [
+    "if"
+    "else"
+  ] @keyword.conditional)
+
+(ternary_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+(animate_statement
+  "animate" @keyword)
+
+(callback
+  "callback" @keyword)
+
+(component_definition
+  [
+    "component"
+    "inherits"
+  ] @keyword)
+
+(enum_definition
+  "enum" @keyword.type)
+
+(for_loop
+  [
+    "for"
+    "in"
+  ] @keyword.repeat)
+
+(function_definition
+  "function" @keyword.function)
+
+(global_definition
+  "global" @keyword)
+
+(imperative_block
+  "return" @keyword.return)
+
+(import_statement
+  [
+    "import"
+    "from"
+  ] @keyword.import)
+
+(import_type
+  "as" @keyword.import)
+
+(property
+  "property" @keyword)
+
+(states_definition
+  [
+    "states"
+    "when"
+  ] @keyword)
+
+(struct_definition
+  "struct" @keyword.type)
+
+(transitions_definition
+  [
+    "transitions"
+    "in"
+    "out"
+  ] @keyword)
diff --git a/pack/ant/start/nvim-treesitter/queries/slint/indents.scm b/pack/ant/start/nvim-treesitter/queries/slint/indents.scm
new file mode 100644
index 0000000..d6bdeac
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/slint/indents.scm
@@ -0,0 +1,26 @@
+[
+  (arguments)
+  (block)
+  (enum_block)
+  (global_block)
+  (imperative_block)
+  (struct_block)
+  (typed_identifier)
+] @indent.begin
+
+([
+  (block)
+  (enum_block)
+  (global_block)
+  (imperative_block)
+  (struct_block)
+]
+  "}" @indent.end)
+
+([
+  (arguments)
+  (typed_identifier)
+]
+  ")" @indent.end)
+
+(string_value) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/slint/injections.scm b/pack/ant/start/nvim-treesitter/queries/slint/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/slint/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/slint/locals.scm b/pack/ant/start/nvim-treesitter/queries/slint/locals.scm
new file mode 100644
index 0000000..7e895a6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/slint/locals.scm
@@ -0,0 +1,117 @@
+[
+  (anon_struct_block)
+  (block)
+  (callback_event)
+  (component)
+  (enum_block)
+  (function_definition)
+  (global_definition)
+  (imperative_block)
+  (struct_block)
+] @local.scope
+
+(anon_struct_block
+  (_) @local.definition.field)
+
+(argument) @local.definition.var
+
+(callback
+  name: (_) @local.definition.field)
+
+(component_definition
+  name: (_) @local.definition.type)
+
+(enum_definition
+  name: (_) @local.definition.type)
+
+(enum_block
+  (_) @local.definition.field)
+
+(function_definition
+  name: (_) @local.definition.function)
+
+(global_definition
+  name: (_) @local.definition.type)
+
+(import_type
+  import_name: (_)
+  !local_name) @local.definition.import
+
+(import_type
+  import_name: (_)
+  local_name: (_) @local.definition.import)
+
+(property
+  name: (_) @local.definition.field)
+
+(struct_block
+  (_) @local.definition.field)
+
+(struct_definition
+  name: (_) @local.definition.type)
+
+(typed_identifier
+  name: (_) @local.definition.var)
+
+(argument
+  (_) @local.reference)
+
+(binary_expression
+  left: (_) @local.reference)
+
+(binary_expression
+  right: (_) @local.reference)
+
+(callback_event
+  name: (_) @local.reference)
+
+(component
+  type: (_) @local.reference
+  (#set! reference.kind "type"))
+
+(component_definition
+  base_type: (_) @local.reference
+  (#set! reference.kind "type"))
+
+(function_call
+  name: (_) @local.reference)
+
+(index_op
+  index: (_) @local.reference)
+
+(index_op
+  left: (_) @local.reference)
+
+(member_access
+  base: (_) @local.reference)
+
+(member_access
+  member: (_) @local.reference)
+
+(parens_op
+  left: (_) @local.reference)
+
+(property
+  type: (_) @local.reference
+  (#set! reference.kind "type"))
+
+(property_assignment
+  property: (_) @local.reference
+  (#set! reference.kind "field"))
+
+(property_assignment
+  value: (_) @local.reference)
+
+(struct_block
+  (_) @local.reference
+  (#set! reference.kind "type"))
+
+(tr
+  percent: (_) @local.reference)
+
+(typed_identifier
+  type: (_) @local.reference
+  (#set! reference.kind "type"))
+
+(unary_expression
+  left: (_) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/smali/folds.scm b/pack/ant/start/nvim-treesitter/queries/smali/folds.scm
new file mode 100644
index 0000000..c2062e5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/smali/folds.scm
@@ -0,0 +1,12 @@
+[
+  (annotation_directive)
+  (array_data_directive)
+  (field_definition)
+  (method_definition)
+  (packed_switch_directive)
+  (param_directive)
+  (parameter_directive)
+  (sparse_switch_directive)
+  (subannotation_directive)
+  (list)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/smali/highlights.scm b/pack/ant/start/nvim-treesitter/queries/smali/highlights.scm
new file mode 100644
index 0000000..161b732
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/smali/highlights.scm
@@ -0,0 +1,226 @@
+; Types
+(class_identifier
+  (identifier) @type)
+
+(primitive_type) @type.builtin
+
+((class_identifier
+  .
+  (identifier) @_first @type.builtin
+  (identifier) @type.builtin)
+  (#any-of? @_first "android" "dalvik" "java" "kotlinx"))
+
+((class_identifier
+  .
+  (identifier) @_first @type.builtin
+  .
+  (identifier) @_second @type.builtin
+  (identifier) @type.builtin)
+  (#eq? @_first "com")
+  (#any-of? @_second "android" "google"))
+
+; Methods
+(method_definition
+  (method_signature
+    (method_identifier) @function.method))
+
+(expression
+  (opcode) @_invoke
+  (body
+    (full_method_signature
+      (method_signature
+        (method_identifier) @function.method.call)))
+  (#lua-match? @_invoke "^invoke"))
+
+(method_handle
+  (full_method_signature
+    (method_signature
+      (method_identifier) @function.method.call)))
+
+(custom_invoke
+  .
+  (identifier) @function.method.call
+  (method_signature
+    (method_identifier) @function.method.call))
+
+(annotation_value
+  (body
+    (method_signature
+      (method_identifier) @function.method.call)))
+
+(annotation_value
+  (body
+    (full_method_signature
+      (method_signature
+        (method_identifier) @function.method.call))))
+
+(field_definition
+  (body
+    (method_signature
+      (method_identifier) @function.method.call)))
+
+(field_definition
+  (body
+    (full_method_signature
+      (method_signature
+        (method_identifier) @function.method.call))))
+
+((method_identifier) @constructor
+  (#any-of? @constructor "<init>" "<clinit>"))
+
+"constructor" @constructor
+
+; Fields
+(field_identifier) @variable.member
+
+(annotation_key) @variable.member
+
+((field_identifier) @constant
+  (#lua-match? @constant "^[%u_]*$"))
+
+; Variables
+(variable) @variable.builtin
+
+(local_directive
+  (identifier) @variable)
+
+; Parameters
+(parameter) @variable.parameter.builtin
+
+(param_identifier) @variable.parameter
+
+; Labels
+[
+  (label)
+  (jmp_label)
+] @label
+
+; Operators
+(opcode) @keyword.operator
+
+((opcode) @keyword.return
+  (#lua-match? @keyword.return "^return"))
+
+((opcode) @keyword.conditional
+  (#lua-match? @keyword.conditional "^if"))
+
+((opcode) @keyword.conditional
+  (#lua-match? @keyword.conditional "^cmp"))
+
+((opcode) @keyword.exception
+  (#lua-match? @keyword.exception "^throw"))
+
+((opcode) @comment
+  (#eq? @comment "nop")) ; haha, anyone get it? ;)
+
+[
+  "="
+  ".."
+] @operator
+
+; Keywords
+[
+  ".class"
+  ".super"
+  ".implements"
+  ".field"
+  ".end field"
+  ".annotation"
+  ".end annotation"
+  ".subannotation"
+  ".end subannotation"
+  ".param"
+  ".end param"
+  ".parameter"
+  ".end parameter"
+  ".line"
+  ".locals"
+  ".local"
+  ".end local"
+  ".restart local"
+  ".registers"
+  ".packed-switch"
+  ".end packed-switch"
+  ".sparse-switch"
+  ".end sparse-switch"
+  ".array-data"
+  ".end array-data"
+  ".enum"
+  (prologue_directive)
+  (epilogue_directive)
+] @keyword
+
+".source" @keyword.import
+
+[
+  ".method"
+  ".end method"
+] @keyword.function
+
+[
+  ".catch"
+  ".catchall"
+] @keyword.exception
+
+; Literals
+(string) @string
+
+(source_directive
+  (string
+    "\""
+    _ @string.special.url
+    "\""))
+
+(escape_sequence) @string.escape
+
+(character) @character
+
+"L" @character.special
+
+(number) @number
+
+[
+  (float)
+  (NaN)
+  (Infinity)
+] @number.float
+
+(boolean) @boolean
+
+(null) @constant.builtin
+
+; Misc
+(annotation_visibility) @keyword.modifier
+
+(access_modifier) @keyword.modifier
+
+(array_type
+  "[" @punctuation.special)
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "->"
+  ","
+  ":"
+  ";"
+  "@"
+  "/"
+] @punctuation.delimiter
+
+(line_directive
+  (number) @string.special)
+
+; Comments
+(comment) @comment @spell
+
+(class_definition
+  (comment) @comment.documentation)
diff --git a/pack/ant/start/nvim-treesitter/queries/smali/indents.scm b/pack/ant/start/nvim-treesitter/queries/smali/indents.scm
new file mode 100644
index 0000000..b4f37dd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/smali/indents.scm
@@ -0,0 +1,35 @@
+[
+  (annotation_directive)
+  (array_data_directive)
+  (field_definition)
+  (method_definition)
+  (packed_switch_directive)
+  (param_directive)
+  (parameter_directive)
+  (sparse_switch_directive)
+  (subannotation_directive)
+  (list)
+] @indent.begin
+
+[
+  ".end annotation"
+  ".end array-data"
+  ".end field"
+  ".end method"
+  ".end packed-switch"
+  ".end param"
+  ".end parameter"
+  ".end sparse-switch"
+  ".end subannotation"
+  "}"
+] @indent.end @indent.branch
+
+[
+  "{"
+  "}"
+] @indent.branch
+
+[
+  (ERROR)
+  (comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/smali/injections.scm b/pack/ant/start/nvim-treesitter/queries/smali/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/smali/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/smali/locals.scm b/pack/ant/start/nvim-treesitter/queries/smali/locals.scm
new file mode 100644
index 0000000..a34b799
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/smali/locals.scm
@@ -0,0 +1,43 @@
+[
+  (class_directive)
+  (expression)
+  (annotation_directive)
+  (array_data_directive)
+  (method_definition)
+  (packed_switch_directive)
+  (sparse_switch_directive)
+  (subannotation_directive)
+] @local.scope
+
+[
+  (identifier)
+  (class_identifier)
+  (label)
+  (jmp_label)
+] @local.reference
+
+(enum_reference
+  (field_identifier) @local.definition.enum)
+
+((field_definition
+  (access_modifiers) @_mod
+  (field_identifier) @local.definition.enum)
+  (#eq? @_mod "enum"))
+
+(field_definition
+  (field_identifier) @local.definition.field
+  (field_type) @local.definition.associated)
+
+(annotation_key) @local.definition.field
+
+(method_definition
+  (method_signature
+    (method_identifier) @local.definition.method))
+
+(param_identifier) @local.definition.parameter
+
+(annotation_directive
+  (class_identifier) @local.definition.type)
+
+(class_directive
+  (class_identifier) @local.definition.type)
diff --git a/pack/ant/start/nvim-treesitter/queries/smithy/highlights.scm b/pack/ant/start/nvim-treesitter/queries/smithy/highlights.scm
new file mode 100644
index 0000000..14e1f20
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/smithy/highlights.scm
@@ -0,0 +1,114 @@
+; Preproc
+(control_key) @keyword.directive
+
+; Namespace
+(namespace) @module
+
+; Includes
+"use" @keyword.import
+
+; Builtins
+(primitive) @type.builtin
+
+[
+  "enum"
+  "intEnum"
+  "list"
+  "map"
+  "set"
+  "structure"
+  "union"
+  "namespace"
+  "service"
+  "operation"
+  "resource"
+] @keyword.type
+
+; Fields (Members)
+; (field) @variable.member
+(key_identifier) @variable.member
+
+(shape_member
+  (field) @variable.member)
+
+(operation_field) @variable.member
+
+(operation_error_field) @variable.member
+
+; Constants
+(enum_member
+  (enum_field) @constant)
+
+; Types
+(identifier) @type
+
+(structure_resource
+  (shape_id) @type)
+
+; Attributes
+(mixins
+  (shape_id) @attribute)
+
+(trait_statement
+  (shape_id
+    (#set! priority 105)) @attribute)
+
+; Operators
+[
+  "@"
+  "-"
+  "="
+  ":="
+] @operator
+
+; Keywords
+[
+  "metadata"
+  "apply"
+  "for"
+  "with"
+] @keyword
+
+; Literals
+(string) @string
+
+(escape_sequence) @string.escape
+
+(number) @number
+
+(float) @number.float
+
+(boolean) @boolean
+
+(null) @constant.builtin
+
+; Misc
+[
+  "$"
+  "#"
+] @punctuation.special
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ":"
+  "."
+] @punctuation.delimiter
+
+; Comments
+(comment) @comment @spell
+
+(documentation_comment) @comment.documentation @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/smithy/injections.scm b/pack/ant/start/nvim-treesitter/queries/smithy/injections.scm
new file mode 100644
index 0000000..cb85eca
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/smithy/injections.scm
@@ -0,0 +1,5 @@
+([
+  (comment)
+  (documentation_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/snakemake/folds.scm b/pack/ant/start/nvim-treesitter/queries/snakemake/folds.scm
new file mode 100644
index 0000000..d154f3c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/snakemake/folds.scm
@@ -0,0 +1,8 @@
+; inherits: python
+
+[
+  (rule_definition)
+  (rule_inheritance)
+  (module_definition)
+  (checkpoint_definition)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/snakemake/highlights.scm b/pack/ant/start/nvim-treesitter/queries/snakemake/highlights.scm
new file mode 100644
index 0000000..8781b40
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/snakemake/highlights.scm
@@ -0,0 +1,82 @@
+; inherits: python
+
+; Compound directives
+[
+  "rule"
+  "checkpoint"
+  "module"
+] @keyword
+
+; Top level directives (eg. configfile, include)
+(module
+  (directive
+    name: _ @keyword))
+
+; Subordinate directives (eg. input, output)
+body: (_
+  (directive
+    name: _ @label))
+
+; rule/module/checkpoint names
+(rule_definition
+  name: (identifier) @type)
+
+(module_definition
+  name: (identifier) @type)
+
+(checkpoint_definition
+  name: (identifier) @type)
+
+; Rule imports
+(rule_import
+  [
+    "use"
+    "rule"
+    "from"
+    "exclude"
+    "as"
+    "with"
+  ] @keyword.import)
+
+; Rule inheritance
+(rule_inheritance
+  "use" @keyword
+  "rule" @keyword
+  "with" @keyword)
+
+; Wildcard names
+(wildcard
+  (identifier) @variable)
+
+(wildcard
+  (flag) @variable.parameter.builtin)
+
+; builtin variables
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin "checkpoints" "config" "gather" "rules" "scatter" "workflow"))
+
+; References to directive labels in wildcard interpolations
+; the #any-of? queries are moved above the #has-ancestor? queries to
+; short-circuit the potentially expensive tree traversal, if possible
+; see:
+; https://github.com/nvim-treesitter/nvim-treesitter/pull/4302#issuecomment-1685789790
+; directive labels in wildcard context
+((wildcard
+  (identifier) @label)
+  (#any-of? @label "input" "log" "output" "params" "resources" "threads" "wildcards"))
+
+((wildcard
+  (attribute
+    object: (identifier) @label))
+  (#any-of? @label "input" "log" "output" "params" "resources" "threads" "wildcards"))
+
+((wildcard
+  (subscript
+    value: (identifier) @label))
+  (#any-of? @label "input" "log" "output" "params" "resources" "threads" "wildcards"))
+
+; directive labels in block context (eg. within 'run:')
+((identifier) @label
+  (#any-of? @label "input" "log" "output" "params" "resources" "threads" "wildcards")
+  (#has-ancestor? @label "directive")
+  (#has-ancestor? @label "block"))
diff --git a/pack/ant/start/nvim-treesitter/queries/snakemake/indents.scm b/pack/ant/start/nvim-treesitter/queries/snakemake/indents.scm
new file mode 100644
index 0000000..140b7fb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/snakemake/indents.scm
@@ -0,0 +1,25 @@
+; inherits: python
+
+((rule_definition) @indent.begin
+  (#set! indent.immediate 1))
+
+((checkpoint_definition) @indent.begin
+  (#set! indent.immediate 1))
+
+((rule_inheritance) @indent.begin
+  (#set! indent.immediate 1))
+
+((rule_import
+  "with"
+  ":") @indent.begin
+  (#set! indent.immediate 1))
+
+((module_definition) @indent.begin
+  (#set! indent.immediate 1))
+
+((directive) @indent.begin
+  (#set! indent.immediate 1))
+
+; end indentation after last parameter node (no following ',')
+(directive_parameters
+  (_) @indent.end .)
diff --git a/pack/ant/start/nvim-treesitter/queries/snakemake/injections.scm b/pack/ant/start/nvim-treesitter/queries/snakemake/injections.scm
new file mode 100644
index 0000000..fa56daa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/snakemake/injections.scm
@@ -0,0 +1,5 @@
+; inherits: python
+
+(wildcard
+  (constraint) @injection.content
+  (#set! injection.language "regex"))
diff --git a/pack/ant/start/nvim-treesitter/queries/snakemake/locals.scm b/pack/ant/start/nvim-treesitter/queries/snakemake/locals.scm
new file mode 100644
index 0000000..0b920cb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/snakemake/locals.scm
@@ -0,0 +1 @@
+; inherits: python
diff --git a/pack/ant/start/nvim-treesitter/queries/solidity/folds.scm b/pack/ant/start/nvim-treesitter/queries/solidity/folds.scm
new file mode 100644
index 0000000..7e3cbde
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/solidity/folds.scm
@@ -0,0 +1,20 @@
+[
+  (error_declaration)
+  (contract_body)
+  (struct_declaration)
+  (enum_declaration)
+  (event_definition)
+  (assembly_statement)
+  (block_statement)
+  (if_statement)
+  (for_statement)
+  (while_statement)
+  (yul_block)
+  (function_body)
+  (call_expression)
+  (inline_array_expression)
+  (tuple_expression)
+  (struct_expression)
+  (comment)
+  (emit_statement)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/solidity/highlights.scm b/pack/ant/start/nvim-treesitter/queries/solidity/highlights.scm
new file mode 100644
index 0000000..1f1d2fe
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/solidity/highlights.scm
@@ -0,0 +1,316 @@
+; Pragma
+[
+  "pragma"
+  "solidity"
+] @keyword.directive
+
+(solidity_pragma_token
+  "||" @string.special.symbol)
+
+(solidity_pragma_token
+  "-" @string.special.symbol)
+
+(solidity_version_comparison_operator) @operator
+
+(solidity_version) @string.special
+
+; Literals
+[
+  (string)
+  (yul_string_literal)
+] @string
+
+(hex_string_literal
+  "hex" @string.special.symbol
+  (_) @string)
+
+(unicode_string_literal
+  "unicode" @string.special.symbol
+  (_) @string)
+
+[
+  (number_literal)
+  (yul_decimal_number)
+  (yul_hex_number)
+] @number
+
+(yul_boolean) @boolean
+
+; Variables
+[
+  (identifier)
+  (yul_identifier)
+] @variable
+
+; Types
+(type_name
+  (identifier) @type)
+
+(type_name
+  (user_defined_type
+    (identifier) @type))
+
+(type_name
+  "mapping" @function.builtin)
+
+[
+  (primitive_type)
+  (number_unit)
+] @type.builtin
+
+(contract_declaration
+  name: (identifier) @type)
+
+(struct_declaration
+  name: (identifier) @type)
+
+(struct_member
+  name: (identifier) @variable.member)
+
+(enum_declaration
+  name: (identifier) @type)
+
+(emit_statement
+  .
+  (expression
+    (identifier)) @type)
+
+; Handles ContractA, ContractB in function foo() override(ContractA, contractB) {}
+(override_specifier
+  (user_defined_type) @type)
+
+; Functions and parameters
+(function_definition
+  name: (identifier) @function)
+
+(modifier_definition
+  name: (identifier) @function)
+
+(yul_evm_builtin) @function.builtin
+
+; Use constructor coloring for special functions
+(constructor_definition
+  "constructor" @constructor)
+
+(modifier_invocation
+  (identifier) @function)
+
+; Handles expressions like structVariable.g();
+(call_expression
+  .
+  (expression
+    (member_expression
+      (identifier) @function.method.call)))
+
+; Handles expressions like g();
+(call_expression
+  .
+  (expression
+    (identifier) @function.call))
+
+; Function parameters
+(event_parameter
+  name: (_) @variable.parameter)
+
+(parameter
+  name: (_) @variable.parameter)
+
+; Yul functions
+(yul_function_call
+  function: (yul_identifier) @function.call)
+
+; Yul function parameters
+(yul_function_definition
+  .
+  (yul_identifier) @function
+  (yul_identifier) @variable.parameter)
+
+(meta_type_expression
+  "type" @keyword)
+
+(member_expression
+  property: (_) @variable.member)
+
+(call_struct_argument
+  name: (_) @variable.member)
+
+(struct_field_assignment
+  name: (identifier) @variable.member)
+
+(enum_value) @constant
+
+; Keywords
+[
+  "library"
+  "is"
+  "event"
+  "assembly"
+  "emit"
+  "override"
+  "modifier"
+  "var"
+  "let"
+  "emit"
+  "error"
+  "fallback"
+  "receive"
+  (virtual)
+] @keyword
+
+[
+  "enum"
+  "struct"
+  "contract"
+  "interface"
+] @keyword.type
+
+; FIXME: update grammar
+; (block_statement "unchecked" @keyword)
+(event_parameter
+  "indexed" @keyword)
+
+[
+  "public"
+  "internal"
+  "private"
+  "external"
+  "pure"
+  "view"
+  "payable"
+  (immutable)
+] @keyword.modifier
+
+[
+  "memory"
+  "storage"
+  "calldata"
+  "constant"
+] @keyword.modifier
+
+[
+  "for"
+  "while"
+  "do"
+  "break"
+  "continue"
+] @keyword.repeat
+
+[
+  "if"
+  "else"
+  "switch"
+  "case"
+  "default"
+] @keyword.conditional
+
+(ternary_expression
+  "?" @keyword.conditional.ternary
+  ":" @keyword.conditional.ternary)
+
+[
+  "try"
+  "catch"
+  "revert"
+] @keyword.exception
+
+[
+  "return"
+  "returns"
+  (yul_leave)
+] @keyword.return
+
+"function" @keyword.function
+
+[
+  "import"
+  "using"
+] @keyword.import
+
+(import_directive
+  "as" @keyword.import)
+
+(import_directive
+  "from" @keyword.import)
+
+((import_directive
+  source: (string) @string.special.path)
+  (#offset! @string.special.path 0 1 0 -1))
+
+; Punctuation
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "."
+  ","
+  ":"
+  ; FIXME: update grammar
+  ; (semicolon)
+  "->"
+  "=>"
+] @punctuation.delimiter
+
+; Operators
+[
+  "&&"
+  "||"
+  ">>"
+  ">>>"
+  "<<"
+  "&"
+  "^"
+  "|"
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "**"
+  "="
+  "<"
+  "<="
+  "=="
+  "!="
+  "!=="
+  ">="
+  ">"
+  "!"
+  "~"
+  "-"
+  "+"
+  "++"
+  "--"
+  ":="
+] @operator
+
+[
+  "delete"
+  "new"
+] @keyword.operator
+
+(import_directive
+  "*" @character.special)
+
+; Comments
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^///[^/]"))
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^///$"))
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$"))
diff --git a/pack/ant/start/nvim-treesitter/queries/solidity/injections.scm b/pack/ant/start/nvim-treesitter/queries/solidity/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/solidity/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/soql/highlights.scm b/pack/ant/start/nvim-treesitter/queries/soql/highlights.scm
new file mode 100644
index 0000000..e61a811
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/soql/highlights.scm
@@ -0,0 +1,158 @@
+(field_identifier
+  (identifier) @variable.member)
+
+(field_identifier
+  (dotted_identifier
+    (identifier) @variable.member))
+
+(type_of_clause
+  (identifier) @variable.member)
+
+(when_expression
+  (identifier) @type)
+
+(when_expression
+  (field_list
+    (identifier) @variable.member))
+
+(when_expression
+  (field_list
+    (dotted_identifier
+      (identifier) @variable.member)))
+
+(else_expression
+  (field_list
+    (identifier) @variable.member))
+
+(else_expression
+  (field_list
+    (dotted_identifier
+      (identifier) @variable.member)))
+
+(alias_expression
+  (identifier) @label)
+
+(storage_identifier) @keyword.modifier
+
+(_
+  function_name: (identifier) @function)
+
+(date_literal) @string.special
+
+[
+  ","
+  "."
+  ":"
+  "("
+  ")"
+] @punctuation.delimiter
+
+[
+  "AND"
+  "OR"
+  "NOT"
+  "LIKE"
+  "NOT_IN"
+  "INCLUDES"
+  "EXCLUDES"
+] @keyword.operator
+
+[
+  "="
+  "!="
+  "<="
+  ">="
+] @operator
+
+(value_comparison_operator
+  [
+    "<"
+    ">"
+  ] @operator)
+
+(set_comparison_operator
+  "IN" @keyword.operator)
+
+[
+  (int)
+  (decimal)
+  (currency_literal)
+] @number
+
+(string_literal) @string
+
+[
+  (date)
+  (date_time)
+] @string.special
+
+[
+  "TRUE"
+  "FALSE"
+] @boolean
+
+(null_literal) @constant.builtin
+
+[
+  "ABOVE"
+  "ABOVE_OR_BELOW"
+  "ALL"
+  "AS"
+  "ASC"
+  "AT"
+  "BELOW"
+  "CUSTOM"
+  "DATA_CATEGORY"
+  "DESC"
+  "END"
+  "FIELDS"
+  "FOR"
+  "FROM"
+  "GROUP_BY"
+  "HAVING"
+  "LIMIT"
+  "NULLS_FIRST"
+  "NULLS_LAST"
+  "OFFSET"
+  "ORDER_BY"
+  "REFERENCE"
+  "SELECT"
+  "STANDARD"
+  "TRACKING"
+  "TYPEOF"
+  "UPDATE"
+  "USING_SCOPE"
+  "VIEW"
+  "VIEWSTAT"
+  "WITH"
+] @keyword
+
+[
+  "WHERE"
+  "WHEN"
+  "ELSE"
+  "THEN"
+] @keyword.conditional
+
+; Using Scope
+[
+  "delegated"
+  "everything"
+  "mine"
+  "mine_and_my_groups"
+  "my_territory"
+  "my_team_territory"
+  "team"
+] @keyword
+
+; With
+[
+  "maxDescriptorPerRecord"
+  "RecordVisibilityContext"
+  "Security_Enforced"
+  "supportsDomains"
+  "supportsDelegates"
+  "System_Mode"
+  "User_Mode"
+  "UserId"
+] @keyword
diff --git a/pack/ant/start/nvim-treesitter/queries/sosl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/sosl/highlights.scm
new file mode 100644
index 0000000..f3b77be
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sosl/highlights.scm
@@ -0,0 +1,30 @@
+(find_clause
+  (term) @string)
+
+(sobject_return
+  (identifier) @type)
+
+(with_type
+  (_
+    "=" @operator))
+
+[
+  "ALL"
+  "DIVISION"
+  "EMAIL"
+  "FIND"
+  "ListView"
+  "HIGHLIGHT"
+  "IN"
+  "METADATA"
+  "NAME"
+  "NETWORK"
+  "PHONE"
+  "PricebookId"
+  "RETURNING"
+  "SIDEBAR"
+  "SNIPPET"
+  "SPELL_CORRECTION"
+  "target_length"
+  "USING"
+] @keyword
diff --git a/pack/ant/start/nvim-treesitter/queries/sourcepawn/highlights.scm b/pack/ant/start/nvim-treesitter/queries/sourcepawn/highlights.scm
new file mode 100644
index 0000000..21cbb97
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sourcepawn/highlights.scm
@@ -0,0 +1,303 @@
+(identifier) @variable
+
+; Assume all-caps names are constants
+((identifier) @constant
+  (#lua-match? @constant "^[A-Z][A-Z0-9_]+$"))
+
+; Function definitions/declarations
+(function_definition
+  name: (identifier) @function)
+
+(function_declaration
+  name: (identifier) @function)
+
+(parameter_declaration
+  name: (identifier) @variable.parameter)
+
+; Methods / Properties
+(field_access
+  field: (identifier) @variable.member)
+
+; Function calls
+(call_expression
+  function: (identifier) @function)
+
+(call_expression
+  function: (field_access
+    field: (identifier) @function.method.call))
+
+; Types
+[
+  (builtin_type)
+  (any_type)
+] @type.builtin
+
+(type
+  (identifier) @type)
+
+; Variables
+(variable_declaration
+  name: (identifier) @variable)
+
+(old_variable_declaration
+  name: (identifier) @variable)
+
+[
+  (system_lib_string)
+  (string_literal)
+] @string
+
+; Preprocessor
+[
+  "#include"
+  "#tryinclude"
+] @keyword.import
+
+[
+  (preproc_assert)
+  (preproc_pragma)
+  (preproc_if)
+  (preproc_else)
+  (preproc_elseif)
+  (preproc_endinput)
+  (preproc_endif)
+  (preproc_error)
+  (preproc_warning)
+] @keyword.directive
+
+[
+  "#define"
+  "#undef"
+] @keyword.directive.define
+
+(macro_param) @variable.parameter
+
+(preproc_define
+  name: (identifier) @constant)
+
+(preproc_macro
+  name: (identifier) @function.macro)
+
+(preproc_undefine
+  name: (identifier) @constant)
+
+; Expressions
+(view_as) @function.builtin
+
+(sizeof_expression) @function.macro
+
+[
+  (this)
+  ; https://github.com/alliedmodders/sourcemod/blob/5c0ae11a4619e9cba93478683c7737253ea93ba6/plugins/include/handles.inc#L78
+  (hardcoded_symbol)
+] @variable.builtin
+
+; Comments
+(comment) @comment @spell
+
+; General
+(parameter_declaration
+  defaultValue: (identifier) @constant)
+
+[
+  (fixed_dimension)
+  (dimension)
+] @punctuation.bracket
+
+(escape_sequence) @string.escape
+
+; Constructors
+(new_expression
+  class: (identifier) @type
+  arguments: (call_arguments) @constructor)
+
+; Methodmaps
+(methodmap
+  name: (identifier) @type)
+
+(methodmap
+  inherits: (identifier) @type)
+
+(methodmap_method_constructor
+  name: (identifier) @constructor)
+
+(methodmap_method
+  name: (identifier) @function.method)
+
+(methodmap_native
+  name: (identifier) @function.method)
+
+(methodmap_property
+  name: (identifier) @property)
+
+[
+  (methodmap_property_getter)
+  (methodmap_property_setter)
+] @function.method
+
+; Enum structs
+(enum_struct
+  name: (identifier) @type)
+
+(enum_struct_field
+  name: (identifier) @variable.member)
+
+(enum_struct_method
+  name: (identifier) @function.method)
+
+; Non-type Keywords
+(variable_storage_class) @keyword.modifier
+
+(visibility) @keyword.modifier
+
+(assertion) @function.builtin
+
+(function_declaration_kind) @keyword.function
+
+[
+  "new"
+  "delete"
+] @keyword.operator
+
+[
+  "."
+  ","
+] @punctuation.delimiter
+
+; Operators
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "++"
+  "--"
+  "="
+  "+="
+  "-="
+  "*="
+  "/="
+  "=="
+  "!="
+  "<"
+  ">"
+  ">="
+  "<="
+  "!"
+  "&&"
+  "||"
+  "&"
+  "|"
+  "~"
+  "^"
+  "<<"
+  ">>"
+  ">>>"
+  "|="
+  "&="
+  "^="
+  "~="
+  "<<="
+  ">>="
+  "..."
+  (ignore_argument)
+  (scope_access)
+  (rest_operator)
+] @operator
+
+; public Plugin myinfo
+(struct_declaration
+  name: (identifier) @variable.builtin)
+
+; Typedef/Typedef
+(typedef
+  name: (identifier) @type)
+
+(functag
+  name: (identifier) @type)
+
+(funcenum
+  name: (identifier) @type)
+
+(typeset
+  name: (identifier) @type)
+
+(typedef_expression) @keyword.function ; function void(int x)
+
+; Enums
+(enum
+  name: (identifier) @type)
+
+(enum_entry
+  name: (identifier) @constant)
+
+(enum_entry
+  value: (_) @constant)
+
+; Literals
+(int_literal) @number
+
+(char_literal) @character
+
+(float_literal) @number.float
+
+(string_literal) @string
+
+(array_literal) @punctuation.bracket
+
+(bool_literal) @boolean
+
+(null) @constant.builtin
+
+((identifier) @constant.builtin
+  (#eq? @constant.builtin "INVALID_HANDLE"))
+
+; Keywords
+"return" @keyword.return
+
+[
+  "if"
+  "else"
+  "case"
+  "default"
+  "switch"
+] @keyword.conditional
+
+[
+  "do"
+  "while"
+  "for"
+  "continue"
+  "break"
+] @keyword.repeat
+
+[
+  "__nullable__"
+  "defined"
+  "delete"
+  "functag"
+  "get"
+  "methodmap"
+  "new"
+  "property"
+  "public"
+  "set"
+  "typeset"
+  "void"
+] @keyword
+
+[
+  "enum"
+  "funcenum"
+  "struct"
+  "typedef"
+] @keyword.type
+
+[
+  "const"
+  "native"
+  "static"
+  "stock"
+  "forward"
+] @keyword.modifier
diff --git a/pack/ant/start/nvim-treesitter/queries/sourcepawn/injections.scm b/pack/ant/start/nvim-treesitter/queries/sourcepawn/injections.scm
new file mode 100644
index 0000000..c579ffa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sourcepawn/injections.scm
@@ -0,0 +1,3 @@
+; Parse JSDoc annotations in comments
+((comment) @injection.content
+  (#set! injection.language "jsdoc"))
diff --git a/pack/ant/start/nvim-treesitter/queries/sourcepawn/locals.scm b/pack/ant/start/nvim-treesitter/queries/sourcepawn/locals.scm
new file mode 100644
index 0000000..39d6fb5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sourcepawn/locals.scm
@@ -0,0 +1,19 @@
+[
+  (function_definition)
+  (alias_declaration)
+  (enum_struct_method)
+  (methodmap_method)
+  (methodmap_method_constructor)
+  (methodmap_method_destructor)
+  (methodmap_property_method)
+] @local.scope
+
+; Definitions
+(variable_declaration
+  name: (identifier) @local.definition)
+
+(old_variable_declaration
+  name: (identifier) @local.definition)
+
+; References
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/sparql/folds.scm b/pack/ant/start/nvim-treesitter/queries/sparql/folds.scm
new file mode 100644
index 0000000..2b93a7b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sparql/folds.scm
@@ -0,0 +1,26 @@
+[
+  (prologue)
+  (select_query)
+  (construct_query)
+  (describe_query)
+  (ask_query)
+  (values_clause)
+  (load)
+  (clear)
+  (drop)
+  (add)
+  (move)
+  (copy)
+  (create)
+  (insert_data)
+  (delete_data)
+  (delete_where)
+  (modify)
+  (group_graph_pattern)
+  (triples_same_subject)
+  (where_clause)
+  (delete_clause)
+  (insert_clause)
+  (data_block)
+  (blank_node_property_list)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/sparql/highlights.scm b/pack/ant/start/nvim-treesitter/queries/sparql/highlights.scm
new file mode 100644
index 0000000..19c0257
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sparql/highlights.scm
@@ -0,0 +1,249 @@
+[
+  (path_mod)
+  "||"
+  "&&"
+  "="
+  "<"
+  ">"
+  "<="
+  ">="
+  "+"
+  "-"
+  "*"
+  "/"
+  "!"
+  "|"
+  "^"
+] @operator
+
+[
+  "_:"
+  (namespace)
+] @module
+
+[
+  "UNDEF"
+  "a"
+] @variable.builtin
+
+[
+  "ADD"
+  "ALL"
+  "AS"
+  "ASC"
+  "ASK"
+  "BIND"
+  "BY"
+  "CLEAR"
+  "CONSTRUCT"
+  "COPY"
+  "CREATE"
+  "DEFAULT"
+  "DELETE"
+  "DELETE DATA"
+  "DELETE WHERE"
+  "DESC"
+  "DESCRIBE"
+  "DISTINCT"
+  "DROP"
+  "EXISTS"
+  "FILTER"
+  "FROM"
+  "GRAPH"
+  "GROUP"
+  "HAVING"
+  "INSERT"
+  "INSERT DATA"
+  "INTO"
+  "LIMIT"
+  "LOAD"
+  "MINUS"
+  "MOVE"
+  "NAMED"
+  "NOT"
+  "OFFSET"
+  "OPTIONAL"
+  "ORDER"
+  "PREFIX"
+  "REDUCED"
+  "SELECT"
+  "SERVICE"
+  "SILENT"
+  "UNION"
+  "USING"
+  "VALUES"
+  "WHERE"
+  "WITH"
+] @keyword
+
+(string) @string
+
+(echar) @string.escape
+
+(integer) @number
+
+[
+  (decimal)
+  (double)
+] @number.float
+
+(boolean_literal) @boolean
+
+[
+  "BASE"
+  "PREFIX"
+] @keyword
+
+[
+  "ABS"
+  "AVG"
+  "BNODE"
+  "BOUND"
+  "CEIL"
+  "CONCAT"
+  "COALESCE"
+  "CONTAINS"
+  "DATATYPE"
+  "DAY"
+  "ENCODE_FOR_URI"
+  "FLOOR"
+  "HOURS"
+  "IF"
+  "IRI"
+  "LANG"
+  "LANGMATCHES"
+  "LCASE"
+  "MD5"
+  "MINUTES"
+  "MONTH"
+  "NOW"
+  "RAND"
+  "REGEX"
+  "ROUND"
+  "SECONDS"
+  "SHA1"
+  "SHA256"
+  "SHA384"
+  "SHA512"
+  "STR"
+  "SUM"
+  "MAX"
+  "MIN"
+  "SAMPLE"
+  "GROUP_CONCAT"
+  "SEPARATOR"
+  "COUNT"
+  "STRAFTER"
+  "STRBEFORE"
+  "STRDT"
+  "STRENDS"
+  "STRLANG"
+  "STRLEN"
+  "STRSTARTS"
+  "STRUUID"
+  "TIMEZONE"
+  "TZ"
+  "UCASE"
+  "URI"
+  "UUID"
+  "YEAR"
+  "isBLANK"
+  "isIRI"
+  "isLITERAL"
+  "isNUMERIC"
+  "isURI"
+  "sameTerm"
+] @function.builtin
+
+[
+  "."
+  ","
+  ";"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  (nil)
+  (anon)
+] @punctuation.bracket
+
+[
+  "IN"
+  ("NOT"
+    "IN")
+] @keyword.operator
+
+(comment) @comment @spell
+
+; Could this be summarized?
+(select_clause
+  [
+    bound_variable: (var)
+    "*"
+  ] @variable.parameter)
+
+(bind
+  bound_variable: (var) @variable.parameter)
+
+(data_block
+  bound_variable: (var) @variable.parameter)
+
+(group_condition
+  bound_variable: (var) @variable.parameter)
+
+(iri_reference
+  [
+    "<"
+    ">"
+  ] @module)
+
+(lang_tag) @type
+
+(rdf_literal
+  "^^" @type
+  datatype: (_
+    [
+      "<"
+      ">"
+      (namespace)
+    ] @type) @type)
+
+(function_call
+  identifier: (_) @function)
+
+(function_call
+  identifier: (iri_reference
+    [
+      "<"
+      ">"
+    ] @function))
+
+(function_call
+  identifier: (prefixed_name
+    (namespace) @function))
+
+(base_declaration
+  (iri_reference
+    [
+      "<"
+      ">"
+    ] @variable))
+
+(prefix_declaration
+  (iri_reference
+    [
+      "<"
+      ">"
+    ] @variable))
+
+[
+  (var)
+  (blank_node_label)
+  (iri_reference)
+  (prefixed_name)
+] @variable
diff --git a/pack/ant/start/nvim-treesitter/queries/sparql/indents.scm b/pack/ant/start/nvim-treesitter/queries/sparql/indents.scm
new file mode 100644
index 0000000..e070546
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sparql/indents.scm
@@ -0,0 +1,18 @@
+[
+  (group_graph_pattern)
+  (triples_block)
+  (triples_template)
+  (construct_template)
+  (construct_triples)
+  (quads)
+  (data_block)
+  (blank_node_property_list)
+  (collection)
+] @indent.begin
+
+[
+  "}"
+  "]"
+  ")"
+  (triples_same_subject)
+] @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/sparql/injections.scm b/pack/ant/start/nvim-treesitter/queries/sparql/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sparql/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/sparql/locals.scm b/pack/ant/start/nvim-treesitter/queries/sparql/locals.scm
new file mode 100644
index 0000000..cbb2bb2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sparql/locals.scm
@@ -0,0 +1,14 @@
+(group_graph_pattern
+  (triples_block) @local.scope)
+
+((sub_select
+  (select_clause
+    (var) @local.definition.var))
+  (#set! definition.var.scope "parent"))
+
+((select_query
+  (select_clause
+    (var) @local.definition.var))
+  (#set! definition.var.scope "parent"))
+
+(var) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/sql/highlights.scm b/pack/ant/start/nvim-treesitter/queries/sql/highlights.scm
new file mode 100644
index 0000000..67eef18
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sql/highlights.scm
@@ -0,0 +1,427 @@
+(invocation
+  (object_reference
+    name: (identifier) @function.call))
+
+[
+  (keyword_gist)
+  (keyword_btree)
+  (keyword_hash)
+  (keyword_spgist)
+  (keyword_gin)
+  (keyword_brin)
+  (keyword_array)
+] @function.call
+
+(object_reference
+  name: (identifier) @type)
+
+(relation
+  alias: (identifier) @variable)
+
+(field
+  name: (identifier) @variable.member)
+
+(column_definition
+  name: (identifier) @variable.member)
+
+(term
+  alias: (identifier) @variable)
+
+(term
+  value: (cast
+    name: (keyword_cast) @function.call
+    parameter: (literal)?))
+
+(literal) @string
+
+(comment) @comment @spell
+
+(marginalia) @comment
+
+((literal) @number
+  (#lua-match? @number "^%d+$"))
+
+((literal) @number.float
+  (#lua-match? @number.float "^[-]?%d*\.%d*$"))
+
+(parameter) @variable.parameter
+
+[
+  (keyword_true)
+  (keyword_false)
+] @boolean
+
+[
+  (keyword_asc)
+  (keyword_desc)
+  (keyword_terminated)
+  (keyword_escaped)
+  (keyword_unsigned)
+  (keyword_nulls)
+  (keyword_last)
+  (keyword_delimited)
+  (keyword_replication)
+  (keyword_auto_increment)
+  (keyword_default)
+  (keyword_collate)
+  (keyword_concurrently)
+  (keyword_engine)
+  (keyword_always)
+  (keyword_generated)
+  (keyword_preceding)
+  (keyword_following)
+  (keyword_first)
+  (keyword_current_timestamp)
+  (keyword_immutable)
+  (keyword_atomic)
+  (keyword_parallel)
+  (keyword_leakproof)
+  (keyword_safe)
+  (keyword_cost)
+  (keyword_strict)
+] @attribute
+
+[
+  (keyword_materialized)
+  (keyword_recursive)
+  (keyword_temp)
+  (keyword_temporary)
+  (keyword_unlogged)
+  (keyword_external)
+  (keyword_parquet)
+  (keyword_csv)
+  (keyword_rcfile)
+  (keyword_textfile)
+  (keyword_orc)
+  (keyword_avro)
+  (keyword_jsonfile)
+  (keyword_sequencefile)
+  (keyword_volatile)
+] @keyword.modifier
+
+[
+  (keyword_case)
+  (keyword_when)
+  (keyword_then)
+  (keyword_else)
+] @keyword.conditional
+
+[
+  (keyword_select)
+  (keyword_from)
+  (keyword_where)
+  (keyword_index)
+  (keyword_join)
+  (keyword_primary)
+  (keyword_delete)
+  (keyword_create)
+  (keyword_insert)
+  (keyword_merge)
+  (keyword_distinct)
+  (keyword_replace)
+  (keyword_update)
+  (keyword_into)
+  (keyword_overwrite)
+  (keyword_matched)
+  (keyword_values)
+  (keyword_value)
+  (keyword_attribute)
+  (keyword_set)
+  (keyword_left)
+  (keyword_right)
+  (keyword_outer)
+  (keyword_inner)
+  (keyword_full)
+  (keyword_order)
+  (keyword_partition)
+  (keyword_group)
+  (keyword_with)
+  (keyword_without)
+  (keyword_as)
+  (keyword_having)
+  (keyword_limit)
+  (keyword_offset)
+  (keyword_table)
+  (keyword_tables)
+  (keyword_key)
+  (keyword_references)
+  (keyword_foreign)
+  (keyword_constraint)
+  (keyword_force)
+  (keyword_use)
+  (keyword_for)
+  (keyword_if)
+  (keyword_exists)
+  (keyword_column)
+  (keyword_columns)
+  (keyword_cross)
+  (keyword_lateral)
+  (keyword_natural)
+  (keyword_alter)
+  (keyword_drop)
+  (keyword_add)
+  (keyword_view)
+  (keyword_end)
+  (keyword_is)
+  (keyword_using)
+  (keyword_between)
+  (keyword_window)
+  (keyword_no)
+  (keyword_data)
+  (keyword_type)
+  (keyword_rename)
+  (keyword_to)
+  (keyword_schema)
+  (keyword_owner)
+  (keyword_authorization)
+  (keyword_all)
+  (keyword_any)
+  (keyword_some)
+  (keyword_returning)
+  (keyword_begin)
+  (keyword_commit)
+  (keyword_rollback)
+  (keyword_transaction)
+  (keyword_only)
+  (keyword_like)
+  (keyword_similar)
+  (keyword_over)
+  (keyword_change)
+  (keyword_modify)
+  (keyword_after)
+  (keyword_before)
+  (keyword_range)
+  (keyword_rows)
+  (keyword_groups)
+  (keyword_exclude)
+  (keyword_current)
+  (keyword_ties)
+  (keyword_others)
+  (keyword_zerofill)
+  (keyword_format)
+  (keyword_fields)
+  (keyword_row)
+  (keyword_sort)
+  (keyword_compute)
+  (keyword_comment)
+  (keyword_location)
+  (keyword_cached)
+  (keyword_uncached)
+  (keyword_lines)
+  (keyword_stored)
+  (keyword_virtual)
+  (keyword_partitioned)
+  (keyword_analyze)
+  (keyword_explain)
+  (keyword_verbose)
+  (keyword_truncate)
+  (keyword_rewrite)
+  (keyword_optimize)
+  (keyword_vacuum)
+  (keyword_cache)
+  (keyword_language)
+  (keyword_called)
+  (keyword_conflict)
+  (keyword_declare)
+  (keyword_filter)
+  (keyword_function)
+  (keyword_input)
+  (keyword_name)
+  (keyword_oid)
+  (keyword_oids)
+  (keyword_precision)
+  (keyword_regclass)
+  (keyword_regnamespace)
+  (keyword_regproc)
+  (keyword_regtype)
+  (keyword_restricted)
+  (keyword_return)
+  (keyword_returns)
+  (keyword_separator)
+  (keyword_setof)
+  (keyword_stable)
+  (keyword_support)
+  (keyword_tblproperties)
+  (keyword_trigger)
+  (keyword_unsafe)
+  (keyword_admin)
+  (keyword_connection)
+  (keyword_cycle)
+  (keyword_database)
+  (keyword_encrypted)
+  (keyword_increment)
+  (keyword_logged)
+  (keyword_none)
+  (keyword_owned)
+  (keyword_password)
+  (keyword_reset)
+  (keyword_role)
+  (keyword_sequence)
+  (keyword_start)
+  (keyword_restart)
+  (keyword_tablespace)
+  (keyword_until)
+  (keyword_user)
+  (keyword_valid)
+  (keyword_action)
+  (keyword_definer)
+  (keyword_invoker)
+  (keyword_security)
+  (keyword_extension)
+  (keyword_version)
+  (keyword_out)
+  (keyword_inout)
+  (keyword_variadic)
+  (keyword_session)
+  (keyword_isolation)
+  (keyword_level)
+  (keyword_serializable)
+  (keyword_repeatable)
+  (keyword_read)
+  (keyword_write)
+  (keyword_committed)
+  (keyword_uncommitted)
+  (keyword_deferrable)
+  (keyword_names)
+  (keyword_zone)
+  (keyword_immediate)
+  (keyword_deferred)
+  (keyword_constraints)
+  (keyword_snapshot)
+  (keyword_characteristics)
+  (keyword_off)
+  (keyword_follows)
+  (keyword_precedes)
+  (keyword_each)
+  (keyword_instead)
+  (keyword_of)
+  (keyword_initially)
+  (keyword_old)
+  (keyword_new)
+  (keyword_referencing)
+  (keyword_statement)
+  (keyword_execute)
+  (keyword_procedure)
+] @keyword
+
+[
+  (keyword_restrict)
+  (keyword_unbounded)
+  (keyword_unique)
+  (keyword_cascade)
+  (keyword_delayed)
+  (keyword_high_priority)
+  (keyword_low_priority)
+  (keyword_ignore)
+  (keyword_nothing)
+  (keyword_check)
+  (keyword_option)
+  (keyword_local)
+  (keyword_cascaded)
+  (keyword_wait)
+  (keyword_nowait)
+  (keyword_metadata)
+  (keyword_incremental)
+  (keyword_bin_pack)
+  (keyword_noscan)
+  (keyword_stats)
+  (keyword_statistics)
+  (keyword_maxvalue)
+  (keyword_minvalue)
+] @keyword.modifier
+
+[
+  (keyword_int)
+  (keyword_null)
+  (keyword_boolean)
+  (keyword_binary)
+  (keyword_varbinary)
+  (keyword_image)
+  (keyword_bit)
+  (keyword_inet)
+  (keyword_character)
+  (keyword_smallserial)
+  (keyword_serial)
+  (keyword_bigserial)
+  (keyword_smallint)
+  (keyword_mediumint)
+  (keyword_bigint)
+  (keyword_tinyint)
+  (keyword_decimal)
+  (keyword_float)
+  (keyword_double)
+  (keyword_numeric)
+  (keyword_real)
+  (double)
+  (keyword_money)
+  (keyword_smallmoney)
+  (keyword_char)
+  (keyword_nchar)
+  (keyword_varchar)
+  (keyword_nvarchar)
+  (keyword_varying)
+  (keyword_text)
+  (keyword_string)
+  (keyword_uuid)
+  (keyword_json)
+  (keyword_jsonb)
+  (keyword_xml)
+  (keyword_bytea)
+  (keyword_enum)
+  (keyword_date)
+  (keyword_datetime)
+  (keyword_time)
+  (keyword_datetime2)
+  (keyword_datetimeoffset)
+  (keyword_smalldatetime)
+  (keyword_timestamp)
+  (keyword_timestamptz)
+  (keyword_geometry)
+  (keyword_geography)
+  (keyword_box2d)
+  (keyword_box3d)
+  (keyword_interval)
+] @type.builtin
+
+[
+  (keyword_in)
+  (keyword_and)
+  (keyword_or)
+  (keyword_not)
+  (keyword_by)
+  (keyword_on)
+  (keyword_do)
+  (keyword_union)
+  (keyword_except)
+  (keyword_intersect)
+] @keyword.operator
+
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "^"
+  ":="
+  "="
+  "<"
+  "<="
+  "!="
+  ">="
+  ">"
+  "<>"
+  (op_other)
+  (op_unary_other)
+] @operator
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  ";"
+  ","
+  "."
+] @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/sql/indents.scm b/pack/ant/start/nvim-treesitter/queries/sql/indents.scm
new file mode 100644
index 0000000..34ae079
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sql/indents.scm
@@ -0,0 +1,29 @@
+[
+  (select)
+  (cte)
+  (column_definitions)
+  (case)
+  (subquery)
+  (insert)
+  (when_clause)
+] @indent.begin
+
+(block
+  (keyword_begin)) @indent.begin
+
+(column_definitions
+  ")" @indent.branch)
+
+(subquery
+  ")" @indent.branch)
+
+(cte
+  ")" @indent.branch)
+
+[
+  (keyword_end)
+  (keyword_values)
+  (keyword_into)
+] @indent.branch
+
+(keyword_end) @indent.end
diff --git a/pack/ant/start/nvim-treesitter/queries/sql/injections.scm b/pack/ant/start/nvim-treesitter/queries/sql/injections.scm
new file mode 100644
index 0000000..6029974
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sql/injections.scm
@@ -0,0 +1,5 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((marginalia) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/squirrel/folds.scm b/pack/ant/start/nvim-treesitter/queries/squirrel/folds.scm
new file mode 100644
index 0000000..c2903cc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/squirrel/folds.scm
@@ -0,0 +1,23 @@
+[
+  (class_declaration)
+  (function_declaration)
+  (member_declaration)
+  (enum_declaration)
+  (array)
+  (block)
+  (table)
+  (anonymous_function)
+  (parenthesized_expression)
+  (string)
+  (verbatim_string)
+  (comment)
+  (if_statement)
+  (else_statement)
+  (while_statement)
+  (do_while_statement)
+  (switch_statement)
+  (for_statement)
+  (foreach_statement)
+  (try_statement)
+  (catch_statement)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/squirrel/highlights.scm b/pack/ant/start/nvim-treesitter/queries/squirrel/highlights.scm
new file mode 100644
index 0000000..03acaca
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/squirrel/highlights.scm
@@ -0,0 +1,316 @@
+; Keywords
+[
+  "clone"
+  "delete"
+  "extends"
+  "rawcall"
+  "resume"
+  "var"
+] @keyword
+
+[
+  "class"
+  "enum"
+] @keyword.type
+
+"function" @keyword.function
+
+[
+  "in"
+  "instanceof"
+  "typeof"
+] @keyword.operator
+
+[
+  "return"
+  "yield"
+] @keyword.return
+
+((global_variable
+  "::"
+  (_) @keyword.coroutine)
+  (#any-of? @keyword.coroutine "suspend" "newthread"))
+
+; Conditionals
+[
+  "if"
+  "else"
+  "switch"
+  "case"
+  "default"
+  "break"
+] @keyword.conditional
+
+; Repeats
+[
+  "for"
+  "foreach"
+  "do"
+  "while"
+  "continue"
+] @keyword.repeat
+
+; Exceptions
+[
+  "try"
+  "catch"
+  "throw"
+] @keyword.exception
+
+; Storageclasses
+"local" @keyword.modifier
+
+; Qualifiers
+[
+  "static"
+  "const"
+] @keyword.modifier
+
+; Variables
+[
+  (identifier)
+  (global_variable)
+] @variable
+
+(local_declaration
+  (identifier) @variable
+  .
+  "=")
+
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin "base" "this" "vargv"))
+
+; Parameters
+(parameter
+  .
+  (identifier) @variable.parameter)
+
+; Properties (Slots)
+(deref_expression
+  "."
+  .
+  (identifier) @variable.member)
+
+(member_declaration
+  (identifier) @variable.member
+  .
+  "=")
+
+((table_slot
+  .
+  (identifier) @variable.member
+  .
+  [
+    "="
+    ":"
+  ])
+  (#set! priority 105))
+
+; Types
+((identifier) @type
+  (#lua-match? @type "^[A-Z]"))
+
+(class_declaration
+  (identifier) @type
+  "extends"?
+  .
+  (identifier)? @type)
+
+(enum_declaration
+  (identifier) @type)
+
+; Attributes
+(attribute_declaration
+  left: (identifier) @attribute)
+
+; Functions & Methods
+(member_declaration
+  (function_declaration
+    "::"?
+    (_) @function.method
+    .
+    "("
+    (_)?
+    ")"))
+
+((function_declaration
+  "::"?
+  (_) @function
+  .
+  "("
+  (_)?
+  ")")
+  (#not-has-ancestor? @function member_declaration))
+
+(call_expression
+  function: (identifier) @function.call)
+
+(call_expression
+  function: (deref_expression
+    "."
+    .
+    (identifier) @function.call))
+
+(call_expression
+  (global_variable
+    "::"
+    (_) @function.call))
+
+(_
+  (identifier) @function
+  "="
+  (lambda_expression
+    "@" @string.special.symbol))
+
+(call_expression
+  [
+    function: (identifier) @function.builtin
+    function: (global_variable
+      "::"
+      (_) @function.builtin)
+    function: (deref_expression
+      "."
+      (_) @function.builtin)
+  ]
+  (#any-of? @function.builtin
+    ; General Methods
+    "assert" "array" "callee" "collectgarbage" "compilestring" "enabledebughook" "enabledebuginfo"
+    "error" "getconsttable" "getroottable" "print" "resurrectunreachable" "setconsttable"
+    "setdebughook" "seterrorhandler" "setroottable" "type"
+    ; Hidden Methods
+    "_charsize_" "_intsize_" "_floatsize_" "_version_" "_versionnumber_"
+    ; Number Methods
+    "tofloat" "tostring" "tointeger" "tochar"
+    ; String Methods
+    "len" "slice" "find" "tolower" "toupper"
+    ; Table Methods
+    "rawget" "rawset" "rawdelete" "rawin" "clear" "setdelegate" "getdelegate" "filter" "keys"
+    "values"
+    ; Array Methods
+    "append" "push" "extend" "pop" "top" "insert" "remove" "resize" "sort" "reverse" "map" "apply"
+    "reduce"
+    ; Function Methods
+    "call" "pcall" "acall" "pacall" "setroot" "getroot" "bindenv" "getinfos"
+    ; Class Methods
+    "instance" "getattributes" "setattributes" "newmember" "rawnewmember"
+    ; Class Instance Methods
+    "getclass"
+    ; Generator Methods
+    "getstatus"
+    ; Thread Methods
+    "call" "wakeup" "wakeupthrow" "getstackinfos"
+    ; Weak Reference Methods
+    "ref" "weakref"))
+
+(member_declaration
+  "constructor" @constructor)
+
+; Constants
+(const_declaration
+  "const"
+  .
+  (identifier) @constant)
+
+(enum_declaration
+  "{"
+  .
+  (identifier) @constant)
+
+((identifier) @constant
+  (#lua-match? @constant "^_*[A-Z][A-Z%d_]*$"))
+
+; Operators
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "||"
+  "&&"
+  "|"
+  "^"
+  "&"
+  "=="
+  "!="
+  "<=>"
+  ">"
+  ">="
+  "<="
+  "<"
+  "<<"
+  ">>"
+  ">>>"
+  "="
+  "<-"
+  "+="
+  "-="
+  "*="
+  "/="
+  "%="
+  "~"
+  "!"
+  "++"
+  "--"
+] @operator
+
+; Punctuation
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "</"
+  "/>"
+] @punctuation.bracket
+
+[
+  "."
+  ","
+  ";"
+  ":"
+] @punctuation.delimiter
+
+[
+  "::"
+  "..."
+] @punctuation.special
+
+; Ternaries
+(ternary_expression
+  "?" @keyword.conditional.ternary
+  ":" @keyword.conditional.ternary)
+
+; Literals
+(string) @string
+
+(verbatim_string) @string.special
+
+(char) @character
+
+(escape_sequence) @string.escape
+
+(integer) @number
+
+(float) @number.float
+
+(bool) @boolean
+
+(null) @constant.builtin
+
+; Comments
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$"))
diff --git a/pack/ant/start/nvim-treesitter/queries/squirrel/indents.scm b/pack/ant/start/nvim-treesitter/queries/squirrel/indents.scm
new file mode 100644
index 0000000..00245d6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/squirrel/indents.scm
@@ -0,0 +1,63 @@
+[
+  (class_declaration)
+  (function_declaration)
+  (enum_declaration)
+  (array)
+  (block)
+  (table)
+  (anonymous_function)
+  (parenthesized_expression)
+  (while_statement)
+  (switch_statement)
+  (for_statement)
+  (foreach_statement)
+  ; (try_statement)
+  (catch_statement)
+] @indent.begin
+
+((if_statement)
+  (ERROR
+    "else") @indent.begin)
+
+(if_statement
+  condition: (_) @indent.begin)
+
+(if_statement
+  consequence: (_)
+  (else_statement) @indent.begin)
+
+(do_while_statement
+  "do"
+  (_) @indent.begin)
+
+(try_statement
+  (_) @indent.begin
+  (catch_statement) @indent.begin)
+
+[
+  "{"
+  "}"
+] @indent.branch
+
+[
+  "("
+  ")"
+] @indent.branch
+
+[
+  "["
+  "]"
+] @indent.branch
+
+[
+  "}"
+  ")"
+  "]"
+] @indent.end
+
+[
+  (ERROR)
+  (comment)
+  (string)
+  (verbatim_string)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/squirrel/injections.scm b/pack/ant/start/nvim-treesitter/queries/squirrel/injections.scm
new file mode 100644
index 0000000..578a9ee
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/squirrel/injections.scm
@@ -0,0 +1,12 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((verbatim_string) @injection.content
+  (#lua-match? @injection.content "^@\"<html")
+  (#set! injection.language "html")
+  (#offset! @injection.content 0 2 0 -1))
+
+((verbatim_string) @injection.content
+  (#lua-match? @injection.content "@\"<!DOCTYPE html>")
+  (#set! injection.language "html")
+  (#offset! @injection.content 0 2 0 -1))
diff --git a/pack/ant/start/nvim-treesitter/queries/squirrel/locals.scm b/pack/ant/start/nvim-treesitter/queries/squirrel/locals.scm
new file mode 100644
index 0000000..e5fce7d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/squirrel/locals.scm
@@ -0,0 +1,75 @@
+; Scopes
+[
+  (script)
+  (class_declaration)
+  (enum_declaration)
+  (function_declaration)
+  (attribute_declaration)
+  (array)
+  (block)
+  (table)
+  (anonymous_function)
+  (parenthesized_expression)
+  (if_statement)
+  (else_statement)
+  (while_statement)
+  (do_while_statement)
+  (switch_statement)
+  (for_statement)
+  (foreach_statement)
+  (try_statement)
+  (catch_statement)
+] @local.scope
+
+; References
+[
+  (identifier)
+  (global_variable)
+] @local.reference
+
+; Definitions
+(const_declaration
+  .
+  (identifier) @local.definition.constant)
+
+(enum_declaration
+  .
+  (identifier) @local.definition.enum)
+
+(member_declaration
+  (identifier) @local.definition.field
+  .
+  "=")
+
+(table_slot
+  .
+  (identifier) @local.definition.field
+  .
+  [
+    "="
+    ":"
+  ])
+
+((function_declaration
+  .
+  (identifier) @local.definition.function)
+  (#not-has-ancestor? @local.definition.function member_declaration))
+
+(member_declaration
+  (function_declaration
+    .
+    (identifier) @local.definition.method))
+
+(class_declaration
+  .
+  (identifier) @local.definition.type)
+
+(var_statement
+  "var"
+  .
+  (identifier) @local.definition.var)
+
+(local_declaration
+  (identifier) @local.definition.var
+  .
+  "=")
diff --git a/pack/ant/start/nvim-treesitter/queries/ssh_config/folds.scm b/pack/ant/start/nvim-treesitter/queries/ssh_config/folds.scm
new file mode 100644
index 0000000..6598356
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ssh_config/folds.scm
@@ -0,0 +1,4 @@
+[
+  (host_declaration)
+  (match_declaration)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/ssh_config/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ssh_config/highlights.scm
new file mode 100644
index 0000000..9338eee
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ssh_config/highlights.scm
@@ -0,0 +1,106 @@
+; Literals
+(string) @string
+
+(pattern) @string.regexp
+
+(token) @character
+
+[
+  (number)
+  (bytes)
+  (time)
+] @number
+
+[
+  (kex)
+  (mac)
+  (cipher)
+  (key_sig)
+] @variable.parameter
+
+[
+  ; generic
+  "yes"
+  "no"
+  "ask"
+  "auto"
+  "none"
+  "any"
+  ; ControlMaster
+  "autoask"
+  ; FingerprintHash
+  "md5"
+  "sha256"
+  ; PubkeyAuthentication
+  "unbound"
+  "host-bound"
+  ; RequestTTY
+  "force"
+  ; SessionType
+  "subsystem"
+  "default"
+  ; StrictHostKeyChecking
+  "accept-new"
+  "off"
+  ; Tunnel
+  "point-to-point"
+  "ethernet"
+  (ipqos)
+  (verbosity)
+  (facility)
+  (authentication)
+] @constant.builtin
+
+(uri) @string.special.url
+
+; Keywords
+[
+  "Host"
+  "Match"
+] @keyword
+
+(parameter
+  keyword: _ @keyword)
+
+(host_declaration
+  argument: _ @module)
+
+(match_declaration
+  (condition
+    criteria: _ @attribute))
+
+"all" @attribute
+
+; Misc
+[
+  "SSH_AUTH_SOCK"
+  (variable)
+] @constant
+
+(comment) @comment @spell
+
+; Punctuation
+[
+  "${"
+  "}"
+] @punctuation.special
+
+[
+  "\""
+  ","
+  ":"
+  "@"
+] @punctuation.delimiter
+
+[
+  "="
+  "!"
+  "+"
+  "-"
+  "^"
+] @operator
+
+[
+  "*"
+  "?"
+] @character.special
diff --git a/pack/ant/start/nvim-treesitter/queries/ssh_config/indents.scm b/pack/ant/start/nvim-treesitter/queries/ssh_config/indents.scm
new file mode 100644
index 0000000..760707f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ssh_config/indents.scm
@@ -0,0 +1,12 @@
+[
+  (host_declaration)
+  (match_declaration)
+] @indent.begin
+
+; incomplete declarations
+(ERROR
+  .
+  [
+    "Host"
+    "Match"
+  ]) @indent.begin
diff --git a/pack/ant/start/nvim-treesitter/queries/ssh_config/injections.scm b/pack/ant/start/nvim-treesitter/queries/ssh_config/injections.scm
new file mode 100644
index 0000000..d1b24be
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ssh_config/injections.scm
@@ -0,0 +1,17 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((condition
+  criteria: "exec"
+  argument: (string) @injection.content)
+  (#set! injection.language "bash"))
+
+((parameter
+  keyword: [
+    "KnownHostsCommand"
+    "LocalCommand"
+    "RemoteCommand"
+    "ProxyCommand"
+  ]
+  argument: (string) @injection.content)
+  (#set! injection.language "bash"))
diff --git a/pack/ant/start/nvim-treesitter/queries/ssh_config/locals.scm b/pack/ant/start/nvim-treesitter/queries/ssh_config/locals.scm
new file mode 100644
index 0000000..a3309a9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ssh_config/locals.scm
@@ -0,0 +1,7 @@
+(parameter
+  keyword: "Tag"
+  argument: (string) @local.reference)
+
+(condition
+  criteria: "tagged"
+  argument: (pattern) @local.definition)
diff --git a/pack/ant/start/nvim-treesitter/queries/starlark/folds.scm b/pack/ant/start/nvim-treesitter/queries/starlark/folds.scm
new file mode 100644
index 0000000..0c9d2a2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/starlark/folds.scm
@@ -0,0 +1,17 @@
+[
+  (function_definition)
+  (for_statement)
+  (if_statement)
+  (while_statement)
+  (with_statement)
+  (match_statement)
+  (parameters)
+  (argument_list)
+  (parenthesized_expression)
+  (list_comprehension)
+  (dictionary_comprehension)
+  (tuple)
+  (list)
+  (dictionary)
+  (string)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/starlark/highlights.scm b/pack/ant/start/nvim-treesitter/queries/starlark/highlights.scm
new file mode 100644
index 0000000..fe3dce8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/starlark/highlights.scm
@@ -0,0 +1,337 @@
+; From tree-sitter-python licensed under MIT License
+; Copyright (c) 2016 Max Brunsfeld
+; Variables
+(identifier) @variable
+
+; Reset highlighting in f-string interpolations
+(interpolation) @none
+
+; Identifier naming conventions
+((identifier) @type
+  (#lua-match? @type "^[A-Z].*[a-z]"))
+
+((identifier) @constant
+  (#lua-match? @constant "^[A-Z][A-Z_0-9]*$"))
+
+((identifier) @constant.builtin
+  (#lua-match? @constant.builtin "^__[a-zA-Z0-9_]*__$"))
+
+((identifier) @constant.builtin
+  (#any-of? @constant.builtin
+    ; https://docs.python.org/3/library/constants.html
+    "NotImplemented" "Ellipsis" "quit" "exit" "copyright" "credits" "license"))
+
+((attribute
+  attribute: (identifier) @variable.member)
+  (#lua-match? @variable.member "^[%l_].*$"))
+
+((assignment
+  left: (identifier) @type.definition
+  (type
+    (identifier) @_annotation))
+  (#eq? @_annotation "TypeAlias"))
+
+((assignment
+  left: (identifier) @type.definition
+  right: (call
+    function: (identifier) @_func))
+  (#any-of? @_func "TypeVar" "NewType"))
+
+; Decorators
+((decorator
+  "@" @attribute)
+  (#set! priority 101))
+
+(decorator
+  (identifier) @attribute)
+
+(decorator
+  (attribute
+    attribute: (identifier) @attribute))
+
+(decorator
+  (call
+    (identifier) @attribute))
+
+(decorator
+  (call
+    (attribute
+      attribute: (identifier) @attribute)))
+
+((decorator
+  (identifier) @attribute.builtin)
+  (#any-of? @attribute.builtin "classmethod" "property"))
+
+; Builtin functions
+((call
+  function: (identifier) @function.builtin)
+  (#any-of? @function.builtin
+    "abs" "all" "any" "ascii" "bin" "bool" "breakpoint" "bytearray" "bytes" "callable" "chr"
+    "classmethod" "compile" "complex" "delattr" "dict" "dir" "divmod" "enumerate" "eval" "exec"
+    "fail" "filter" "float" "format" "frozenset" "getattr" "globals" "hasattr" "hash" "help" "hex"
+    "id" "input" "int" "isinstance" "issubclass" "iter" "len" "list" "locals" "map" "max"
+    "memoryview" "min" "next" "object" "oct" "open" "ord" "pow" "print" "property" "range" "repr"
+    "reversed" "round" "set" "setattr" "slice" "sorted" "staticmethod" "str" "struct" "sum" "super"
+    "tuple" "type" "vars" "zip" "__import__"))
+
+; Function definitions
+(function_definition
+  name: (identifier) @function)
+
+(type
+  (identifier) @type)
+
+(type
+  (subscript
+    (identifier) @type)) ; type subscript: Tuple[int]
+
+((call
+  function: (identifier) @_isinstance
+  arguments: (argument_list
+    (_)
+    (identifier) @type))
+  (#eq? @_isinstance "isinstance"))
+
+((identifier) @type.builtin
+  (#any-of? @type.builtin
+    ; https://docs.python.org/3/library/exceptions.html
+    "ArithmeticError" "BufferError" "LookupError" "AssertionError" "AttributeError" "EOFError"
+    "FloatingPointError" "ModuleNotFoundError" "IndexError" "KeyError" "KeyboardInterrupt"
+    "MemoryError" "NameError" "NotImplementedError" "OSError" "OverflowError" "RecursionError"
+    "ReferenceError" "RuntimeError" "StopIteration" "StopAsyncIteration" "SyntaxError"
+    "IndentationError" "TabError" "SystemError" "SystemExit" "TypeError" "UnboundLocalError"
+    "UnicodeError" "UnicodeEncodeError" "UnicodeDecodeError" "UnicodeTranslateError" "ValueError"
+    "ZeroDivisionError" "EnvironmentError" "IOError" "WindowsError" "BlockingIOError"
+    "ChildProcessError" "ConnectionError" "BrokenPipeError" "ConnectionAbortedError"
+    "ConnectionRefusedError" "ConnectionResetError" "FileExistsError" "FileNotFoundError"
+    "InterruptedError" "IsADirectoryError" "NotADirectoryError" "PermissionError"
+    "ProcessLookupError" "TimeoutError" "Warning" "UserWarning" "DeprecationWarning"
+    "PendingDeprecationWarning" "SyntaxWarning" "RuntimeWarning" "FutureWarning" "UnicodeWarning"
+    "BytesWarning" "ResourceWarning"
+    ; https://docs.python.org/3/library/stdtypes.html
+    "bool" "int" "float" "complex" "list" "tuple" "range" "str" "bytes" "bytearray" "memoryview"
+    "set" "frozenset" "dict" "type"))
+
+; Normal parameters
+(parameters
+  (identifier) @variable.parameter)
+
+; Lambda parameters
+(lambda_parameters
+  (identifier) @variable.parameter)
+
+(lambda_parameters
+  (tuple_pattern
+    (identifier) @variable.parameter))
+
+; Default parameters
+(keyword_argument
+  name: (identifier) @variable.parameter)
+
+; Naming parameters on call-site
+(default_parameter
+  name: (identifier) @variable.parameter)
+
+(typed_parameter
+  (identifier) @variable.parameter)
+
+(typed_default_parameter
+  (identifier) @variable.parameter)
+
+; Variadic parameters *args, **kwargs
+(parameters
+  (list_splat_pattern
+    ; *args
+    (identifier) @variable.parameter))
+
+(parameters
+  (dictionary_splat_pattern
+    ; **kwargs
+    (identifier) @variable.parameter))
+
+; Literals
+(none) @constant.builtin
+
+[
+  (true)
+  (false)
+] @boolean
+
+((identifier) @variable.builtin
+  (#eq? @variable.builtin "self"))
+
+((identifier) @variable.builtin
+  (#eq? @variable.builtin "cls"))
+
+(integer) @number
+
+(float) @number.float
+
+(comment) @comment @spell
+
+((module
+  .
+  (comment) @keyword.directive @nospell)
+  (#lua-match? @keyword.directive "^#!/"))
+
+(string) @string
+
+[
+  (escape_sequence)
+  (escape_interpolation)
+] @string.escape
+
+; doc-strings
+(module
+  .
+  (expression_statement
+    (string) @string.documentation @spell))
+
+(function_definition
+  body: (block
+    .
+    (expression_statement
+      (string) @string.documentation @spell)))
+
+; Tokens
+[
+  "-"
+  "-="
+  ":="
+  "!="
+  "*"
+  "**"
+  "**="
+  "*="
+  "/"
+  "//"
+  "//="
+  "/="
+  "&"
+  "&="
+  "%"
+  "%="
+  "^"
+  "^="
+  "+"
+  "+="
+  "<"
+  "<<"
+  "<<="
+  "<="
+  "<>"
+  "="
+  "=="
+  ">"
+  ">="
+  ">>"
+  ">>="
+  "@"
+  "@="
+  "|"
+  "|="
+  "~"
+  "->"
+] @operator
+
+; Keywords
+[
+  "and"
+  "in"
+  "not"
+  "or"
+  "del"
+] @keyword.operator
+
+[
+  "def"
+  "lambda"
+] @keyword.function
+
+[
+  "async"
+  "exec"
+  "pass"
+  "print"
+  "with"
+  "as"
+] @keyword
+
+"async" @keyword.coroutine
+
+"return" @keyword.return
+
+((call
+  function: (identifier) @keyword.import
+  arguments: (argument_list
+    (string) @string))
+  (#eq? @keyword.import "load"))
+
+[
+  "if"
+  "elif"
+  "else"
+  "match"
+  "case"
+] @keyword.conditional
+
+[
+  "for"
+  "while"
+  "break"
+  "continue"
+] @keyword.repeat
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+(interpolation
+  "{" @punctuation.special
+  "}" @punctuation.special)
+
+(type_conversion) @function.macro
+
+[
+  ","
+  "."
+  ":"
+  ";"
+  (ellipsis)
+] @punctuation.delimiter
+
+; Starlark-specific
+; Assertion calls
+(assert_keyword) @keyword
+
+(assert_builtin) @function.builtin
+
+; Struct definitions
+((call
+  function: (identifier) @_func
+  arguments: (argument_list
+    (keyword_argument
+      name: (identifier) @variable.member)))
+  (#eq? @_func "struct"))
+
+; Function calls
+(call
+  function: (identifier) @function.call)
+
+(call
+  function: (attribute
+    attribute: (identifier) @function.method.call))
+
+((call
+  function: (identifier) @constructor)
+  (#lua-match? @constructor "^[A-Z]"))
+
+((call
+  function: (attribute
+    attribute: (identifier) @constructor))
+  (#lua-match? @constructor "^[A-Z]"))
diff --git a/pack/ant/start/nvim-treesitter/queries/starlark/indents.scm b/pack/ant/start/nvim-treesitter/queries/starlark/indents.scm
new file mode 100644
index 0000000..1aeb9f6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/starlark/indents.scm
@@ -0,0 +1,56 @@
+[
+  (list)
+  (dictionary)
+  (set)
+  (for_statement)
+  (if_statement)
+  (while_statement)
+  (with_statement)
+  (parenthesized_expression)
+  (dictionary_comprehension)
+  (list_comprehension)
+  (set_comprehension)
+  (tuple_pattern)
+  (list_pattern)
+  (binary_operator)
+  (lambda)
+  (function_definition)
+] @indent.begin
+
+(if_statement
+  condition: (parenthesized_expression) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+((ERROR
+  "("
+  .
+  (_)) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+((argument_list) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+((argument_list) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+((parameters) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+((tuple) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+[
+  ")"
+  "]"
+  "}"
+  (elif_clause)
+  (else_clause)
+] @indent.branch
+
+(string) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/starlark/injections.scm b/pack/ant/start/nvim-treesitter/queries/starlark/injections.scm
new file mode 100644
index 0000000..2b60646
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/starlark/injections.scm
@@ -0,0 +1 @@
+; inherits python
diff --git a/pack/ant/start/nvim-treesitter/queries/starlark/locals.scm b/pack/ant/start/nvim-treesitter/queries/starlark/locals.scm
new file mode 100644
index 0000000..82ec0b5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/starlark/locals.scm
@@ -0,0 +1,96 @@
+; Program structure
+(module) @local.scope
+
+; Function with parameters, defines parameters
+(parameters
+  (identifier) @local.definition.parameter)
+
+(default_parameter
+  (identifier) @local.definition.parameter)
+
+(typed_parameter
+  (identifier) @local.definition.parameter)
+
+(typed_default_parameter
+  (identifier) @local.definition.parameter)
+
+; *args parameter
+(parameters
+  (list_splat_pattern
+    (identifier) @local.definition.parameter))
+
+; **kwargs parameter
+(parameters
+  (dictionary_splat_pattern
+    (identifier) @local.definition.parameter))
+
+; Function defines function and scope
+((function_definition
+  name: (identifier) @local.definition.function) @local.scope
+  (#set! definition.function.scope "parent"))
+
+; Loops
+; not a scope!
+(for_statement
+  left: (pattern_list
+    (identifier) @local.definition.var))
+
+(for_statement
+  left: (tuple_pattern
+    (identifier) @local.definition.var))
+
+(for_statement
+  left: (identifier) @local.definition.var)
+
+; for in list comprehension
+(for_in_clause
+  left: (identifier) @local.definition.var)
+
+(for_in_clause
+  left: (tuple_pattern
+    (identifier) @local.definition.var))
+
+(for_in_clause
+  left: (pattern_list
+    (identifier) @local.definition.var))
+
+(dictionary_comprehension) @local.scope
+
+(list_comprehension) @local.scope
+
+(set_comprehension) @local.scope
+
+; Assignments
+(assignment
+  left: (identifier) @local.definition.var)
+
+(assignment
+  left: (pattern_list
+    (identifier) @local.definition.var))
+
+(assignment
+  left: (tuple_pattern
+    (identifier) @local.definition.var))
+
+(assignment
+  left: (attribute
+    (identifier)
+    (identifier) @local.definition.field))
+
+; Walrus operator  x := 1
+(named_expression
+  (identifier) @local.definition.var)
+
+(as_pattern
+  alias: (as_pattern_target) @local.definition.var)
+
+; REFERENCES
+(identifier) @local.reference
+
+; Starlark-specific
+; Loads
+((call
+  function: (identifier) @_fn
+  arguments: (argument_list
+    (string) @local.definition.import))
+  (#eq? @_fn "load"))
diff --git a/pack/ant/start/nvim-treesitter/queries/strace/highlights.scm b/pack/ant/start/nvim-treesitter/queries/strace/highlights.scm
new file mode 100644
index 0000000..70a14fd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/strace/highlights.scm
@@ -0,0 +1,56 @@
+[
+  "killed"
+  "by"
+  "exited"
+  "with"
+  "<unfinished ...>"
+  "<..."
+  "resumed>"
+] @keyword
+
+[
+  (errorName)
+  (errorDescription)
+] @keyword.exception
+
+(syscall) @function.builtin
+
+; Literals
+[
+  (integer)
+  (pointer)
+] @number
+
+(value) @label
+
+(string) @string
+
+[
+  "="
+  "|"
+  "*"
+  "&&"
+  "=="
+] @operator
+
+; Punctuation
+[
+  "+++"
+  "---"
+  "..."
+  "~"
+] @punctuation.special
+
+[
+  "("
+  ")"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ","
+  "=>"
+] @punctuation.delimiter
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/strace/injections.scm b/pack/ant/start/nvim-treesitter/queries/strace/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/strace/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/styled/folds.scm b/pack/ant/start/nvim-treesitter/queries/styled/folds.scm
new file mode 100644
index 0000000..cbe4187
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/styled/folds.scm
@@ -0,0 +1 @@
+; inherits: css
diff --git a/pack/ant/start/nvim-treesitter/queries/styled/highlights.scm b/pack/ant/start/nvim-treesitter/queries/styled/highlights.scm
new file mode 100644
index 0000000..cbe4187
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/styled/highlights.scm
@@ -0,0 +1 @@
+; inherits: css
diff --git a/pack/ant/start/nvim-treesitter/queries/styled/indents.scm b/pack/ant/start/nvim-treesitter/queries/styled/indents.scm
new file mode 100644
index 0000000..cbe4187
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/styled/indents.scm
@@ -0,0 +1 @@
+; inherits: css
diff --git a/pack/ant/start/nvim-treesitter/queries/styled/injections.scm b/pack/ant/start/nvim-treesitter/queries/styled/injections.scm
new file mode 100644
index 0000000..cbe4187
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/styled/injections.scm
@@ -0,0 +1 @@
+; inherits: css
diff --git a/pack/ant/start/nvim-treesitter/queries/supercollider/folds.scm b/pack/ant/start/nvim-treesitter/queries/supercollider/folds.scm
new file mode 100644
index 0000000..2f5f104
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/supercollider/folds.scm
@@ -0,0 +1,6 @@
+[
+  (function_call)
+  (code_block)
+  (function_block)
+  (control_structure)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/supercollider/highlights.scm b/pack/ant/start/nvim-treesitter/queries/supercollider/highlights.scm
new file mode 100644
index 0000000..c56bce6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/supercollider/highlights.scm
@@ -0,0 +1,103 @@
+; highlights.scm
+; See this for full list: https://github.com/nvim-treesitter/nvim-treesitter/blob/master/CONTRIBUTING.md
+; comments
+(line_comment) @comment @spell
+
+(block_comment) @comment @spell
+
+; Argument definition
+(argument
+  name: (identifier) @variable.parameter)
+
+; Variables
+(local_var
+  name: (identifier) @variable)
+
+(environment_var
+  name: (identifier) @variable.builtin)
+
+(builtin_var) @constant.builtin
+
+; (variable) @variable
+; Functions
+(function_definition
+  name: (variable) @function)
+
+; For function calls
+(named_argument
+  name: (identifier) @function.call)
+
+; Methods
+(method_call
+  name: (method_name) @function.method.call)
+
+; Classes
+(class) @type
+
+; Literals
+(number) @number
+
+(float) @number.float
+
+(string) @string
+
+(symbol) @string.special.symbol
+
+; Operators
+[
+  "&&"
+  "||"
+  "&"
+  "|"
+  "^"
+  "=="
+  "!="
+  "<"
+  "<="
+  ">"
+  ">="
+  "<<"
+  ">>"
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "="
+] @operator
+
+; Keywords
+[
+  "arg"
+  "classvar"
+  "const"
+  ; "super"
+  ; "this"
+  "var"
+] @keyword
+
+; Brackets
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  "|"
+] @punctuation.bracket
+
+; Delimiters
+[
+  ";"
+  "."
+  ","
+] @punctuation.delimiter
+
+; control structure
+(control_structure) @keyword.conditional
+
+(escape_sequence) @string.escape
+
+; SinOsc.ar()!2
+(duplicated_statement) @keyword.repeat
diff --git a/pack/ant/start/nvim-treesitter/queries/supercollider/indents.scm b/pack/ant/start/nvim-treesitter/queries/supercollider/indents.scm
new file mode 100644
index 0000000..c0cffab
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/supercollider/indents.scm
@@ -0,0 +1,33 @@
+[
+  (function_block)
+  (binary_expression)
+  (collection)
+  (indexed_collection)
+  (parameter_call_list)
+  (function_call)
+  (class_def)
+  (classvar)
+  (const)
+  (instance_var)
+  (variable_definition)
+  (variable_definition_sequence
+    (variable_definition))
+  (control_structure)
+  (return_statement)
+] @indent.begin
+
+[
+  (parameter_call_list
+    (argument_calls))
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @indent.branch
+
+[
+  (block_comment)
+  (line_comment)
+] @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/supercollider/injections.scm b/pack/ant/start/nvim-treesitter/queries/supercollider/injections.scm
new file mode 100644
index 0000000..3cd6aac
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/supercollider/injections.scm
@@ -0,0 +1,5 @@
+([
+  (line_comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/supercollider/locals.scm b/pack/ant/start/nvim-treesitter/queries/supercollider/locals.scm
new file mode 100644
index 0000000..066bbf9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/supercollider/locals.scm
@@ -0,0 +1,29 @@
+; Scopes
+[
+  (function_call)
+  (code_block)
+  (function_block)
+  (control_structure)
+] @local.scope
+
+; Definitions
+(argument
+  name: (identifier) @local.definition.parameter
+  (#set! definition.var.scope "local"))
+
+(variable_definition
+  name: (variable
+    (local_var
+      (identifier) @local.definition.var)))
+
+(variable_definition
+  name: (variable
+    (environment_var
+      (identifier) @local.definition.var))
+  (#set! definition.var.scope "global"))
+
+(function_definition
+  name: (variable) @local.definition.var
+  (#set! definition.var.scope "parent"))
+
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/superhtml/highlights.scm b/pack/ant/start/nvim-treesitter/queries/superhtml/highlights.scm
new file mode 100644
index 0000000..cbf366d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/superhtml/highlights.scm
@@ -0,0 +1,44 @@
+(doctype) @constant
+
+(comment) @comment
+
+(tag_name) @tag
+
+((tag_name) @string.special
+  (#any-of? @string.special "super" "extend"))
+
+(attribute_name) @attribute
+
+(attribute_value) @string
+
+((element
+  (start_tag
+    (attribute
+      (attribute_name) @_attribute
+      [
+        (attribute_value) @markup.link.url
+        (quoted_attribute_value
+          (attribute_value) @markup.link.url)
+      ]))
+  (element
+    (start_tag
+      (tag_name) @tag)))
+  (#eq? @tag "super")
+  (#eq? @_attribute "id"))
+
+(element
+  (start_tag
+    (tag_name) @string.special)
+  (#eq? @string.special "super"))
+
+"\"" @string
+
+[
+  "<"
+  ">"
+  "</"
+  "/>"
+  "<!"
+] @punctuation.bracket
+
+"=" @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/superhtml/injections.scm b/pack/ant/start/nvim-treesitter/queries/superhtml/injections.scm
new file mode 100644
index 0000000..138fe7c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/superhtml/injections.scm
@@ -0,0 +1,7 @@
+((script_element
+  (raw_text) @injection.content)
+  (#set! injection.language "javascript"))
+
+((style_element
+  (raw_text) @injection.content)
+  (#set! injection.language "css"))
diff --git a/pack/ant/start/nvim-treesitter/queries/surface/folds.scm b/pack/ant/start/nvim-treesitter/queries/surface/folds.scm
new file mode 100644
index 0000000..994f12e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/surface/folds.scm
@@ -0,0 +1,6 @@
+; Surface folds similar to HTML and includes blocks
+[
+  (tag)
+  (component)
+  (block)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/surface/highlights.scm b/pack/ant/start/nvim-treesitter/queries/surface/highlights.scm
new file mode 100644
index 0000000..b874b8c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/surface/highlights.scm
@@ -0,0 +1,44 @@
+; Surface text is not highlighted
+(text) @none
+
+; Surface has two types of comments, both are highlighted as such
+(comment) @comment @spell
+
+; Surface attributes are highlighted as HTML attributes
+(attribute_name) @tag.attribute
+
+; Attributes are highlighted as strings
+(quoted_attribute_value) @string
+
+; Surface blocks are highlighted as keywords
+[
+  (start_block)
+  (end_block)
+  (subblock)
+] @keyword
+
+; Surface supports HTML tags and are highlighted as such
+[
+  "<"
+  ">"
+  "</"
+  "/>"
+  "{"
+  "}"
+  "<!--"
+  "-->"
+  "{!--"
+  "--}"
+] @tag.delimiter
+
+; Surface tags are highlighted as HTML
+(tag_name) @tag
+
+; Surface components are highlighted as types (Elixir modules)
+(component_name) @type
+
+; Surface directives are highlighted as keywords
+(directive_name) @keyword
+
+; Surface operators
+"=" @operator
diff --git a/pack/ant/start/nvim-treesitter/queries/surface/indents.scm b/pack/ant/start/nvim-treesitter/queries/surface/indents.scm
new file mode 100644
index 0000000..1df9fe6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/surface/indents.scm
@@ -0,0 +1,14 @@
+; Surface indents like HTML, with the addition of blocks
+[
+  (component)
+  (tag)
+  (block)
+] @indent.begin
+
+; Dedent at the end of each tag, as well as a subblock
+[
+  (end_tag)
+  (end_component)
+  (end_block)
+  (subblock)
+] @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/surface/injections.scm b/pack/ant/start/nvim-treesitter/queries/surface/injections.scm
new file mode 100644
index 0000000..72cab5e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/surface/injections.scm
@@ -0,0 +1,10 @@
+; Surface expressions and components are Elixir code
+([
+  (expression_value)
+  (component_name)
+] @injection.content
+  (#set! injection.language "elixir"))
+
+; Surface comments are nvim-treesitter comments
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/svelte/folds.scm b/pack/ant/start/nvim-treesitter/queries/svelte/folds.scm
new file mode 100644
index 0000000..6440301
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/svelte/folds.scm
@@ -0,0 +1,13 @@
+; inherits: html
+
+[
+  (if_statement)
+  (else_if_block)
+  (else_block)
+  (each_statement)
+  (await_statement)
+  (then_block)
+  (catch_block)
+  (key_statement)
+  (snippet_statement)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/svelte/highlights.scm b/pack/ant/start/nvim-treesitter/queries/svelte/highlights.scm
new file mode 100644
index 0000000..600eb99
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/svelte/highlights.scm
@@ -0,0 +1,42 @@
+; inherits: html
+
+(raw_text) @none
+
+[
+  "as"
+  "key"
+  "html"
+  "snippet"
+  "render"
+] @keyword
+
+"const" @keyword.modifier
+
+[
+  "if"
+  "else"
+  "then"
+] @keyword.conditional
+
+"each" @keyword.repeat
+
+[
+  "await"
+  "then"
+] @keyword.coroutine
+
+"catch" @keyword.exception
+
+"debug" @keyword.debug
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "#"
+  ":"
+  "/"
+  "@"
+] @tag.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/svelte/indents.scm b/pack/ant/start/nvim-treesitter/queries/svelte/indents.scm
new file mode 100644
index 0000000..0c67647
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/svelte/indents.scm
@@ -0,0 +1,34 @@
+; inherits: html
+
+[
+  (if_statement)
+  (each_statement)
+  (await_statement)
+  (key_statement)
+  (snippet_statement)
+] @indent.begin
+
+(if_end
+  "}" @indent.end)
+
+(each_end
+  "}" @indent.end)
+
+(await_end
+  "}" @indent.end)
+
+(key_end
+  "}" @indent.end)
+
+(snippet_end
+  "}" @indent.end)
+
+[
+  (if_end)
+  (else_if_block)
+  (else_block)
+  (each_end)
+  (await_end)
+  (key_end)
+  (snippet_end)
+] @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/svelte/injections.scm b/pack/ant/start/nvim-treesitter/queries/svelte/injections.scm
new file mode 100644
index 0000000..f20ae66
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/svelte/injections.scm
@@ -0,0 +1,47 @@
+; inherits: html_tags
+
+((style_element
+  (start_tag
+    (attribute
+      (attribute_name) @_attr
+      (quoted_attribute_value
+        (attribute_value) @_lang)))
+  (raw_text) @injection.content)
+  (#eq? @_attr "lang")
+  (#any-of? @_lang "scss" "postcss" "less")
+  (#set! injection.language "scss"))
+
+((svelte_raw_text) @injection.content
+  (#set! injection.language "javascript"))
+
+((script_element
+  (start_tag
+    (attribute
+      (attribute_name) @_attr
+      (quoted_attribute_value
+        (attribute_value) @_lang)))
+  (raw_text) @injection.content)
+  (#eq? @_attr "lang")
+  (#any-of? @_lang "ts" "typescript")
+  (#set! injection.language "typescript"))
+
+((script_element
+  (start_tag
+    (attribute
+      (attribute_name) @_attr
+      (quoted_attribute_value
+        (attribute_value) @_lang)))
+  (raw_text) @injection.content)
+  (#eq? @_attr "lang")
+  (#any-of? @_lang "js" "javascript")
+  (#set! injection.language "javascript"))
+
+((element
+  (start_tag
+    (attribute
+      (attribute_name) @_attr
+      (quoted_attribute_value
+        (attribute_value) @injection.language)))
+  (text) @injection.content)
+  (#eq? @_attr "lang")
+  (#eq? @injection.language "pug"))
diff --git a/pack/ant/start/nvim-treesitter/queries/svelte/locals.scm b/pack/ant/start/nvim-treesitter/queries/svelte/locals.scm
new file mode 100644
index 0000000..1f2129c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/svelte/locals.scm
@@ -0,0 +1 @@
+; inherits: html
diff --git a/pack/ant/start/nvim-treesitter/queries/swift/folds.scm b/pack/ant/start/nvim-treesitter/queries/swift/folds.scm
new file mode 100644
index 0000000..cfbc6d0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/swift/folds.scm
@@ -0,0 +1,35 @@
+; format-ignore
+[
+  (protocol_body)               ; protocol Foo { ... }
+  (class_body)                  ; class Foo { ... }
+  (enum_class_body)             ; enum Foo { ... }
+  (function_body)               ; func Foo (...) {...}
+  (computed_property)           ; { ... }
+
+  (computed_getter)             ; get { ... }
+  (computed_setter)             ; set { ... }
+
+  (do_statement)
+  (if_statement)
+  (for_statement)
+  (switch_statement)
+  (while_statement)
+  (guard_statement)
+  (switch_entry)
+
+  (type_parameters)             ; x<Foo>
+  (tuple_type)                  ; (...)
+  (array_type)                  ; [String]
+  (dictionary_type)             ; [Foo: Bar]
+
+  (call_expression)             ; callFunc(...)
+  (tuple_expression)            ; ( foo + bar )
+  (array_literal)               ; [ foo, bar ]
+  (dictionary_literal)          ; [ foo: bar, x: y ]
+  (lambda_literal) 
+  (willset_didset_block)
+  (willset_clause)
+  (didset_clause)
+
+  (import_declaration)+
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/swift/highlights.scm b/pack/ant/start/nvim-treesitter/queries/swift/highlights.scm
new file mode 100644
index 0000000..5c52ee9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/swift/highlights.scm
@@ -0,0 +1,347 @@
+[
+  "."
+  ";"
+  ":"
+  ","
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; Identifiers
+(type_identifier) @type
+
+[
+  (self_expression)
+  (super_expression)
+] @variable.builtin
+
+; Declarations
+[
+  "func"
+  "deinit"
+] @keyword.function
+
+[
+  (visibility_modifier)
+  (member_modifier)
+  (function_modifier)
+  (property_modifier)
+  (parameter_modifier)
+  (inheritance_modifier)
+  (mutation_modifier)
+] @keyword.modifier
+
+(simple_identifier) @variable
+
+(function_declaration
+  (simple_identifier) @function.method)
+
+(protocol_function_declaration
+  name: (simple_identifier) @function.method)
+
+(init_declaration
+  "init" @constructor)
+
+(parameter
+  external_name: (simple_identifier) @variable.parameter)
+
+(parameter
+  name: (simple_identifier) @variable.parameter)
+
+(type_parameter
+  (type_identifier) @variable.parameter)
+
+(inheritance_constraint
+  (identifier
+    (simple_identifier) @variable.parameter))
+
+(equality_constraint
+  (identifier
+    (simple_identifier) @variable.parameter))
+
+[
+  "protocol"
+  "extension"
+  "indirect"
+  "nonisolated"
+  "override"
+  "convenience"
+  "required"
+  "some"
+  "any"
+  "weak"
+  "unowned"
+  "didSet"
+  "willSet"
+  "subscript"
+  "let"
+  "var"
+  (throws)
+  (where_keyword)
+  (getter_specifier)
+  (setter_specifier)
+  (modify_specifier)
+  (else)
+  (as_operator)
+] @keyword
+
+[
+  "enum"
+  "struct"
+  "class"
+  "typealias"
+] @keyword.type
+
+[
+  "async"
+  "await"
+] @keyword.coroutine
+
+(shebang_line) @keyword.directive
+
+(class_body
+  (property_declaration
+    (pattern
+      (simple_identifier) @variable.member)))
+
+(protocol_property_declaration
+  (pattern
+    (simple_identifier) @variable.member))
+
+(navigation_expression
+  (navigation_suffix
+    (simple_identifier) @variable.member))
+
+(value_argument
+  name: (value_argument_label
+    (simple_identifier) @variable.member))
+
+(import_declaration
+  "import" @keyword.import)
+
+(enum_entry
+  "case" @keyword)
+
+(modifiers
+  (attribute
+    "@" @attribute
+    (user_type
+      (type_identifier) @attribute)))
+
+; Function calls
+(call_expression
+  (simple_identifier) @function.call) ; foo()
+
+(call_expression
+  ; foo.bar.baz(): highlight the baz()
+  (navigation_expression
+    (navigation_suffix
+      (simple_identifier) @function.call)))
+
+(call_expression
+  (prefix_expression
+    (simple_identifier) @function.call)) ; .foo()
+
+((navigation_expression
+  (simple_identifier) @type) ; SomeType.method(): highlight SomeType as a type
+  (#lua-match? @type "^[A-Z]"))
+
+(directive) @keyword.directive
+
+; See https://docs.swift.org/swift-book/documentation/the-swift-programming-language/lexicalstructure/#Keywords-and-Punctuation
+[
+  (diagnostic)
+  "#available"
+  "#unavailable"
+  "#fileLiteral"
+  "#colorLiteral"
+  "#imageLiteral"
+  "#keyPath"
+  "#selector"
+  "#externalMacro"
+] @function.macro
+
+[
+  "#column"
+  "#dsohandle"
+  "#fileID"
+  "#filePath"
+  "#file"
+  "#function"
+  "#line"
+] @constant.macro
+
+; Statements
+(for_statement
+  "for" @keyword.repeat)
+
+(for_statement
+  "in" @keyword.repeat)
+
+[
+  "while"
+  "repeat"
+  "continue"
+  "break"
+] @keyword.repeat
+
+(guard_statement
+  "guard" @keyword.conditional)
+
+(if_statement
+  "if" @keyword.conditional)
+
+(switch_statement
+  "switch" @keyword.conditional)
+
+(switch_entry
+  "case" @keyword)
+
+(switch_entry
+  "fallthrough" @keyword)
+
+(switch_entry
+  (default_keyword) @keyword)
+
+"return" @keyword.return
+
+(ternary_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+[
+  (try_operator)
+  "do"
+  (throw_keyword)
+  (catch_keyword)
+] @keyword.exception
+
+(statement_label) @label
+
+; Comments
+[
+  (comment)
+  (multiline_comment)
+] @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^///[^/]"))
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^///$"))
+
+((multiline_comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$"))
+
+; String literals
+(line_str_text) @string
+
+(str_escaped_char) @string.escape
+
+(multi_line_str_text) @string
+
+(raw_str_part) @string
+
+(raw_str_end_part) @string
+
+(line_string_literal
+  [
+    "\\("
+    ")"
+  ] @punctuation.special)
+
+(multi_line_string_literal
+  [
+    "\\("
+    ")"
+  ] @punctuation.special)
+
+(raw_str_interpolation
+  [
+    (raw_str_interpolation_start)
+    ")"
+  ] @punctuation.special)
+
+[
+  "\""
+  "\"\"\""
+] @string
+
+; Lambda literals
+(lambda_literal
+  "in" @keyword.operator)
+
+; Basic literals
+[
+  (integer_literal)
+  (hex_literal)
+  (oct_literal)
+  (bin_literal)
+] @number
+
+(real_literal) @number.float
+
+(boolean_literal) @boolean
+
+"nil" @constant.builtin
+
+(wildcard_pattern) @character.special
+
+; Regex literals
+(regex_literal) @string.regexp
+
+; Operators
+(custom_operator) @operator
+
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "="
+  "+="
+  "-="
+  "*="
+  "/="
+  "<"
+  ">"
+  "<<"
+  ">>"
+  "<="
+  ">="
+  "++"
+  "--"
+  "^"
+  "&"
+  "&&"
+  "|"
+  "||"
+  "~"
+  "%="
+  "!="
+  "!=="
+  "=="
+  "==="
+  "?"
+  "??"
+  "->"
+  "..<"
+  "..."
+  (bang)
+] @operator
+
+(type_arguments
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
diff --git a/pack/ant/start/nvim-treesitter/queries/swift/indents.scm b/pack/ant/start/nvim-treesitter/queries/swift/indents.scm
new file mode 100644
index 0000000..2366c3b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/swift/indents.scm
@@ -0,0 +1,122 @@
+; format-ignore
+[
+  ; ... refers to the section that will get affected by this indent.begin capture
+  (protocol_body)               ; protocol Foo { ... }
+  (class_body)                  ; class Foo { ... }
+  (enum_class_body)             ; enum Foo { ... }
+  (function_declaration)        ; func Foo (...) {...}
+  (init_declaration)            ; init(...) {...}
+  (deinit_declaration)          ; deinit {...}
+  (computed_property)           ; { ... }
+  (subscript_declaration)       ; subscript Foo(...) { ... }
+
+  (computed_getter)             ; get { ... }
+  (computed_setter)             ; set { ... }
+
+  (assignment)                  ; a = b
+
+  (control_transfer_statement)  ; return ...
+  (for_statement)
+  (while_statement)
+  (repeat_while_statement)
+  (do_statement)
+  (if_statement)
+  (switch_statement)
+  (guard_statement)
+
+  (type_parameters)             ; x<Foo>
+  (tuple_type)                  ; (...)
+  (array_type)                  ; [String]
+  (dictionary_type)             ; [Foo: Bar]
+
+  (call_expression)             ; callFunc(...)
+  (tuple_expression)            ; ( foo + bar )
+  (array_literal)               ; [ foo, bar ]
+  (dictionary_literal)          ; [ foo: bar, x: y ]
+  (lambda_literal) 
+  (willset_didset_block)
+  (willset_clause)
+  (didset_clause)
+] @indent.begin
+
+(init_declaration) @indent.begin
+
+(init_declaration
+  [
+    "init"
+    "("
+  ] @indent.branch)
+
+; indentation for init parameters
+(init_declaration
+  ")" @indent.branch @indent.end)
+
+(init_declaration
+  (parameter) @indent.begin
+  (#set! indent.immediate))
+
+; @something(...)
+(modifiers
+  (attribute) @indent.begin)
+
+(function_declaration
+  (modifiers
+    .
+    (attribute)
+    (_)* @indent.branch)
+  .
+  _ @indent.branch
+  (#not-kind-eq? @indent.branch "type_parameters" "parameter"))
+
+(ERROR
+  [
+    "<"
+    "{"
+    "("
+    "["
+  ]) @indent.begin
+
+; if-elseif
+(if_statement
+  (if_statement) @indent.dedent)
+
+; case Foo:
+; default Foo:
+; @attribute default Foo:
+(switch_entry
+  .
+  _ @indent.branch)
+
+(function_declaration
+  ")" @indent.branch)
+
+(type_parameters
+  ">" @indent.branch @indent.end .)
+
+(tuple_expression
+  ")" @indent.branch @indent.end)
+
+(value_arguments
+  ")" @indent.branch @indent.end)
+
+(tuple_type
+  ")" @indent.branch @indent.end)
+
+(modifiers
+  (attribute
+    ")" @indent.branch @indent.end))
+
+[
+  "}"
+  "]"
+] @indent.branch @indent.end
+
+[
+  ; (ERROR)
+  (comment)
+  (multiline_comment)
+  (raw_str_part)
+  (multi_line_string_literal)
+] @indent.auto
+
+(directive) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/swift/injections.scm b/pack/ant/start/nvim-treesitter/queries/swift/injections.scm
new file mode 100644
index 0000000..19aae90
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/swift/injections.scm
@@ -0,0 +1,5 @@
+([
+  (comment)
+  (multiline_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/swift/locals.scm b/pack/ant/start/nvim-treesitter/queries/swift/locals.scm
new file mode 100644
index 0000000..dc8a62e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/swift/locals.scm
@@ -0,0 +1,21 @@
+(import_declaration
+  (identifier) @local.definition.import)
+
+(function_declaration
+  name: (simple_identifier) @local.definition.function)
+
+; Scopes
+[
+  (statements)
+  (for_statement)
+  (while_statement)
+  (repeat_while_statement)
+  (do_statement)
+  (if_statement)
+  (guard_statement)
+  (switch_statement)
+  (property_declaration)
+  (function_declaration)
+  (class_declaration)
+  (protocol_declaration)
+] @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/sxhkdrc/folds.scm b/pack/ant/start/nvim-treesitter/queries/sxhkdrc/folds.scm
new file mode 100644
index 0000000..c6634aa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sxhkdrc/folds.scm
@@ -0,0 +1 @@
+(binding) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/sxhkdrc/highlights.scm b/pack/ant/start/nvim-treesitter/queries/sxhkdrc/highlights.scm
new file mode 100644
index 0000000..3f633a7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sxhkdrc/highlights.scm
@@ -0,0 +1,19 @@
+(modifier) @keyword
+
+(operator) @operator
+
+(attribute) @attribute
+
+(command_sync_prefix) @type
+
+(punctuation) @punctuation.bracket
+
+(delimiter) @punctuation.delimiter
+
+(keysym) @variable
+
+(comment) @comment @spell
+
+(range) @number
+
+"\\\n" @punctuation.special
diff --git a/pack/ant/start/nvim-treesitter/queries/sxhkdrc/injections.scm b/pack/ant/start/nvim-treesitter/queries/sxhkdrc/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/sxhkdrc/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/systemtap/folds.scm b/pack/ant/start/nvim-treesitter/queries/systemtap/folds.scm
new file mode 100644
index 0000000..58bb03e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/systemtap/folds.scm
@@ -0,0 +1,18 @@
+[
+  (preprocessor_macro_definition)
+  (preprocessor_macro_expansion)
+  (conditional_preprocessing)
+  (embedded_code)
+  (probe_point_definition)
+  (probe_point_alias_prologue)
+  (probe_point_alias_epilogue)
+  (variable_declaration)
+  (function_definition)
+  (if_statement)
+  (while_statement)
+  (for_statement)
+  (foreach_statement)
+  (try_statement)
+  (catch_clause)
+  (comment)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/systemtap/highlights.scm b/pack/ant/start/nvim-treesitter/queries/systemtap/highlights.scm
new file mode 100644
index 0000000..d1348dc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/systemtap/highlights.scm
@@ -0,0 +1,158 @@
+(identifier) @variable
+
+(preprocessor_macro_definition
+  name: (identifier) @function.macro)
+
+(preprocessor_macro_expansion) @function.macro
+
+(preprocessor_constant) @constant.macro
+
+(number) @number
+
+(string) @string
+
+(escape_sequence) @string.escape
+
+[
+  (script_argument_string)
+  (script_argument_number)
+] @constant
+
+(probe_point_component) @function
+
+(function_definition
+  name: (identifier) @function)
+
+(parameter
+  name: (identifier) @variable.parameter)
+
+(type) @type.builtin
+
+(aggregation_operator) @attribute
+
+(member_expression
+  member: (identifier) @variable.member)
+
+(call_expression
+  function: (identifier) @function.call)
+
+((call_expression
+  function: (identifier) @function.builtin)
+  (#any-of? @function.builtin
+    "print" "printd" "printdln" "printf" "println" "sprint" "sprintd" "sprintdln" "sprintf"
+    "sprintln"))
+
+((identifier) @variable.builtin
+  (#lua-match? @variable.builtin "^\$+[0-9A-Z_a-z]+\$*$"))
+
+(shebang_line) @keyword.directive
+
+(comment) @comment @spell
+
+[
+  "!"
+  "!="
+  "!~"
+  "$"
+  "$$"
+  "%"
+  "%="
+  "&"
+  "&&"
+  "&="
+  "*"
+  "*="
+  "+"
+  "++"
+  "+="
+  "-"
+  "--"
+  "-="
+  "->"
+  "."
+  ".="
+  "/"
+  "/="
+  ":"
+  "<"
+  "<<"
+  "<<<"
+  "<<="
+  "<="
+  "="
+  "=="
+  "=~"
+  ">"
+  ">="
+  ">>"
+  ">>="
+  "?"
+  "^"
+  "^="
+  "|"
+  "|="
+  "||"
+  "~"
+] @operator
+
+[
+  ","
+  (null_statement)
+] @punctuation.delimiter
+
+[
+  "%{"
+  "%}"
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "delete"
+  "limit"
+  "next"
+  "probe"
+] @keyword
+
+"function" @keyword.function
+
+"in" @keyword.operator
+
+"return" @keyword.return
+
+[
+  "if"
+  "else"
+] @keyword.conditional
+
+[
+  "break"
+  "continue"
+  "for"
+  "foreach"
+  "while"
+] @keyword.repeat
+
+[
+  "try"
+  "catch"
+] @keyword.exception
+
+[
+  "%("
+  "%)"
+  "%:"
+  "%?"
+  (preprocessor_tokens)
+  (embedded_code)
+] @keyword.directive
+
+"@define" @keyword.directive.define
+
+"private" @keyword.modifier
+
+"global" @keyword.modifier
diff --git a/pack/ant/start/nvim-treesitter/queries/systemtap/injections.scm b/pack/ant/start/nvim-treesitter/queries/systemtap/injections.scm
new file mode 100644
index 0000000..591df60
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/systemtap/injections.scm
@@ -0,0 +1,5 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((embedded_code) @injection.content
+  (#set! injection.language "c"))
diff --git a/pack/ant/start/nvim-treesitter/queries/systemtap/locals.scm b/pack/ant/start/nvim-treesitter/queries/systemtap/locals.scm
new file mode 100644
index 0000000..1505680
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/systemtap/locals.scm
@@ -0,0 +1,35 @@
+[
+  (function_definition)
+  (statement_block)
+  (if_statement)
+  (while_statement)
+  (for_statement)
+  (foreach_statement)
+  (catch_clause)
+] @local.scope
+
+(init_declarator
+  name: (identifier) @local.definition.var)
+
+(array_declarator
+  name: (identifier) @local.definition.var)
+
+(function_definition
+  name: (identifier) @local.definition.function)
+
+(parameter
+  name: (identifier) @local.definition.parameter)
+
+(tuple_capture
+  (identifier) @local.definition.var)
+
+(catch_clause
+  parameter: (identifier) @local.definition.var)
+
+(assignment_expression
+  left: (identifier) @local.definition.var)
+
+(call_expression
+  function: (identifier) @local.reference)
+
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/t32/folds.scm b/pack/ant/start/nvim-treesitter/queries/t32/folds.scm
new file mode 100644
index 0000000..fd7d239
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/t32/folds.scm
@@ -0,0 +1 @@
+(block) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/t32/highlights.scm b/pack/ant/start/nvim-treesitter/queries/t32/highlights.scm
new file mode 100644
index 0000000..9211a49
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/t32/highlights.scm
@@ -0,0 +1,223 @@
+; Keywords, punctuation and operators
+[
+  "="
+  "^^"
+  "||"
+  "&&"
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "|"
+  "^"
+  "=="
+  "!="
+  ">"
+  ">="
+  "<="
+  "<"
+  "<<"
+  ">>"
+  ".."
+  "--"
+  "++"
+  "+"
+  "-"
+  "~"
+  "!"
+  "&"
+  "->"
+  "*"
+  "-="
+  "+="
+  "*="
+  "/="
+  "%="
+  "|="
+  "&="
+  "^="
+  ">>="
+  "<<="
+  "--"
+  "++"
+] @operator
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ","
+  "."
+] @punctuation.delimiter
+
+[
+  "enum"
+  "struct"
+  "union"
+] @keyword.type
+
+"sizeof" @keyword.operator
+
+[
+  "const"
+  "volatile"
+] @keyword.modifier
+
+; Operators in comma and conditional HLL expressions
+(hll_comma_expression
+  "," @operator)
+
+(hll_conditional_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+; Strings and others literal types
+(access_class) @constant.builtin
+
+[
+  (address)
+  (bitmask)
+  (file_handle)
+  (integer)
+  (hll_number_literal)
+] @number
+
+[
+  (float)
+  (frequency)
+  (percentage)
+  (time)
+] @number.float
+
+[
+  (string)
+  (hll_string_literal)
+] @string
+
+(hll_escape_sequence) @string.escape
+
+(path) @string.special.path
+
+(symbol) @string.special.symbol
+
+[
+  (character)
+  (hll_char_literal)
+] @character
+
+; Types in HLL expressions
+[
+  (hll_type_identifier)
+  (hll_type_descriptor)
+] @type
+
+(hll_type_qualifier) @keyword.modifier
+
+(hll_primitive_type) @type.builtin
+
+; HLL expressions
+(hll_call_expression
+  function: (identifier) @function.call)
+
+(hll_call_expression
+  function: (hll_field_expression
+    field: (hll_field_identifier) @function.call))
+
+; HLL variables
+(identifier) @variable
+
+(hll_field_identifier) @variable.member
+
+; Commands
+(command_expression
+  command: (identifier) @keyword)
+
+(macro_definition
+  command: (identifier) @keyword)
+
+(call_expression
+  function: (identifier) @function.builtin)
+
+; Returns
+((command_expression
+  command: (identifier) @keyword.return)
+  (#match? @keyword.return "^[eE][nN][dD]([dD][oO])?$"))
+
+((command_expression
+  command: (identifier) @keyword.return)
+  (#lua-match? @keyword.return "^[rR][eE][tT][uU][rR][nN]$"))
+
+; Subroutine calls
+(subroutine_call_expression
+  command: (identifier) @keyword
+  subroutine: (identifier) @function.call)
+
+; Variables, constants and labels
+(macro) @variable.builtin
+
+(trace32_hll_variable) @variable.builtin
+
+(argument_list
+  (identifier) @constant.builtin)
+
+((argument_list
+  (identifier) @constant.builtin)
+  (#lua-match? @constant.builtin "^[%%/][%l%u][%l%u%d.]*$"))
+
+((command_expression
+  command: (identifier) @keyword
+  arguments: (argument_list
+    .
+    (identifier) @label))
+  (#lua-match? @keyword "^[gG][oO][tT][oO]$"))
+
+(labeled_expression
+  label: (identifier) @label)
+
+(option_expression
+  (identifier) @constant.builtin)
+
+(format_expression
+  (identifier) @constant.builtin)
+
+; Subroutine blocks
+(subroutine_block
+  command: (identifier) @keyword.function
+  subroutine: (identifier) @function)
+
+(labeled_expression
+  label: (identifier) @function
+  (block))
+
+; Parameter declarations
+(parameter_declaration
+  command: (identifier) @keyword
+  (identifier)? @constant.builtin
+  macro: (macro) @variable.parameter)
+
+; Control flow
+(if_block
+  command: (identifier) @keyword.conditional)
+
+(elif_block
+  command: (identifier) @keyword.conditional)
+
+(else_block
+  command: (identifier) @keyword.conditional)
+
+(while_block
+  command: (identifier) @keyword.repeat)
+
+(repeat_block
+  command: (identifier) @keyword.repeat)
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/t32/indents.scm b/pack/ant/start/nvim-treesitter/queries/t32/indents.scm
new file mode 100644
index 0000000..01d5f39
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/t32/indents.scm
@@ -0,0 +1,22 @@
+(block
+  ")" @indent.branch .) @indent.begin
+
+(if_block) @indent.begin
+
+(if_block
+  (block)) @indent.dedent
+
+(elif_block) @indent.branch
+
+(else_block) @indent.branch
+
+(else_block
+  (if_block) @indent.dedent)
+
+(while_block
+  (command_expression)) @indent.auto
+
+(repeat_block
+  (command_expression)) @indent.auto
+
+(comment) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/t32/injections.scm b/pack/ant/start/nvim-treesitter/queries/t32/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/t32/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/t32/locals.scm b/pack/ant/start/nvim-treesitter/queries/t32/locals.scm
new file mode 100644
index 0000000..91bf766
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/t32/locals.scm
@@ -0,0 +1,36 @@
+(block) @local.scope
+
+; Parameter definitions
+(parameter_declaration
+  command: (identifier)
+  macro: (macro) @local.definition.parameter)
+
+; Variable definitions
+(macro_definition
+  command: (identifier)
+  macro: (macro) @local.definition.var)
+
+(command_expression
+  command: (identifier)
+  arguments: (argument_list
+    declarator: (trace32_hll_variable) @local.definition.var))
+
+; Function definitions
+(subroutine_block
+  command: (identifier)
+  subroutine: (identifier) @local.definition.function)
+
+(labeled_expression
+  label: (identifier) @local.definition.function
+  (block))
+
+; References
+((subroutine_call_expression
+  command: (identifier)
+  subroutine: (identifier) @local.reference)
+  (#set! reference.kind "function"))
+
+[
+  (macro)
+  (trace32_hll_variable)
+] @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/tablegen/folds.scm b/pack/ant/start/nvim-treesitter/queries/tablegen/folds.scm
new file mode 100644
index 0000000..0e95ca5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tablegen/folds.scm
@@ -0,0 +1,13 @@
+[
+  (assert)
+  (class)
+  (multiclass)
+  (def)
+  (defm)
+  (defset)
+  (defvar)
+  (foreach)
+  (if)
+  (let)
+  (value_suffix)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/tablegen/highlights.scm b/pack/ant/start/nvim-treesitter/queries/tablegen/highlights.scm
new file mode 100644
index 0000000..c2f63b0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tablegen/highlights.scm
@@ -0,0 +1,159 @@
+; Preprocs
+(preprocessor_directive) @keyword.directive
+
+; Includes
+"include" @keyword.import
+
+; Keywords
+[
+  "assert"
+  "field"
+  "let"
+  "def"
+  "defm"
+  "defset"
+  "defvar"
+] @keyword
+
+[
+  "multiclass"
+  "class"
+] @keyword.type
+
+"in" @keyword.operator
+
+; Conditionals
+[
+  "if"
+  "else"
+  "then"
+] @keyword.conditional
+
+; Repeats
+"foreach" @keyword.repeat
+
+; Variables
+(identifier) @variable
+
+(var) @variable.builtin
+
+; Parameters
+(template_arg
+  (identifier) @variable.parameter)
+
+; Types
+(type) @type
+
+[
+  "bit"
+  "int"
+  "string"
+  "dag"
+  "bits"
+  "list"
+  "code"
+] @type.builtin
+
+(class
+  name: (identifier) @type)
+
+(multiclass
+  name: (identifier) @type)
+
+(def
+  name: (value
+    (_) @type))
+
+(defm
+  name: (value
+    (_) @type))
+
+(defset
+  name: (identifier) @type)
+
+(parent_class_list
+  (identifier) @type
+  (value
+    (_) @type)?)
+
+(anonymous_record
+  (identifier) @type)
+
+(anonymous_record
+  (value
+    (_) @type))
+
+((identifier) @type
+  (#lua-match? @type "^_*[A-Z][A-Z0-9_]+$"))
+
+; Fields
+(instruction
+  (identifier) @variable.member)
+
+(let_instruction
+  (identifier) @variable.member)
+
+; Functions
+([
+  (bang_operator)
+  (cond_operator)
+] @function
+  (#set! priority 105))
+
+; Operators
+[
+  "="
+  "#"
+  "-"
+  ":"
+  "..."
+] @operator
+
+; Literals
+(string) @string
+
+(code) @string.special
+
+(integer) @number
+
+(boolean) @boolean
+
+(uninitialized_value) @constant.builtin
+
+; Punctuation
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "<"
+  ">"
+] @punctuation.bracket
+
+[
+  "."
+  ","
+  ";"
+] @punctuation.delimiter
+
+"!" @punctuation.special
+
+; Comments
+[
+  (comment)
+  (multiline_comment)
+] @comment @spell
+
+((comment) @keyword.directive @nospell
+  (#lua-match? @keyword.directive "^.*RUN"))
diff --git a/pack/ant/start/nvim-treesitter/queries/tablegen/indents.scm b/pack/ant/start/nvim-treesitter/queries/tablegen/indents.scm
new file mode 100644
index 0000000..16748ed
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tablegen/indents.scm
@@ -0,0 +1,39 @@
+[
+  (assert)
+  (class)
+  (multiclass)
+  (def)
+  (defm)
+  (defvar)
+  (foreach)
+  (if)
+  (let)
+  (value_suffix)
+] @indent.begin
+
+[
+  "}"
+  "]"
+  ")"
+  ">"
+] @indent.end
+
+[
+  "{"
+  "}"
+] @indent.branch
+
+[
+  "["
+  "]"
+] @indent.branch
+
+[
+  "("
+  ")"
+] @indent.branch
+
+[
+  "<"
+  ">"
+] @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/tablegen/injections.scm b/pack/ant/start/nvim-treesitter/queries/tablegen/injections.scm
new file mode 100644
index 0000000..08390aa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tablegen/injections.scm
@@ -0,0 +1,9 @@
+((code) @injection.content
+  (#set! injection.language "cpp")
+  (#offset! @injection.content 0 2 0 -2))
+
+((tablegen_file
+  (comment) @injection.content)
+  (#lua-match? @injection.content "^.*RUN")
+  (#set! injection.language "bash")
+  (#offset! @injection.content 0 8))
diff --git a/pack/ant/start/nvim-treesitter/queries/tablegen/locals.scm b/pack/ant/start/nvim-treesitter/queries/tablegen/locals.scm
new file mode 100644
index 0000000..c731001
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tablegen/locals.scm
@@ -0,0 +1,51 @@
+; Scopes
+[
+  (class)
+  (multiclass)
+  (def)
+  (defm)
+  (defset)
+  (defvar)
+  (foreach)
+  (if)
+  (let)
+] @local.scope
+
+; References
+[
+  (var)
+  (identifier)
+] @local.reference
+
+; Definitions
+(instruction
+  (identifier) @local.definition.field)
+
+(let_instruction
+  (identifier) @local.definition.field)
+
+(include_directive
+  (string) @local.definition.import)
+
+(template_arg
+  (identifier) @local.definition.parameter)
+
+(class
+  name: (identifier) @local.definition.type)
+
+(multiclass
+  name: (identifier) @local.definition.type)
+
+(def
+  name: (value
+    (_) @local.definition.type))
+
+(defm
+  name: (value
+    (_) @local.definition.type))
+
+(defset
+  name: (identifier) @local.definition.type)
+
+(def_var
+  name: (identifier) @local.definition.var)
diff --git a/pack/ant/start/nvim-treesitter/queries/tact/folds.scm b/pack/ant/start/nvim-treesitter/queries/tact/folds.scm
new file mode 100644
index 0000000..66e7bda
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tact/folds.scm
@@ -0,0 +1,18 @@
+[
+  ; import …
+  (import)+
+  ; (…, …)
+  (parameter_list)
+  (argument_list)
+  ; {…, …}
+  (instance_argument_list)
+  ; {…; …}
+  (message_body)
+  (struct_body)
+  (contract_body)
+  (trait_body)
+  (function_body)
+  (block_statement)
+  (asm_function_body)
+  (asm_list)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/tact/highlights.scm b/pack/ant/start/nvim-treesitter/queries/tact/highlights.scm
new file mode 100644
index 0000000..d65b501
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tact/highlights.scm
@@ -0,0 +1,292 @@
+; variable
+; --------
+(identifier) @variable
+
+; variable.builtin
+; ----------------
+(self) @variable.builtin
+
+; variable.parameter
+; ------------------
+(parameter
+  name: (identifier) @variable.parameter)
+
+; punctuation.delimiter
+; ---------------------
+[
+  ";"
+  ","
+  "."
+  ":"
+  "?"
+] @punctuation.delimiter
+
+; punctuation.bracket
+; -------------------
+[
+  "("
+  ")"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; operator
+; --------
+[
+  "-"
+  "-="
+  "+"
+  "+="
+  "*"
+  "*="
+  "/"
+  "/="
+  "%"
+  "%="
+  "="
+  "=="
+  "!"
+  "!="
+  "!!"
+  "<"
+  "<="
+  "<<"
+  ">"
+  ">="
+  ">>"
+  "&"
+  "|"
+  "^"
+  "&&"
+  "||"
+  "->"
+] @operator
+
+; constructor
+; -----------
+(instance_expression
+  name: (identifier) @constructor)
+
+(initOf
+  name: (identifier) @constructor)
+
+; type
+; ----
+(type_identifier) @type
+
+; type.builtin
+; ------------
+((identifier) @type.builtin
+  (#any-of? @type.builtin "Context" "SendParameters" "StateInit" "StdAddress" "VarAddress"))
+
+(bounced_type
+  "bounced" @type.builtin
+  "<" @punctuation.bracket
+  ">" @punctuation.bracket)
+
+(map_type
+  "map" @type.builtin
+  "<" @punctuation.bracket
+  ">" @punctuation.bracket)
+
+((type_identifier) @type.builtin
+  (#any-of? @type.builtin "Address" "Bool" "Builder" "Cell" "Int" "Slice" "String" "StringBuilder"))
+
+(tlb_serialization
+  "as" @keyword
+  type: (identifier) @type.builtin)
+
+; string
+; ------
+(string) @string
+
+; string.escape
+; -------------
+(escape_sequence) @string.escape
+
+; string.special.path
+; -------------------
+(import
+  library: (string) @string.special.path)
+
+; boolean
+; -------
+(boolean) @boolean
+
+; constant
+; --------
+(global_constant
+  name: (identifier) @constant)
+
+(storage_constant
+  name: (identifier) @constant)
+
+; constant.builtin
+; ----------------
+(null) @constant.builtin
+
+((identifier) @constant.builtin
+  (#any-of? @constant.builtin
+    "SendBounceIfActionFail" "SendPayGasSeparately" "SendIgnoreErrors" "SendDestroyIfZero"
+    "SendRemainingValue" "SendRemainingBalance" "SendOnlyEstimateFee" "ReserveExact"
+    "ReserveAllExcept" "ReserveAtMost" "ReserveAddOriginalBalance" "ReserveInvertSign"
+    "ReserveBounceIfActionFail"))
+
+; property
+; --------
+(instance_argument
+  name: (identifier) @variable.member)
+
+(field_access_expression
+  name: (identifier) @variable.member)
+
+(field
+  name: (identifier) @variable.member)
+
+(storage_variable
+  name: (identifier) @variable.member)
+
+; number
+; ------
+(integer) @number
+
+; keyword
+; -------
+[
+  "with"
+  "const"
+  "let"
+  ; "public" ; -- not used, but declared in grammar.ohm
+  ; "extend" ; -- not used, but declared in grammar.ohm
+] @keyword
+
+; keyword.type
+; ------------
+[
+  "contract"
+  "trait"
+  "struct"
+  "message"
+] @keyword.type
+
+; keyword.function
+; ----------------
+[
+  "fun"
+  "native"
+  "asm"
+] @keyword.function
+
+; keyword.operator
+; ----------------
+"initOf" @keyword.operator
+
+; keyword.import
+; --------------
+"import" @keyword.import
+
+; keyword.modifier
+; ---------------
+[
+  "get"
+  "mutates"
+  "extends"
+  "virtual"
+  "override"
+  "inline"
+  "abstract"
+] @keyword.modifier
+
+; keyword.repeat
+; --------------
+(foreach_statement
+  .
+  (_)
+  .
+  (_)
+  .
+  "in" @keyword.repeat)
+
+[
+  "while"
+  "repeat"
+  "do"
+  "until"
+  "foreach"
+] @keyword.repeat
+
+; keyword.return
+; --------------
+"return" @keyword.return
+
+; keyword.exception
+; -----------------
+[
+  "try"
+  "catch"
+] @keyword.exception
+
+; keyword.conditional
+; -------------------
+[
+  "if"
+  "else"
+] @keyword.conditional
+
+; keyword.directive.define
+; ------------------------
+"primitive" @keyword.directive.define
+
+; function
+; --------
+(native_function
+  name: (identifier) @function)
+
+(asm_function
+  name: (identifier) @function)
+
+(global_function
+  name: (identifier) @function)
+
+(func_identifier) @function
+
+; function.method
+; ---------------
+(init_function
+  "init" @function.method)
+
+(receive_function
+  "receive" @function.method)
+
+(bounced_function
+  "bounced" @function.method)
+
+(external_function
+  "external" @function.method)
+
+(storage_function
+  name: (identifier) @function.method)
+
+; function.call
+; -------------
+(static_call_expression
+  name: (identifier) @function.call)
+
+; function.method.call
+; ---------------
+(method_call_expression
+  name: (identifier) @function.method.call)
+
+; attribute
+; ---------
+[
+  "@name"
+  "@interface"
+] @attribute
+
+; comment
+; -------
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$"))
diff --git a/pack/ant/start/nvim-treesitter/queries/tact/indents.scm b/pack/ant/start/nvim-treesitter/queries/tact/indents.scm
new file mode 100644
index 0000000..b26ce14
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tact/indents.scm
@@ -0,0 +1,52 @@
+; indent.begin       ; indent children when matching this node
+; ------------
+[
+  ; (..., ...)
+  (parameter_list)
+  (argument_list)
+  ; {..., ...}
+  (instance_argument_list)
+  ; {...; ...}
+  (message_body)
+  (struct_body)
+  (contract_body)
+  (trait_body)
+  (function_body)
+  (block_statement)
+  (asm_function_body)
+  (asm_list)
+  ; misc.
+  (binary_expression)
+  (ternary_expression)
+  (return_statement)
+  (static_call_expression)
+  (method_call_expression)
+] @indent.begin
+
+; indent.branch      ; dedent itself when matching this node
+; -------------
+[
+  "}"
+  ")"
+  ">"
+] @indent.branch
+
+; indent.end         ; marks the end of indented block
+; ----------
+[
+  "}"
+  ")"
+  ">"
+] @indent.end
+
+; indent.auto        ; behaves like 'autoindent' buffer option
+; -----------
+[
+  (comment)
+  (ERROR)
+] @indent.auto
+
+; indent.align       ; behaves like python aligned/hanging indent
+; indent.dedent      ; dedent children when matching this node
+; indent.ignore      ; do not indent in this node
+; indent.zero        ; sets this node at position 0 (no indent)
diff --git a/pack/ant/start/nvim-treesitter/queries/tact/injections.scm b/pack/ant/start/nvim-treesitter/queries/tact/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tact/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/tact/locals.scm b/pack/ant/start/nvim-treesitter/queries/tact/locals.scm
new file mode 100644
index 0000000..042afb9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tact/locals.scm
@@ -0,0 +1,83 @@
+; Scopes       @local.scope
+; -------------------------
+[
+  (asm_function)
+  (global_function)
+  (init_function)
+  (bounced_function)
+  (receive_function)
+  (external_function)
+  (storage_function)
+  (block_statement)
+] @local.scope
+
+; Definitions  @local.definition
+; ------------------------------
+; variables
+(storage_variable
+  name: (identifier) @local.definition.var)
+
+(let_statement
+  name: (identifier) @local.definition.var)
+
+; constants
+(global_constant
+  name: (identifier) @local.definition.constant)
+
+(storage_constant
+  name: (identifier) @local.definition.constant)
+
+; functions
+(asm_function
+  name: (identifier) @local.definition.function
+  (#set! definition.var.scope parent))
+
+(global_function
+  name: (identifier) @local.definition.function
+  (#set! definition.var.scope parent))
+
+; methods (functions off of contracts and traits)
+(init_function
+  "init" @local.definition.method
+  (#set! definition.var.scope parent))
+
+(bounced_function
+  "bounced" @local.definition.method
+  (#set! definition.var.scope parent))
+
+(receive_function
+  "receive" @local.definition.method
+  (#set! definition.var.scope parent))
+
+(external_function
+  "external" @local.definition.method
+  (#set! definition.var.scope parent))
+
+(storage_function
+  name: (identifier) @local.definition.method
+  (#set! definition.var.scope parent))
+
+; parameters
+(parameter
+  name: (identifier) @local.definition.parameter)
+
+; user-defined types (structs and messages)
+(type_identifier) @local.definition.type
+
+; fields (of messages and structs)
+(field
+  name: (identifier) @local.definition.field)
+
+; imports
+(import
+  (string) @local.definition.import)
+
+; References   @local.reference
+; -----------------------------
+(self) @local.reference
+
+(value_expression
+  (identifier) @local.reference)
+
+(field_access_expression
+  name: (identifier) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/tcl/folds.scm b/pack/ant/start/nvim-treesitter/queries/tcl/folds.scm
new file mode 100644
index 0000000..9084c66
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tcl/folds.scm
@@ -0,0 +1 @@
+(braced_word) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/tcl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/tcl/highlights.scm
new file mode 100644
index 0000000..c5f1f4c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tcl/highlights.scm
@@ -0,0 +1,114 @@
+(comment) @comment @spell
+
+(command
+  name: (simple_word) @function)
+
+"proc" @keyword.function
+
+(procedure
+  name: (_) @variable)
+
+(set
+  (simple_word) @variable)
+
+(argument
+  name: (_) @variable.parameter)
+
+((simple_word) @variable.builtin
+  (#any-of? @variable.builtin
+    "argc" "argv" "argv0" "auto_path" "env" "errorCode" "errorInfo" "tcl_interactive" "tcl_library"
+    "tcl_nonwordchars" "tcl_patchLevel" "tcl_pkgPath" "tcl_platform" "tcl_precision"
+    "tcl_rcFileName" "tcl_traceCompile" "tcl_traceExec" "tcl_wordchars" "tcl_version"))
+
+"expr" @function.builtin
+
+(command
+  name: (simple_word) @function.builtin
+  (#any-of? @function.builtin
+    "cd" "exec" "exit" "incr" "info" "join" "puts" "regexp" "regsub" "split" "subst" "trace"
+    "source"))
+
+(command
+  name: (simple_word) @keyword
+  (#any-of? @keyword
+    "append" "break" "catch" "continue" "default" "dict" "error" "eval" "global" "lappend" "lassign"
+    "lindex" "linsert" "list" "llength" "lmap" "lrange" "lrepeat" "lreplace" "lreverse" "lsearch"
+    "lset" "lsort" "package" "return" "switch" "throw" "unset" "variable"))
+
+[
+  "error"
+  "on"
+  "set"
+  "try"
+] @keyword
+
+"namespace" @keyword.type
+
+(unpack) @operator
+
+[
+  "while"
+  "foreach"
+] @keyword.repeat
+
+[
+  "if"
+  "else"
+  "elseif"
+] @keyword.conditional
+
+[
+  "**"
+  "/"
+  "*"
+  "%"
+  "+"
+  "-"
+  "<<"
+  ">>"
+  ">"
+  "<"
+  ">="
+  "<="
+  "=="
+  "!="
+  "eq"
+  "ne"
+  "in"
+  "ni"
+  "&"
+  "^"
+  "|"
+  "&&"
+  "||"
+] @operator
+
+(variable_substitution) @variable
+
+(quoted_word) @string
+
+(escaped_character) @string.escape
+
+[
+  "{"
+  "}"
+  "["
+  "]"
+  ";"
+] @punctuation.delimiter
+
+((simple_word) @number
+  (#lua-match? @number "^[0-9]+$"))
+
+((simple_word) @boolean
+  (#any-of? @boolean "true" "false"))
+
+; after apply array auto_execok auto_import auto_load auto_mkindex auto_qualify
+; auto_reset bgerror binary chan clock close coroutine dde encoding eof fblocked
+; fconfigure fcopy file fileevent filename flush format gets glob history http
+; interp load mathfunc mathop memory msgcat my next nextto open parray pid
+; pkg::create pkg_mkIndex platform platform::shell pwd re_syntax read refchan
+; registry rename safe scan seek self socket source string tailcall tcl::prefix
+; tcl_endOfWord tcl_findLibrary tcl_startOfNextWord tcl_startOfPreviousWord
+; tcl_wordBreakAfter tcl_wordBreakBefore tcltest tell time timerate tm
+; transchan unknown unload update uplevel upvar vwait yield yieldto zlib
diff --git a/pack/ant/start/nvim-treesitter/queries/tcl/indents.scm b/pack/ant/start/nvim-treesitter/queries/tcl/indents.scm
new file mode 100644
index 0000000..bc03553
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tcl/indents.scm
@@ -0,0 +1,25 @@
+[
+  (braced_word_simple)
+  (namespace)
+  (command)
+  (conditional)
+  (foreach)
+  (while)
+  (try)
+  (procedure)
+  (command_substitution)
+] @indent.begin
+
+(quoted_word) @indent.align
+
+([
+  (expr)
+  (arguments)
+] @indent.align
+  (#set! indent.open_delimiter "{")
+  (#set! indent.close_delimiter "}"))
+
+[
+  "}"
+  "]"
+] @indent.branch @indent.end
diff --git a/pack/ant/start/nvim-treesitter/queries/tcl/injections.scm b/pack/ant/start/nvim-treesitter/queries/tcl/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tcl/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/teal/folds.scm b/pack/ant/start/nvim-treesitter/queries/teal/folds.scm
new file mode 100644
index 0000000..27755de
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/teal/folds.scm
@@ -0,0 +1,13 @@
+[
+  (do_statement)
+  (numeric_for_statement)
+  (generic_for_statement)
+  (while_statement)
+  (repeat_statement)
+  (if_statement)
+  (function_statement)
+  (record_declaration)
+  (enum_declaration)
+  (anon_function)
+  (table_constructor)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/teal/highlights.scm b/pack/ant/start/nvim-treesitter/queries/teal/highlights.scm
new file mode 100644
index 0000000..e58d588
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/teal/highlights.scm
@@ -0,0 +1,237 @@
+; Primitives
+(boolean) @boolean
+
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^[-][-][-]"))
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^[-][-](%s?)@"))
+
+(shebang_comment) @keyword.directive
+
+(identifier) @variable
+
+((identifier) @variable.builtin
+  (#eq? @variable.builtin "self"))
+
+(nil) @constant.builtin
+
+(number) @number
+
+(string) @string
+
+(table_constructor
+  [
+    "{"
+    "}"
+  ] @constructor)
+
+(varargs
+  "..." @constant.builtin)
+
+[
+  ","
+  "."
+  ":"
+  ";"
+] @punctuation.delimiter
+
+(escape_sequence) @string.escape
+
+(format_specifier) @string.escape
+
+; Basic statements/Keywords
+[
+  "if"
+  "then"
+  "elseif"
+  "else"
+] @keyword.conditional
+
+[
+  "for"
+  "while"
+  "repeat"
+  "until"
+] @keyword.repeat
+
+"return" @keyword.return
+
+[
+  "in"
+  "local"
+  (break)
+  (goto)
+  "do"
+  "end"
+] @keyword
+
+(label) @label
+
+; Global isn't a real keyword, but it gets special treatment in these places
+(var_declaration
+  "global" @keyword)
+
+(type_declaration
+  "global" @keyword)
+
+(function_statement
+  "global" @keyword)
+
+(record_declaration
+  "global" @keyword)
+
+(enum_declaration
+  "global" @keyword)
+
+; Ops
+(bin_op
+  (op) @operator)
+
+(unary_op
+  (op) @operator)
+
+[
+  "="
+  "as"
+] @operator
+
+; Functions
+(function_statement
+  "function" @keyword.function
+  .
+  name: (_) @function)
+
+(anon_function
+  "function" @keyword.function)
+
+(function_body
+  "end" @keyword.function)
+
+(arg
+  name: (identifier) @variable.parameter)
+
+(function_signature
+  (arguments
+    .
+    (arg
+      name: (identifier) @variable.builtin))
+  (#eq? @variable.builtin "self"))
+
+(typeargs
+  "<" @punctuation.bracket
+  .
+  (_) @variable.parameter
+  .
+  (","
+    .
+    (_) @variable.parameter)*
+  .
+  ">" @punctuation.bracket)
+
+(function_call
+  (identifier) @function
+  .
+  (arguments))
+
+(function_call
+  (index
+    (_)
+    key: (identifier) @function)
+  .
+  (arguments))
+
+(function_call
+  (method_index
+    (_)
+    key: (identifier) @function)
+  .
+  (arguments))
+
+; Types
+(record_declaration
+  .
+  "record" @keyword.type
+  name: (identifier) @type)
+
+(anon_record
+  .
+  "record" @keyword.type)
+
+(record_body
+  (record_declaration
+    .
+    "record" @keyword.type
+    .
+    name: (identifier) @type))
+
+(record_body
+  (enum_declaration
+    .
+    "enum" @keyword.type
+    .
+    name: (identifier) @type))
+
+(record_body
+  (typedef
+    .
+    "type" @keyword
+    .
+    name: (identifier) @type
+    .
+    "="))
+
+(record_body
+  (metamethod
+    "metamethod" @keyword))
+
+(record_body
+  (userdata) @keyword)
+
+(enum_declaration
+  "enum" @keyword.type
+  name: (identifier) @type)
+
+(type_declaration
+  "type" @keyword)
+
+(type_declaration
+  (identifier) @type)
+
+(simple_type
+  name: (identifier) @type)
+
+(type_index
+  (identifier) @type)
+
+(type_union
+  "|" @operator)
+
+(function_type
+  "function" @type)
+
+; The rest of it
+(var_declaration
+  declarators: (var_declarators
+    (var
+      name: (identifier) @variable)))
+
+(var_declaration
+  declarators: (var_declarators
+    (var
+      "<" @punctuation.bracket
+      .
+      attribute: (attribute) @attribute
+      .
+      ">" @punctuation.bracket)))
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/teal/indents.scm b/pack/ant/start/nvim-treesitter/queries/teal/indents.scm
new file mode 100644
index 0000000..77b269c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/teal/indents.scm
@@ -0,0 +1,18 @@
+[
+  (record_declaration)
+  (anon_function)
+  (function_body)
+  (table_constructor)
+  (if_statement)
+  (return_statement)
+  (while_statement)
+] @indent.begin
+
+[
+  "{"
+  "}"
+  "("
+  ")"
+  "end"
+  "then"
+] @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/teal/injections.scm b/pack/ant/start/nvim-treesitter/queries/teal/injections.scm
new file mode 100644
index 0000000..830b745
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/teal/injections.scm
@@ -0,0 +1,43 @@
+((function_call
+  (index
+    (identifier) @_cdef_identifier)
+  (arguments
+    (string) @injection.content))
+  (#eq? @_cdef_identifier "cdef")
+  (#lua-match? @injection.content "^[\"']")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.language "c"))
+
+((function_call
+  (index
+    (identifier) @_cdef_identifier)
+  (arguments
+    (string) @injection.content))
+  (#eq? @_cdef_identifier "cdef")
+  (#lua-match? @injection.content "^%[%[")
+  (#offset! @injection.content 0 2 0 -2)
+  (#set! injection.language "c"))
+
+; string.format('...')
+((function_call
+  (index
+    (identifier) @_base
+    key: (identifier) @_entry)
+  (arguments
+    .
+    (string) @injection.content))
+  (#eq? @_base "string")
+  (#eq? @_entry "format")
+  (#set! injection.language "printf"))
+
+; ('...'):format()
+((function_call
+  (method_index
+    (parenthesized_expression
+      (string) @printf)
+    key: (identifier) @_func))
+  (#eq? @_func "format")
+  (#set! injection.language "printf"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/teal/locals.scm b/pack/ant/start/nvim-treesitter/queries/teal/locals.scm
new file mode 100644
index 0000000..c2386c6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/teal/locals.scm
@@ -0,0 +1,36 @@
+(var_declaration
+  declarators: (var_declarators
+    (var
+      (identifier)) @local.definition.var))
+
+(var_assignment
+  variables: (assignment_variables
+    (var
+      (identifier) @local.definition.var) @local.definition.associated))
+
+(arg
+  name: (identifier) @local.definition.parameter)
+
+(anon_function) @local.scope
+
+(function_statement
+  (function_name) @local.definition.function) @local.scope
+
+(program) @local.scope
+
+(if_statement) @local.scope
+
+(generic_for_statement
+  (for_body) @local.scope)
+
+(numeric_for_statement
+  (for_body) @local.scope)
+
+(repeat_statement) @local.scope
+
+(while_statement
+  (while_body) @local.scope)
+
+(do_statement) @local.scope
+
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/templ/folds.scm b/pack/ant/start/nvim-treesitter/queries/templ/folds.scm
new file mode 100644
index 0000000..adbbb10
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/templ/folds.scm
@@ -0,0 +1,15 @@
+[
+  (component_block)
+  (css_declaration)
+  (script_declaration)
+  (element)
+  (style_element)
+  (script_element)
+  (component_switch_statement)
+  (field_declaration_list)
+  (block)
+  (interface_type)
+  (comment)
+  (const_declaration)
+  (var_declaration)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/templ/highlights.scm b/pack/ant/start/nvim-treesitter/queries/templ/highlights.scm
new file mode 100644
index 0000000..034c91d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/templ/highlights.scm
@@ -0,0 +1,60 @@
+; inherits: go
+
+(component_declaration
+  name: (component_identifier) @function)
+
+[
+  (tag_start)
+  (tag_end)
+  (self_closing_tag)
+  (style_element)
+] @tag
+
+(doctype) @constant
+
+(attribute
+  name: (attribute_name) @tag.attribute)
+
+(attribute
+  value: (quoted_attribute_value) @string)
+
+[
+  (element_text)
+  (style_element_text)
+] @string.special
+
+(css_identifier) @function
+
+(css_property
+  name: (css_property_name) @property)
+
+(css_property
+  value: (css_property_value) @string)
+
+[
+  (expression)
+  (dynamic_class_attribute_value)
+] @function.method
+
+(component_import
+  name: (component_identifier) @function)
+
+(component_render) @function.call
+
+(element_comment) @comment @spell
+
+[
+  "<"
+  ">"
+  "</"
+  "/>"
+  "<!"
+] @tag.delimiter
+
+"@" @operator
+
+[
+  "templ"
+  "css"
+  "script"
+] @keyword
diff --git a/pack/ant/start/nvim-treesitter/queries/templ/injections.scm b/pack/ant/start/nvim-treesitter/queries/templ/injections.scm
new file mode 100644
index 0000000..b9cf5a0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/templ/injections.scm
@@ -0,0 +1,13 @@
+; inherits: go
+
+((element_comment) @injection.content
+  (#set! injection.language "comment"))
+
+((script_block_text) @injection.content
+  (#set! injection.language "javascript"))
+
+((script_element_text) @injection.content
+  (#set! injection.language "javascript"))
+
+((style_element_text) @injection.content
+  (#set! injection.language "css"))
diff --git a/pack/ant/start/nvim-treesitter/queries/terraform/folds.scm b/pack/ant/start/nvim-treesitter/queries/terraform/folds.scm
new file mode 100644
index 0000000..0e5ffc2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/terraform/folds.scm
@@ -0,0 +1 @@
+; inherits: hcl
diff --git a/pack/ant/start/nvim-treesitter/queries/terraform/highlights.scm b/pack/ant/start/nvim-treesitter/queries/terraform/highlights.scm
new file mode 100644
index 0000000..a6bf83c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/terraform/highlights.scm
@@ -0,0 +1,41 @@
+; inherits: hcl
+
+; Terraform specific references
+;
+;
+; local/module/data/var/output
+(expression
+  (variable_expr
+    (identifier) @variable.builtin
+    (#any-of? @variable.builtin "data" "var" "local" "module" "output"))
+  (get_attr
+    (identifier) @variable.member))
+
+; path.root/cwd/module
+(expression
+  (variable_expr
+    (identifier) @type.builtin
+    (#eq? @type.builtin "path"))
+  (get_attr
+    (identifier) @variable.builtin
+    (#any-of? @variable.builtin "root" "cwd" "module")))
+
+; terraform.workspace
+(expression
+  (variable_expr
+    (identifier) @type.builtin
+    (#eq? @type.builtin "terraform"))
+  (get_attr
+    (identifier) @variable.builtin
+    (#any-of? @variable.builtin "workspace")))
+
+; Terraform specific keywords
+; FIXME: ideally only for identifiers under a `variable` block to minimize false positives
+((identifier) @type.builtin
+  (#any-of? @type.builtin "bool" "string" "number" "object" "tuple" "list" "map" "set" "any"))
+
+(object_elem
+  val: (expression
+    (variable_expr
+      (identifier) @type.builtin
+      (#any-of? @type.builtin "bool" "string" "number" "object" "tuple" "list" "map" "set" "any"))))
diff --git a/pack/ant/start/nvim-treesitter/queries/terraform/indents.scm b/pack/ant/start/nvim-treesitter/queries/terraform/indents.scm
new file mode 100644
index 0000000..0e5ffc2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/terraform/indents.scm
@@ -0,0 +1 @@
+; inherits: hcl
diff --git a/pack/ant/start/nvim-treesitter/queries/terraform/injections.scm b/pack/ant/start/nvim-treesitter/queries/terraform/injections.scm
new file mode 100644
index 0000000..0e5ffc2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/terraform/injections.scm
@@ -0,0 +1 @@
+; inherits: hcl
diff --git a/pack/ant/start/nvim-treesitter/queries/textproto/folds.scm b/pack/ant/start/nvim-treesitter/queries/textproto/folds.scm
new file mode 100644
index 0000000..f6eeead
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/textproto/folds.scm
@@ -0,0 +1,5 @@
+[
+  (message_value)
+  (scalar_list)
+  (message_list)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/textproto/highlights.scm b/pack/ant/start/nvim-treesitter/queries/textproto/highlights.scm
new file mode 100644
index 0000000..527af03
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/textproto/highlights.scm
@@ -0,0 +1,23 @@
+(string) @string
+
+(field_name) @variable.member
+
+(comment) @comment @spell
+
+(number) @number
+
+; For stuff like "inf" and "-inf".
+(scalar_value
+  [
+    (identifier)
+    (signed_identifier)
+  ]) @number
+
+[
+  (open_squiggly)
+  (close_squiggly)
+  (open_square)
+  (close_square)
+  (open_arrow)
+  (close_arrow)
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/textproto/indents.scm b/pack/ant/start/nvim-treesitter/queries/textproto/indents.scm
new file mode 100644
index 0000000..155299e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/textproto/indents.scm
@@ -0,0 +1,14 @@
+(message_value) @indent.begin
+
+(message_value
+  (close_squiggly) @indent.branch)
+
+(scalar_list) @indent.begin
+
+(scalar_list
+  (close_square) @indent.branch)
+
+(message_list) @indent.begin
+
+(message_list
+  (close_square) @indent.branch)
diff --git a/pack/ant/start/nvim-treesitter/queries/textproto/injections.scm b/pack/ant/start/nvim-treesitter/queries/textproto/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/textproto/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/thrift/folds.scm b/pack/ant/start/nvim-treesitter/queries/thrift/folds.scm
new file mode 100644
index 0000000..3beec35
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/thrift/folds.scm
@@ -0,0 +1,11 @@
+[
+  (annotation_definition)
+  (enum_definition)
+  (exception_definition)
+  (function_definition)
+  (senum_definition)
+  (service_definition)
+  (struct_definition)
+  (union_definition)
+  (comment)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/thrift/highlights.scm b/pack/ant/start/nvim-treesitter/queries/thrift/highlights.scm
new file mode 100644
index 0000000..6d81291
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/thrift/highlights.scm
@@ -0,0 +1,245 @@
+; Variables
+((identifier) @variable
+  (#set! priority 95))
+
+; Includes
+[
+  "include"
+  "cpp_include"
+] @keyword.import
+
+; Function
+(function_definition
+  (identifier) @function)
+
+; Fields
+(field
+  (identifier) @variable.member)
+
+; Parameters
+(function_definition
+  (parameters
+    (parameter
+      (identifier) @variable.parameter)))
+
+(throws
+  (parameters
+    (parameter
+      (identifier) @variable.parameter)))
+
+; Types
+(typedef_identifier) @type
+
+(struct_definition
+  "struct"
+  (identifier) @type)
+
+(union_definition
+  "union"
+  (identifier) @type)
+
+(exception_definition
+  "exception"
+  (identifier) @type)
+
+(service_definition
+  "service"
+  (identifier) @type)
+
+(interaction_definition
+  "interaction"
+  (identifier) @type)
+
+(type
+  type: (identifier) @type)
+
+(definition_type
+  type: (identifier) @type)
+
+((identifier) @type
+  (#lua-match? @type "^[_]*[A-Z]"))
+
+; Constants
+(const_definition
+  (identifier) @constant)
+
+((identifier) @constant
+  (#lua-match? @constant "^[_A-Z][A-Z0-9_]*$"))
+
+(enum_definition
+  "enum"
+  .
+  (identifier) @type
+  "{"
+  (identifier) @constant
+  "}")
+
+; Builtin Types
+(primitive) @type.builtin
+
+[
+  "list"
+  "map"
+  "set"
+  "sink"
+  "stream"
+  "void"
+] @type.builtin
+
+; Namespace
+(namespace_declaration
+  (namespace_scope) @string.special
+  [
+    (namespace) @module
+    (_
+      (identifier) @module)
+  ])
+
+; Attributes
+(annotation_definition
+  (annotation_identifier
+    (identifier) @attribute))
+
+(fb_annotation_definition
+  "@" @attribute
+  (annotation_identifier
+    (identifier) @attribute)
+  (identifier)? @attribute)
+
+(namespace_uri
+  (string) @attribute)
+
+; Operators
+[
+  "="
+  "&"
+] @operator
+
+; Exceptions
+"throws" @keyword.exception
+
+; Keywords
+[
+  "exception"
+  "extends"
+  "typedef"
+  "uri"
+] @keyword
+
+[
+  "enum"
+  "struct"
+  "union"
+  "senum"
+  "interaction"
+  "namespace"
+  "service"
+] @keyword.type
+
+; Deprecated Keywords
+[
+  "cocoa_prefix"
+  "cpp_namespace"
+  "csharp_namespace"
+  "delphi_namespace"
+  "java_package"
+  "perl_package"
+  "php_namespace"
+  "py_module"
+  "ruby_namespace"
+  "smalltalk_category"
+  "smalltalk_prefix"
+  "xsd_all"
+  "xsd_attrs"
+  "xsd_namespace"
+  "xsd_nillable"
+  "xsd_optional"
+] @keyword
+
+; Extended Keywords
+[
+  "package"
+  "performs"
+] @keyword
+
+[
+  "async"
+  "oneway"
+] @keyword.coroutine
+
+; Qualifiers
+[
+  "client"
+  "const"
+  "idempotent"
+  "optional"
+  "permanent"
+  "readonly"
+  "required"
+  "safe"
+  "server"
+  "stateful"
+  "transient"
+] @keyword.modifier
+
+; Literals
+(string) @string
+
+(escape_sequence) @string.escape
+
+(namespace_uri
+  (string) @string.special.url)
+
+(number) @number
+
+(double) @number.float
+
+(boolean) @boolean
+
+; Typedefs
+(typedef_identifier) @type.definition
+
+; Punctuation
+"*" @punctuation.special
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "<"
+  ">"
+] @punctuation.bracket
+
+[
+  "."
+  ","
+  ";"
+  ":"
+] @punctuation.delimiter
+
+; Comments
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$"))
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^///[^/]"))
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^///$"))
+
+((comment) @keyword.directive @nospell
+  (#lua-match? @keyword.directive "#!.*"))
diff --git a/pack/ant/start/nvim-treesitter/queries/thrift/indents.scm b/pack/ant/start/nvim-treesitter/queries/thrift/indents.scm
new file mode 100644
index 0000000..db49c07
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/thrift/indents.scm
@@ -0,0 +1,23 @@
+(definition) @indent.begin
+
+((parameters
+  (parameter)) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+"}" @indent.end
+
+[
+  "{"
+  "}"
+] @indent.branch
+
+[
+  "("
+  ")"
+] @indent.branch
+
+[
+  (ERROR)
+  (comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/thrift/injections.scm b/pack/ant/start/nvim-treesitter/queries/thrift/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/thrift/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/thrift/locals.scm b/pack/ant/start/nvim-treesitter/queries/thrift/locals.scm
new file mode 100644
index 0000000..49f25bd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/thrift/locals.scm
@@ -0,0 +1,70 @@
+; Scopes
+[
+  (document)
+  (definition)
+] @local.scope
+
+; References
+(identifier) @local.reference
+
+; Definitions
+(annotation_identifier) @local.definition
+
+(const_definition
+  (identifier) @local.definition.constant)
+
+(enum_definition
+  "enum"
+  .
+  (identifier) @local.definition.enum
+  "{"
+  (identifier) @local.definition.constant
+  "}")
+
+(senum_definition
+  "senum"
+  .
+  (identifier) @local.definition.enum)
+
+(field
+  (identifier) @local.definition.field)
+
+(function_definition
+  (identifier) @local.definition.function)
+
+(namespace_declaration
+  "namespace"
+  (namespace_scope)
+  .
+  (_) @local.definition.namespace
+  (namespace_uri)?)
+
+(parameter
+  (identifier) @local.definition.parameter)
+
+(struct_definition
+  "struct"
+  .
+  (identifier) @local.definition.type)
+
+(union_definition
+  "union"
+  .
+  (identifier) @local.definition.type)
+
+(exception_definition
+  "exception"
+  .
+  (identifier) @local.definition.type)
+
+(service_definition
+  "service"
+  .
+  (identifier) @local.definition.type)
+
+(interaction_definition
+  "interaction"
+  .
+  (identifier) @local.definition.type)
+
+(typedef_identifier) @local.definition.type
diff --git a/pack/ant/start/nvim-treesitter/queries/tiger/folds.scm b/pack/ant/start/nvim-treesitter/queries/tiger/folds.scm
new file mode 100644
index 0000000..3b076bc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tiger/folds.scm
@@ -0,0 +1,17 @@
+[
+  (array_expression)
+  (record_expression)
+  (sequence_expression)
+  (if_expression)
+  (while_expression)
+  (for_expression)
+  (let_expression)
+  (function_declaration)
+  (primitive_declaration)
+  (record_type)
+  (class_declaration)
+  (class_type)
+  (method_declaration)
+] @fold
+
+; vim: sw=2 foldmethod=marker
diff --git a/pack/ant/start/nvim-treesitter/queries/tiger/highlights.scm b/pack/ant/start/nvim-treesitter/queries/tiger/highlights.scm
new file mode 100644
index 0000000..cbb1f23
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tiger/highlights.scm
@@ -0,0 +1,121 @@
+; Built-ins {{{
+((function_call
+  function: (identifier) @function.builtin)
+  (#any-of? @function.builtin
+    "chr" "concat" "exit" "flush" "getchar" "not" "ord" "print" "print_err" "print_int" "size"
+    "strcmp" "streq" "substring"))
+
+((type_identifier) @type.builtin
+  (#any-of? @type.builtin "int" "string" "Object"))
+
+((identifier) @variable.builtin
+  (#eq? @variable.builtin "self"))
+
+; }}}
+; Keywords {{{
+[
+  "function"
+  "primitive"
+  "method"
+] @keyword.function
+
+[
+  "do"
+  "for"
+  "to"
+  "while"
+] @keyword.repeat
+
+"new" @keyword.operator
+
+"import" @keyword.import
+
+[
+  "array"
+  (break_expression)
+  "else"
+  "end"
+  "if"
+  "in"
+  "let"
+  "of"
+  "then"
+  "type"
+  "var"
+  "extends"
+  "_cast"
+  "_chunks"
+  "_exp"
+  "_lvalue"
+  "_namety"
+] @keyword
+
+"class" @keyword.type
+
+; }}}
+; Operators {{{
+(operator) @operator
+
+[
+  ","
+  ";"
+  ":"
+  "."
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; }}}
+; Functions and methods {{{
+(function_call
+  function: (identifier) @function)
+
+(function_declaration
+  name: (identifier) @function)
+
+(primitive_declaration
+  name: (identifier) @function)
+
+(method_call
+  method: (identifier) @function.method)
+
+(method_declaration
+  name: (identifier) @function.method)
+
+(parameters
+  name: (identifier) @variable.parameter)
+
+; }}}
+; Declarations {{{
+(import_declaration
+  file: (string_literal) @string.special.path)
+
+; }}}
+; Literals {{{
+(nil_literal) @constant.builtin
+
+(integer_literal) @number
+
+(string_literal) @string
+
+(escape_sequence) @string.escape
+
+; }}}
+; Misc {{{
+(comment) @comment @spell
+
+(type_identifier) @type
+
+(field_identifier) @variable.member
+
+(identifier) @variable
+
+; }}}
+; vim: sw=2 foldmethod=marker
diff --git a/pack/ant/start/nvim-treesitter/queries/tiger/indents.scm b/pack/ant/start/nvim-treesitter/queries/tiger/indents.scm
new file mode 100644
index 0000000..686bfde
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tiger/indents.scm
@@ -0,0 +1,104 @@
+; Control flow {{{
+(if_expression) @indent.begin
+
+"then" @indent.branch
+
+"else" @indent.branch
+
+(while_expression) @indent.begin
+
+"do" @indent.branch
+
+(for_expression) @indent.begin
+
+"to" @indent.branch
+
+; }}}
+; Class {{{
+(class_declaration) @indent.begin
+
+(class_declaration
+  "}" @indent.end)
+
+(class_type) @indent.begin
+
+(class_type
+  "}" @indent.end)
+
+; }}}
+; Groups {{{
+(let_expression) @indent.begin
+
+"in" @indent.branch
+
+"end" @indent.branch
+
+(let_expression
+  "end" @indent.end)
+
+(sequence_expression) @indent.begin
+
+")" @indent.branch
+
+(sequence_expression
+  ")" @indent.end)
+
+; }}}
+; Functions and methods {{{
+(parameters) @indent.begin
+
+(parameters
+  ")" @indent.end)
+
+(function_call) @indent.begin
+
+(function_call
+  ")" @indent.end)
+
+(method_call) @indent.begin
+
+")" @indent.branch
+
+(function_declaration) @indent.begin
+
+(primitive_declaration) @indent.begin
+
+(method_declaration) @indent.begin
+
+; }}}
+; Values and expressions {{{
+(array_value) @indent.begin
+
+"]" @indent.branch
+
+(array_value
+  "]" @indent.end)
+
+(array_expression) @indent.begin
+
+"of" @indent.branch
+
+(record_expression) @indent.begin
+
+"}" @indent.branch
+
+(record_expression
+  "}" @indent.end)
+
+(record_type) @indent.begin
+
+"}" @indent.branch
+
+(record_type
+  "}" @indent.end)
+
+(variable_declaration) @indent.begin
+
+; }}}
+; Misc{{{
+(comment) @indent.ignore
+
+(string_literal) @indent.ignore
+
+; }}}
+; vim: sw=2 foldmethod=marker
diff --git a/pack/ant/start/nvim-treesitter/queries/tiger/injections.scm b/pack/ant/start/nvim-treesitter/queries/tiger/injections.scm
new file mode 100644
index 0000000..9735c59
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tiger/injections.scm
@@ -0,0 +1,4 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; vim: sw=2 foldmethod=marker
diff --git a/pack/ant/start/nvim-treesitter/queries/tiger/locals.scm b/pack/ant/start/nvim-treesitter/queries/tiger/locals.scm
new file mode 100644
index 0000000..cd8dcd6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tiger/locals.scm
@@ -0,0 +1,39 @@
+; See this issue [1] for support for "lazy scoping" which is somewhat needed
+; for Tiger semantics (e.g: one can call a function before it has been defined
+; top-to-bottom).
+;
+; [1]: https://github.com/tree-sitter/tree-sitter/issues/918
+; Scopes {{{
+[
+  (for_expression)
+  (let_expression)
+  (function_declaration)
+] @local.scope
+
+; }}}
+; Definitions {{{
+(type_declaration
+  name: (identifier) @local.definition.type
+  (#set! definition.var.scope "parent"))
+
+(parameters
+  name: (identifier) @local.definition.parameter)
+
+(function_declaration
+  name: (identifier) @local.definition.function
+  (#set! definition.var.scope "parent"))
+
+(primitive_declaration
+  name: (identifier) @local.definition.function
+  (#set! definition.var.scope "parent"))
+
+(variable_declaration
+  name: (identifier) @local.definition.var
+  (#set! definition.var.scope "parent"))
+
+; }}}
+; References {{{
+(identifier) @local.reference
+
+; }}}
+; vim: sw=2 foldmethod=marker
diff --git a/pack/ant/start/nvim-treesitter/queries/tlaplus/folds.scm b/pack/ant/start/nvim-treesitter/queries/tlaplus/folds.scm
new file mode 100644
index 0000000..2ca0168
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tlaplus/folds.scm
@@ -0,0 +1,5 @@
+[
+  (extramodular_text)
+  (block_comment)
+  (non_terminal_proof)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/tlaplus/highlights.scm b/pack/ant/start/nvim-treesitter/queries/tlaplus/highlights.scm
new file mode 100644
index 0000000..2eca927
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tlaplus/highlights.scm
@@ -0,0 +1,380 @@
+; Keywords
+[
+  "ACTION"
+  "ASSUME"
+  "ASSUMPTION"
+  "AXIOM"
+  "BY"
+  "CASE"
+  "CHOOSE"
+  "CONSTANT"
+  "CONSTANTS"
+  "COROLLARY"
+  "DEF"
+  "DEFINE"
+  "DEFS"
+  "ELSE"
+  "EXCEPT"
+  "EXTENDS"
+  "HAVE"
+  "HIDE"
+  "IF"
+  "IN"
+  "INSTANCE"
+  "LAMBDA"
+  "LEMMA"
+  "LET"
+  "LOCAL"
+  "MODULE"
+  "NEW"
+  "OBVIOUS"
+  "OMITTED"
+  "ONLY"
+  "OTHER"
+  "PICK"
+  "PROOF"
+  "PROPOSITION"
+  "PROVE"
+  "QED"
+  "RECURSIVE"
+  "SF_"
+  "STATE"
+  "SUFFICES"
+  "TAKE"
+  "TEMPORAL"
+  "THEN"
+  "THEOREM"
+  "USE"
+  "VARIABLE"
+  "VARIABLES"
+  "WF_"
+  "WITH"
+  "WITNESS"
+  (address)
+  (all_map_to)
+  (assign)
+  (case_arrow)
+  (case_box)
+  (def_eq)
+  (exists)
+  (forall)
+  (gets)
+  (label_as)
+  (maps_to)
+  (set_in)
+  (temporal_exists)
+  (temporal_forall)
+] @keyword
+
+;  Pluscal keywords
+[
+  (pcal_algorithm_start)
+  "algorithm"
+  "assert"
+  "begin"
+  "call"
+  "define"
+  "end"
+  "fair"
+  "goto"
+  "macro"
+  "or"
+  "procedure"
+  "process"
+  (pcal_skip)
+  "variable"
+  "variables"
+  "when"
+  "with"
+] @keyword
+
+"await" @keyword.coroutine
+
+(pcal_with
+  "=" @keyword)
+
+(pcal_process
+  "=" @keyword)
+
+[
+  "if"
+  "then"
+  "else"
+  "elsif"
+  (pcal_end_if)
+  "either"
+  (pcal_end_either)
+] @keyword.conditional
+
+[
+  "while"
+  "do"
+  (pcal_end_while)
+  "with"
+  (pcal_end_with)
+] @keyword.repeat
+
+(pcal_return) @keyword.return
+
+"print" @function.macro
+
+; Literals
+(binary_number
+  (format) @keyword)
+
+(binary_number
+  (value) @number)
+
+(boolean) @boolean
+
+(boolean_set) @type
+
+(hex_number
+  (format) @keyword)
+
+(hex_number
+  (value) @number)
+
+(int_number_set) @type
+
+(nat_number) @number
+
+(nat_number_set) @type
+
+(octal_number
+  (format) @keyword)
+
+(octal_number
+  (value) @number)
+
+(real_number) @number
+
+(real_number_set) @type
+
+(string) @string
+
+(escape_char) @string.escape
+
+(string_set) @type
+
+; Namespaces
+(extends
+  (identifier_ref) @module)
+
+(instance
+  (identifier_ref) @module)
+
+(module
+  name: (identifier) @module)
+
+(pcal_algorithm
+  name: (identifier) @module)
+
+; Operators, functions, and macros
+(bound_infix_op
+  symbol: (_) @operator)
+
+(bound_nonfix_op
+  symbol: (_) @operator)
+
+(bound_postfix_op
+  symbol: (_) @operator)
+
+(bound_prefix_op
+  symbol: (_) @operator)
+
+(prefix_op_symbol) @operator
+
+(infix_op_symbol) @operator
+
+(postfix_op_symbol) @operator
+
+(function_definition
+  name: (identifier) @function)
+
+(module_definition
+  name: (_) @keyword.import)
+
+(operator_definition
+  name: (_) @function.macro)
+
+(pcal_macro_decl
+  name: (identifier) @function.macro)
+
+(pcal_macro_call
+  name: (identifier) @function.macro)
+
+(pcal_proc_decl
+  name: (identifier) @function.macro)
+
+(pcal_process
+  name: (identifier) @function)
+
+(recursive_declaration
+  (identifier) @function.macro)
+
+(recursive_declaration
+  (operator_declaration
+    name: (_) @function.macro))
+
+; Constants and variables
+(constant_declaration
+  (identifier) @constant)
+
+(constant_declaration
+  (operator_declaration
+    name: (_) @constant))
+
+(pcal_var_decl
+  (identifier) @variable)
+
+(pcal_with
+  (identifier) @variable.parameter)
+
+("."
+  .
+  (identifier) @attribute)
+
+(record_literal
+  (identifier) @attribute)
+
+(set_of_records
+  (identifier) @attribute)
+
+(variable_declaration
+  (identifier) @variable)
+
+; Parameters
+(choose
+  (identifier) @variable.parameter)
+
+(choose
+  (tuple_of_identifiers
+    (identifier) @variable.parameter))
+
+(lambda
+  (identifier) @variable.parameter)
+
+(module_definition
+  (operator_declaration
+    name: (_) @variable.parameter))
+
+(module_definition
+  parameter: (identifier) @variable.parameter)
+
+(operator_definition
+  (operator_declaration
+    name: (_) @variable.parameter))
+
+(operator_definition
+  parameter: (identifier) @variable.parameter)
+
+(pcal_macro_decl
+  parameter: (identifier) @variable.parameter)
+
+(pcal_proc_var_decl
+  (identifier) @variable.parameter)
+
+(quantifier_bound
+  (identifier) @variable.parameter)
+
+(quantifier_bound
+  (tuple_of_identifiers
+    (identifier) @variable.parameter))
+
+(unbounded_quantification
+  (identifier) @variable.parameter)
+
+; Delimiters
+[
+  (langle_bracket)
+  (rangle_bracket)
+  (rangle_bracket_sub)
+  "{"
+  "}"
+  "["
+  "]"
+  "]_"
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  ","
+  ":"
+  "."
+  "!"
+  ";"
+  (bullet_conj)
+  (bullet_disj)
+  (prev_func_val)
+  (placeholder)
+] @punctuation.delimiter
+
+; Proofs
+(assume_prove
+  (new
+    (identifier) @variable.parameter))
+
+(assume_prove
+  (new
+    (operator_declaration
+      name: (_) @variable.parameter)))
+
+(assumption
+  name: (identifier) @constant)
+
+(pick_proof_step
+  (identifier) @variable.parameter)
+
+(proof_step_id
+  "<" @punctuation.bracket)
+
+(proof_step_id
+  (level) @label)
+
+(proof_step_id
+  (name) @label)
+
+(proof_step_id
+  ">" @punctuation.bracket)
+
+(proof_step_ref
+  "<" @punctuation.bracket)
+
+(proof_step_ref
+  (level) @label)
+
+(proof_step_ref
+  (name) @label)
+
+(proof_step_ref
+  ">" @punctuation.bracket)
+
+(take_proof_step
+  (identifier) @variable.parameter)
+
+(theorem
+  name: (identifier) @constant)
+
+; Comments and tags
+(block_comment
+  "(*" @comment)
+
+(block_comment
+  "*)" @comment)
+
+(block_comment_text) @comment @spell
+
+(comment) @comment @spell
+
+(single_line) @comment
+
+(_
+  label: (identifier) @label)
+
+(label
+  name: (_) @label)
+
+(pcal_goto
+  statement: (identifier) @label)
diff --git a/pack/ant/start/nvim-treesitter/queries/tlaplus/injections.scm b/pack/ant/start/nvim-treesitter/queries/tlaplus/injections.scm
new file mode 100644
index 0000000..fbeff50
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tlaplus/injections.scm
@@ -0,0 +1,5 @@
+([
+  (comment)
+  (block_comment_text)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/tlaplus/locals.scm b/pack/ant/start/nvim-treesitter/queries/tlaplus/locals.scm
new file mode 100644
index 0000000..e105351
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tlaplus/locals.scm
@@ -0,0 +1,167 @@
+; TLA+ scopes and definitions
+[
+  (bounded_quantification)
+  (choose)
+  (function_definition)
+  (function_literal)
+  (lambda)
+  (let_in)
+  (module)
+  (module_definition)
+  (operator_definition)
+  (set_filter)
+  (set_map)
+  (unbounded_quantification)
+] @local.scope
+
+(choose
+  (identifier) @local.definition.parameter)
+
+(choose
+  (tuple_of_identifiers
+    (identifier) @local.definition.parameter))
+
+(constant_declaration
+  (identifier) @local.definition.constant)
+
+(constant_declaration
+  (operator_declaration
+    name: (_) @local.definition.constant))
+
+(function_definition
+  name: (identifier) @local.definition.function
+  (#set! definition.function.scope "parent"))
+
+(lambda
+  (identifier) @local.definition.parameter)
+
+(module_definition
+  name: (_) @local.definition.import
+  (#set! definition.import.scope "parent"))
+
+(module_definition
+  parameter: (identifier) @local.definition.parameter)
+
+(module_definition
+  parameter: (operator_declaration
+    name: (_) @local.definition.parameter))
+
+(operator_definition
+  name: (_) @local.definition.macro
+  (#set! definition.macro.scope "parent"))
+
+(operator_definition
+  parameter: (identifier) @local.definition.parameter)
+
+(operator_definition
+  parameter: (operator_declaration
+    name: (_) @local.definition.parameter))
+
+(quantifier_bound
+  (identifier) @local.definition.parameter)
+
+(quantifier_bound
+  (tuple_of_identifiers
+    (identifier) @local.definition.parameter))
+
+(unbounded_quantification
+  (identifier) @local.definition.parameter)
+
+(variable_declaration
+  (identifier) @local.definition.var)
+
+; Proof scopes and definitions
+[
+  (non_terminal_proof)
+  (suffices_proof_step)
+  (theorem)
+] @local.scope
+
+(assume_prove
+  (new
+    (identifier) @local.definition.parameter))
+
+(assume_prove
+  (new
+    (operator_declaration
+      name: (_) @local.definition.parameter)))
+
+(assumption
+  name: (identifier) @local.definition.constant)
+
+(pick_proof_step
+  (identifier) @local.definition.parameter)
+
+(take_proof_step
+  (identifier) @local.definition.parameter)
+
+(theorem
+  name: (identifier) @local.definition.constant
+  (#set! definition.constant.scope "parent"))
+
+; PlusCal scopes and definitions
+[
+  (pcal_algorithm)
+  (pcal_macro)
+  (pcal_procedure)
+  (pcal_with)
+] @local.scope
+
+(pcal_macro_decl
+  parameter: (identifier) @local.definition.parameter)
+
+(pcal_proc_var_decl
+  (identifier) @local.definition.parameter)
+
+(pcal_var_decl
+  (identifier) @local.definition.var)
+
+(pcal_with
+  (identifier) @local.definition.parameter)
+
+; Built-in PlusCal variables
+(pcal_algorithm_body
+  [
+    (_
+      (identifier_ref) @local.definition.var)
+    (_
+      (_
+        (identifier_ref) @local.definition.var))
+    (_
+      (_
+        (_
+          (identifier_ref) @local.definition.var)))
+    (_
+      (_
+        (_
+          (_
+            (identifier_ref) @local.definition.var))))
+    (_
+      (_
+        (_
+          (_
+            (_
+              (identifier_ref) @local.definition.var)))))
+  ]
+  (#any-of? @local.definition.var "self" "pc" "stack"))
+
+; References
+(identifier_ref) @local.reference
+
+(prefix_op_symbol) @local.reference
+
+(bound_prefix_op
+  symbol: (_) @local.reference)
+
+(infix_op_symbol) @local.reference
+
+(bound_infix_op
+  symbol: (_) @local.reference)
+
+(postfix_op_symbol) @local.reference
+
+(bound_postfix_op
+  symbol: (_) @local.reference)
+
+(bound_nonfix_op
+  symbol: (_) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/tmux/highlights.scm b/pack/ant/start/nvim-treesitter/queries/tmux/highlights.scm
new file mode 100644
index 0000000..50da7d7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tmux/highlights.scm
@@ -0,0 +1,52 @@
+; Comments
+(comment) @comment @spell
+
+; General
+[
+  (string)
+  (raw_string)
+] @string
+
+(int) @number
+
+(path) @string.special.path
+
+[
+  (option)
+  (variable_name)
+] @variable
+
+(command_line_option) @variable.builtin
+
+((option) @variable.builtin
+  (#not-lua-match? @variable.builtin "^@"))
+
+(command) @keyword
+
+(source_file_directive
+  (command) @keyword.import)
+
+(attribute) @attribute
+
+(function_name) @function.call
+
+"=" @operator
+
+[
+  ","
+  ":"
+] @punctuation.delimiter
+
+[
+  "#"
+  "?"
+] @punctuation.special
+
+[
+  "#{"
+  "}"
+  "#["
+  "]"
+  "["
+  "{"
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/tmux/injections.scm b/pack/ant/start/nvim-treesitter/queries/tmux/injections.scm
new file mode 100644
index 0000000..5bf6e27
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tmux/injections.scm
@@ -0,0 +1,5 @@
+((shell) @injection.content
+  (#set! injection.language "bash"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/todotxt/highlights.scm b/pack/ant/start/nvim-treesitter/queries/todotxt/highlights.scm
new file mode 100644
index 0000000..1da0962
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/todotxt/highlights.scm
@@ -0,0 +1,16 @@
+(done_task) @comment
+
+(task
+  (priority) @keyword)
+
+(task
+  (date) @comment)
+
+(task
+  (kv) @comment)
+
+(task
+  (project) @string)
+
+(task
+  (context) @type)
diff --git a/pack/ant/start/nvim-treesitter/queries/toml/folds.scm b/pack/ant/start/nvim-treesitter/queries/toml/folds.scm
new file mode 100644
index 0000000..a58aae4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/toml/folds.scm
@@ -0,0 +1,5 @@
+[
+  (table)
+  (array)
+  (table_array_element)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/toml/highlights.scm b/pack/ant/start/nvim-treesitter/queries/toml/highlights.scm
new file mode 100644
index 0000000..f4eaf3f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/toml/highlights.scm
@@ -0,0 +1,39 @@
+(bare_key) @property
+
+[
+  (string)
+  (quoted_key)
+] @string
+
+(boolean) @boolean
+
+(comment) @comment @spell
+
+(escape_sequence) @string.escape
+
+(integer) @number
+
+(float) @number.float
+
+[
+  (local_date)
+  (local_date_time)
+  (local_time)
+  (offset_date_time)
+] @string.special
+
+"=" @operator
+
+[
+  "."
+  ","
+] @punctuation.delimiter
+
+[
+  "["
+  "]"
+  "[["
+  "]]"
+  "{"
+  "}"
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/toml/indents.scm b/pack/ant/start/nvim-treesitter/queries/toml/indents.scm
new file mode 100644
index 0000000..a2391a4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/toml/indents.scm
@@ -0,0 +1,11 @@
+[
+  (array)
+  (inline_table)
+] @indent.begin
+
+[
+  "["
+  "]"
+  "{"
+  "}"
+] @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/toml/injections.scm b/pack/ant/start/nvim-treesitter/queries/toml/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/toml/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/toml/locals.scm b/pack/ant/start/nvim-treesitter/queries/toml/locals.scm
new file mode 100644
index 0000000..2ca4e54
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/toml/locals.scm
@@ -0,0 +1,4 @@
+[
+  (table)
+  (table_array_element)
+] @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/tsv/highlights.scm b/pack/ant/start/nvim-treesitter/queries/tsv/highlights.scm
new file mode 100644
index 0000000..f00f13d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tsv/highlights.scm
@@ -0,0 +1,7 @@
+(text) @string
+
+(number) @number
+
+(float) @number.float
+
+(boolean) @boolean
diff --git a/pack/ant/start/nvim-treesitter/queries/tsx/folds.scm b/pack/ant/start/nvim-treesitter/queries/tsx/folds.scm
new file mode 100644
index 0000000..0739123
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tsx/folds.scm
@@ -0,0 +1 @@
+; inherits: typescript,jsx
diff --git a/pack/ant/start/nvim-treesitter/queries/tsx/highlights.scm b/pack/ant/start/nvim-treesitter/queries/tsx/highlights.scm
new file mode 100644
index 0000000..0739123
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tsx/highlights.scm
@@ -0,0 +1 @@
+; inherits: typescript,jsx
diff --git a/pack/ant/start/nvim-treesitter/queries/tsx/indents.scm b/pack/ant/start/nvim-treesitter/queries/tsx/indents.scm
new file mode 100644
index 0000000..0739123
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tsx/indents.scm
@@ -0,0 +1 @@
+; inherits: typescript,jsx
diff --git a/pack/ant/start/nvim-treesitter/queries/tsx/injections.scm b/pack/ant/start/nvim-treesitter/queries/tsx/injections.scm
new file mode 100644
index 0000000..b6d9b28
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tsx/injections.scm
@@ -0,0 +1 @@
+; inherits: ecma,jsx
diff --git a/pack/ant/start/nvim-treesitter/queries/tsx/locals.scm b/pack/ant/start/nvim-treesitter/queries/tsx/locals.scm
new file mode 100644
index 0000000..0739123
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/tsx/locals.scm
@@ -0,0 +1 @@
+; inherits: typescript,jsx
diff --git a/pack/ant/start/nvim-treesitter/queries/turtle/folds.scm b/pack/ant/start/nvim-treesitter/queries/turtle/folds.scm
new file mode 100644
index 0000000..f932a37
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/turtle/folds.scm
@@ -0,0 +1,5 @@
+[
+  (directive)
+  (triple)
+  (blank_node_property_list)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/turtle/highlights.scm b/pack/ant/start/nvim-treesitter/queries/turtle/highlights.scm
new file mode 100644
index 0000000..30d1f45
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/turtle/highlights.scm
@@ -0,0 +1,62 @@
+(string) @string
+
+(lang_tag) @type
+
+[
+  "_:"
+  "<"
+  ">"
+  (namespace)
+] @module
+
+[
+  (iri_reference)
+  (prefixed_name)
+] @variable
+
+(blank_node_label) @variable
+
+"a" @variable.builtin
+
+(integer) @number
+
+[
+  (decimal)
+  (double)
+] @number.float
+
+(boolean_literal) @boolean
+
+[
+  "BASE"
+  "PREFIX"
+  "@prefix"
+  "@base"
+] @keyword
+
+[
+  "."
+  ","
+  ";"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  (anon)
+] @punctuation.bracket
+
+(comment) @comment @spell
+
+(echar) @string.escape
+
+(rdf_literal
+  "^^" @type
+  datatype: (_
+    [
+      "<"
+      ">"
+      (namespace)
+    ] @type) @type)
diff --git a/pack/ant/start/nvim-treesitter/queries/turtle/indents.scm b/pack/ant/start/nvim-treesitter/queries/turtle/indents.scm
new file mode 100644
index 0000000..a601056
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/turtle/indents.scm
@@ -0,0 +1,11 @@
+[
+  (directive)
+  (triple)
+  (blank_node_property_list)
+  (collection)
+] @indent.begin
+
+[
+  "]"
+  ")"
+] @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/turtle/injections.scm b/pack/ant/start/nvim-treesitter/queries/turtle/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/turtle/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/turtle/locals.scm b/pack/ant/start/nvim-treesitter/queries/turtle/locals.scm
new file mode 100644
index 0000000..0e251e2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/turtle/locals.scm
@@ -0,0 +1,12 @@
+(document) @local.scope
+
+(subject
+  [
+    (prefixed_name)
+    (iri_reference)
+  ] @local.definition.var)
+
+[
+  (prefixed_name)
+  (iri_reference)
+] @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/twig/highlights.scm b/pack/ant/start/nvim-treesitter/queries/twig/highlights.scm
new file mode 100644
index 0000000..435fdc0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/twig/highlights.scm
@@ -0,0 +1,81 @@
+(comment) @comment @spell
+
+(filter_identifier) @function.call
+
+(function_identifier) @function.call
+
+(test) @function.builtin
+
+(variable) @variable
+
+(string) @string
+
+(interpolated_string) @string
+
+(operator) @operator
+
+(number) @number
+
+(boolean) @boolean
+
+(null) @constant.builtin
+
+(keyword) @keyword
+
+(attribute) @attribute
+
+(tag) @tag
+
+(conditional) @keyword.conditional
+
+(repeat) @keyword.repeat
+
+(method) @function.method
+
+(parameter) @variable.parameter
+
+[
+  "{{"
+  "}}"
+  "{{-"
+  "-}}"
+  "{{~"
+  "~}}"
+  "{%"
+  "%}"
+  "{%-"
+  "-%}"
+  "{%~"
+  "~%}"
+] @tag.delimiter
+
+[
+  ","
+  "."
+] @punctuation.delimiter
+
+[
+  "?"
+  ":"
+  "="
+  "|"
+] @operator
+
+(interpolated_string
+  [
+    "#{"
+    "}"
+  ] @punctuation.special)
+
+[
+  "("
+  ")"
+  "["
+  "]"
+] @punctuation.bracket
+
+(hash
+  [
+    "{"
+    "}"
+  ] @punctuation.bracket)
diff --git a/pack/ant/start/nvim-treesitter/queries/twig/injections.scm b/pack/ant/start/nvim-treesitter/queries/twig/injections.scm
new file mode 100644
index 0000000..3fd93fe
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/twig/injections.scm
@@ -0,0 +1,6 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((content) @injection.content
+  (#set! injection.language "html")
+  (#set! injection.combined))
diff --git a/pack/ant/start/nvim-treesitter/queries/typescript/folds.scm b/pack/ant/start/nvim-treesitter/queries/typescript/folds.scm
new file mode 100644
index 0000000..df0b894
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typescript/folds.scm
@@ -0,0 +1,8 @@
+; inherits: ecma
+
+[
+  (interface_declaration)
+  (internal_module)
+  (type_alias_declaration)
+  (enum_declaration)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/typescript/highlights.scm b/pack/ant/start/nvim-treesitter/queries/typescript/highlights.scm
new file mode 100644
index 0000000..663c4a4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typescript/highlights.scm
@@ -0,0 +1,205 @@
+; inherits: ecma
+
+"require" @keyword.import
+
+(import_require_clause
+  source: (string) @string.special.url)
+
+[
+  "declare"
+  "implements"
+  "type"
+  "override"
+  "module"
+  "asserts"
+  "infer"
+  "is"
+  "using"
+] @keyword
+
+[
+  "namespace"
+  "interface"
+  "enum"
+] @keyword.type
+
+[
+  "keyof"
+  "satisfies"
+] @keyword.operator
+
+(as_expression
+  "as" @keyword.operator)
+
+(mapped_type_clause
+  "as" @keyword.operator)
+
+[
+  "abstract"
+  "private"
+  "protected"
+  "public"
+  "readonly"
+] @keyword.modifier
+
+; types
+(type_identifier) @type
+
+(predefined_type) @type.builtin
+
+(import_statement
+  "type"
+  (import_clause
+    (named_imports
+      (import_specifier
+        name: (identifier) @type))))
+
+(template_literal_type) @string
+
+(non_null_expression
+  "!" @operator)
+
+; punctuation
+(type_arguments
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(type_parameters
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(object_type
+  [
+    "{|"
+    "|}"
+  ] @punctuation.bracket)
+
+(union_type
+  "|" @punctuation.delimiter)
+
+(intersection_type
+  "&" @punctuation.delimiter)
+
+(type_annotation
+  ":" @punctuation.delimiter)
+
+(type_predicate_annotation
+  ":" @punctuation.delimiter)
+
+(index_signature
+  ":" @punctuation.delimiter)
+
+(omitting_type_annotation
+  "-?:" @punctuation.delimiter)
+
+(adding_type_annotation
+  "+?:" @punctuation.delimiter)
+
+(opting_type_annotation
+  "?:" @punctuation.delimiter)
+
+"?." @punctuation.delimiter
+
+(abstract_method_signature
+  "?" @punctuation.special)
+
+(method_signature
+  "?" @punctuation.special)
+
+(method_definition
+  "?" @punctuation.special)
+
+(property_signature
+  "?" @punctuation.special)
+
+(optional_parameter
+  "?" @punctuation.special)
+
+(optional_type
+  "?" @punctuation.special)
+
+(public_field_definition
+  [
+    "?"
+    "!"
+  ] @punctuation.special)
+
+(flow_maybe_type
+  "?" @punctuation.special)
+
+(template_type
+  [
+    "${"
+    "}"
+  ] @punctuation.special)
+
+(conditional_type
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+; Parameters
+(required_parameter
+  (identifier) @variable.parameter)
+
+(optional_parameter
+  (identifier) @variable.parameter)
+
+(required_parameter
+  (rest_pattern
+    (identifier) @variable.parameter))
+
+; ({ a }) => null
+(required_parameter
+  (object_pattern
+    (shorthand_property_identifier_pattern) @variable.parameter))
+
+; ({ a = b }) => null
+(required_parameter
+  (object_pattern
+    (object_assignment_pattern
+      (shorthand_property_identifier_pattern) @variable.parameter)))
+
+; ({ a: b }) => null
+(required_parameter
+  (object_pattern
+    (pair_pattern
+      value: (identifier) @variable.parameter)))
+
+; ([ a ]) => null
+(required_parameter
+  (array_pattern
+    (identifier) @variable.parameter))
+
+; a => null
+(arrow_function
+  parameter: (identifier) @variable.parameter)
+
+; global declaration
+(ambient_declaration
+  "global" @module)
+
+; function signatures
+(ambient_declaration
+  (function_signature
+    name: (identifier) @function))
+
+; method signatures
+(method_signature
+  name: (_) @function.method)
+
+; property signatures
+(property_signature
+  name: (property_identifier) @function.method
+  type: (type_annotation
+    [
+      (union_type
+        (parenthesized_type
+          (function_type)))
+      (function_type)
+    ]))
diff --git a/pack/ant/start/nvim-treesitter/queries/typescript/indents.scm b/pack/ant/start/nvim-treesitter/queries/typescript/indents.scm
new file mode 100644
index 0000000..9a269ba
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typescript/indents.scm
@@ -0,0 +1,7 @@
+; inherits: ecma
+
+[
+  (enum_declaration)
+  (interface_declaration)
+  (object_type)
+] @indent.begin
diff --git a/pack/ant/start/nvim-treesitter/queries/typescript/injections.scm b/pack/ant/start/nvim-treesitter/queries/typescript/injections.scm
new file mode 100644
index 0000000..04328f0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typescript/injections.scm
@@ -0,0 +1 @@
+; inherits: ecma
diff --git a/pack/ant/start/nvim-treesitter/queries/typescript/locals.scm b/pack/ant/start/nvim-treesitter/queries/typescript/locals.scm
new file mode 100644
index 0000000..b89d9a0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typescript/locals.scm
@@ -0,0 +1,31 @@
+; inherits: ecma
+
+(required_parameter
+  (identifier) @local.definition)
+
+(optional_parameter
+  (identifier) @local.definition)
+
+; x => x
+(arrow_function
+  parameter: (identifier) @local.definition.parameter)
+
+; ({ a }) => null
+(required_parameter
+  (object_pattern
+    (shorthand_property_identifier_pattern) @local.definition.parameter))
+
+; ({ a: b }) => null
+(required_parameter
+  (object_pattern
+    (pair_pattern
+      value: (identifier) @local.definition.parameter)))
+
+; ([ a ]) => null
+(required_parameter
+  (array_pattern
+    (identifier) @local.definition.parameter))
+
+(required_parameter
+  (rest_pattern
+    (identifier) @local.definition.parameter))
diff --git a/pack/ant/start/nvim-treesitter/queries/typespec/highlights.scm b/pack/ant/start/nvim-treesitter/queries/typespec/highlights.scm
new file mode 100644
index 0000000..68c67c0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typespec/highlights.scm
@@ -0,0 +1,135 @@
+(identifier_or_member_expression) @type
+
+[
+  "is"
+  "extends"
+  "valueof"
+] @keyword.operator
+
+[
+  "namespace"
+  "model"
+  "scalar"
+  "interface"
+  "enum"
+  "union"
+  "alias"
+] @keyword.type
+
+[
+  "op"
+  "fn"
+  "dec"
+] @keyword.function
+
+"extern" @keyword.modifier
+
+[
+  "import"
+  "using"
+] @keyword.import
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "<"
+  ">"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ","
+  ";"
+  "."
+  ":"
+] @punctuation.delimiter
+
+[
+  "|"
+  "&"
+  "="
+  "..."
+] @operator
+
+"?" @punctuation.special
+
+[
+  (single_line_comment)
+  (multi_line_comment)
+] @comment @spell
+
+[
+  (quoted_string_literal)
+  (triple_quoted_string_literal)
+] @string
+
+(boolean_literal) @boolean
+
+[
+  (decimal_literal)
+  (hex_integer_literal)
+  (binary_integer_literal)
+] @number
+
+(escape_sequence) @string.escape
+
+(builtin_type) @type.builtin
+
+(decorator
+  "@" @attribute
+  name: (identifier_or_member_expression) @attribute)
+
+(augment_decorator_statement
+  name: (identifier_or_member_expression) @attribute)
+
+(using_statement
+  module: (identifier_or_member_expression) @module)
+
+(namespace_statement
+  name: (identifier_or_member_expression) @module)
+
+(model_statement
+  name: (identifier) @type)
+
+(model_property
+  name: (identifier) @variable.member)
+
+(union_statement
+  name: (identifier) @type)
+
+(union_variant
+  name: (identifier) @variable.member)
+
+(scalar_statement
+  name: (identifier) @type)
+
+(interface_statement
+  name: (identifier) @type)
+
+(enum_statement
+  name: (identifier) @type)
+
+(enum_member
+  name: (identifier) @constant)
+
+(operation_statement
+  name: (identifier) @function)
+
+(template_parameter
+  name: (identifier) @type)
+
+(alias_statement
+  name: (identifier) @type)
+
+(decorator_declaration_statement
+  name: (identifier) @attribute)
+
+(function_parameter
+  name: (identifier) @variable.parameter)
+
+(operation_arguments
+  (model_property
+    name: (identifier) @variable.parameter))
diff --git a/pack/ant/start/nvim-treesitter/queries/typespec/indents.scm b/pack/ant/start/nvim-treesitter/queries/typespec/indents.scm
new file mode 100644
index 0000000..aee01f3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typespec/indents.scm
@@ -0,0 +1,18 @@
+[
+  (model_expression)
+  (tuple_expression)
+  (namespace_body)
+  (interface_body)
+  (union_body)
+  (enum_body)
+  (template_arguments)
+  (template_parameters)
+  (operation_arguments)
+] @indent.begin
+
+[
+  "}"
+  ")"
+  ">"
+  "]"
+] @indent.end
diff --git a/pack/ant/start/nvim-treesitter/queries/typespec/injections.scm b/pack/ant/start/nvim-treesitter/queries/typespec/injections.scm
new file mode 100644
index 0000000..81d7734
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typespec/injections.scm
@@ -0,0 +1,5 @@
+([
+  (single_line_comment)
+  (multi_line_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/typoscript/folds.scm b/pack/ant/start/nvim-treesitter/queries/typoscript/folds.scm
new file mode 100644
index 0000000..fd7d239
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typoscript/folds.scm
@@ -0,0 +1 @@
+(block) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/typoscript/highlights.scm b/pack/ant/start/nvim-treesitter/queries/typoscript/highlights.scm
new file mode 100644
index 0000000..63327f1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typoscript/highlights.scm
@@ -0,0 +1,47 @@
+(identifier) @variable.member
+
+(constant) @constant
+
+(modifier_function) @function
+
+(modifier_predefined) @function.builtin
+
+[
+  (condition)
+  (condition_end)
+  (condition_else)
+] @keyword.conditional
+
+(cobject) @type.builtin
+
+[
+  "@import"
+  "INCLUDE_TYPOSCRIPT"
+] @keyword.import
+
+[
+  (comment)
+  (single_line_comment)
+] @comment @spell
+
+[
+  (string)
+  (multiline_value)
+] @string
+
+[
+  "="
+  ">"
+  "<"
+  ":="
+  "=<"
+  (condition_bool)
+] @operator
+
+"," @punctuation.delimiter
+
+[
+  "("
+  ")"
+  (block_punctuation)
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/typoscript/indents.scm b/pack/ant/start/nvim-treesitter/queries/typoscript/indents.scm
new file mode 100644
index 0000000..4f5fb47
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typoscript/indents.scm
@@ -0,0 +1,5 @@
+(block) @indent.begin
+
+"}" @indent.branch @indent.end
+
+(comment) @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/typoscript/injections.scm b/pack/ant/start/nvim-treesitter/queries/typoscript/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typoscript/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/typst/folds.scm b/pack/ant/start/nvim-treesitter/queries/typst/folds.scm
new file mode 100644
index 0000000..f2c13cc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typst/folds.scm
@@ -0,0 +1,7 @@
+[
+  (set)
+  (let)
+  (show)
+  (call)
+  (section)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/typst/highlights.scm b/pack/ant/start/nvim-treesitter/queries/typst/highlights.scm
new file mode 100644
index 0000000..e361054
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typst/highlights.scm
@@ -0,0 +1,113 @@
+; punctuation
+"#" @punctuation.special
+
+[
+  ":"
+  ";"
+  ","
+] @punctuation.delimiter
+
+; TODO: context blocks for "[" "]"?
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+; operators
+[
+  "-"
+  "+"
+  "*"
+  "/"
+  "=="
+  "!="
+  "<"
+  "<="
+  ">"
+  ">="
+  "="
+  "in"
+  "and"
+  "or"
+  "not"
+] @operator
+
+; keywords
+[
+  "import"
+  "include"
+] @keyword.import
+
+[
+  "let"
+  "set"
+  "show"
+] @keyword
+
+; control flow
+[
+  "for"
+  "while"
+  "break"
+  "continue"
+] @keyword.repeat
+
+[
+  "if"
+  "else"
+] @keyword.conditional
+
+; special case: #for (ident) in (expr)
+(for
+  "in" @keyword.repeat)
+
+; type literals
+(number) @number
+
+(string) @string
+
+(bool) @boolean
+
+(ident) @constant
+
+; name-value pairs
+(tagged
+  field: (ident) @variable.member)
+
+(call
+  item: (ident) @function.call)
+
+; text
+(text) @spell
+
+; TODO: use multi level headings
+(heading) @markup.heading
+
+(strong) @markup.strong
+
+(emph) @markup.italic
+
+(url) @markup.link.url
+
+; code blocks
+(raw_span) @markup.raw
+
+(raw_blck) @markup.raw
+
+(raw_blck
+  (blob) @markup.raw.block)
+
+; refs and labels
+(label) @markup.link.label
+
+(ref) @markup.link
+
+; math
+(math) @markup.math
+
+; comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/typst/indents.scm b/pack/ant/start/nvim-treesitter/queries/typst/indents.scm
new file mode 100644
index 0000000..d43c586
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typst/indents.scm
@@ -0,0 +1,12 @@
+[
+  (set)
+  (let)
+  (show)
+  (call)
+] @indent.begin
+
+[
+  "]"
+  "}"
+  ")"
+] @indent.branch @indent.end
diff --git a/pack/ant/start/nvim-treesitter/queries/typst/injections.scm b/pack/ant/start/nvim-treesitter/queries/typst/injections.scm
new file mode 100644
index 0000000..344c6a3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/typst/injections.scm
@@ -0,0 +1,6 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+(raw_blck
+  (ident) @injection.language
+  (blob) @injection.content)
diff --git a/pack/ant/start/nvim-treesitter/queries/udev/highlights.scm b/pack/ant/start/nvim-treesitter/queries/udev/highlights.scm
new file mode 100644
index 0000000..f95238d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/udev/highlights.scm
@@ -0,0 +1,67 @@
+(match
+  key: _ @keyword)
+
+(assignment
+  key: _ @property)
+
+(value) @string
+
+; NOTE: higher priorities override bash highlights
+((fmt_sub
+  .
+  _ @character.special)
+  (#set! priority 101))
+
+((var_sub
+  .
+  _ @variable.builtin)
+  (#set! priority 101))
+
+[
+  (system_const)
+  (run_type)
+  (import_type)
+  (kernel_param)
+  (seclabel)
+] @attribute
+
+((attribute) @attribute
+  (#set! priority 101))
+
+((env_var) @constant
+  (#set! priority 101))
+
+((pattern) @string.special
+  (#set! priority 101))
+
+([
+  "\\\""
+  (c_escape)
+] @string.escape
+  (#set! priority 101))
+
+(octal) @number
+
+((number) @number
+  (#set! priority 101))
+
+[
+  (match_op)
+  (assignment_op)
+] @operator
+
+("+" @punctuation.special
+  (#set! priority 101))
+
+([
+  "{"
+  "}"
+] @punctuation.bracket
+  (#set! priority 101))
+
+[
+  ","
+  (linebreak)
+] @punctuation.delimiter
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/udev/injections.scm b/pack/ant/start/nvim-treesitter/queries/udev/injections.scm
new file mode 100644
index 0000000..1718349
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/udev/injections.scm
@@ -0,0 +1,14 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((match
+  key: "PROGRAM"
+  (value
+    (content) @injection.content))
+  (#set! injection.language "bash"))
+
+((assignment
+  key: "RUN"
+  (value
+    (content) @injection.content))
+  (#set! injection.language "bash"))
diff --git a/pack/ant/start/nvim-treesitter/queries/udev/locals.scm b/pack/ant/start/nvim-treesitter/queries/udev/locals.scm
new file mode 100644
index 0000000..e1a2f65
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/udev/locals.scm
@@ -0,0 +1,29 @@
+; labels
+(assignment
+  key: "LABEL"
+  (value
+    (content) @local.definition))
+
+(assignment
+  key: "GOTO"
+  (value
+    (content) @local.reference))
+
+; env vars
+(assignment
+  key: "ENV"
+  (env_var) @local.definition.var)
+
+(match
+  key: "ENV"
+  (env_var) @local.reference)
+
+(var_sub
+  (env_var) @local.reference)
+
+; misc
+[
+  (attribute)
+  (kernel_param)
+  (seclabel)
+] @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/ungrammar/folds.scm b/pack/ant/start/nvim-treesitter/queries/ungrammar/folds.scm
new file mode 100644
index 0000000..206c4be
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ungrammar/folds.scm
@@ -0,0 +1 @@
+(node) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/ungrammar/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ungrammar/highlights.scm
new file mode 100644
index 0000000..4ed523c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ungrammar/highlights.scm
@@ -0,0 +1,26 @@
+(comment) @comment @spell
+
+(definition) @keyword
+
+(identifier) @variable
+
+(label_name) @label
+
+(token) @string
+
+[
+  "="
+  "|"
+] @operator
+
+[
+  "*"
+  "?"
+] @keyword.repeat
+
+":" @punctuation.delimiter
+
+[
+  "("
+  ")"
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/ungrammar/indents.scm b/pack/ant/start/nvim-treesitter/queries/ungrammar/indents.scm
new file mode 100644
index 0000000..a5ececd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ungrammar/indents.scm
@@ -0,0 +1,6 @@
+(node) @indent.begin
+
+[
+  (ERROR)
+  (comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/ungrammar/injections.scm b/pack/ant/start/nvim-treesitter/queries/ungrammar/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ungrammar/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/ungrammar/locals.scm b/pack/ant/start/nvim-treesitter/queries/ungrammar/locals.scm
new file mode 100644
index 0000000..0f745bd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ungrammar/locals.scm
@@ -0,0 +1,8 @@
+(grammar) @local.scope
+
+[
+  (definition)
+  (label_name)
+] @local.definition
+
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/unison/highlights.scm b/pack/ant/start/nvim-treesitter/queries/unison/highlights.scm
new file mode 100644
index 0000000..39c2393
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/unison/highlights.scm
@@ -0,0 +1,115 @@
+; Primitives
+(comment) @comment @spell
+
+(nat) @number
+
+(unit) @constant.builtin
+
+(literal_char) @character
+
+(literal_text) @string
+
+(literal_boolean) @boolean
+
+; Keywords
+[
+  (kw_forall)
+  (unique)
+  (type_kw)
+  (do)
+  (kw_let)
+  (ability)
+  (where)
+] @keyword
+
+(kw_equals) @keyword.operator
+
+(structural) @keyword.modifier
+
+(unique) @keyword.modifier
+
+(type_constructor) @constructor
+
+(doc_block) @comment.documentation
+
+[
+  (operator)
+  (pipe)
+  (arrow_symbol)
+  ">"
+  (or)
+] @keyword.operator
+
+[
+  "if"
+  "else"
+  "then"
+  (match)
+  (with)
+  (cases)
+] @keyword.conditional
+
+(blank_pattern) @variable.builtin
+
+(pattern) @variable
+
+(constructor_or_variable_pattern) @type
+
+(use_clause) @keyword.import
+
+; Types
+(record_field
+  name: (wordy_id) @variable
+  type: (wordy_id) @type)
+
+(type_name) @type
+
+(ability_declaration
+  (ability_name) @type
+  (type_argument) @variable.parameter)
+
+(effect
+  (wordy_id) @attribute) ; NOTE: an effect is a special type
+
+; Namespaces
+(path) @module
+
+(namespace) @module
+
+; Terms
+(type_signature
+  term_name: (path) @module
+  term_name: (wordy_id) @variable)
+
+(type_signature
+  term_name: (wordy_id) @variable)
+
+(term_type) @type
+
+(function_application
+  function_name: (path)
+  function_name: (wordy_id) @function)
+
+(term_definition
+  name: (wordy_id) @variable)
+
+(term_definition
+  param: (wordy_id) @variable.parameter)
+
+; Punctuation
+[
+  (type_signature_colon)
+  ":"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+(test_watch_expression
+  (wordy_id) @keyword.directive)
diff --git a/pack/ant/start/nvim-treesitter/queries/unison/injections.scm b/pack/ant/start/nvim-treesitter/queries/unison/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/unison/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/usd/folds.scm b/pack/ant/start/nvim-treesitter/queries/usd/folds.scm
new file mode 100644
index 0000000..fd7d239
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/usd/folds.scm
@@ -0,0 +1 @@
+(block) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/usd/highlights.scm b/pack/ant/start/nvim-treesitter/queries/usd/highlights.scm
new file mode 100644
index 0000000..d6c2a36
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/usd/highlights.scm
@@ -0,0 +1,154 @@
+(None) @constant.builtin
+
+(asset_path) @string.special.url
+
+(attribute_property) @property
+
+(bool) @boolean
+
+(comment) @comment @spell
+
+(custom) @function.builtin
+
+(float) @number.float
+
+(integer) @number
+
+(orderer) @function.call
+
+(prim_path) @string.special
+
+(relationship_type) @type
+
+(string) @string
+
+(uniform) @function.builtin
+
+(variant_set_definition) @keyword
+
+; Prefer namespace highlighting, if any.
+;
+; e.g. `rel fizz` - `fizz` uses `@identifier`
+; e.g. `rel foo:bar:fizz` - `foo` and `bar` use `@module` and `fizz` uses `@identifier`
+;
+(identifier) @variable
+
+(namespace_identifier) @module
+
+(namespace_identifier
+  (identifier) @module)
+
+[
+  "def"
+  "over"
+] @keyword.function
+
+"class" @keyword.type
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  ":"
+  ";"
+  "."
+] @punctuation.delimiter
+
+"=" @operator
+
+(attribute_type) @type
+
+((attribute_type) @type.builtin
+  ;format-ignore
+  (#any-of? @type.builtin
+    ;; Reference: https://openusd.org/release/api/sdf_page_front.html
+    ;; Scalar types
+    "asset" "asset[]"
+    "bool" "bool[]"
+    "double" "double[]"
+    "float" "float[]"
+    "half" "half[]"
+    "int" "int[]"
+    "int64" "int64[]"
+    "string" "string[]"
+    "timecode" "timecode[]"
+    "token" "token[]"
+    "uchar" "uchar[]"
+    "uint" "uint[]"
+    "uint64" "uint64[]"
+
+    ;; Dimensioned Types
+    "double2" "double2[]"
+    "double3" "double3[]"
+    "double4" "double4[]"
+    "float2" "float2[]"
+    "float3" "float3[]"
+    "float4" "float4[]"
+    "half2" "half2[]"
+    "half3" "half3[]"
+    "half4" "half4[]"
+    "int2" "int2[]"
+    "int3" "int3[]"
+    "int4" "int4[]"
+    "matrix2d" "matrix2d[]"
+    "matrix3d" "matrix3d[]"
+    "matrix4d" "matrix4d[]"
+    "quatd" "quatd[]"
+    "quatf" "quatf[]"
+    "quath" "quath[]"
+
+    ;; Extra Types
+    "color3f" "color3f[]"
+    "normal3f" "normal3f[]"
+    "point3f" "point3f[]"
+    "texCoord2f" "texCoord2f[]"
+    "vector3d" "vector3d[]"
+    "vector3f" "vector3f[]"
+    "vector3h" "vector3h[]"
+
+    "dictionary"
+
+    ;; Deprecated Types
+    "EdgeIndex" "EdgeIndex[]"
+    "FaceIndex" "FaceIndex[]"
+    "Matrix4d" "Matrix4d[]"
+    "PointIndex" "PointIndex[]"
+    "PointFloat" "PointFloat[]"
+    "Transform" "Transform[]"
+    "Vec3f" "Vec3f[]"))
+
+((identifier) @keyword
+  (#any-of? @keyword
+    ; Reference: https://openusd.org/release/api/sdf_page_front.html
+    ; LIVRPS names
+    "inherits" "payload" "references" "specializes" "variantSets" "variants"
+    ; assetInfo names
+    "assetInfo" "identifier" "name" "payloadAssetDependencies" "version"
+    ; clips names
+    "clips" "active" "assetPaths" "manifestAssetPath" "primPath" "templateAssetPath"
+    "templateEndTime" "templateStartTime" "templateStride" "times"
+    ; customData names
+    "customData" "apiSchemaAutoApplyTo" "apiSchemaOverridePropertyNames" "className" "extraPlugInfo"
+    "isUsdShadeContainer" "libraryName" "providesUsdShadeConnectableAPIBehavior"
+    "requiresUsdShadeEncapsulation" "skipCodeGeneration"
+    ; Layer metadata names
+    "colorConfiguration" "colorManagementSystem" "customLayerData" "defaultPrim" "doc" "endTimeCode"
+    "framesPerSecond" "owner" "startTimeCode" "subLayers"
+    ; Prim metadata
+    "instanceable"))
+
+; Common attribute metadata
+(layer_offset
+  (identifier) @keyword
+  (#any-of? @keyword "offset" "scale"))
+
+; Docstrings in USD
+(metadata
+  (comment)*
+  (string) @comment.documentation)
diff --git a/pack/ant/start/nvim-treesitter/queries/usd/indents.scm b/pack/ant/start/nvim-treesitter/queries/usd/indents.scm
new file mode 100644
index 0000000..217d12d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/usd/indents.scm
@@ -0,0 +1,42 @@
+; format-ignore
+[
+  (block)  ; The {}s in `def "foo" { ... Attributes / Prims here ... }`
+  (dictionary)  ; The {}s in `dictionary foo = { string "foo" = "bar" }`
+  (list)
+  (list_proxy)  ; [@foo.usda@, @bar.usda@]
+  (metadata)  ; ( anything = "goes-here" )
+  (prim_paths)  ; [</foo>, <../bar>]
+  (timeSamples)  ; The {}s in `int value.timeSamples = { 0: 1, -10: 10, ... }`
+  (tuple)
+  (variant_set_definition)  ; The {}s in `variantSet "foo" = { "vr1" { ... } "vr2" { ... } }`
+] @indent.begin
+
+(block
+  "}" @indent.end)
+
+(dictionary
+  "}" @indent.end)
+
+(list
+  "]" @indent.end)
+
+(list_proxy
+  "]" @indent.end)
+
+(metadata
+  ")" @indent.end)
+
+(timeSamples
+  "}" @indent.end)
+
+(tuple
+  ")" @indent.end)
+
+(variant_set_definition
+  "}" @indent.end)
+
+[
+  ")"
+  "]"
+  "}"
+] @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/usd/injections.scm b/pack/ant/start/nvim-treesitter/queries/usd/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/usd/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/usd/locals.scm b/pack/ant/start/nvim-treesitter/queries/usd/locals.scm
new file mode 100644
index 0000000..89eb171
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/usd/locals.scm
@@ -0,0 +1,4 @@
+[
+  (block)
+  (metadata)
+] @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/uxntal/folds.scm b/pack/ant/start/nvim-treesitter/queries/uxntal/folds.scm
new file mode 100644
index 0000000..9e3f27d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/uxntal/folds.scm
@@ -0,0 +1,6 @@
+[
+  (macro)
+  (memory_execution)
+  (subroutine)
+  (comment)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/uxntal/highlights.scm b/pack/ant/start/nvim-treesitter/queries/uxntal/highlights.scm
new file mode 100644
index 0000000..962b6d7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/uxntal/highlights.scm
@@ -0,0 +1,87 @@
+; Includes
+(include
+  "~" @keyword.import
+  _ @string.special.url)
+
+; Variables
+(identifier) @variable
+
+; Macros
+(macro
+  "%"
+  (identifier) @function.macro)
+
+((identifier) @function.macro
+  (#lua-match? @function.macro "^[a-z]?[0-9]*[A-Z-_]+$"))
+
+(rune
+  .
+  rune_start: (rune_char
+    ",")
+  .
+  (identifier) @function.call)
+
+(rune
+  .
+  rune_start: (rune_char
+    ";")
+  .
+  (identifier) @function.call)
+
+((identifier) @function.call
+  (#lua-match? @function.call "^:"))
+
+; Keywords
+(opcode) @keyword
+
+; Labels
+(label
+  "@" @string.special.symbol
+  (identifier) @function)
+
+(sublabel_reference
+  (identifier) @module
+  "/" @punctuation.delimiter
+  (identifier) @label)
+
+; Repeats
+((identifier) @keyword.repeat
+  (#eq? @keyword.repeat "while"))
+
+; Literals
+(raw_ascii) @string
+
+(hex_literal
+  "#" @string.special.symbol
+  (hex_lit_value) @string.special)
+
+(number) @number
+
+; Punctuation
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "%"
+  "|"
+  "$"
+  ","
+  "_"
+  "."
+  "-"
+  ";"
+  "="
+  "!"
+  "?"
+  "&"
+] @punctuation.special
+
+; Comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/uxntal/indents.scm b/pack/ant/start/nvim-treesitter/queries/uxntal/indents.scm
new file mode 100644
index 0000000..b795b89
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/uxntal/indents.scm
@@ -0,0 +1,23 @@
+(memory_execution) @indent.auto
+
+[
+  (subroutine)
+  (brackets)
+] @indent.begin
+
+"}" @indent.end
+
+[
+  "{"
+  "}"
+] @indent.branch
+
+[
+  "["
+  "]"
+] @indent.branch
+
+[
+  (ERROR)
+  (comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/uxntal/injections.scm b/pack/ant/start/nvim-treesitter/queries/uxntal/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/uxntal/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/uxntal/locals.scm b/pack/ant/start/nvim-treesitter/queries/uxntal/locals.scm
new file mode 100644
index 0000000..41fbb5b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/uxntal/locals.scm
@@ -0,0 +1,21 @@
+; Scopes
+[
+  (program)
+  (macro)
+  (memory_execution)
+  (subroutine)
+] @local.scope
+
+; References
+(identifier) @local.reference
+
+; Definitions
+(label
+  "@"
+  .
+  (identifier) @local.definition.function)
+
+(macro
+  "%"
+  .
+  (identifier) @local.definition.macro)
diff --git a/pack/ant/start/nvim-treesitter/queries/v/folds.scm b/pack/ant/start/nvim-treesitter/queries/v/folds.scm
new file mode 100644
index 0000000..952b6bb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/v/folds.scm
@@ -0,0 +1,8 @@
+[
+  (function_declaration)
+  (const_declaration)
+  (type_declaration)
+  (import_declaration)
+  (if_expression)
+  (struct_declaration)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/v/highlights.scm b/pack/ant/start/nvim-treesitter/queries/v/highlights.scm
new file mode 100644
index 0000000..982f3db
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/v/highlights.scm
@@ -0,0 +1,300 @@
+(shebang) @keyword.directive
+
+; Includes
+[
+  "import"
+  "module"
+] @keyword.import
+
+; Keywords
+[
+  "asm"
+  "assert"
+  "const"
+  "defer"
+  "goto"
+  "sql"
+  "unsafe"
+] @keyword
+
+[
+  "enum"
+  "union"
+  "struct"
+  "interface"
+  "type"
+] @keyword.type
+
+[
+  "as"
+  "in"
+  "!in"
+  "or"
+  "is"
+  "!is"
+] @keyword.operator
+
+[
+  "match"
+  "if"
+  "$if"
+  "else"
+  "$else"
+  "select"
+] @keyword.conditional
+
+[
+  "for"
+  "$for"
+  "continue"
+  "break"
+] @keyword.repeat
+
+"fn" @keyword.function
+
+"return" @keyword.return
+
+[
+  "__global"
+  "shared"
+  "static"
+  "const"
+] @keyword.modifier
+
+[
+  "pub"
+  "mut"
+] @keyword.modifier
+
+[
+  "go"
+  "spawn"
+  "lock"
+  "rlock"
+] @keyword.coroutine
+
+; Variables
+(identifier) @variable
+
+; Namespace
+(module_clause
+  (identifier) @module)
+
+(import_path
+  (import_name) @module)
+
+(import_alias
+  (import_name) @module)
+
+; Literals
+[
+  (true)
+  (false)
+] @boolean
+
+(interpreted_string_literal) @string
+
+(string_interpolation) @none
+
+; Types
+(struct_declaration
+  name: (identifier) @type)
+
+(enum_declaration
+  name: (identifier) @type)
+
+(interface_declaration
+  name: (identifier) @type)
+
+(type_declaration
+  name: (identifier) @type)
+
+(type_reference_expression
+  (identifier) @type)
+
+; Labels
+(label_reference) @label
+
+; Fields
+(selector_expression
+  field: (reference_expression
+    (identifier) @variable.member))
+
+(field_name) @variable.member
+
+(struct_field_declaration
+  name: (identifier) @variable.member)
+
+; Parameters
+(parameter_declaration
+  name: (identifier) @variable.parameter)
+
+(receiver
+  name: (identifier) @variable.parameter)
+
+; Constants
+((identifier) @constant
+  (#has-ancestor? @constant compile_time_if_expression))
+
+(enum_fetch
+  (reference_expression) @constant)
+
+(enum_field_definition
+  (identifier) @constant)
+
+(const_definition
+  name: (identifier) @constant)
+
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin "err" "macos" "linux" "windows"))
+
+; Attributes
+(attribute) @attribute
+
+; Functions
+(function_declaration
+  name: (identifier) @function)
+
+(function_declaration
+  receiver: (receiver)
+  name: (identifier) @function.method)
+
+(call_expression
+  name: (selector_expression
+    field: (reference_expression) @function.method.call))
+
+(call_expression
+  name: (reference_expression) @function.call)
+
+((identifier) @function.builtin
+  (#any-of? @function.builtin
+    "eprint" "eprintln" "error" "exit" "panic" "print" "println" "after" "after_char" "all"
+    "all_after" "all_after_last" "all_before" "all_before_last" "any" "ascii_str" "before" "bool"
+    "byte" "byterune" "bytes" "bytestr" "c_error_number_str" "capitalize" "clear" "clone"
+    "clone_to_depth" "close" "code" "compare" "compare_strings" "contains" "contains_any"
+    "contains_any_substr" "copy" "count" "cstring_to_vstring" "delete" "delete_last" "delete_many"
+    "ends_with" "eprint" "eprintln" "eq_epsilon" "error" "error_with_code" "exit" "f32" "f32_abs"
+    "f32_max" "f32_min" "f64" "f64_max" "fields" "filter" "find_between" "first" "flush_stderr"
+    "flush_stdout" "free" "gc_check_leaks" "get_str_intp_u32_format" "get_str_intp_u64_format"
+    "grow_cap" "grow_len" "hash" "hex" "hex2" "hex_full" "i16" "i64" "i8" "index" "index_after"
+    "index_any" "index_byte" "insert" "int" "is_alnum" "is_bin_digit" "is_capital" "is_digit"
+    "is_hex_digit" "is_letter" "is_lower" "is_oct_digit" "is_space" "is_title" "is_upper" "isnil"
+    "join" "join_lines" "keys" "last" "last_index" "last_index_byte" "length_in_bytes" "limit"
+    "malloc" "malloc_noscan" "map" "match_glob" "memdup" "memdup_noscan" "move" "msg" "panic"
+    "panic_error_number" "panic_lasterr" "panic_optional_not_set" "parse_int" "parse_uint"
+    "pointers" "pop" "prepend" "print" "print_backtrace" "println" "proc_pidpath" "ptr_str"
+    "push_many" "realloc_data" "reduce" "repeat" "repeat_to_depth" "replace" "replace_each"
+    "replace_once" "reverse" "reverse_in_place" "runes" "sort" "sort_by_len" "sort_ignore_case"
+    "sort_with_compare" "split" "split_any" "split_into_lines" "split_nth" "starts_with"
+    "starts_with_capital" "str" "str_escaped" "str_intp" "str_intp_g32" "str_intp_g64"
+    "str_intp_rune" "str_intp_sq" "str_intp_sub" "strg" "string_from_wide" "string_from_wide2"
+    "strip_margin" "strip_margin_custom" "strlong" "strsci" "substr" "substr_ni" "substr_with_check"
+    "title" "to_lower" "to_upper" "to_wide" "tos" "tos2" "tos3" "tos4" "tos5" "tos_clone" "trim"
+    "trim_left" "trim_pr" "try_pop" "try_push" "utf32_decode_to_buffer" "utf32_to_str"
+    "utf32_to_str_no_malloc" "utf8_char_len" "utf8_getchar" "utf8_str_len" "utf8_str_visible_length"
+    "utf8_to_utf32" "v_realloc" "vbytes" "vcalloc" "vcalloc_noscan" "vmemcmp" "vmemcpy" "vmemmove"
+    "vmemset" "vstring" "vstring_literal" "vstring_literal_with_len" "vstring_with_len" "vstrlen"
+    "vstrlen_char" "winapi_lasterr_str"))
+
+; Operators
+[
+  "++"
+  "--"
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "~"
+  "&"
+  "|"
+  "^"
+  "!"
+  "&&"
+  "||"
+  "!="
+  "<<"
+  ">>"
+  "<"
+  ">"
+  "<="
+  ">="
+  "+="
+  "-="
+  "*="
+  "/="
+  "&="
+  "|="
+  "^="
+  "<<="
+  ">>="
+  "="
+  ":="
+  "=="
+  "?"
+  "<-"
+  "$"
+  ".."
+  "..."
+] @operator
+
+; Punctuation
+[
+  "."
+  ","
+  ":"
+  ";"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+; Literals
+(int_literal) @number
+
+(float_literal) @number.float
+
+[
+  (c_string_literal)
+  (raw_string_literal)
+  (interpreted_string_literal)
+  (string_interpolation)
+  (rune_literal)
+] @string
+
+(string_interpolation
+  (interpolation_opening) @punctuation.bracket
+  (interpolation_expression) @none
+  (interpolation_closing) @punctuation.bracket)
+
+(escape_sequence) @string.escape
+
+[
+  (true)
+  (false)
+] @boolean
+
+(nil) @constant.builtin
+
+(none) @variable.builtin
+
+; Comments
+[
+  (line_comment)
+  (block_comment)
+] @comment @spell
+
+(_
+  (line_comment)+ @comment.documentation
+  .
+  [
+    (function_declaration)
+    (type_declaration)
+    (enum_declaration)
+  ])
diff --git a/pack/ant/start/nvim-treesitter/queries/v/indents.scm b/pack/ant/start/nvim-treesitter/queries/v/indents.scm
new file mode 100644
index 0000000..bf090ef
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/v/indents.scm
@@ -0,0 +1,20 @@
+[
+  (import_declaration)
+  (const_declaration)
+  (type_declaration)
+  (type_initializer)
+  (block)
+  (map_init_expression)
+  (call_expression)
+  (parameter_list)
+] @indent.begin
+
+"}" @indent.branch
+
+(parameter_list
+  ")" @indent.branch)
+
+[
+  (line_comment)
+  (block_comment)
+] @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/v/injections.scm b/pack/ant/start/nvim-treesitter/queries/v/injections.scm
new file mode 100644
index 0000000..2d7618b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/v/injections.scm
@@ -0,0 +1,23 @@
+([
+  (line_comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
+
+; asm_statement if asm ever highlighted :)
+; #include <...>
+((hash_statement) @injection.content
+  (#set! injection.language "c"))
+
+; regex for the methods defined in `re` module
+((call_expression
+  name: (selector_expression
+    field: (reference_expression
+      (identifier) @_re))
+  arguments: (argument_list
+    (argument
+      (literal
+        (raw_string_literal) @injection.content
+        (#offset! @injection.content 0 2 0 -1)))))
+  (#any-of? @_re "regex_base" "regex_opt" "compile_opt")
+  (#set! injection.language "regex"))
diff --git a/pack/ant/start/nvim-treesitter/queries/v/locals.scm b/pack/ant/start/nvim-treesitter/queries/v/locals.scm
new file mode 100644
index 0000000..a3423f6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/v/locals.scm
@@ -0,0 +1,37 @@
+(function_declaration
+  name: (identifier) @local.definition.function) ;@function
+
+(var_declaration
+  var_list: (expression_list
+    (reference_expression
+      (identifier) @local.definition.var)))
+
+(function_declaration
+  name: (identifier) @local.definition.function)
+
+(const_declaration
+  (const_definition
+    name: (identifier) @local.definition.var))
+
+(identifier) @local.reference
+
+((call_expression
+  name: (reference_expression
+    (identifier)) @local.reference)
+  (#set! reference.kind "call"))
+
+((call_expression
+  name: (selector_expression
+    field: (reference_expression
+      (identifier) @local.definition.function)))
+  (#set! reference.kind "call"))
+
+(source_file) @local.scope
+
+(function_declaration) @local.scope
+
+(if_expression) @local.scope
+
+(block) @local.scope
+
+(for_statement) @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/vala/folds.scm b/pack/ant/start/nvim-treesitter/queries/vala/folds.scm
new file mode 100644
index 0000000..a334e60
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vala/folds.scm
@@ -0,0 +1,11 @@
+[
+  (namespace_member)
+  (enum_declaration)
+  (class_declaration)
+  (if_statement)
+  (elseif_statement)
+  (try_statement)
+  (catch_clause)
+  (block)
+  (class_member)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/vala/highlights.scm b/pack/ant/start/nvim-treesitter/queries/vala/highlights.scm
new file mode 100644
index 0000000..0ba11ca
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vala/highlights.scm
@@ -0,0 +1,346 @@
+; highlights.scm
+; highlight comments and symbols
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$"))
+
+(symbol) @string.special.symbol
+
+(member_access_expression
+  (_)
+  (identifier) @string.special.symbol)
+
+; highlight constants
+((member_access_expression
+  (identifier) @constant)
+  (#lua-match? @constant "^[%u][%u%d_]*$"))
+
+((member_access_expression
+  (member_access_expression) @keyword.import
+  (identifier) @constant)
+  (#lua-match? @constant "^[%u][%u%d_]*$"))
+
+; highlight types and probable types
+(type
+  (symbol
+    (_)? @module
+    (identifier) @type))
+
+((member_access_expression
+  .
+  (identifier) @type)
+  (#match? @type "^[A-Z][A-Za-z_0-9]{2,}$"))
+
+; highlight creation methods in object creation expressions
+((object_creation_expression
+  (type
+    (symbol
+      (symbol
+        (symbol)? @keyword.import
+        (identifier) @type)
+      (identifier) @constructor)))
+  (#lua-match? @constructor "^[%l][%l%d_]*$"))
+
+(unqualified_type
+  (symbol
+    .
+    (identifier) @type))
+
+(unqualified_type
+  (symbol
+    (symbol) @module
+    (identifier) @type))
+
+(attribute) @attribute
+
+(namespace_declaration
+  (symbol) @module)
+
+(method_declaration
+  (symbol
+    (symbol) @type
+    (identifier) @function))
+
+(method_declaration
+  (symbol
+    (identifier) @function))
+
+(local_declaration
+  (assignment
+    (identifier) @variable))
+
+(local_function_declaration
+  (identifier) @function)
+
+(destructor_declaration
+  (identifier) @function)
+
+(creation_method_declaration
+  (symbol
+    (symbol) @type
+    (identifier) @constructor))
+
+(creation_method_declaration
+  (symbol
+    (identifier) @constructor))
+
+(constructor_declaration
+  (_)?
+  "construct" @keyword.function)
+
+(enum_declaration
+  (symbol) @type)
+
+(enum_value
+  (identifier) @constant)
+
+(errordomain_declaration
+  (symbol) @type)
+
+(errorcode
+  (identifier) @constant)
+
+(constant_declaration
+  (identifier) @constant)
+
+(method_call_expression
+  (member_access_expression
+    (identifier) @function))
+
+; highlight macros
+((method_call_expression
+  (member_access_expression
+    (identifier) @function.macro))
+  (#match? @function.macro "^assert[A-Za-z_0-9]*|error|info|debug|print|warning|warning_once$"))
+
+(lambda_expression
+  (identifier) @variable.parameter)
+
+(parameter
+  (identifier) @variable.parameter)
+
+(property_declaration
+  (symbol
+    (identifier) @property))
+
+(field_declaration
+  (identifier) @variable.member)
+
+[
+  (this_access)
+  (base_access)
+  (value_access)
+] @constant.builtin
+
+(boolean) @boolean
+
+(character) @character
+
+(escape_sequence) @string.escape
+
+(integer) @number
+
+(null) @constant.builtin
+
+(real) @number.float
+
+(regex) @string.regexp
+
+(string) @string
+
+(string_formatter) @string.special
+
+(template_string) @string
+
+(template_string_expression) @string.special
+
+(verbatim_string) @string
+
+[
+  "var"
+  "void"
+] @type.builtin
+
+(if_directive
+  expression: (_) @keyword.directive) @keyword
+
+(elif_directive
+  expression: (_) @keyword.directive) @keyword
+
+(else_directive) @keyword
+
+(endif_directive) @keyword
+
+[
+  "abstract"
+  "construct"
+  "continue"
+  "default"
+  "errordomain"
+  "get"
+  "inline"
+  "new"
+  "out"
+  "override"
+  "partial"
+  "ref"
+  "set"
+  "signal"
+  "virtual"
+  "with"
+] @keyword
+
+[
+  "enum"
+  "class"
+  "struct"
+  "interface"
+  "namespace"
+] @keyword.type
+
+"delegate" @keyword.function
+
+[
+  "async"
+  "yield"
+] @keyword.coroutine
+
+[
+  "const"
+  "dynamic"
+  "owned"
+  "weak"
+  "unowned"
+] @keyword.modifier
+
+[
+  "case"
+  "else"
+  "if"
+  "switch"
+] @keyword.conditional
+
+; specially highlight break statements in switch sections
+(switch_section
+  (break_statement
+    "break" @keyword.conditional))
+
+[
+  "extern"
+  "internal"
+  "private"
+  "protected"
+  "public"
+  "static"
+] @keyword.modifier
+
+[
+  "and"
+  "as"
+  "delete"
+  "in"
+  "is"
+  "lock"
+  "not"
+  "or"
+  "sizeof"
+  "typeof"
+] @keyword.operator
+
+"using" @keyword.import
+
+(using_directive
+  (symbol) @module)
+
+(symbol
+  "global::" @module)
+
+(array_creation_expression
+  "new" @keyword.operator)
+
+(object_creation_expression
+  "new" @keyword.operator)
+
+(argument
+  "out" @keyword.operator)
+
+(argument
+  "ref" @keyword.operator)
+
+[
+  "break"
+  "continue"
+  "do"
+  "for"
+  "foreach"
+  "while"
+] @keyword.repeat
+
+[
+  "catch"
+  "finally"
+  "throw"
+  "throws"
+  "try"
+] @keyword.exception
+
+"return" @keyword.return
+
+[
+  "="
+  "=="
+  "+"
+  "+="
+  "-"
+  "-="
+  "++"
+  "--"
+  "|"
+  "|="
+  "&"
+  "&="
+  "^"
+  "^="
+  "/"
+  "/="
+  "*"
+  "*="
+  "%"
+  "%="
+  "<<"
+  "<<="
+  ">>"
+  ">>="
+  "."
+  "?."
+  "->"
+  "!"
+  "!="
+  "~"
+  "??"
+  "?"
+  ":"
+  "<"
+  "<="
+  ">"
+  ">="
+  "||"
+  "&&"
+  "=>"
+] @operator
+
+[
+  ","
+  ";"
+] @punctuation.delimiter
+
+[
+  "$("
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/vala/injections.scm b/pack/ant/start/nvim-treesitter/queries/vala/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vala/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/vento/highlights.scm b/pack/ant/start/nvim-treesitter/queries/vento/highlights.scm
new file mode 100644
index 0000000..9d35b2f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vento/highlights.scm
@@ -0,0 +1,13 @@
+(comment) @comment @spell
+
+(keyword) @keyword
+
+(tag
+  [
+    "{{"
+    "{{-"
+    "}}"
+    "-}}"
+  ] @punctuation.special)
+
+"|>" @operator
diff --git a/pack/ant/start/nvim-treesitter/queries/vento/injections.scm b/pack/ant/start/nvim-treesitter/queries/vento/injections.scm
new file mode 100644
index 0000000..66023c7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vento/injections.scm
@@ -0,0 +1,9 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((content) @injection.content
+  (#set! injection.language "html")
+  (#set! injection.combined))
+
+((code) @injection.content
+  (#set! injection.language "javascript"))
diff --git a/pack/ant/start/nvim-treesitter/queries/verilog/folds.scm b/pack/ant/start/nvim-treesitter/queries/verilog/folds.scm
new file mode 100644
index 0000000..ea52476
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/verilog/folds.scm
@@ -0,0 +1,23 @@
+[
+  (seq_block)
+  (function_body_declaration)
+  (task_body_declaration)
+  (generate_block)
+  (always_construct)
+  (property_declaration)
+  (checker_declaration)
+  (class_declaration)
+  (config_declaration)
+  (covergroup_declaration)
+  (clocking_declaration)
+  (interface_declaration)
+  (module_declaration)
+  (package_declaration)
+  (module_instantiation)
+  (program_declaration)
+  (specify_block)
+  (generate_region)
+  (package_import_declaration)
+  (text_macro_definition)
+  (include_compiler_directive)+
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/verilog/highlights.scm b/pack/ant/start/nvim-treesitter/queries/verilog/highlights.scm
new file mode 100644
index 0000000..c8cff45
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/verilog/highlights.scm
@@ -0,0 +1,595 @@
+; Keywords
+[
+  "begin"
+  "end"
+  "generate"
+  "endgenerate"
+  (module_keyword)
+  "endmodule"
+  "program"
+  "endprogram"
+  "package"
+  "endpackage"
+  "checker"
+  "endchecker"
+  "config"
+  "endconfig"
+  "pure"
+  "virtual"
+  "extends"
+  "implements"
+  "super"
+  (class_item_qualifier)
+  "parameter"
+  "localparam"
+  "defparam"
+  "assign"
+  "modport"
+  "fork"
+  "join"
+  "join_none"
+  "join_any"
+  "default"
+  "break"
+  "tagged"
+  "extern"
+  "alias"
+  "posedge"
+  "negedge"
+  "bind"
+  "expect"
+  "type"
+  "void"
+  "coverpoint"
+  "cross"
+  "nettype"
+  "export"
+  "force"
+  "release"
+  "timeunit"
+  "timeprecision"
+  "sequence"
+  "endsequence"
+  "property"
+  "endproperty"
+  "clocking"
+  "endclocking"
+  "covergroup"
+  "endgroup"
+  "specify"
+  "endspecify"
+  "primitive"
+  "endprimitive"
+  "wait"
+  "wait_order"
+  "const"
+  "constraint"
+  "unique"
+  "do"
+  "genvar"
+  "inside"
+  "rand"
+  "continue"
+  "randc"
+  "event"
+  "global"
+  "ref"
+  "initial"
+  (unique_priority)
+  (bins_keyword)
+  (always_keyword)
+] @keyword
+
+[
+  "class"
+  "endclass"
+  "interface"
+  "endinterface"
+  "enum"
+  "struct"
+  "union"
+  "typedef"
+] @keyword.type
+
+[
+  "function"
+  "endfunction"
+  "task"
+  "endtask"
+] @keyword.function
+
+"return" @keyword.return
+
+[
+  "for"
+  "foreach"
+  "repeat"
+  "forever"
+  "while"
+] @keyword.repeat
+
+; for
+(loop_generate_construct
+  (generate_block
+    [
+      "begin"
+      "end"
+    ] @keyword.conditional))
+
+; foreach
+(loop_statement
+  (statement
+    (statement_item
+      (seq_block
+        [
+          "begin"
+          "end"
+        ] @keyword.conditional))))
+
+; repeat forever while
+(loop_statement
+  (statement_or_null
+    (statement
+      (statement_item
+        (seq_block
+          [
+            "begin"
+            "end"
+          ] @keyword.conditional)))))
+
+[
+  "if"
+  "else"
+  "iff"
+  (case_keyword)
+  "endcase"
+] @keyword.conditional
+
+[
+  "="
+  "-"
+  "+"
+  "/"
+  "*"
+  "^"
+  "&"
+  "|"
+  "&&"
+  "||"
+  "<="
+  "=="
+  "!="
+  "==="
+  "!=="
+  "-:"
+  "<"
+  ">"
+  ">="
+  "%"
+  ">>"
+  "<<"
+  "|="
+  "|=>"
+  "|->"
+  ">>>"
+  "<<<"
+  "->>"
+  "->"
+  "=>"
+  "*>"
+  ".*"
+  (unary_operator)
+  (inc_or_dec_operator)
+  (queue_dimension)
+] @operator
+
+"#" @constructor
+
+[
+  ";"
+  "::"
+  ","
+  "."
+  ":"
+] @punctuation.delimiter
+
+(conditional_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+[
+  "["
+  "]"
+  "("
+  ")"
+  "{"
+  "}"
+  "'{"
+] @punctuation.bracket
+
+[
+  "or"
+  "and"
+] @keyword.operator
+
+[
+  "input"
+  "output"
+  "inout"
+  "signed"
+  "unsigned"
+  "assert"
+  "cover"
+  "assume"
+  "disable"
+  "automatic"
+  "static"
+  (dpi_function_import_property)
+  (dpi_task_import_property)
+] @keyword.modifier
+
+[
+  "include"
+  "import"
+  "directive_include"
+] @keyword.import
+
+(comment) @comment @spell
+
+[
+  "@"
+  (cycle_delay_range)
+  (delay_control)
+  (cycle_delay)
+  (attribute_instance)
+] @attribute
+
+(attribute_instance
+  (attr_spec
+    (simple_identifier) @property))
+
+[
+  (integral_number)
+  (unbased_unsized_literal)
+  (fixed_point_number)
+  (unsigned_number)
+] @number
+
+[
+  (net_type)
+  (data_type)
+  (time_unit)
+] @type.builtin
+
+; variable
+(list_of_variable_decl_assignments
+  (variable_decl_assignment
+    name: (simple_identifier) @variable))
+
+(hierarchical_identifier
+  (simple_identifier) @variable)
+
+(tf_port_item
+  (simple_identifier) @variable)
+
+port_name: (simple_identifier) @variable
+
+(port
+  (simple_identifier) @variable)
+
+(list_of_port_identifiers
+  (simple_identifier) @variable)
+
+(net_lvalue
+  (simple_identifier) @variable)
+
+(sequence_port_item
+  (simple_identifier) @variable)
+
+(property_port_item
+  (simple_identifier) @variable)
+
+(net_decl_assignment
+  (simple_identifier) @variable)
+
+(ERROR
+  (simple_identifier) @variable)
+
+; variable.member
+(hierarchical_identifier
+  (simple_identifier)
+  (simple_identifier) @variable.member)
+
+(select
+  (simple_identifier) @variable.member)
+
+(named_port_connection
+  port_name: (simple_identifier) @variable.member)
+
+(ordered_port_connection
+  (expression
+    (primary
+      (hierarchical_identifier
+        (simple_identifier) @variable.member))))
+
+(coverage_option
+  (simple_identifier) @variable.member)
+
+; variable.builtin
+(method_call_body
+  arguments: (list_of_arguments
+    (expression) @variable.builtin
+    (#any-of? @variable.builtin "this")))
+
+(implicit_class_handle) @variable.builtin
+
+; variable.parameter
+(named_parameter_assignment
+  (simple_identifier) @variable.parameter)
+
+(parameter_declaration
+  (list_of_param_assignments
+    (param_assignment
+      (simple_identifier) @variable.parameter)))
+
+(local_parameter_declaration
+  (list_of_param_assignments
+    (param_assignment
+      (simple_identifier) @variable.parameter)))
+
+; function builtin
+[
+  (simulation_control_task)
+  (system_tf_identifier)
+  (severity_system_task)
+  (randomize_call)
+  (array_or_queue_method_name)
+  "new"
+] @function.builtin
+
+; declaration
+(task_body_declaration
+  .
+  name: (simple_identifier) @function
+  (simple_identifier)? @label)
+
+(function_body_declaration
+  .
+  name: (simple_identifier) @function
+  (simple_identifier)? @label)
+
+(function_body_declaration
+  .
+  (data_type_or_void)
+  name: (simple_identifier) @function
+  (simple_identifier)? @label)
+
+(clocking_declaration
+  .
+  name: (simple_identifier) @constructor
+  (simple_identifier)? @label)
+
+(sequence_declaration
+  .
+  name: (simple_identifier) @constructor
+  (simple_identifier)? @label)
+
+(property_declaration
+  .
+  name: (simple_identifier) @constructor
+  (simple_identifier)? @label)
+
+(class_declaration
+  .
+  name: (simple_identifier) @constructor
+  (simple_identifier)? @label)
+
+(interface_class_declaration
+  .
+  name: (simple_identifier) @constructor
+  (simple_identifier)? @label)
+
+(covergroup_declaration
+  .
+  name: (simple_identifier) @constructor
+  (simple_identifier)? @label)
+
+(package_declaration
+  .
+  name: (simple_identifier) @constructor
+  (simple_identifier)? @label)
+
+(checker_declaration
+  .
+  name: (simple_identifier) @constructor
+  (simple_identifier)? @label)
+
+(interface_declaration
+  .
+  [
+    (simple_identifier) @constructor
+    (interface_nonansi_header
+      (simple_identifier) @constructor)
+    (interface_ansi_header
+      (simple_identifier) @constructor)
+  ]
+  (simple_identifier)? @label)
+
+(module_declaration
+  .
+  [
+    (simple_identifier) @constructor
+    (module_nonansi_header
+      (simple_identifier) @constructor)
+    (module_ansi_header
+      (simple_identifier) @constructor)
+  ]
+  (simple_identifier)? @label)
+
+(program_declaration
+  .
+  [
+    (simple_identifier) @constructor
+    (program_nonansi_header
+      (simple_identifier) @constructor)
+    (program_ansi_header
+      (simple_identifier) @constructor)
+  ]
+  (simple_identifier)? @label)
+
+; function.call
+(method_call_body
+  name: (simple_identifier) @function.call)
+
+(tf_call
+  (hierarchical_identifier
+    (simple_identifier) @function.call))
+
+; instance
+(module_instantiation
+  instance_type: (simple_identifier) @constructor)
+
+(name_of_instance
+  instance_name: (simple_identifier) @module)
+
+(sequence_instance
+  (hierarchical_identifier
+    (simple_identifier) @module))
+
+(udp_instantiation
+  (simple_identifier) @constructor)
+
+(ansi_port_declaration
+  (interface_port_header
+    interface_name: (simple_identifier) @variable
+    modport_name: (simple_identifier) @variable.member)
+  port_name: (simple_identifier) @variable)
+
+; bind
+(bind_directive
+  (bind_target_scope
+    (simple_identifier) @constructor))
+
+(bind_target_instance
+  (hierarchical_identifier
+    (simple_identifier) @module))
+
+; assertion
+(concurrent_assertion_item
+  (simple_identifier) @label)
+
+; converge
+(cover_point
+  name: (simple_identifier) @label)
+
+(cover_cross
+  name: (simple_identifier) @module)
+
+(list_of_cross_items
+  (simple_identifier) @constructor)
+
+;package
+(package_import_item
+  (simple_identifier) @constructor)
+
+; label
+(seq_block
+  (simple_identifier) @label)
+
+(statement
+  block_name: (simple_identifier) @label)
+
+; dpi
+(dpi_spec_string) @string
+
+c_name: (c_identifier) @function
+
+(dpi_import_export
+  name: (simple_identifier) @function)
+
+; type def
+(class_type
+  (simple_identifier) @constructor)
+
+(class_type
+  (simple_identifier)
+  (simple_identifier) @type)
+
+(data_type
+  (class_scope
+    (class_type
+      (simple_identifier) @constructor)))
+
+(task_prototype
+  name: (simple_identifier) @function)
+
+(function_prototype
+  name: (simple_identifier) @function)
+
+(type_assignment
+  name: (simple_identifier) @type.definition)
+
+(interface_class_type
+  (simple_identifier) @type.definition)
+
+(package_scope
+  (simple_identifier) @constructor)
+
+(data_declaration
+  (type_declaration
+    type_name: (simple_identifier) @type.definition))
+
+(net_declaration
+  (simple_identifier) @type)
+
+(constraint_declaration
+  (simple_identifier) @constructor)
+
+(method_call
+  (primary
+    (hierarchical_identifier
+      (simple_identifier) @constructor)))
+
+(string_literal
+  (quoted_string) @string)
+
+; include
+(include_statement
+  (file_path_spec) @string.special.path)
+
+; directive
+[
+  "directive_define"
+  "directive_default_nettype"
+  "directive_resetall"
+  "directive_timescale"
+  "directive_undef"
+  "directive_undefineall"
+  "directive_ifdef"
+  "directive_elsif"
+  "directive_endif"
+  "directive_else"
+] @keyword.directive.define
+
+(include_compiler_directive
+  (quoted_string) @string.special.path)
+
+(include_compiler_directive
+  (system_lib_string) @string)
+
+(default_nettype_compiler_directive
+  (default_nettype_value) @type.builtin)
+
+(text_macro_definition
+  (text_macro_name
+    (simple_identifier) @keyword.directive))
+
+(text_macro_usage) @keyword.directive
+
+(ifdef_condition
+  (simple_identifier) @keyword.directive)
+
+(undefine_compiler_directive
+  (simple_identifier) @keyword.directive)
diff --git a/pack/ant/start/nvim-treesitter/queries/verilog/injections.scm b/pack/ant/start/nvim-treesitter/queries/verilog/injections.scm
new file mode 100644
index 0000000..05aa24d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/verilog/injections.scm
@@ -0,0 +1,5 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((macro_text) @injection.content
+  (#set! injection.language "verilog"))
diff --git a/pack/ant/start/nvim-treesitter/queries/vhdl/folds.scm b/pack/ant/start/nvim-treesitter/queries/vhdl/folds.scm
new file mode 100644
index 0000000..9fc6dea
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vhdl/folds.scm
@@ -0,0 +1,46 @@
+[
+  (block_comment)
+  (architecture_definition)
+  (architecture_head)
+  (concurrent_block)
+  (configuration_declaration)
+  (component_instantiation_statement)
+  (generic_map_aspect)
+  (port_map_aspect)
+  (process_statement)
+  (process_head)
+  (sequential_block)
+  (block_configuration)
+  (block_statement)
+  (block_head)
+  (component_declaration)
+  (component_configuration)
+  (generic_clause)
+  (port_clause)
+  (entity_declaration)
+  (entity_head)
+  (entity_body)
+  (package_declaration)
+  (package_definition)
+  (function_specification)
+  (subprogram_declaration)
+  (subprogram_definition)
+  (subprogram_head)
+  (procedure_specification)
+  (sequential_block)
+  (loop_statement)
+  (if_statement_block)
+  (if_statement)
+  (elsif_statement)
+  (else_statement)
+  (case_statement)
+  (case_statement_alternative)
+  (for_generate_statement)
+  (if_generate_statement)
+  (if_generate)
+  (elsif_generate)
+  (else_generate)
+  (case_generate_statement)
+  (case_generate_alternative)
+  (type_declaration)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/vhdl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/vhdl/highlights.scm
new file mode 100644
index 0000000..36cd562
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vhdl/highlights.scm
@@ -0,0 +1,427 @@
+(line_comment
+  (comment_content) @spell) @comment
+
+(block_comment
+  (comment_content) @spell) @comment.documentation
+
+(identifier) @variable
+
+[
+  "access"
+  "after"
+  "alias"
+  "architecture"
+  "array"
+  ; "assume"
+  "attribute"
+  "block"
+  "body"
+  "component"
+  "configuration"
+  "context"
+  ; "cover"
+  "disconnect"
+  "entity"
+  ; "fairness"
+  "file"
+  "force"
+  "generate"
+  "generic"
+  "group"
+  "label"
+  "literal"
+  "map"
+  "new"
+  "package"
+  "parameter"
+  "port"
+  "property"
+  "range"
+  "reject"
+  "release"
+  ; "restrict"
+  "sequence"
+  "transport"
+  "unaffected"
+  "view"
+  ; "vmode"
+  ; "vpkg"
+  ; "vprop"
+  "vunit"
+] @keyword
+
+[
+  (ALL)
+  (OTHERS)
+  "<>"
+  (DEFAULT)
+  (OPEN)
+] @constant.builtin
+
+[
+  "is"
+  "begin"
+  "end"
+] @keyword
+
+(parameter_specification
+  "in" @keyword)
+
+[
+  "process"
+  "wait"
+  "on"
+  "until"
+] @keyword.coroutine
+
+(end_process
+  "end" @keyword.coroutine)
+
+(timeout_clause
+  "for" @keyword.coroutine)
+
+[
+  "function"
+  "procedure"
+] @keyword.function
+
+(subprogram_end
+  "end" @keyword.function)
+
+[
+  "to"
+  "downto"
+  "of"
+] @keyword.operator
+
+[
+  "library"
+  "use"
+] @keyword.import
+
+[
+  "subtype"
+  "type"
+  "record"
+  "units"
+  "constant"
+  "signal"
+  "variable"
+] @keyword.type
+
+[
+  "protected"
+  "private"
+  "pure"
+  "impure"
+  "inertial"
+  "postponed"
+  ; "strong"
+  "guarded"
+  "out"
+  "inout"
+  "linkage"
+  "buffer"
+  "register"
+  "bus"
+  "shared"
+] @keyword.modifier
+
+(mode
+  "in" @keyword.modifier)
+
+(force_mode
+  "in" @keyword.modifier)
+
+[
+  "while"
+  "loop"
+  "next"
+  "exit"
+] @keyword.repeat
+
+(end_loop
+  "end" @keyword.repeat)
+
+(for_loop
+  "for" @keyword.repeat)
+
+(block_configuration
+  "for" @keyword)
+
+(configuration_specification
+  "for" @keyword)
+
+(component_configuration
+  "for" @keyword)
+
+(end_for
+  "for" @keyword)
+
+"return" @keyword.return
+
+[
+  "assert"
+  "report"
+  "severity"
+] @keyword.debug
+
+[
+  "if"
+  "then"
+  "elsif"
+  "case"
+] @keyword.conditional
+
+(end_if
+  "end" @keyword.conditional)
+
+(end_case
+  "end" @keyword.conditional)
+
+(when_element
+  "when" @keyword.conditional)
+
+(case_generate_alternative
+  "when" @keyword.conditional)
+
+(else_statement
+  "else" @keyword.conditional)
+
+(else_generate
+  "else" @keyword.conditional)
+
+[
+  "with"
+  "select"
+] @keyword.conditional.ternary
+
+(when_expression
+  "when" @keyword.conditional.ternary)
+
+(else_expression
+  "else" @keyword.conditional.ternary)
+
+(else_waveform
+  "else" @keyword.conditional.ternary)
+
+(else_expression_or_unaffected
+  "else" @keyword.conditional.ternary)
+
+"null" @constant.builtin
+
+(user_directive) @keyword.directive
+
+(protect_directive) @keyword.directive
+
+(warning_directive) @keyword.directive
+
+(error_directive) @keyword.directive
+
+(if_conditional_analysis
+  "if" @keyword.directive)
+
+(if_conditional_analysis
+  "then" @keyword.directive)
+
+(elsif_conditional_analysis
+  "elsif" @keyword.directive)
+
+(else_conditional_analysis
+  "else" @keyword.directive)
+
+(end_conditional_analysis
+  "end" @keyword.directive)
+
+(end_conditional_analysis
+  "if" @keyword.directive)
+
+(directive_body) @keyword.directive
+
+(directive_constant_builtin) @constant.macro
+
+(directive_error) @comment.error
+
+(directive_protect) @keyword.directive
+
+(directive_warning) @comment.warning
+
+[
+  (condition_conversion)
+  (relational_operator)
+  (sign)
+  (adding_operator)
+  (exponentiate)
+  (variable_assignment)
+  (signal_assignment)
+  "*"
+  "/"
+  ":"
+  "=>"
+] @operator
+
+[
+  (unary_operator)
+  (logical_operator)
+  (shift_operator)
+  "mod"
+  "not"
+  "rem"
+] @keyword.operator
+
+[
+  "'"
+  ","
+  "."
+  ";"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "<<"
+  ">>"
+] @punctuation.bracket
+
+"@" @punctuation.special
+
+[
+  (decimal_integer)
+  (string_literal_std_logic)
+] @number
+
+(decimal_float) @number.float
+
+(bit_string_length) @property
+
+(bit_string_base) @type.builtin
+
+(bit_string_value) @number
+
+(based_literal
+  (based_base) @type.builtin
+  (based_integer) @number)
+
+(based_literal
+  (based_base) @type.builtin
+  (based_float) @number.float)
+
+(string_literal) @string @spell
+
+(character_literal) @character
+
+(library_constant_std_logic) @constant.builtin
+
+(library_constant) @constant.builtin
+
+(library_function) @function.builtin
+
+(library_constant_boolean) @boolean
+
+(library_constant_character) @character
+
+(library_constant_debug) @keyword.debug
+
+(unit) @keyword.modifier
+
+(library_constant_unit) @keyword.modifier
+
+(label) @label
+
+(generic_map_aspect
+  "generic" @constructor
+  "map" @constructor)
+
+(port_map_aspect
+  "port" @constructor
+  "map" @constructor)
+
+(selection
+  (identifier) @variable.member)
+
+(_
+  view: (_) @type)
+
+(_
+  type: (_) @type)
+
+(_
+  library: (_) @module)
+
+(_
+  package: (_) @module)
+
+(_
+  entity: (_) @module)
+
+(_
+  component: (_) @module)
+
+(_
+  configuration: (_) @property)
+
+(_
+  architecture: (_) @property)
+
+(_
+  function: (_) @function)
+
+(_
+  procedure: (_) @function.method)
+
+(_
+  attribute: (_) @attribute)
+
+(_
+  constant: (_) @constant)
+
+(_
+  generic: (_) @variable.parameter)
+
+(_
+  view: (name
+    (_)) @type)
+
+(_
+  type: (name
+    (_)) @type)
+
+(_
+  entity: (name
+    (_)) @module)
+
+(_
+  component: (name
+    (_)) @module)
+
+(_
+  configuration: (name
+    (_)) @module)
+
+(library_type) @type.builtin
+
+[
+  (attribute_function)
+  (attribute_impure_function)
+  (attribute_mode_view)
+  (attribute_pure_function)
+  (attribute_range)
+  (attribute_signal)
+  (attribute_subtype)
+  (attribute_type)
+  (attribute_value)
+  (library_attribute)
+] @attribute.builtin
+
+(library_namespace) @module.builtin
+
+(subtype_declaration
+  (identifier) @type.definition)
+
+(type_declaration
+  (identifier) @type.definition)
+
+(mode_view_declaration
+  (identifier) @type.definition)
diff --git a/pack/ant/start/nvim-treesitter/queries/vhdl/injections.scm b/pack/ant/start/nvim-treesitter/queries/vhdl/injections.scm
new file mode 100644
index 0000000..5cbc06c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vhdl/injections.scm
@@ -0,0 +1,7 @@
+(line_comment
+  (comment_content) @injection.content
+  (#set! injection.language "comment"))
+
+(block_comment
+  (comment_content) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/vhs/highlights.scm b/pack/ant/start/nvim-treesitter/queries/vhs/highlights.scm
new file mode 100644
index 0000000..469fdd1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vhs/highlights.scm
@@ -0,0 +1,52 @@
+[
+  "Output"
+  "Backspace"
+  "Down"
+  "Enter"
+  "Escape"
+  "Left"
+  "Right"
+  "Space"
+  "Tab"
+  "Up"
+  "Set"
+  "Type"
+  "Sleep"
+  "Hide"
+  "Show"
+] @keyword
+
+[
+  "Shell"
+  "FontFamily"
+  "FontSize"
+  "Framerate"
+  "PlaybackSpeed"
+  "Height"
+  "LetterSpacing"
+  "TypingSpeed"
+  "LineHeight"
+  "Padding"
+  "Theme"
+  "LoopOffset"
+  "Width"
+] @type
+
+"@" @operator
+
+(control) @function.macro
+
+(float) @number.float
+
+(integer) @number
+
+(comment) @comment @spell
+
+[
+  (string)
+  (json)
+] @string
+
+(path) @string.special.path
+
+(time) @string.special
diff --git a/pack/ant/start/nvim-treesitter/queries/vhs/injections.scm b/pack/ant/start/nvim-treesitter/queries/vhs/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vhs/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/vim/folds.scm b/pack/ant/start/nvim-treesitter/queries/vim/folds.scm
new file mode 100644
index 0000000..0a1fb69
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vim/folds.scm
@@ -0,0 +1,4 @@
+[
+  (if_statement)
+  (function_definition)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/vim/highlights.scm b/pack/ant/start/nvim-treesitter/queries/vim/highlights.scm
new file mode 100644
index 0000000..14e5a81
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vim/highlights.scm
@@ -0,0 +1,353 @@
+(identifier) @variable
+
+((identifier) @constant
+  (#lua-match? @constant "^[A-Z][A-Z_0-9]*$"))
+
+; Keywords
+[
+  "if"
+  "else"
+  "elseif"
+  "endif"
+] @keyword.conditional
+
+[
+  "try"
+  "catch"
+  "finally"
+  "endtry"
+  "throw"
+] @keyword.exception
+
+[
+  "for"
+  "endfor"
+  "in"
+  "while"
+  "endwhile"
+  "break"
+  "continue"
+] @keyword.repeat
+
+[
+  "function"
+  "endfunction"
+] @keyword.function
+
+; Function related
+(function_declaration
+  name: (_) @function)
+
+(call_expression
+  function: (identifier) @function.call)
+
+(call_expression
+  function: (scoped_identifier
+    (identifier) @function.call))
+
+(parameters
+  (identifier) @variable.parameter)
+
+(default_parameter
+  (identifier) @variable.parameter)
+
+[
+  (bang)
+  (spread)
+] @punctuation.special
+
+[
+  (no_option)
+  (inv_option)
+  (default_option)
+  (option_name)
+] @variable.builtin
+
+[
+  (scope)
+  "a:"
+  "$"
+] @module
+
+; Commands and user defined commands
+[
+  "let"
+  "unlet"
+  "const"
+  "call"
+  "execute"
+  "normal"
+  "set"
+  "setfiletype"
+  "setlocal"
+  "silent"
+  "echo"
+  "echon"
+  "echohl"
+  "echomsg"
+  "echoerr"
+  "autocmd"
+  "augroup"
+  "return"
+  "syntax"
+  "filetype"
+  "source"
+  "lua"
+  "ruby"
+  "perl"
+  "python"
+  "highlight"
+  "command"
+  "delcommand"
+  "comclear"
+  "colorscheme"
+  "scriptencoding"
+  "startinsert"
+  "stopinsert"
+  "global"
+  "runtime"
+  "wincmd"
+  "cnext"
+  "cprevious"
+  "cNext"
+  "vertical"
+  "leftabove"
+  "aboveleft"
+  "rightbelow"
+  "belowright"
+  "topleft"
+  "botright"
+  (unknown_command_name)
+  "edit"
+  "enew"
+  "find"
+  "ex"
+  "visual"
+  "view"
+  "eval"
+  "sign"
+  "abort"
+] @keyword
+
+(map_statement
+  cmd: _ @keyword)
+
+(keycode) @character.special
+
+(command_name) @function.macro
+
+; Filetype command
+(filetype_statement
+  [
+    "detect"
+    "plugin"
+    "indent"
+    "on"
+    "off"
+  ] @keyword)
+
+; Syntax command
+(syntax_statement
+  (keyword) @string)
+
+(syntax_statement
+  [
+    "enable"
+    "on"
+    "off"
+    "reset"
+    "case"
+    "spell"
+    "foldlevel"
+    "iskeyword"
+    "keyword"
+    "match"
+    "cluster"
+    "region"
+    "clear"
+    "include"
+  ] @keyword)
+
+(syntax_argument
+  name: _ @keyword)
+
+[
+  "<buffer>"
+  "<nowait>"
+  "<silent>"
+  "<script>"
+  "<expr>"
+  "<unique>"
+] @constant.builtin
+
+(augroup_name) @module
+
+(au_event) @constant
+
+(normal_statement
+  (commands) @constant)
+
+; Highlight command
+(hl_attribute
+  key: _ @property
+  val: _ @constant)
+
+(hl_group) @type
+
+(highlight_statement
+  [
+    "default"
+    "link"
+    "clear"
+  ] @keyword)
+
+; Command command
+(command) @string
+
+(command_attribute
+  name: _ @property
+  val: (behavior
+    name: _ @constant
+    val: (identifier)? @function)?)
+
+; Edit command
+(plus_plus_opt
+  val: _? @constant) @property
+
+(plus_cmd
+  "+" @property) @property
+
+; Runtime command
+(runtime_statement
+  (where) @keyword.operator)
+
+; Colorscheme command
+(colorscheme_statement
+  (name) @string)
+
+; Scriptencoding command
+(scriptencoding_statement
+  (encoding) @string.special)
+
+; Literals
+(string_literal) @string
+
+(integer_literal) @number
+
+(float_literal) @number.float
+
+(comment) @comment @spell
+
+(line_continuation_comment) @comment @spell
+
+(pattern) @string.special
+
+(pattern_multi) @string.regexp
+
+(filename) @string.special.path
+
+(heredoc
+  (body) @string)
+
+(heredoc
+  (parameter) @keyword)
+
+[
+  (marker_definition)
+  (endmarker)
+] @label
+
+(literal_dictionary
+  (literal_key) @property)
+
+((scoped_identifier
+  (scope) @_scope
+  .
+  (identifier) @boolean)
+  (#eq? @_scope "v:")
+  (#any-of? @boolean "true" "false"))
+
+; Operators
+[
+  "||"
+  "&&"
+  "&"
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  ".."
+  "=="
+  "!="
+  ">"
+  ">="
+  "<"
+  "<="
+  "=~"
+  "!~"
+  "="
+  "+="
+  "-="
+  "*="
+  "/="
+  "%="
+  ".="
+  "..="
+  "<<"
+  "=<<"
+  "->"
+  (match_case)
+] @operator
+
+[
+  "is"
+  "isnot"
+] @keyword.operator
+
+; Some characters have different meanings based on the context
+(unary_operation
+  "!" @operator)
+
+(binary_operation
+  "." @operator)
+
+; Punctuation
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+  "#{"
+] @punctuation.bracket
+
+(field_expression
+  "." @punctuation.delimiter)
+
+[
+  ","
+  ":"
+] @punctuation.delimiter
+
+(ternary_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+; Options
+((set_value) @number
+  (#lua-match? @number "^[%d]+(%.[%d]+)?$"))
+
+(inv_option
+  "!" @operator)
+
+(set_item
+  "?" @operator)
+
+((set_item
+  option: (option_name) @_option
+  value: (set_value) @function)
+  (#any-of? @_option "tagfunc" "tfu" "completefunc" "cfu" "omnifunc" "ofu" "operatorfunc" "opfunc"))
diff --git a/pack/ant/start/nvim-treesitter/queries/vim/injections.scm b/pack/ant/start/nvim-treesitter/queries/vim/injections.scm
new file mode 100644
index 0000000..30d11cb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vim/injections.scm
@@ -0,0 +1,44 @@
+(lua_statement
+  (script
+    (body) @injection.content
+    (#set! injection.language "lua")))
+
+(lua_statement
+  (chunk) @injection.content
+  (#set! injection.language "lua"))
+
+(ruby_statement
+  (script
+    (body) @injection.content
+    (#set! injection.language "ruby")))
+
+(ruby_statement
+  (chunk) @injection.content
+  (#set! injection.language "ruby"))
+
+(python_statement
+  (script
+    (body) @injection.content
+    (#set! injection.language "python")))
+
+(python_statement
+  (chunk) @injection.content
+  (#set! injection.language "python"))
+
+; If we support perl at some point...
+; (perl_statement (script (body) @perl))
+; (perl_statement (chunk) @perl)
+(autocmd_statement
+  (pattern) @injection.content
+  (#set! injection.language "regex"))
+
+((set_item
+  option: (option_name) @_option
+  value: (set_value) @injection.content)
+  (#any-of? @_option
+    "includeexpr" "inex" "printexpr" "pexpr" "formatexpr" "fex" "indentexpr" "inde" "foldtext" "fdt"
+    "foldexpr" "fde" "diffexpr" "dex" "patchexpr" "pex" "charconvert" "ccv")
+  (#set! injection.language "vim"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/vim/locals.scm b/pack/ant/start/nvim-treesitter/queries/vim/locals.scm
new file mode 100644
index 0000000..8706472
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vim/locals.scm
@@ -0,0 +1,19 @@
+[
+  (script_file)
+  (function_definition)
+] @local.scope
+
+(function_declaration
+  name: (identifier) @local.definition.function)
+
+(function_declaration
+  parameters: (parameters
+    (identifier) @local.definition.parameter))
+
+(let_statement
+  [
+    (scoped_identifier)
+    (identifier)
+  ] @local.definition.var)
+
+(identifier) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/vimdoc/highlights.scm b/pack/ant/start/nvim-treesitter/queries/vimdoc/highlights.scm
new file mode 100644
index 0000000..829a643
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vimdoc/highlights.scm
@@ -0,0 +1,74 @@
+(h1
+  (delimiter) @markup.heading.1
+  (heading) @markup.heading.1)
+
+(h2
+  (delimiter) @markup.heading.2
+  (heading) @markup.heading.2)
+
+(h3
+  (heading) @markup.heading.3)
+
+(column_heading
+  (heading) @markup.heading.4)
+
+(column_heading
+  (delimiter) @markup.heading.4
+  (#set! conceal ""))
+
+(tag
+  "*" @label
+  (#set! conceal ""))
+
+(tag
+  text: (_) @label)
+
+(taglink
+  "|" @markup.link
+  (#set! conceal ""))
+
+(taglink
+  text: (_) @markup.link)
+
+(optionlink
+  text: (_) @markup.link)
+
+(codespan
+  "`" @markup.raw
+  (#set! conceal ""))
+
+(codespan
+  text: (_) @markup.raw)
+
+((codeblock) @markup.raw.block
+  (#set! priority 90))
+
+(codeblock
+  ">" @markup.raw
+  (#set! conceal ""))
+
+(codeblock
+  (language) @label
+  (#set! conceal ""))
+
+(block
+  "<" @markup.raw
+  (#set! conceal ""))
+
+(argument) @variable.parameter
+
+(keycode) @string.special
+
+((url) @string.special.url
+  (#set! @string.special.url url @string.special.url))
+
+(modeline) @keyword.directive
+
+((note) @comment.note
+  (#any-of? @comment.note "Note:" "NOTE:" "Notes:"))
+
+((note) @comment.warning
+  (#any-of? @comment.warning "Warning:" "WARNING:"))
+
+((note) @comment.error
+  (#any-of? @comment.error "Deprecated:" "DEPRECATED:"))
diff --git a/pack/ant/start/nvim-treesitter/queries/vimdoc/injections.scm b/pack/ant/start/nvim-treesitter/queries/vimdoc/injections.scm
new file mode 100644
index 0000000..3b8fbf0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vimdoc/injections.scm
@@ -0,0 +1,4 @@
+((codeblock
+  (language) @injection.language
+  (code) @injection.content)
+  (#set! injection.include-children))
diff --git a/pack/ant/start/nvim-treesitter/queries/vrl/folds.scm b/pack/ant/start/nvim-treesitter/queries/vrl/folds.scm
new file mode 100644
index 0000000..6c6d587
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vrl/folds.scm
@@ -0,0 +1,6 @@
+[
+  (block)
+  (object)
+  (array)
+  (arguments)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/vrl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/vrl/highlights.scm
new file mode 100644
index 0000000..f74d6dd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vrl/highlights.scm
@@ -0,0 +1,108 @@
+(comment) @comment @spell
+
+(null) @constant.builtin
+
+(timestamp) @constant
+
+(closure_variables
+  (ident) @variable.parameter)
+
+(integer) @number
+
+(float) @number.float
+
+[
+  (string)
+  (raw_string)
+] @string
+
+[
+  (raw_string_escape_sequence)
+  (escape_sequence)
+  (regex_escape_sequence)
+] @string.escape
+
+(string_template
+  "{{" @punctuation.special
+  (_)
+  "}}" @punctuation.special)
+
+(regex) @string.regexp
+
+(boolean) @boolean
+
+(ident) @variable
+
+(noop) @variable.builtin
+
+(function_call
+  (ident) @function.call)
+
+; VRL queries
+(query
+  [
+    (event)
+    (metadata)
+  ] @variable.builtin)
+
+(query
+  (path
+    [
+      (field) @variable
+      (string) @string
+      (index) @number
+      "." @punctuation.delimiter
+    ]))
+
+"return" @keyword.return
+
+"abort" @keyword.exception
+
+[
+  "if"
+  "else"
+] @keyword.conditional
+
+[
+  "="
+  "=="
+  "!="
+  "|="
+  ">"
+  ">="
+  "<"
+  "<="
+  "+"
+  "-"
+  "*"
+  "/"
+  "&&"
+  "||"
+  "??"
+  "|"
+  "!"
+] @operator
+
+[
+  "->"
+  ":"
+  ";"
+  ","
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+(closure_variables
+  "|" @punctuation.bracket)
+
+(function_call
+  (ident) @keyword.exception
+  "!"
+  (#any-of? @keyword.exception "assert" "assert_eq"))
diff --git a/pack/ant/start/nvim-treesitter/queries/vrl/indents.scm b/pack/ant/start/nvim-treesitter/queries/vrl/indents.scm
new file mode 100644
index 0000000..1fc1249
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vrl/indents.scm
@@ -0,0 +1,24 @@
+[
+  (block)
+  (object)
+  (array)
+  (arguments)
+] @indent.begin
+
+(block
+  "}" @indent.end)
+
+(object
+  "}" @indent.end)
+
+(array
+  "]" @indent.end)
+
+(arguments
+  ")" @indent.end)
+
+[
+  ")"
+  "]"
+  "}"
+] @indent.branch
diff --git a/pack/ant/start/nvim-treesitter/queries/vrl/injections.scm b/pack/ant/start/nvim-treesitter/queries/vrl/injections.scm
new file mode 100644
index 0000000..5aaf9bc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vrl/injections.scm
@@ -0,0 +1,6 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((regex) @injection.content
+  (#offset! @injection.content 0 2 0 -1)
+  (#set! injection.language "regex"))
diff --git a/pack/ant/start/nvim-treesitter/queries/vrl/locals.scm b/pack/ant/start/nvim-treesitter/queries/vrl/locals.scm
new file mode 100644
index 0000000..786da98
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vrl/locals.scm
@@ -0,0 +1,16 @@
+(closure_variables
+  (ident) @local.definition.parameter)
+
+[
+  (ident)
+  (metadata)
+] @local.reference
+
+(query
+  (event) @local.reference)
+
+[
+  (block)
+  (closure)
+  (if_statement)
+] @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/vue/folds.scm b/pack/ant/start/nvim-treesitter/queries/vue/folds.scm
new file mode 100644
index 0000000..314256e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vue/folds.scm
@@ -0,0 +1,6 @@
+[
+  (element)
+  (template_element)
+  (script_element)
+  (style_element)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/vue/highlights.scm b/pack/ant/start/nvim-treesitter/queries/vue/highlights.scm
new file mode 100644
index 0000000..64195c3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vue/highlights.scm
@@ -0,0 +1,43 @@
+; inherits: html_tags
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+(interpolation) @punctuation.special
+
+(interpolation
+  (raw_text) @none)
+
+(dynamic_directive_inner_value) @variable
+
+(directive_name) @tag.attribute
+
+; Accessing a component object's field
+(":"
+  .
+  (directive_value) @variable.member)
+
+("."
+  .
+  (directive_value) @property)
+
+; @click is like onclick for HTML
+("@"
+  .
+  (directive_value) @function.method)
+
+; Used in v-slot, declaring position the element should be put in
+("#"
+  .
+  (directive_value) @variable)
+
+(directive_attribute
+  (quoted_attribute_value) @punctuation.special)
+
+(directive_attribute
+  (quoted_attribute_value
+    (attribute_value) @none))
+
+(directive_modifier) @function.method
diff --git a/pack/ant/start/nvim-treesitter/queries/vue/indents.scm b/pack/ant/start/nvim-treesitter/queries/vue/indents.scm
new file mode 100644
index 0000000..6b377f3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vue/indents.scm
@@ -0,0 +1,7 @@
+; inherits: html_tags
+
+(template_element) @indent.begin
+
+(template_element
+  (end_tag
+    ">" @indent.end) @indent.branch)
diff --git a/pack/ant/start/nvim-treesitter/queries/vue/injections.scm b/pack/ant/start/nvim-treesitter/queries/vue/injections.scm
new file mode 100644
index 0000000..5869640
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/vue/injections.scm
@@ -0,0 +1,77 @@
+; inherits html_tags
+; <script lang="css">
+((style_element
+  (start_tag
+    (attribute
+      (attribute_name) @_lang
+      (quoted_attribute_value
+        (attribute_value) @injection.language)))
+  (raw_text) @injection.content)
+  (#eq? @_lang "lang")
+  (#any-of? @injection.language "css" "scss"))
+
+; TODO: When nvim-treesitter has postcss and less parsers, use @injection.language and @injection.content instead
+; <script lang="scss">
+(style_element
+  (start_tag
+    (attribute
+      (attribute_name) @_lang
+      (quoted_attribute_value
+        (attribute_value) @_scss)))
+  (raw_text) @injection.content
+  (#eq? @_lang "lang")
+  (#any-of? @_scss "less" "postcss" "sass")
+  (#set! injection.language "scss"))
+
+; <script lang="js">
+((script_element
+  (start_tag
+    (attribute
+      (attribute_name) @_lang
+      (quoted_attribute_value
+        (attribute_value) @_js)))
+  (raw_text) @injection.content)
+  (#eq? @_lang "lang")
+  (#eq? @_js "js")
+  (#set! injection.language "javascript"))
+
+; <script lang="ts">
+((script_element
+  (start_tag
+    (attribute
+      (attribute_name) @_lang
+      (quoted_attribute_value
+        (attribute_value) @_ts)))
+  (raw_text) @injection.content)
+  (#eq? @_lang "lang")
+  (#eq? @_ts "ts")
+  (#set! injection.language "typescript"))
+
+; <script lang="tsx">
+; <script lang="jsx">
+(script_element
+  (start_tag
+    (attribute
+      (attribute_name) @_attr
+      (quoted_attribute_value
+        (attribute_value) @injection.language)))
+  (#eq? @_attr "lang")
+  (#any-of? @injection.language "tsx" "jsx")
+  (raw_text) @injection.content)
+
+((interpolation
+  (raw_text) @injection.content)
+  (#set! injection.language "typescript"))
+
+(directive_attribute
+  (quoted_attribute_value
+    (attribute_value) @injection.content
+    (#set! injection.language "typescript")))
+
+(template_element
+  (start_tag
+    (attribute
+      (quoted_attribute_value
+        (attribute_value) @injection.language)))
+  (text) @injection.content
+  (#eq? @injection.language "pug"))
diff --git a/pack/ant/start/nvim-treesitter/queries/wgsl/folds.scm b/pack/ant/start/nvim-treesitter/queries/wgsl/folds.scm
new file mode 100644
index 0000000..60b526c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/wgsl/folds.scm
@@ -0,0 +1,10 @@
+[
+  (struct_declaration)
+  (function_declaration)
+  (if_statement)
+  (switch_statement)
+  (switch_body)
+  (loop_statement)
+  (for_statement)
+  (while_statement)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/wgsl/highlights.scm b/pack/ant/start/nvim-treesitter/queries/wgsl/highlights.scm
new file mode 100644
index 0000000..854ffe9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/wgsl/highlights.scm
@@ -0,0 +1,127 @@
+(identifier) @variable
+
+(int_literal) @number
+
+(float_literal) @number.float
+
+(bool_literal) @boolean
+
+(type_declaration) @type
+
+(function_declaration
+  (identifier) @function)
+
+(parameter
+  (variable_identifier_declaration
+    (identifier) @variable.parameter))
+
+(struct_declaration
+  (identifier) @type)
+
+(struct_declaration
+  (struct_member
+    (variable_identifier_declaration
+      (identifier) @variable.member)))
+
+(type_constructor_or_function_call_expression
+  (type_declaration) @function.call)
+
+[
+  "bitcast"
+  "discard"
+  "enable"
+  "fallthrough"
+  "let"
+  "type"
+  "var"
+  "override"
+  (texel_format)
+] @keyword
+
+"struct" @keyword.type
+
+[
+  "private"
+  "storage"
+  "uniform"
+  "workgroup"
+] @keyword.modifier
+
+[
+  "read"
+  "read_write"
+  "write"
+] @keyword.modifier
+
+"fn" @keyword.function
+
+"return" @keyword.return
+
+[
+  ","
+  "."
+  ":"
+  ";"
+  "->"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "loop"
+  "for"
+  "while"
+  "break"
+  "continue"
+  "continuing"
+] @keyword.repeat
+
+[
+  "if"
+  "else"
+  "switch"
+  "case"
+  "default"
+] @keyword.conditional
+
+[
+  "&"
+  "&&"
+  "/"
+  "!"
+  "="
+  "=="
+  "!="
+  ">"
+  ">="
+  ">>"
+  "<"
+  "<="
+  "<<"
+  "%"
+  "-"
+  "+"
+  "|"
+  "||"
+  "*"
+  "~"
+  "^"
+  "@"
+  "++"
+  "--"
+] @operator
+
+(attribute
+  (identifier) @attribute)
+
+[
+  (line_comment)
+  (block_comment)
+] @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/wgsl/indents.scm b/pack/ant/start/nvim-treesitter/queries/wgsl/indents.scm
new file mode 100644
index 0000000..b74e56e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/wgsl/indents.scm
@@ -0,0 +1,29 @@
+[
+  (parameter_list)
+  (compound_statement)
+  (loop_statement)
+  (struct_declaration)
+] @indent.begin
+
+(compound_statement
+  "}" @indent.end)
+
+(loop_statement
+  "}" @indent.end)
+
+(function_declaration
+  ")" @indent.end)
+
+(struct_declaration
+  "}" @indent.end)
+
+[
+  "else"
+  ")"
+  "}"
+] @indent.branch
+
+[
+  (line_comment)
+  (block_comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/wgsl/injections.scm b/pack/ant/start/nvim-treesitter/queries/wgsl/injections.scm
new file mode 100644
index 0000000..3cd6aac
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/wgsl/injections.scm
@@ -0,0 +1,5 @@
+([
+  (line_comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/wgsl_bevy/folds.scm b/pack/ant/start/nvim-treesitter/queries/wgsl_bevy/folds.scm
new file mode 100644
index 0000000..bb37140
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/wgsl_bevy/folds.scm
@@ -0,0 +1,2 @@
+; inherits wgsl
+(preproc_ifdef) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/wgsl_bevy/highlights.scm b/pack/ant/start/nvim-treesitter/queries/wgsl_bevy/highlights.scm
new file mode 100644
index 0000000..2a6a974
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/wgsl_bevy/highlights.scm
@@ -0,0 +1,44 @@
+; inherits wgsl
+[
+  "virtual"
+  "override"
+] @keyword
+
+[
+  "#import"
+  "#define_import_path"
+  "as"
+] @keyword.import
+
+"::" @punctuation.delimiter
+
+(function_declaration
+  (import_path
+    (identifier) @function .))
+
+(import_path
+  (identifier) @module
+  (identifier))
+
+(struct_declaration
+  (preproc_ifdef
+    (struct_member
+      (variable_identifier_declaration
+        (identifier) @variable.member))))
+
+(struct_declaration
+  (preproc_ifdef
+    (preproc_else
+      (struct_member
+        (variable_identifier_declaration
+          (identifier) @variable.member)))))
+
+(preproc_ifdef
+  name: (identifier) @constant.macro)
+
+[
+  "#ifdef"
+  "#ifndef"
+  "#endif"
+  "#else"
+] @keyword.directive
diff --git a/pack/ant/start/nvim-treesitter/queries/wgsl_bevy/indents.scm b/pack/ant/start/nvim-treesitter/queries/wgsl_bevy/indents.scm
new file mode 100644
index 0000000..3813218
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/wgsl_bevy/indents.scm
@@ -0,0 +1,7 @@
+; inherits wgsl
+[
+  "#ifdef"
+  "#ifndef"
+  "#else"
+  "#endif"
+] @indent.zero
diff --git a/pack/ant/start/nvim-treesitter/queries/wing/folds.scm b/pack/ant/start/nvim-treesitter/queries/wing/folds.scm
new file mode 100644
index 0000000..0acd8ad
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/wing/folds.scm
@@ -0,0 +1,17 @@
+[
+  (class_definition)
+  (class_implementation)
+  (interface_definition)
+  (interface_implementation)
+  (for_in_loop)
+  (while_statement)
+  (if_statement)
+  (if_let_statement)
+  (else_if_block)
+  (struct_definition)
+  (enum_definition)
+  (try_catch_statement)
+  (method_definition)
+  (import_statement)+
+  (initializer)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/wing/highlights.scm b/pack/ant/start/nvim-treesitter/queries/wing/highlights.scm
new file mode 100644
index 0000000..31e914f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/wing/highlights.scm
@@ -0,0 +1,179 @@
+(identifier) @variable
+
+(reference_identifier) @variable
+
+(member_identifier) @variable.member
+
+; Classes
+(custom_type) @type
+
+(class_field
+  name: (identifier) @property)
+
+(struct_field
+  name: (identifier) @property)
+
+(class_definition
+  name: (identifier) @type)
+
+(struct_definition
+  name: (identifier) @type)
+
+(interface_definition
+  name: (identifier) @type)
+
+(method_definition
+  name: (identifier) @function.method)
+
+(json_literal_member
+  (identifier) @property)
+
+; Functions
+(keyword_argument_key) @variable.parameter
+
+(parameter_definition
+  name: (identifier) @variable.parameter)
+
+(variadic) @variable.parameter.builtin
+
+(call
+  caller: (reference
+    (nested_identifier
+      property: (member_identifier) @function.method.call)))
+
+(call
+  caller: (reference
+    (reference_identifier) @function.method.call))
+
+; Primitives
+(number) @number
+
+(duration) @constant
+
+(string) @string
+
+(bool) @boolean
+
+[
+  (builtin_type)
+  "MutSet"
+  "MutMap"
+  "MutArray"
+  "Json"
+  "Set"
+  "Map"
+  "Array"
+  "MutJson"
+] @type.builtin
+
+(json_container_type) @type.builtin
+
+; Special
+(comment) @comment @spell
+
+[
+  "-"
+  "-="
+  "+"
+  "+="
+  "*"
+  "**"
+  "/"
+  "%"
+  "<"
+  "<="
+  "="
+  "=="
+  "!"
+  "!="
+  ">"
+  ">="
+  "&&"
+  "??"
+  "||"
+  "?"
+] @operator
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+(mutable_container_type
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(immutable_container_type
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+[
+  ";"
+  "."
+  ","
+  ":"
+  "=>"
+] @punctuation.delimiter
+
+[
+  "as"
+  "let"
+  "new"
+  (phase_specifier)
+  "impl"
+  "test"
+] @keyword
+
+"bring" @keyword.import
+
+[
+  "class"
+  "struct"
+  "interface"
+] @keyword.type
+
+[
+  "for"
+  "in"
+] @keyword.repeat
+
+[
+  "if"
+  "else"
+] @keyword.conditional
+
+[
+  "pub"
+  "protected"
+  "internal"
+  "extern"
+  (static)
+] @keyword.modifier
+
+"return" @keyword.return
+
+(import_statement
+  module_name: (identifier) @module)
+
+(import_statement
+  alias: (identifier) @module)
+
+(call
+  (reference
+    (nested_identifier
+      object: (reference) @_ref
+      property: (member_identifier) @_ident))
+  (argument_list
+    (positional_argument
+      (string) @string.regexp))
+  (#eq? @_ref "regex")
+  (#eq? @_ident "compile")
+  (#offset! @string.regexp 0 1 0 -1))
diff --git a/pack/ant/start/nvim-treesitter/queries/wing/injections.scm b/pack/ant/start/nvim-treesitter/queries/wing/injections.scm
new file mode 100644
index 0000000..bd3fdae
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/wing/injections.scm
@@ -0,0 +1,15 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+(call
+  (reference
+    (nested_identifier
+      object: (reference) @_ref
+      property: (member_identifier) @_ident))
+  (argument_list
+    (positional_argument
+      (string) @injection.content))
+  (#eq? @_ref "regex")
+  (#eq? @_ident "compile")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.language "regex"))
diff --git a/pack/ant/start/nvim-treesitter/queries/wing/locals.scm b/pack/ant/start/nvim-treesitter/queries/wing/locals.scm
new file mode 100644
index 0000000..9a860c5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/wing/locals.scm
@@ -0,0 +1,6 @@
+(block) @local.scope
+
+(variable_definition_statement
+  name: (identifier) @local.definition)
+
+; TODO: Missing "@local.reference" usage tuned for each relevant identifier location
diff --git a/pack/ant/start/nvim-treesitter/queries/wit/folds.scm b/pack/ant/start/nvim-treesitter/queries/wit/folds.scm
new file mode 100644
index 0000000..7f84ddd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/wit/folds.scm
@@ -0,0 +1,12 @@
+[
+  (world_items)
+  (world_body)
+  (interface_items)
+  (interface_body)
+] @fold
+
+(world_items
+  [
+    (use_item)
+    (import_item)
+  ])+ @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/wit/highlights.scm b/pack/ant/start/nvim-treesitter/queries/wit/highlights.scm
new file mode 100644
index 0000000..1f4b01c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/wit/highlights.scm
@@ -0,0 +1,166 @@
+(comment) @comment @spell
+
+(ty
+  (id)) @type
+
+(package_decl
+  (id) @module)
+
+(valid_semver) @string.special
+
+(world_item
+  name: (id) @module)
+
+(interface_item
+  name: (id) @module)
+
+(import_item
+  name: (id) @module
+  (extern_type
+    (interface_body)))
+
+(import_item
+  name: (id) @function
+  (extern_type
+    (func_type)))
+
+(export_item
+  name: (id) @module
+  (extern_type
+    (interface_body)))
+
+(export_item
+  name: (id) @function
+  (extern_type
+    (func_type)))
+
+(type_item
+  alias: (id) @type.definition)
+
+(func_item
+  name: (id) @function.method)
+
+(handle
+  (id) @type)
+
+(named_type
+  name: (id) @variable.parameter)
+
+(record_item
+  name: (id) @type)
+
+(record_field
+  name: (id) @variable.member)
+
+(flags_items
+  name: (id) @type)
+
+(flags_body
+  (id) @variable.member)
+
+(variant_items
+  name: (id) @type)
+
+(variant_case
+  name: (id) @constant)
+
+(enum_items
+  name: (id) @type)
+
+(enum_case
+  name: (id) @constant)
+
+(resource_item
+  name: (id) @type)
+
+(resource_method
+  (id) @function.method)
+
+(resource_method
+  "constructor" @constructor)
+
+(toplevel_use_item
+  "use" @keyword.import)
+
+(toplevel_use_item
+  alias: (id) @module)
+
+(use_item
+  "use" @keyword.import)
+
+(use_path
+  (id) @module)
+
+(use_names_item
+  (id) @module)
+
+"func" @keyword.function
+
+[
+  "type"
+  "interface"
+  "world"
+  "package"
+  "resource"
+  "record"
+  "enum"
+  "flags"
+  "variant"
+] @keyword.type
+
+"static" @keyword.modifier
+
+[
+  "include"
+  "import"
+  "export"
+  "as"
+] @keyword.import
+
+[
+  "u8"
+  "u16"
+  "u32"
+  "u64"
+  "s8"
+  "s16"
+  "s32"
+  "s64"
+  "f32"
+  "f64"
+  "float32" ; deprecated
+  "float64" ; deprecated
+  "char"
+  "bool"
+  "string"
+  "tuple"
+  "list"
+  "option"
+  "result"
+  "borrow"
+] @type.builtin
+
+[
+  "@"
+  "_"
+] @punctuation.special
+
+[
+  "/"
+  ";"
+  ":"
+  ","
+  "."
+  "->"
+] @punctuation.delimiter
+
+[
+  "{"
+  "}"
+  "("
+  ")"
+  ">"
+  "<"
+] @punctuation.bracket
+
+"=" @operator
diff --git a/pack/ant/start/nvim-treesitter/queries/wit/injections.scm b/pack/ant/start/nvim-treesitter/queries/wit/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/wit/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/xcompose/highlights.scm b/pack/ant/start/nvim-treesitter/queries/xcompose/highlights.scm
new file mode 100644
index 0000000..2afab42
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/xcompose/highlights.scm
@@ -0,0 +1,38 @@
+(keysym) @constant
+
+((keysym) @constant.builtin
+  (#eq? @constant.builtin "Multi_key"))
+
+(text) @string
+
+"include" @keyword.import
+
+[
+  (octal)
+  (hex)
+] @number
+
+[
+  (modifier)
+  "None"
+] @keyword.modifier
+
+[
+  "%L"
+  "%H"
+  "%S"
+] @string.special
+
+[
+  "!"
+  "~"
+] @operator
+
+[
+  ":"
+  "<"
+  ">"
+  "\""
+] @punctuation.delimiter
+
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/xcompose/injections.scm b/pack/ant/start/nvim-treesitter/queries/xcompose/injections.scm
new file mode 100644
index 0000000..2f0e58e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/xcompose/injections.scm
@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/xcompose/locals.scm b/pack/ant/start/nvim-treesitter/queries/xcompose/locals.scm
new file mode 100644
index 0000000..9b6f359
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/xcompose/locals.scm
@@ -0,0 +1,5 @@
+(result
+  (keysym) @local.definition)
+
+(event
+  (keysym) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/xml/folds.scm b/pack/ant/start/nvim-treesitter/queries/xml/folds.scm
new file mode 100644
index 0000000..494e8c0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/xml/folds.scm
@@ -0,0 +1,5 @@
+[
+  (element)
+  (doctypedecl)
+  (Comment)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/xml/highlights.scm b/pack/ant/start/nvim-treesitter/queries/xml/highlights.scm
new file mode 100644
index 0000000..85e6e9b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/xml/highlights.scm
@@ -0,0 +1,199 @@
+; XML declaration
+(XMLDecl
+  "xml" @keyword.directive)
+
+(XMLDecl
+  [
+    "version"
+    "encoding"
+    "standalone"
+  ] @tag.attribute)
+
+(XMLDecl
+  (EncName) @string.special)
+
+(XMLDecl
+  (VersionNum) @number)
+
+(XMLDecl
+  [
+    "yes"
+    "no"
+  ] @boolean)
+
+; Processing instructions
+(PI) @keyword.directive
+
+; Element declaration
+(elementdecl
+  "ELEMENT" @keyword.directive.define
+  (Name) @tag)
+
+(contentspec
+  (_
+    (Name) @tag.attribute))
+
+"#PCDATA" @type.builtin
+
+[
+  "EMPTY"
+  "ANY"
+] @keyword.modifier
+
+[
+  "*"
+  "?"
+  "+"
+] @character.special
+
+; Entity declaration
+(GEDecl
+  "ENTITY" @keyword.directive.define
+  (Name) @constant)
+
+(GEDecl
+  (EntityValue) @string)
+
+(NDataDecl
+  "NDATA" @keyword
+  (Name) @label)
+
+; Parsed entity declaration
+(PEDecl
+  "ENTITY" @keyword.directive.define
+  "%" @operator
+  (Name) @function.macro)
+
+(PEDecl
+  (EntityValue) @string)
+
+; Notation declaration
+(NotationDecl
+  "NOTATION" @keyword.directive
+  (Name) @label)
+
+; Attlist declaration
+(AttlistDecl
+  "ATTLIST" @keyword.directive.define
+  (Name) @tag)
+
+(AttDef
+  (Name) @tag.attribute)
+
+(AttDef
+  (Enumeration
+    (Nmtoken) @string))
+
+[
+  (StringType)
+  (TokenizedType)
+] @type.builtin
+
+(NotationType
+  "NOTATION" @type.builtin)
+
+[
+  "#REQUIRED"
+  "#IMPLIED"
+  "#FIXED"
+] @attribute
+
+; Entities
+(EntityRef) @constant
+
+((EntityRef) @constant.builtin
+  (#any-of? @constant.builtin "&amp;" "&lt;" "&gt;" "&quot;" "&apos;"))
+
+(CharRef) @character
+
+(PEReference) @function.macro
+
+; External references
+[
+  "PUBLIC"
+  "SYSTEM"
+] @keyword
+
+(PubidLiteral) @string.special
+
+(SystemLiteral
+  (URI) @string.special.url)
+
+; Processing instructions
+(XmlModelPI
+  "xml-model" @keyword.directive)
+
+(StyleSheetPI
+  "xml-stylesheet" @keyword.directive)
+
+(PseudoAtt
+  (Name) @tag.attribute)
+
+(PseudoAtt
+  (PseudoAttValue) @string)
+
+; Doctype declaration
+(doctypedecl
+  "DOCTYPE" @keyword.directive.define)
+
+(doctypedecl
+  (Name) @type.definition)
+
+; Tags
+(STag
+  (Name) @tag)
+
+(ETag
+  (Name) @tag)
+
+(EmptyElemTag
+  (Name) @tag)
+
+; Attributes
+(Attribute
+  (Name) @tag.attribute)
+
+(Attribute
+  (AttValue) @string)
+
+; Delimiters & punctuation
+[
+  "<?"
+  "?>"
+  "<"
+  ">"
+  "</"
+  "/>"
+  "<!"
+  "]]>"
+] @tag.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "\""
+  "'"
+] @punctuation.delimiter
+
+[
+  ","
+  "|"
+  "="
+] @operator
+
+; Text
+(CharData) @none @spell
+
+((CDSect
+  (CDStart) @module
+  (CData) @markup.raw
+  "]]>" @module)
+  (#set! priority 105))
+
+; Misc
+(Comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/xml/indents.scm b/pack/ant/start/nvim-treesitter/queries/xml/indents.scm
new file mode 100644
index 0000000..24cd75c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/xml/indents.scm
@@ -0,0 +1,16 @@
+(element) @indent.begin
+
+[
+  (Attribute)
+  (AttlistDecl)
+  (contentspec)
+] @indent.align
+
+(ETag) @indent.dedent
+
+(doctypedecl) @indent.ignore
+
+[
+  (Comment)
+  (ERROR)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/xml/injections.scm b/pack/ant/start/nvim-treesitter/queries/xml/injections.scm
new file mode 100644
index 0000000..02e99f0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/xml/injections.scm
@@ -0,0 +1,32 @@
+((Comment) @injection.content
+  (#set! injection.language "comment"))
+
+; SVG style
+((element
+  (STag
+    (Name) @_name)
+  (content) @injection.content)
+  (#eq? @_name "style")
+  (#set! injection.combined)
+  (#set! injection.include-children)
+  (#set! injection.language "css"))
+
+; SVG script
+((element
+  (STag
+    (Name) @_name)
+  (content) @injection.content)
+  (#eq? @_name "script")
+  (#set! injection.combined)
+  (#set! injection.include-children)
+  (#set! injection.language "javascript"))
+
+; phpMyAdmin dump
+((element
+  (STag
+    (Name) @_name)
+  (content) @injection.content)
+  (#eq? @_name "pma:table")
+  (#set! injection.combined)
+  (#set! injection.include-children)
+  (#set! injection.language "sql"))
diff --git a/pack/ant/start/nvim-treesitter/queries/xml/locals.scm b/pack/ant/start/nvim-treesitter/queries/xml/locals.scm
new file mode 100644
index 0000000..2806b53
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/xml/locals.scm
@@ -0,0 +1,35 @@
+; tags
+(elementdecl
+  (Name) @local.definition.type)
+
+(elementdecl
+  (contentspec
+    (children
+      (Name) @local.reference)))
+
+(AttlistDecl
+  .
+  (Name) @local.reference)
+
+(STag
+  (Name) @local.reference)
+
+(ETag
+  (Name) @local.reference)
+
+(EmptyElemTag
+  (Name) @local.reference)
+
+; attributes
+(AttDef
+  (Name) @local.definition.field)
+
+(Attribute
+  (Name) @local.reference)
+
+; entities
+(GEDecl
+  (Name) @local.definition.macro)
+
+(EntityRef
+  (Name) @local.reference)
diff --git a/pack/ant/start/nvim-treesitter/queries/xresources/folds.scm b/pack/ant/start/nvim-treesitter/queries/xresources/folds.scm
new file mode 100644
index 0000000..9cc7d5c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/xresources/folds.scm
@@ -0,0 +1,10 @@
+[
+  (elif_directive)
+  (elifdef_directive)
+  (else_directive)
+  (if_directive)
+  (ifdef_directive)
+  (preprocessor_comment)
+  (comment)+
+  (include_directive)+
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/xresources/highlights.scm b/pack/ant/start/nvim-treesitter/queries/xresources/highlights.scm
new file mode 100644
index 0000000..4bf3947
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/xresources/highlights.scm
@@ -0,0 +1,75 @@
+[
+  (comment)
+  (preprocessor_comment)
+] @comment @spell
+
+"#include" @keyword.import
+
+[
+  "#define"
+  "#undef"
+] @keyword.directive.define
+
+[
+  "#if"
+  "#ifdef"
+  "#ifndef"
+  "#elif"
+  "#elifdef"
+  "#elifndef"
+  "#else"
+  "#endif"
+  (directive)
+] @keyword.directive
+
+(identifier) @variable
+
+(define_directive
+  name: (identifier) @constant.macro)
+
+(define_function_directive
+  name: (identifier) @function.macro)
+
+(parameters
+  (identifier) @variable.parameter)
+
+"..." @variable.parameter.builtin
+
+(undef_directive
+  name: (identifier) @constant.macro)
+
+(ifdef_directive
+  condition: (identifier) @constant.macro)
+
+(elifdef_directive
+  condition: (identifier) @constant.macro)
+
+(expansion) @markup.raw
+
+(component) @variable.member
+
+(components
+  (component) @property .)
+
+[
+  (string)
+  (resource_value)
+] @string
+
+(escape_sequence) @string.escape
+
+[
+  "*"
+  (any_component)
+] @character.special
+
+[
+  "."
+  ","
+  ":"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/xresources/injections.scm b/pack/ant/start/nvim-treesitter/queries/xresources/injections.scm
new file mode 100644
index 0000000..1f12a21
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/xresources/injections.scm
@@ -0,0 +1,5 @@
+([
+  (comment)
+  (preprocessor_comment)
+] @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/xresources/locals.scm b/pack/ant/start/nvim-treesitter/queries/xresources/locals.scm
new file mode 100644
index 0000000..a7f9324
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/xresources/locals.scm
@@ -0,0 +1,12 @@
+(define_directive
+  name: (identifier) @local.definition.macro)
+
+(define_function_directive
+  name: (identifier) @local.definition.macro)
+
+(parameters
+  (identifier) @local.definition.parameter)
+
+(identifier) @local.reference
+
+(resources) @local.scope
diff --git a/pack/ant/start/nvim-treesitter/queries/yaml/folds.scm b/pack/ant/start/nvim-treesitter/queries/yaml/folds.scm
new file mode 100644
index 0000000..c426afb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/yaml/folds.scm
@@ -0,0 +1,4 @@
+[
+  (block_mapping_pair)
+  (block_sequence_item)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/yaml/highlights.scm b/pack/ant/start/nvim-treesitter/queries/yaml/highlights.scm
new file mode 100644
index 0000000..d410683
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/yaml/highlights.scm
@@ -0,0 +1,82 @@
+(boolean_scalar) @boolean
+
+(null_scalar) @constant.builtin
+
+(double_quote_scalar) @string
+
+(single_quote_scalar) @string
+
+((block_scalar) @string
+  (#set! priority 99))
+
+(string_scalar) @string
+
+(escape_sequence) @string.escape
+
+(integer_scalar) @number
+
+(float_scalar) @number
+
+(comment) @comment @spell
+
+[
+  (anchor_name)
+  (alias_name)
+] @label
+
+(tag) @type
+
+[
+  (yaml_directive)
+  (tag_directive)
+  (reserved_directive)
+] @keyword.directive
+
+(block_mapping_pair
+  key: (flow_node
+    [
+      (double_quote_scalar)
+      (single_quote_scalar)
+    ] @property))
+
+(block_mapping_pair
+  key: (flow_node
+    (plain_scalar
+      (string_scalar) @property)))
+
+(flow_mapping
+  (_
+    key: (flow_node
+      [
+        (double_quote_scalar)
+        (single_quote_scalar)
+      ] @property)))
+
+(flow_mapping
+  (_
+    key: (flow_node
+      (plain_scalar
+        (string_scalar) @property))))
+
+[
+  ","
+  "-"
+  ":"
+  ">"
+  "?"
+  "|"
+] @punctuation.delimiter
+
+[
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "*"
+  "&"
+  "---"
+  "..."
+] @punctuation.special
diff --git a/pack/ant/start/nvim-treesitter/queries/yaml/indents.scm b/pack/ant/start/nvim-treesitter/queries/yaml/indents.scm
new file mode 100644
index 0000000..f7146d3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/yaml/indents.scm
@@ -0,0 +1,7 @@
+[
+  (block_mapping_pair
+    value: (block_node))
+  (block_sequence_item)
+] @indent.begin
+
+(ERROR) @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/yaml/injections.scm b/pack/ant/start/nvim-treesitter/queries/yaml/injections.scm
new file mode 100644
index 0000000..b05c332
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/yaml/injections.scm
@@ -0,0 +1,80 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; Github actions ("run") / Gitlab CI ("scripts")
+(block_mapping_pair
+  key: (flow_node) @_run
+  (#any-of? @_run "run" "script" "before_script" "after_script")
+  value: (flow_node
+    (plain_scalar
+      (string_scalar) @injection.content)
+    (#set! injection.language "bash")))
+
+(block_mapping_pair
+  key: (flow_node) @_run
+  (#any-of? @_run "run" "script" "before_script" "after_script")
+  value: (block_node
+    (block_scalar) @injection.content
+    (#set! injection.language "bash")
+    (#offset! @injection.content 0 1 0 0)))
+
+(block_mapping_pair
+  key: (flow_node) @_run
+  (#any-of? @_run "run" "script" "before_script" "after_script")
+  value: (block_node
+    (block_sequence
+      (block_sequence_item
+        (flow_node
+          (plain_scalar
+            (string_scalar) @injection.content))
+        (#set! injection.language "bash")))))
+
+(block_mapping_pair
+  key: (flow_node) @_run
+  (#any-of? @_run "script" "before_script" "after_script")
+  value: (block_node
+    (block_sequence
+      (block_sequence_item
+        (block_node
+          (block_scalar) @injection.content
+          (#set! injection.language "bash")
+          (#offset! @injection.content 0 1 0 0))))))
+
+; Prometheus Alertmanager ("expr")
+(block_mapping_pair
+  key: (flow_node) @_expr
+  (#eq? @_expr "expr")
+  value: (flow_node
+    (plain_scalar
+      (string_scalar) @injection.content)
+    (#set! injection.language "promql")))
+
+(block_mapping_pair
+  key: (flow_node) @_expr
+  (#eq? @_expr "expr")
+  value: (block_node
+    (block_scalar) @injection.content
+    (#set! injection.language "promql")
+    (#offset! @injection.content 0 1 0 0)))
+
+(block_mapping_pair
+  key: (flow_node) @_expr
+  (#eq? @_expr "expr")
+  value: (block_node
+    (block_sequence
+      (block_sequence_item
+        (flow_node
+          (plain_scalar
+            (string_scalar) @injection.content))
+        (#set! injection.language "promql")))))
+
+(block_mapping_pair
+  key: (flow_node) @_expr
+  (#eq? @_expr "expr")
+  value: (block_node
+    (block_sequence
+      (block_sequence_item
+        (block_node
+          (block_scalar) @injection.content
+          (#set! injection.language "promql")
+          (#offset! @injection.content 0 1 0 0))))))
diff --git a/pack/ant/start/nvim-treesitter/queries/yaml/locals.scm b/pack/ant/start/nvim-treesitter/queries/yaml/locals.scm
new file mode 100644
index 0000000..f7c79e0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/yaml/locals.scm
@@ -0,0 +1,9 @@
+[
+  (stream)
+  (document)
+  (block_node)
+] @local.scope
+
+(anchor_name) @local.definition
+
+(alias_name) @local.reference
diff --git a/pack/ant/start/nvim-treesitter/queries/yang/folds.scm b/pack/ant/start/nvim-treesitter/queries/yang/folds.scm
new file mode 100644
index 0000000..fd7d239
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/yang/folds.scm
@@ -0,0 +1 @@
+(block) @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/yang/highlights.scm b/pack/ant/start/nvim-treesitter/queries/yang/highlights.scm
new file mode 100644
index 0000000..1fb588a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/yang/highlights.scm
@@ -0,0 +1,79 @@
+(comment) @comment @spell
+
+; Module / submodule
+[
+  "module"
+  "submodule"
+] @keyword
+
+; Keywords
+(statement_keyword) @keyword
+
+(statement_keyword
+  "import") @keyword.import
+
+(extension_keyword) @function
+
+; Arguments
+(built_in_type) @type.builtin
+
+(number) @number
+
+(boolean) @boolean
+
+(date) @number
+
+(range
+  (_
+    ".." @punctuation.special))
+
+(range
+  (_
+    "|" @punctuation.special))
+
+(quoted_range
+  "\"" @string.special)
+
+(quoted_range
+  "'" @string.special)
+
+(yang_version) @constant.builtin
+
+(identifier) @variable
+
+(node_identifier) @variable
+
+(string) @string
+
+(string
+  (escape_sequence) @string.escape)
+
+(unquoted_string) @string
+
+(keypath) @string.special.path
+
+; Always highlight the value of an enum statement as a constant
+(enum_value) @constant
+
+; Highlight xpath and pattern strings differently from plain strings
+(statement
+  (statement_keyword
+    "must")
+  (argument
+    (string) @string.special))
+
+(statement
+  (statement_keyword
+    "pattern")
+  (argument
+    (string) @string.regexp))
+
+; Punctuation
+(plus_symbol) @operator
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+";" @punctuation.delimiter
diff --git a/pack/ant/start/nvim-treesitter/queries/yang/indents.scm b/pack/ant/start/nvim-treesitter/queries/yang/indents.scm
new file mode 100644
index 0000000..cc4b3ca
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/yang/indents.scm
@@ -0,0 +1,20 @@
+(module) @indent.begin
+
+(submodule) @indent.begin
+
+(statement) @indent.begin
+
+(extension_statement) @indent.begin
+
+(statement
+  ";" @indent.end)
+
+(extension_statement
+  ";" @indent.end)
+
+(block
+  "}" @indent.end @indent.branch)
+
+((string) @indent.align
+  (#set! indent.open_delimiter "\"")
+  (#set! indent.close_delimiter "\""))
diff --git a/pack/ant/start/nvim-treesitter/queries/yang/injections.scm b/pack/ant/start/nvim-treesitter/queries/yang/injections.scm
new file mode 100644
index 0000000..4219eb3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/yang/injections.scm
@@ -0,0 +1,10 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((statement
+  (statement_keyword
+    "pattern")
+  (argument
+    (string) @injection.content))
+  (#set! injection.language "regex")
+  (#offset! @injection.content 0 1 0 -1))
diff --git a/pack/ant/start/nvim-treesitter/queries/yuck/folds.scm b/pack/ant/start/nvim-treesitter/queries/yuck/folds.scm
new file mode 100644
index 0000000..bad5a07
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/yuck/folds.scm
@@ -0,0 +1,9 @@
+[
+  (ast_block)
+  (list)
+  (array)
+  (expr)
+  (json_array)
+  (json_object)
+  (parenthesized_expression)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/yuck/highlights.scm b/pack/ant/start/nvim-treesitter/queries/yuck/highlights.scm
new file mode 100644
index 0000000..7b9a9d2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/yuck/highlights.scm
@@ -0,0 +1,154 @@
+; Tags
+; TODO apply to every symbol in list? I think it should probably only be applied to the first child of the list
+(list
+  (symbol) @tag)
+
+; Includes
+(list
+  .
+  (symbol) @keyword.import
+  (#eq? @keyword.import "include"))
+
+; Keywords
+(list
+  .
+  (symbol) @keyword
+  (#any-of? @keyword
+    "defwindow" "defwidget" "defvar" "defpoll" "deflisten" "geometry" "children" "struts"))
+
+; Loop
+(loop_widget
+  .
+  "for" @keyword.repeat
+  .
+  (symbol) @variable
+  .
+  "in" @keyword.operator)
+
+(loop_widget
+  .
+  "for" @keyword.repeat
+  .
+  (symbol) @variable
+  .
+  "in" @keyword.operator
+  .
+  (symbol) @variable)
+
+; Builtin widgets
+(list
+  .
+  (symbol) @tag.builtin
+  (#any-of? @tag.builtin
+    "box" "button" "calendar" "centerbox" "checkbox" "circular-progress" "color-button"
+    "color-chooser" "combo-box-text" "eventbox" "expander" "graph" "image" "input" "label" "literal"
+    "overlay" "progress" "revealer" "scale" "scroll" "transform"))
+
+; Variables
+(ident) @variable
+
+(array
+  (symbol) @variable)
+
+((ident) @variable.builtin
+  (#any-of? @variable.builtin
+    "EWW_TEMPS" "EWW_RAM" "EWW_DISK" "EWW_BATTERY" "EWW_CPU" "EWW_NET" "EWW_TIME" "EWW_CONFIG_DIR"
+    "EWW_CMD" "EWW_EXECUTABLE"))
+
+; Properties
+(keyword) @property
+
+(json_access
+  (_)
+  "["
+  (simplexpr
+    (ident) @property))
+
+(json_safe_access
+  (_)
+  "?."
+  "["
+  (simplexpr
+    (ident) @property))
+
+(json_dot_access
+  (index) @property)
+
+(json_safe_dot_access
+  (index) @property)
+
+(json_object
+  (simplexpr
+    (ident) @property))
+
+; Functions
+(function_call
+  name: (ident) @function.call)
+
+; Operators
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "||"
+  "&&"
+  "=="
+  "!="
+  "=~"
+  ">"
+  "<"
+  ">="
+  "<="
+  "!"
+  "?."
+  "?:"
+] @operator
+
+; Punctuation
+[
+  ":"
+  "."
+  ","
+] @punctuation.delimiter
+
+[
+  "{"
+  "}"
+  "["
+  "]"
+  "("
+  ")"
+] @punctuation.bracket
+
+; Ternary expression
+(ternary_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+; Literals
+(number) @number
+
+(float) @number.float
+
+(boolean) @boolean
+
+; Strings
+[
+  (string_fragment)
+  "\""
+  "'"
+  "`"
+] @string
+
+(string_interpolation
+  "${" @punctuation.special
+  "}" @punctuation.special)
+
+(escape_sequence) @string.escape
+
+; Comments
+(comment) @comment @spell
diff --git a/pack/ant/start/nvim-treesitter/queries/yuck/indents.scm b/pack/ant/start/nvim-treesitter/queries/yuck/indents.scm
new file mode 100644
index 0000000..5157950
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/yuck/indents.scm
@@ -0,0 +1,30 @@
+[
+  (ast_block)
+  (array)
+  (expr)
+  (json_array)
+  (json_object)
+  (parenthesized_expression)
+] @indent.begin
+
+; TODO: can't get this to work, goal is to indent at the property ":" prefix
+; ((list (identifier) (property)) @indent.align
+;   (#set! indent.open_delimiter "(")
+;   (#set! indent.close_delimiter ")"))
+[
+  ")"
+  "}"
+  "]"
+] @indent.end @indent.branch
+
+; I do not know what/when this should be added.
+; Commenting this out for now
+; [
+;   "("
+;   "{"
+;   "["
+; ] @indent.branch
+[
+  (ERROR)
+  (comment)
+] @indent.auto
diff --git a/pack/ant/start/nvim-treesitter/queries/yuck/injections.scm b/pack/ant/start/nvim-treesitter/queries/yuck/injections.scm
new file mode 100644
index 0000000..298a8d0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/yuck/injections.scm
@@ -0,0 +1,26 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((function_call
+  name: (ident) @_name
+  .
+  (simplexpr)
+  .
+  (simplexpr
+    (string
+      (string_fragment) @injection.content)+))
+  (#any-of? @_name "replace" "search" "matches" "captures")
+  (#set! injection.language "regex")
+  (#set! injection.combined))
+
+((function_call
+  name: (ident) @_name
+  .
+  (simplexpr)
+  .
+  (simplexpr
+    (string
+      (string_fragment) @injection.content)+))
+  (#eq? @_name "jq")
+  (#set! injection.language "jq")
+  (#set! injection.combined))
diff --git a/pack/ant/start/nvim-treesitter/queries/yuck/locals.scm b/pack/ant/start/nvim-treesitter/queries/yuck/locals.scm
new file mode 100644
index 0000000..9f40b20
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/yuck/locals.scm
@@ -0,0 +1,21 @@
+[
+  (ast_block)
+  (list)
+  (array)
+  (expr)
+  (json_array)
+  (json_object)
+  (parenthesized_expression)
+] @local.scope
+
+(symbol) @local.reference
+
+(keyword) @local.definition.field
+
+(json_object
+  (simplexpr
+    (ident) @local.definition.field))
+
+(ast_block
+  (symbol)
+  (ident) @local.definition.type)
diff --git a/pack/ant/start/nvim-treesitter/queries/zathurarc/highlights.scm b/pack/ant/start/nvim-treesitter/queries/zathurarc/highlights.scm
new file mode 100644
index 0000000..04daa19
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/zathurarc/highlights.scm
@@ -0,0 +1,36 @@
+; General
+(path) @string.special.path
+
+(option) @variable.builtin
+
+(command) @keyword
+
+(include_directive
+  (command) @keyword.import)
+
+(mode_name) @type.builtin
+
+(key) @constant
+
+(function) @function.call
+
+(argument) @variable.parameter
+
+; Comments
+(comment) @comment @spell
+
+; Literals
+(int) @number
+
+(float) @number.float
+
+(string) @string
+
+(bool) @boolean
+
+[
+  "<"
+  ">"
+  "["
+  "]"
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/zathurarc/injections.scm b/pack/ant/start/nvim-treesitter/queries/zathurarc/injections.scm
new file mode 100644
index 0000000..8e45396
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/zathurarc/injections.scm
@@ -0,0 +1,9 @@
+(set_directive
+  (option) @_option
+  (string) @injection.content
+  (#eq? @_option "synctex-editor-command")
+  (#offset! @injection.content 0 1 0 -1)
+  (#set! injection.language "bash"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))
diff --git a/pack/ant/start/nvim-treesitter/queries/zig/folds.scm b/pack/ant/start/nvim-treesitter/queries/zig/folds.scm
new file mode 100644
index 0000000..6be5c62
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/zig/folds.scm
@@ -0,0 +1,23 @@
+[
+  (block)
+  (switch_expression)
+  (initializer_list)
+  (asm_expression)
+  (multiline_string)
+  (if_statement)
+  (while_statement)
+  (for_statement)
+  (if_expression)
+  (else_clause)
+  (for_expression)
+  (while_expression)
+  (if_type_expression)
+  (function_signature)
+  (parameters)
+  (call_expression)
+  (struct_declaration)
+  (opaque_declaration)
+  (enum_declaration)
+  (union_declaration)
+  (error_set_declaration)
+] @fold
diff --git a/pack/ant/start/nvim-treesitter/queries/zig/highlights.scm b/pack/ant/start/nvim-treesitter/queries/zig/highlights.scm
new file mode 100644
index 0000000..1f90067
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/zig/highlights.scm
@@ -0,0 +1,283 @@
+; Variables
+(identifier) @variable
+
+; Parameters
+(parameter
+  name: (identifier) @variable.parameter)
+
+(payload
+  (identifier) @variable.parameter)
+
+; Types
+(parameter
+  type: (identifier) @type)
+
+((identifier) @type
+  (#lua-match? @type "^[A-Z_][a-zA-Z0-9_]*"))
+
+(variable_declaration
+  (identifier) @type
+  "="
+  [
+    (struct_declaration)
+    (enum_declaration)
+    (union_declaration)
+    (opaque_declaration)
+  ])
+
+[
+  (builtin_type)
+  "anyframe"
+] @type.builtin
+
+; Constants
+((identifier) @constant
+  (#lua-match? @constant "^[A-Z][A-Z_0-9]+$"))
+
+[
+  "null"
+  "unreachable"
+  "undefined"
+] @constant.builtin
+
+(field_expression
+  .
+  member: (identifier) @constant)
+
+(enum_declaration
+  (container_field
+    type: (identifier) @constant))
+
+; Labels
+(block_label
+  (identifier) @label)
+
+(break_label
+  (identifier) @label)
+
+; Fields
+(field_initializer
+  .
+  (identifier) @variable.member)
+
+(field_expression
+  (_)
+  member: (identifier) @variable.member)
+
+(container_field
+  name: (identifier) @variable.member)
+
+(initializer_list
+  (assignment_expression
+    left: (field_expression
+      .
+      member: (identifier) @variable.member)))
+
+; Functions
+(builtin_identifier) @function.builtin
+
+(call_expression
+  function: (identifier) @function.call)
+
+(call_expression
+  function: (field_expression
+    member: (identifier) @function.call))
+
+(function_declaration
+  name: (identifier) @function)
+
+; Modules
+(variable_declaration
+  (identifier) @module
+  (builtin_function
+    (builtin_identifier) @keyword.import
+    (#any-of? @keyword.import "@import" "@cImport")))
+
+; Builtins
+[
+  "c"
+  "..."
+] @variable.builtin
+
+((identifier) @variable.builtin
+  (#eq? @variable.builtin "_"))
+
+(calling_convention
+  (identifier) @variable.builtin)
+
+; Keywords
+[
+  "asm"
+  "defer"
+  "errdefer"
+  "test"
+  "error"
+  "const"
+  "var"
+] @keyword
+
+[
+  "struct"
+  "union"
+  "enum"
+  "opaque"
+] @keyword.type
+
+[
+  "async"
+  "await"
+  "suspend"
+  "nosuspend"
+  "resume"
+] @keyword.coroutine
+
+"fn" @keyword.function
+
+[
+  "and"
+  "or"
+  "orelse"
+] @keyword.operator
+
+"return" @keyword.return
+
+[
+  "if"
+  "else"
+  "switch"
+] @keyword.conditional
+
+[
+  "for"
+  "while"
+  "break"
+  "continue"
+] @keyword.repeat
+
+[
+  "usingnamespace"
+  "export"
+] @keyword.import
+
+[
+  "try"
+  "catch"
+] @keyword.exception
+
+[
+  "volatile"
+  "allowzero"
+  "noalias"
+  "addrspace"
+  "align"
+  "callconv"
+  "linksection"
+  "pub"
+  "inline"
+  "noinline"
+  "extern"
+  "comptime"
+  "packed"
+  "threadlocal"
+] @keyword.modifier
+
+; Operator
+[
+  "="
+  "*="
+  "*%="
+  "*|="
+  "/="
+  "%="
+  "+="
+  "+%="
+  "+|="
+  "-="
+  "-%="
+  "-|="
+  "<<="
+  "<<|="
+  ">>="
+  "&="
+  "^="
+  "|="
+  "!"
+  "~"
+  "-"
+  "-%"
+  "&"
+  "=="
+  "!="
+  ">"
+  ">="
+  "<="
+  "<"
+  "&"
+  "^"
+  "|"
+  "<<"
+  ">>"
+  "<<|"
+  "+"
+  "++"
+  "+%"
+  "-%"
+  "+|"
+  "-|"
+  "*"
+  "/"
+  "%"
+  "**"
+  "*%"
+  "*|"
+  "||"
+  ".*"
+  ".?"
+  "?"
+  ".."
+] @operator
+
+; Literals
+(character) @character
+
+([
+  (string)
+  (multiline_string)
+] @string
+  (#set! "priority" 95))
+
+(integer) @number
+
+(float) @number.float
+
+(boolean) @boolean
+
+(escape_sequence) @string.escape
+
+; Punctuation
+[
+  "["
+  "]"
+  "("
+  ")"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  ";"
+  "."
+  ","
+  ":"
+  "=>"
+  "->"
+] @punctuation.delimiter
+
+(payload
+  "|" @punctuation.bracket)
+
+; Comments
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^//!"))
diff --git a/pack/ant/start/nvim-treesitter/queries/zig/indents.scm b/pack/ant/start/nvim-treesitter/queries/zig/indents.scm
new file mode 100644
index 0000000..431aed5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/zig/indents.scm
@@ -0,0 +1,22 @@
+[
+  (block)
+  (switch_expression)
+  (initializer_list)
+] @indent.begin
+
+(block
+  "}" @indent.end)
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @indent.branch
+
+[
+  (comment)
+  (multiline_string)
+] @indent.ignore
diff --git a/pack/ant/start/nvim-treesitter/queries/zig/injections.scm b/pack/ant/start/nvim-treesitter/queries/zig/injections.scm
new file mode 100644
index 0000000..48a1b44
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/zig/injections.scm
@@ -0,0 +1,10 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; TODO: add when asm is added
+; (asm_output_item (string) @injection.content
+;   (#set! injection.language "asm"))
+; (asm_input_item (string) @injection.content
+;   (#set! injection.language "asm"))
+; (asm_clobbers (string) @injection.content
+;   (#set! injection.language "asm"))
diff --git a/pack/ant/start/nvim-treesitter/queries/zig/locals.scm b/pack/ant/start/nvim-treesitter/queries/zig/locals.scm
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/zig/locals.scm
@@ -0,0 +1 @@
+
diff --git a/pack/ant/start/nvim-treesitter/queries/ziggy/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ziggy/highlights.scm
new file mode 100644
index 0000000..27f6c9a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ziggy/highlights.scm
@@ -0,0 +1,41 @@
+[
+  (true)
+  (false)
+] @constant.builtin
+
+(null) @constant.builtin
+
+[
+  (integer)
+  (float)
+] @number
+
+(struct_field
+  key: (_) @keyword)
+
+(struct
+  name: (_) @type)
+
+(tag) @function
+
+[
+  (string)
+  (line_string)*
+] @string
+
+(comment) @comment
+
+(escape_sequence) @string.escape
+
+"," @punctuation.delimiter
+
+[
+  "["
+  "]"
+  "{"
+  "}"
+  "("
+  ")"
+] @punctuation.bracket
+
+(top_comment) @comment
diff --git a/pack/ant/start/nvim-treesitter/queries/ziggy/indents.scm b/pack/ant/start/nvim-treesitter/queries/ziggy/indents.scm
new file mode 100644
index 0000000..223bde8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ziggy/indents.scm
@@ -0,0 +1,10 @@
+[
+  (struct)
+  (map)
+  (array)
+] @indent.begin
+
+[
+  "]"
+  "}"
+] @indent.end
diff --git a/pack/ant/start/nvim-treesitter/queries/ziggy_schema/highlights.scm b/pack/ant/start/nvim-treesitter/queries/ziggy_schema/highlights.scm
new file mode 100644
index 0000000..4e17701
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ziggy_schema/highlights.scm
@@ -0,0 +1,38 @@
+(struct_field
+  key: (_) @keyword)
+
+(tag_name) @function
+
+[
+  "unknown"
+  "any"
+  "struct"
+  "root"
+  "enum"
+  "map"
+] @keyword
+
+(identifier) @type
+
+"?" @type
+
+[
+  "bool"
+  "bytes"
+  "int"
+  "float"
+] @constant.builtin
+
+(doc_comment) @comment.documentation
+
+[
+  ","
+  "|"
+] @punctuation.delimiter
+
+[
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/queries/ziggy_schema/indents.scm b/pack/ant/start/nvim-treesitter/queries/ziggy_schema/indents.scm
new file mode 100644
index 0000000..6f7f7b8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/queries/ziggy_schema/indents.scm
@@ -0,0 +1,3 @@
+(struct) @indent.begin
+
+"}" @indent.end
diff --git a/pack/ant/start/nvim-treesitter/scripts/check-queries.lua b/pack/ant/start/nvim-treesitter/scripts/check-queries.lua
new file mode 100755
index 0000000..f3b45ea
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/scripts/check-queries.lua
@@ -0,0 +1,123 @@
+#!/usr/bin/env -S nvim -l
+vim.opt.rtp:prepend "./"
+
+-- Equivalent to print(), but this will ensure consistent output regardless of
+-- operating system.
+local function io_print(text)
+  if not text then
+    text = ""
+  end
+  io.write(text, "\n")
+end
+
+local function extract_captures()
+  local lines = vim.fn.readfile "CONTRIBUTING.md"
+  local captures = {}
+  local current_query
+
+  for _, line in ipairs(lines) do
+    if vim.startswith(line, "### ") then
+      current_query = vim.fn.tolower(line:sub(5))
+    elseif vim.startswith(line, "@") and current_query then
+      if not captures[current_query] then
+        captures[current_query] = {}
+      end
+
+      table.insert(captures[current_query], vim.split(line:sub(2), " ", true)[1])
+    end
+  end
+
+  -- Complete captures for injections.
+  local parsers = vim.tbl_keys(require("nvim-treesitter.parsers").list)
+  for _, lang in pairs(parsers) do
+    table.insert(captures["injections"], lang)
+  end
+
+  return captures
+end
+
+local function do_check()
+  local timings = {}
+  local queries = require "nvim-treesitter.query"
+  local parsers = #_G.arg > 0 and { unpack(_G.arg) } or require("nvim-treesitter.info").installed_parsers()
+  local query_types = queries.built_in_query_groups
+
+  local captures = extract_captures()
+  local errors = {}
+
+  io_print "::group::Check parsers"
+
+  for _, lang in pairs(parsers) do
+    timings[lang] = {}
+    for _, query_type in pairs(query_types) do
+      local before = vim.loop.hrtime()
+      local ok, query = pcall(queries.get_query, lang, query_type)
+      local after = vim.loop.hrtime()
+      local duration = after - before
+      table.insert(timings, { duration = duration, lang = lang, query_type = query_type })
+      io_print("Checking " .. lang .. " " .. query_type .. string.format(" (%.02fms)", duration * 1e-6))
+      if not ok then
+        local err_msg = lang .. " (" .. query_type .. "): " .. query
+        errors[#errors + 1] = err_msg
+      else
+        if query then
+          for _, capture in ipairs(query.captures) do
+            local is_valid = (
+              vim.startswith(capture, "_") -- Helpers.
+              or vim.tbl_contains(captures[query_type], capture)
+            )
+            if not is_valid then
+              local error = string.format("(x) Invalid capture @%s in %s for %s.", capture, query_type, lang)
+              errors[#errors + 1] = error
+            end
+          end
+        end
+      end
+    end
+  end
+
+  io_print "::endgroup::"
+
+  if #errors > 0 then
+    io_print "\nCheck failed!\nErrors:"
+    for _, err in ipairs(errors) do
+      print(err)
+    end
+    error()
+  end
+  return timings
+end
+
+local ok, result = pcall(do_check)
+local allowed_to_fail = vim.split(vim.env.ALLOWED_INSTALLATION_FAILURES or "", ",", true)
+
+for k, v in pairs(require("nvim-treesitter.parsers").get_parser_configs()) do
+  if not require("nvim-treesitter.parsers").has_parser(k) then
+    -- On CI all parsers that can be installed from C files should be installed
+    if
+      vim.env.CI
+      and not v.install_info.requires_generate_from_grammar
+      and not vim.tbl_contains(allowed_to_fail, k)
+    then
+      io_print("Error: parser for " .. k .. " is not installed")
+      vim.cmd "cq"
+    else
+      io_print("Warning: parser for " .. k .. " is not installed")
+    end
+  end
+end
+
+if ok then
+  io_print "::group::Timings"
+  table.sort(result, function(a, b)
+    return a.duration < b.duration
+  end)
+  for i, val in ipairs(result) do
+    io_print(string.format("%i. %.02fms %s %s", #result - i + 1, val.duration * 1e-6, val.lang, val.query_type))
+  end
+  io_print "::endgroup::"
+  io_print "Check successful!"
+  vim.cmd "q"
+else
+  vim.cmd "cq"
+end
diff --git a/pack/ant/start/nvim-treesitter/scripts/ci-install.sh b/pack/ant/start/nvim-treesitter/scripts/ci-install.sh
new file mode 100755
index 0000000..4677bb9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/scripts/ci-install.sh
@@ -0,0 +1,26 @@
+#!/bin/bash
+
+set -e
+
+os=$(uname -s)
+if [[ $os == Linux ]]; then
+  wget https://github.com/neovim/neovim/releases/download/${NVIM_TAG}/nvim-linux64.tar.gz
+  tar -zxf nvim-linux64.tar.gz
+  sudo ln -s "$PWD"/nvim-linux64/bin/nvim /usr/local/bin
+  rm -rf "$PWD"/nvim-linux64/lib/nvim/parser
+  mkdir -p ~/.local/share/nvim/site/pack/nvim-treesitter/start
+  ln -s "$PWD" ~/.local/share/nvim/site/pack/nvim-treesitter/start
+elif [[ $os == Darwin ]]; then
+  RELEASE_NAME="nvim-macos-$(uname -m)"
+  curl -L "https://github.com/neovim/neovim/releases/download/${NVIM_TAG}/$RELEASE_NAME.tar.gz" | tar -xz
+  sudo ln -s "$PWD/$RELEASE_NAME/bin/nvim" /usr/local/bin
+  rm -rf "$PWD/$RELEASE_NAME/lib/nvim/parser"
+  mkdir -p ~/.local/share/nvim/site/pack/nvim-treesitter/start
+  ln -s "$PWD" ~/.local/share/nvim/site/pack/nvim-treesitter/start
+else
+  curl -L https://github.com/neovim/neovim/releases/download/${NVIM_TAG}/nvim-win64.zip -o nvim-win64.zip
+  unzip nvim-win64
+  mkdir -p ~/AppData/Local/nvim/pack/nvim-treesitter/start
+  mkdir -p ~/AppData/Local/nvim-data
+  cp -r "$PWD" ~/AppData/Local/nvim/pack/nvim-treesitter/start
+fi
diff --git a/pack/ant/start/nvim-treesitter/scripts/compile_parsers.makefile b/pack/ant/start/nvim-treesitter/scripts/compile_parsers.makefile
new file mode 100644
index 0000000..020b452
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/scripts/compile_parsers.makefile
@@ -0,0 +1,52 @@
+CFLAGS       ?= -Os -std=c99 -fPIC
+CXX_STANDARD ?= c++14
+CXXFLAGS     ?= -Os -std=$(CXX_STANDARD) -fPIC
+LDFLAGS      ?= 
+SRC_DIR      ?= ./src
+DEST_DIR     ?= ./dest
+
+ifeq ($(OS),Windows_NT)
+   SHELL       := powershell.exe
+   .SHELLFLAGS := -NoProfile -command
+   CP          := Copy-Item -Recurse -ErrorAction SilentlyContinue
+   MKDIR       := New-Item -ItemType directory -ErrorAction SilentlyContinue
+   TARGET      := parser.dll
+   rmf         = Write-Output $(1) | foreach { if (Test-Path $$_) { Remove-Item -Force } }
+else
+   CP          := cp
+   MKDIR       := mkdir -p
+   TARGET      := parser.so
+   rmf         = rm -rf $(1)
+endif
+
+ifneq ($(wildcard $(SRC_DIR)/*.cc),)
+   LDFLAGS += -lstdc++
+endif
+
+OBJECTS := parser.o
+
+ifneq ($(wildcard $(SRC_DIR)/scanner.*),)
+   OBJECTS += scanner.o
+endif
+
+all: $(TARGET)
+
+$(TARGET): $(OBJECTS)
+	$(CC) $(OBJECTS) -o $(TARGET) -shared $(LDFLAGS)
+
+%.o: $(SRC_DIR)/%.c
+	$(CC) -c $(CFLAGS) -I$(SRC_DIR) -o $@ $<
+
+%.o: $(SRC_DIR)/%.cc
+	$(CC) -c $(CXXFLAGS) -I$(SRC_DIR) -o $@ $<
+
+clean:
+	$(call rmf,$(TARGET) $(OBJECTS))
+
+$(DEST_DIR):
+	@$(MKDIR) $(DEST_DIR)
+
+install: $(TARGET) $(DEST_DIR)
+	$(CP) $(TARGET) $(DEST_DIR)/
+
+.PHONY: clean
diff --git a/pack/ant/start/nvim-treesitter/scripts/format-queries.lua b/pack/ant/start/nvim-treesitter/scripts/format-queries.lua
new file mode 100755
index 0000000..9deccdc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/scripts/format-queries.lua
@@ -0,0 +1,453 @@
+#!/usr/bin/env -S nvim -l
+
+local ts = vim.treesitter
+local get_node_text = ts.get_node_text
+
+---@type string[]
+local files
+
+local arg = _G.arg[1] or "."
+if arg:match ".*%.scm$" then
+  files = { arg }
+else
+  files = vim.fn.split(vim.fn.glob(arg .. "/**/*.scm"))
+end
+
+ts.query.add_predicate("kind-eq?", function(match, _, _, pred)
+  local cap = match[pred[2]]
+  local node = type(cap) == "table" and cap[1] or cap
+  if not node then
+    return true
+  end
+
+  local types = { unpack(pred, 3) }
+  return vim.tbl_contains(types, node:type())
+end, true)
+
+ts.query.add_predicate("is-start-of-line?", function(match, _, _, pred)
+  local cap = match[pred[2]]
+  local node = type(cap) == "table" and cap[1] or cap
+  if not node then
+    return true
+  end
+  local start_row, start_col = node:start()
+  return vim.fn.indent(start_row + 1) == start_col
+end)
+
+--- Control the indent here. Change to \t if uses tab instead
+local indent_str = "  "
+local textwidth = 100
+
+-- Query to control the formatter
+local format_queries = [[
+;;query
+;; Ignore next node with `; format-ignore`
+(
+  (comment) @_pattern
+  .
+  (_) @format.ignore
+  (#lua-match? @_pattern "^;+%s*format%-ignore"))
+
+;; {{{
+;; Add newlines to top level nodes
+;; {{{
+;; Preserve inline comments
+(program
+  . (_)
+  (comment) @format.prepend-newline
+  (#is-start-of-line? @format.prepend-newline))
+(program
+  . (_)
+  (comment) @_comment
+  .
+  (comment) @format.prepend-newline
+  (#not-is-start-of-line? @_comment)
+  (#is-start-of-line? @format.prepend-newline))
+; Extra newline for modelines
+(program
+  (comment) @_modeline
+  .
+  (_) @format.prepend-newline
+  (#is-start-of-line? @_modeline)
+  (#contains? @_modeline "^;+%s*inherits:"))
+(program
+  (comment) @_modeline
+  .
+  (_) @format.prepend-newline
+  (#is-start-of-line? @_modeline)
+  (#contains? @_modeline "^;+%s*extends%s*$"))
+;; }}}
+;; Making sure all top-level patterns are separated
+(program
+  (_) @format.append-newline)
+(program
+  (_) @format.cancel-append .)
+(program
+  . (_)
+  [
+    (list)
+    (grouping)
+    (named_node)
+    (anonymous_node)
+    (field_definition)
+  ] @format.prepend-newline)
+
+(program
+  (comment) @_comment
+  .
+  [
+    (list)
+    (grouping)
+    (named_node)
+    (anonymous_node)
+    (field_definition)
+    (comment)
+  ] @format.cancel-prepend
+  (#is-start-of-line? @_comment)
+  (#not-lua-match? @_comment "^;+%s*inherits:")
+  (#not-lua-match? @_comment "^;+%s*extends%s*$"))
+;; }}}
+
+;; delims
+[
+  ":"
+  "."
+] @format.append-space
+(
+  "." @format.prepend-space @format.cancel-append
+  .
+  ")")
+
+;; List handler
+;; Only starts indent if 2 or more elements
+(list
+  "[" @format.indent.begin
+  "]" @format.indent.dedent)
+;; Otherwise, remove brackets
+(list
+  "[" @format.remove @format.cancel-append
+  .
+  (_) @format.cancel-append
+  .
+  "]" @format.remove)
+;; [ ... ] @capture1 @capture2
+;; Append newlines for nodes inside the list
+(list
+  (_) @format.append-newline
+  (#not-kind-eq? @format.append-newline "capture" "quantifier"))
+
+;; (_), "_" and _ handler
+;; Start indents if it's one of these patterns
+(named_node
+  [
+    "_"
+    name: (identifier)
+  ] @format.indent.begin
+  .
+  [
+    (list)              ; (foo [...])
+    (grouping)          ; (foo ((foo)))
+    (negated_field)     ; (foo !field)
+    (field_definition)  ; (foo field: (...))
+    (named_node)        ; (foo (bar))
+    (predicate)         ; (named_node (#set!))
+    (anonymous_node)
+    "."
+  ])
+;; Honoring comment's position within a node
+(named_node
+  [
+    "_"
+    name: (identifier)
+  ] @format.indent.begin
+  .
+  (comment) @_comment
+  (#is-start-of-line? @_comment))
+(named_node
+  [
+    "_"
+    name: (identifier)
+  ] @format.indent.begin @format.cancel-append
+  .
+  "."? @format.prepend-newline
+  .
+  (comment) @format.prepend-space
+  (#not-is-start-of-line? @format.prepend-space))
+
+;; Add newlines for other nodes, in case the top node is indented
+(named_node
+  [
+    (list)
+    (grouping)
+    (negated_field)
+    (field_definition)
+    (named_node)
+    (predicate)
+    (anonymous_node)
+    "."
+  ] @format.append-newline)
+
+;; Collapse closing parentheses
+(named_node
+  [
+    "_"
+    name: (identifier)
+    (_)
+  ] @format.cancel-append
+  .
+  ")"
+  (#not-kind-eq? @format.cancel-append "comment"))
+
+;; All captures should be separated with a space
+(capture) @format.prepend-space
+
+;; Workaround to just use the string's content
+(anonymous_node (string) @format.keep)
+
+; ( (_) ) handler
+(grouping
+  "("
+  .
+  [
+    (named_node)                  ; ((foo))
+    (list)                        ; ([foo] (...))
+    (anonymous_node)              ; ("foo")
+    (grouping . (_))
+  ] @format.indent.begin
+  .
+  (_))
+(grouping
+  "("
+  .
+  (grouping) @format.indent.begin
+  (predicate))
+(grouping
+  "("
+  [
+    (anonymous_node)
+    (named_node)
+    (list)
+    (predicate)
+    (grouping . (_))
+    (field_definition)
+    "."
+  ] @format.append-newline
+  (_) .)
+;; Collapsing closing parens
+(grouping
+  (_) @format.cancel-append . ")"
+  (#not-kind-eq? @format.cancel-append "comment"))
+(grouping
+  (capture) @format.prepend-space)
+;; Remove unnecessary parens
+(grouping
+  "(" @format.remove
+  .
+  (_)
+  .
+  ")" @format.remove .)
+(grouping
+  "(" @format.remove
+  .
+  [
+    (anonymous_node
+      name: (string) .)
+    (named_node
+      [
+        "_"
+        name: (identifier)
+      ] .)
+  ]
+  .
+  ")" @format.remove
+  .
+  (capture))
+
+; Separate this query to avoid capture duplication
+(predicate
+  "(" @format.indent.begin @format.cancel-append)
+(predicate
+  (parameters
+    (comment) @format.prepend-newline
+    .
+    (_) @format.cancel-prepend)
+  (#is-start-of-line? @format.prepend-newline))
+(predicate
+  (parameters
+    (_) @format.prepend-space)
+  (#set! conditional-newline))
+(predicate
+  (parameters
+    .
+    (capture)
+    . (_) @format.prepend-space)
+  (#set! lookahead-newline)
+  (#set! conditional-newline))
+;; Workaround to keep the string's content
+(string) @format.keep
+
+;; Comment related handlers
+(comment) @format.append-newline
+;; comment styling. Feel free to change in the future
+((comment) @format.replace
+  (#gsub! @format.replace "^;+(%s*.-)%s*$" ";%1"))
+;; Preserve end of line comments
+(
+  [
+    "."
+    ":"
+    (list)
+    (grouping)
+    (named_node)
+    (anonymous_node)
+    (negated_field)
+  ] @format.cancel-append
+  .
+  (quantifier)?
+  .
+  "."? @format.prepend-newline ; Make sure anchor are not eol but start of newline
+  .
+  (comment) @format.prepend-space
+  (#not-is-start-of-line? @format.prepend-space))
+]]
+
+---@param lines string[]
+---@param lines_to_append string[]
+local function append_lines(lines, lines_to_append)
+  for i = 1, #lines_to_append, 1 do
+    lines[#lines] = lines[#lines] .. lines_to_append[i]
+    if i ~= #lines_to_append then
+      lines[#lines + 1] = ""
+    end
+  end
+end
+
+---@param bufnr integer
+---@param node TSNode
+---@param lines string[]
+---@param q table<string, TSMetadata>
+---@param level integer
+local function iter(bufnr, node, lines, q, level)
+  --- Sometimes 2 queries apply append twice. This is to prevent the case from happening
+  local apply_newline = false
+  for child, _ in node:iter_children() do
+    local id = child:id()
+    repeat
+      if apply_newline then
+        apply_newline = false
+        lines[#lines + 1] = string.rep(indent_str, level)
+      end
+      if q["format.ignore"][id] then
+        local text = vim.split(get_node_text(child, bufnr):gsub("\r\n?", "\n"), "\n", { trimempty = true })
+        append_lines(lines, text)
+        break
+      elseif q["format.remove"][id] then
+        break
+      end
+      if not q["format.cancel-prepend"][id] then
+        if q["format.prepend-newline"][id] then
+          lines[#lines + 1] = string.rep(indent_str, level)
+        elseif q["format.prepend-space"][id] then
+          if not q["format.prepend-space"][id]["conditional-newline"] then
+            lines[#lines] = lines[#lines] .. " "
+          elseif child:byte_length() + 1 + #lines[#lines] > textwidth then
+            lines[#lines + 1] = string.rep(indent_str, level)
+          else
+            -- Do a rough guess of the actual byte length. If it's larger than `columns` then add a newline first
+            -- column - byte_end + byte_start
+            local _, _, byte_start = child:start()
+            local _, _, byte_end = node:end_()
+            if
+              q["format.prepend-space"][id]["lookahead-newline"]
+              and textwidth - (byte_end - byte_start) - #lines[#lines] < 0
+            then
+              lines[#lines + 1] = string.rep(indent_str, level)
+            else
+              lines[#lines] = lines[#lines] .. " "
+            end
+          end
+        end
+      end
+      if q["format.replace"][id] then
+        append_lines(lines, vim.split(q["format.replace"][id].text, "\n", { trimempty = true }))
+      elseif child:named_child_count() == 0 or q["format.keep"][id] then
+        append_lines(
+          lines,
+          vim.split(string.gsub(get_node_text(child, bufnr), "\r\n?", "\n"), "\n+", { trimempty = true })
+        )
+      else
+        iter(bufnr, child, lines, q, level)
+      end
+      if q["format.indent.begin"][id] then
+        level = level + 1
+        apply_newline = true
+        break
+      end
+      if q["format.indent.dedent"][id] then
+        if string.match(lines[#lines], "^%s*" .. get_node_text(child, bufnr)) then
+          lines[#lines] = string.sub(lines[#lines], 1 + #string.rep(indent_str, 1))
+        end
+      end
+      if q["format.indent.end"][id] then
+        level = math.max(level - 1, 0)
+        if string.match(lines[#lines], "^%s*" .. get_node_text(child, bufnr)) then
+          lines[#lines] = string.sub(lines[#lines], 1 + #string.rep(indent_str, 1))
+        end
+        break
+      end
+    until true
+    repeat
+      if q["format.cancel-append"][id] then
+        apply_newline = false
+      end
+      if not q["format.cancel-append"][id] then
+        if q["format.append-newline"][id] then
+          apply_newline = true
+        elseif q["format.append-space"][id] then
+          lines[#lines] = lines[#lines] .. " "
+        end
+      end
+    until true
+  end
+end
+
+---@param bufnr integer
+---@param queries string
+local function format(bufnr, queries)
+  local lines = { "" }
+  -- stylua: ignore
+  local map = {
+    ['format.ignore'] = {},           -- Ignore the node and its children
+    ['format.indent.begin'] = {},     -- +1 shiftwidth for all nodes after this
+    ['format.indent.end'] = {},       -- -1 shiftwidth for all nodes after this
+    ['format.indent.dedent'] = {},    -- -1 shiftwidth for this line only
+    ['format.prepend-space'] = {},    -- Prepend a space before inserting the node
+    ['format.prepend-newline'] = {},  -- Prepend a \n before inserting the node
+    ['format.append-space'] = {},     -- Append a space after inserting the node
+    ['format.append-newline'] = {},   -- Append a newline after inserting the node
+    ['format.cancel-append'] = {},    -- Cancel any `@format.append-*` applied to the node
+    ['format.cancel-prepend'] = {},   -- Cancel any `@format.prepend-*` applied to the node
+    ['format.keep'] = {},             -- String content is not exposed as a syntax node. This is a workaround for it
+    ['format.replace'] = {},          -- Dedicated capture used to store results of `(#gsub!)`
+    ['format.remove'] = {},           -- Do not add the syntax node to the result, i.e. brackets [], parens ()
+  }
+  local root = ts.get_parser(bufnr, "query"):parse(true)[1]:root()
+  local query = ts.query.parse("query", queries)
+  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 and (metadata[id] and metadata[id] or metadata) or {}
+    end
+  end
+
+  iter(bufnr, root, lines, map, 0)
+  vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
+end
+
+for _, file in ipairs(files) do
+  local buf = vim.fn.bufadd(file)
+  vim.fn.bufload(file)
+  vim.api.nvim_set_current_buf(buf)
+  format(buf, format_queries)
+end
+
+vim.cmd "silent wa!"
diff --git a/pack/ant/start/nvim-treesitter/scripts/minimal_init.lua b/pack/ant/start/nvim-treesitter/scripts/minimal_init.lua
new file mode 100644
index 0000000..f7a7ee5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/scripts/minimal_init.lua
@@ -0,0 +1,25 @@
+vim.opt.runtimepath:append "."
+vim.cmd.runtime { "plugin/plenary.vim", bang = true }
+vim.cmd.runtime { "plugin/nvim-treesitter.lua", bang = true }
+
+vim.filetype.add {
+  extension = {
+    conf = "hocon",
+    cmm = "t32",
+    hurl = "hurl",
+    ncl = "nickel",
+    tig = "tiger",
+    usd = "usd",
+    usda = "usd",
+    wgsl = "wgsl",
+    w = "wing",
+  },
+}
+
+vim.o.swapfile = false
+vim.bo.swapfile = false
+
+require("nvim-treesitter.configs").setup {
+  indent = { enable = true },
+  highlight = { enable = true },
+}
diff --git a/pack/ant/start/nvim-treesitter/scripts/pre-push b/pack/ant/start/nvim-treesitter/scripts/pre-push
new file mode 100755
index 0000000..8d425b3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/scripts/pre-push
@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+# Can be used as a pre-push hook
+# Just symlink this file to .git/hooks/pre-push
+
+echo "Running linter..."
+luacheck .
+
+echo "Checking formatting..."
+stylua --check .
diff --git a/pack/ant/start/nvim-treesitter/scripts/run_tests.sh b/pack/ant/start/nvim-treesitter/scripts/run_tests.sh
new file mode 100755
index 0000000..c6660a7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/scripts/run_tests.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+HERE="$(dirname "$(realpath "${BASH_SOURCE[0]}")")"
+cd $HERE/..
+
+run() {
+    nvim --headless --noplugin -u scripts/minimal_init.lua \
+        -c "PlenaryBustedDirectory $1 { minimal_init = './scripts/minimal_init.lua' }"
+}
+
+if [[ $2 = '--summary' ]]; then
+    ## really simple results summary by filtering plenary busted output
+    run tests/$1  2> /dev/null | grep -E '^\S*(Testing|Success|Failed|Errors)\s*:'
+else
+    run tests/$1
+fi
diff --git a/pack/ant/start/nvim-treesitter/scripts/update-lockfile.sh b/pack/ant/start/nvim-treesitter/scripts/update-lockfile.sh
new file mode 100755
index 0000000..22460d1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/scripts/update-lockfile.sh
@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+make_ignored() {
+  if [[ -n $1 ]]; then
+    while read -r lang; do
+      if [[ $lang != "$1" ]]; then
+        printf '%s,' "$lang"
+      fi
+    done < <(jq -r 'keys[]' lockfile.json)
+  fi
+}
+
+SKIP_LOCKFILE_UPDATE_FOR_LANGS="$(make_ignored "$1")" \
+  nvim --headless -c 'luafile ./scripts/write-lockfile.lua' +q
+
+# Pretty print
+cp lockfile.json /tmp/lockfile.json
+jq --sort-keys > lockfile.json < /tmp/lockfile.json
diff --git a/pack/ant/start/nvim-treesitter/scripts/update-readme.lua b/pack/ant/start/nvim-treesitter/scripts/update-readme.lua
new file mode 100755
index 0000000..251a64a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/scripts/update-readme.lua
@@ -0,0 +1,59 @@
+#!/usr/bin/env -S nvim -l
+
+---@class Parser
+---@field name string
+---@field parser ParserInfo
+
+local parsers = require("nvim-treesitter.parsers").get_parser_configs()
+local sorted_parsers = {}
+
+for k, v in pairs(parsers) 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)
+
+local generated_text = ""
+
+---@param v Parser
+for _, v in ipairs(sorted_parsers) do
+  local link = "[" .. (v.parser.readme_name or v.name) .. "](" .. v.parser.install_info.url .. ")"
+
+  if v.parser.maintainers then
+    generated_text = generated_text
+      .. "- [x] "
+      .. link
+      .. " ("
+      .. (v.parser.experimental and "experimental, " or "")
+      .. "maintained by "
+      .. table.concat(v.parser.maintainers, ", ")
+      .. ")\n"
+  else
+    generated_text = generated_text .. "- [ ] " .. link .. (v.parser.experimental and " (experimental)" or "") .. "\n"
+  end
+end
+
+print(generated_text)
+print "\n"
+
+local readme_text = table.concat(vim.fn.readfile "README.md", "\n")
+
+local new_readme_text = string.gsub(
+  readme_text,
+  "<!%-%-parserinfo%-%->.*<!%-%-parserinfo%-%->",
+  "<!--parserinfo-->\n" .. generated_text .. "<!--parserinfo-->"
+)
+vim.fn.writefile(vim.fn.split(new_readme_text, "\n"), "README.md")
+
+if string.find(readme_text, generated_text, 1, true) then
+  print "README.md is up-to-date!"
+  vim.cmd "q"
+else
+  print "New README.md was written. Please commit that change! Old text was: "
+  print(string.sub(readme_text, string.find(readme_text, "<!%-%-parserinfo%-%->.*<!%-%-parserinfo%-%->")))
+  vim.cmd "cq"
+end
diff --git a/pack/ant/start/nvim-treesitter/scripts/write-lockfile.lua b/pack/ant/start/nvim-treesitter/scripts/write-lockfile.lua
new file mode 100755
index 0000000..7a7606c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/scripts/write-lockfile.lua
@@ -0,0 +1,14 @@
+#!/usr/bin/env -S nvim -l
+
+---@type string|any[]
+local skip_langs = vim.fn.getenv "SKIP_LOCKFILE_UPDATE_FOR_LANGS"
+
+if skip_langs == vim.NIL then
+  skip_langs = {}
+else
+  ---@diagnostic disable-next-line: param-type-mismatch
+  skip_langs = vim.fn.split(skip_langs, ",")
+end
+
+require("nvim-treesitter.install").write_lockfile("verbose", skip_langs)
+vim.cmd "q"
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/algorithm/trailing.py b/pack/ant/start/nvim-treesitter/tests/indent/algorithm/trailing.py
new file mode 100644
index 0000000..9a753ae
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/algorithm/trailing.py
@@ -0,0 +1,6 @@
+class x: # Ignore comment
+
+class y: 
+    def z(): # Ignore comment
+
+class t:    
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/algorithm/trailing_whitespace.html b/pack/ant/start/nvim-treesitter/tests/indent/algorithm/trailing_whitespace.html
new file mode 100644
index 0000000..f3cf177
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/algorithm/trailing_whitespace.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+    <body>
+        <!-- This file deliberately contains trailing whitespace -->
+        <!-- Don't remove them -->
+        <div>   
+            a   
+
+        </div>    
+    </body>     
+</html>
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/algorithm_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/algorithm_spec.lua
new file mode 100644
index 0000000..faf7998
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/algorithm_spec.lua
@@ -0,0 +1,18 @@
+local Runner = require("tests.indent.common").Runner
+-- local XFAIL = require("tests.indent.common").XFAIL
+
+local runner = Runner:new(it, "tests/indent/algorithm", {
+  tabstop = 4,
+  shiftwidth = 4,
+  softtabstop = 4,
+  expandtab = true,
+})
+
+describe("test indent algorithm: ", function()
+  describe("new line:", function()
+    runner:new_line("trailing.py", { on_line = 1, text = "x: str", indent = 4 }, "indent next line, ignore comment")
+    runner:new_line("trailing.py", { on_line = 4, text = "pass", indent = 8 }, "indent next line, ignore comment")
+    runner:new_line("trailing.py", { on_line = 6, text = "pass", indent = 4 }, "indent next line, ignore whitespace")
+    runner:new_line("trailing_whitespace.html", { on_line = 9, text = "x", indent = 8 }, "not ignore @indent.end")
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/angular/defer.html b/pack/ant/start/nvim-treesitter/tests/indent/angular/defer.html
new file mode 100644
index 0000000..a853139
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/angular/defer.html
@@ -0,0 +1,9 @@
+@defer (on viewport) {
+  <calendar-cmp />
+} @placeholder (minimum 100ms) {
+  <small-component />
+} @loading (after 100s; minimum 200ms){
+  <loading-spinner />
+} @error {
+  <error-message />
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/angular/for.html b/pack/ant/start/nvim-treesitter/tests/indent/angular/for.html
new file mode 100644
index 0000000..591472e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/angular/for.html
@@ -0,0 +1,5 @@
+@for (item of items; track item.id) {
+  <li>{{ item.name }}</li>
+} @empty {
+  <p>No items</p>
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/angular/if-else.html b/pack/ant/start/nvim-treesitter/tests/indent/angular/if-else.html
new file mode 100644
index 0000000..7854e1b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/angular/if-else.html
@@ -0,0 +1,15 @@
+@if (someCondition) {
+  <p>someCondition is true</p>
+} @else {
+  <p>someCondition is false</p>
+}
+
+<div>
+  @if (someOther) {
+    <span>True</span>
+
+    @if (nestedCondition) {
+      <span>Nested</span>
+    }
+  }
+</div>
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/angular/switch-case.html b/pack/ant/start/nvim-treesitter/tests/indent/angular/switch-case.html
new file mode 100644
index 0000000..17df966
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/angular/switch-case.html
@@ -0,0 +1,13 @@
+<div>
+  @switch (obj.property) {
+    @case (1) {
+      <p>Case 1</p>
+    }
+    @case (2) {
+      <p>Case 2</p>
+    }
+    @default {
+      <p>Default</p>
+    }
+  }
+</div>
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/angular_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/angular_spec.lua
new file mode 100644
index 0000000..2090420
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/angular_spec.lua
@@ -0,0 +1,70 @@
+local Runner = require("tests.indent.common").Runner
+local runner = Runner:new(it, "tests/indent/angular", {
+  tabstop = 2,
+  shiftwidth = 2,
+  expandtab = true,
+  filetype = "htmlangular",
+})
+
+describe("indent HTML Angular:", function()
+  describe("whole file:", function()
+    runner:whole_file "."
+  end)
+
+  describe("new line:", function()
+    for _, info in ipairs {
+      { 1, 2 },
+      { 2, 2 },
+      { 3, 2 },
+      { 4, 2 },
+      { 6, 0 },
+      { 7, 2 },
+      { 8, 4 },
+      { 10, 4 },
+      { 11, 6 },
+      { 12, 6 },
+      { 13, 4 },
+      { 14, 2 },
+    } do
+      runner:new_line("if-else.html", { on_line = info[1], text = "//", indent = info[2] })
+    end
+
+    for _, info in ipairs {
+      { 1, 2 },
+      { 2, 4 },
+      { 3, 6 },
+      { 4, 6 },
+      { 6, 6 },
+      { 7, 6 },
+      { 9, 6 },
+      { 10, 6 },
+      { 12, 2 },
+    } do
+      runner:new_line("switch-case.html", { on_line = info[1], text = "//", indent = info[2] })
+    end
+
+    for _, info in ipairs {
+      { 1, 2 },
+      { 2, 2 },
+      { 3, 2 },
+      { 4, 2 },
+      { 5, 0 },
+    } do
+      runner:new_line("for.html", { on_line = info[1], text = "//", indent = info[2] })
+    end
+
+    for _, info in ipairs {
+      { 1, 2 },
+      { 2, 2 },
+      { 3, 2 },
+      { 4, 2 },
+      { 5, 2 },
+      { 6, 2 },
+      { 7, 2 },
+      { 8, 2 },
+      { 9, 0 },
+    } do
+      runner:new_line("defer.html", { on_line = info[1], text = "//", indent = info[2] })
+    end
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/aligned_indent.c b/pack/ant/start/nvim-treesitter/tests/indent/c/aligned_indent.c
new file mode 100644
index 0000000..7a31204
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/aligned_indent.c
@@ -0,0 +1,7 @@
+void foo(int a,
+         int b,
+         int c);
+
+void foo(int a,
+         int b
+
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/array.c b/pack/ant/start/nvim-treesitter/tests/indent/c/array.c
new file mode 100644
index 0000000..5bb67c2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/array.c
@@ -0,0 +1,14 @@
+int x[] = {
+    1, 2, 3,
+    4, 5,
+    6
+};
+
+int y[][2] = {
+    {0, 1},
+    {1, 2},
+    {
+        2,
+        3
+    },
+};
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/comment.c b/pack/ant/start/nvim-treesitter/tests/indent/c/comment.c
new file mode 100644
index 0000000..b32de82
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/comment.c
@@ -0,0 +1,8 @@
+/**
+ * Function foo
+ * @param[out] x output
+ * @param[in] x input
+ */
+void foo(int *x, int y) {
+    *x = y;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/compound_lit.c b/pack/ant/start/nvim-treesitter/tests/indent/c/compound_lit.c
new file mode 100644
index 0000000..29e336f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/compound_lit.c
@@ -0,0 +1,10 @@
+struct foo {
+    int x, y;
+};
+
+struct foo bar(int x, int y) {
+    return (struct foo) {
+        .x = x,
+        .y = y
+    };
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/cond.c b/pack/ant/start/nvim-treesitter/tests/indent/c/cond.c
new file mode 100644
index 0000000..1ecb22d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/cond.c
@@ -0,0 +1,10 @@
+void foo(int x)
+{
+    if (x > 10) {
+        return;
+    } else if (x < -10) {
+        x = -10;
+    } else {
+        x = -x;
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/enum.c b/pack/ant/start/nvim-treesitter/tests/indent/c/enum.c
new file mode 100644
index 0000000..bb6b0dc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/enum.c
@@ -0,0 +1,5 @@
+enum foo {
+    A = 1,
+    B,
+    C,
+};
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/expr.c b/pack/ant/start/nvim-treesitter/tests/indent/c/expr.c
new file mode 100644
index 0000000..cafb111
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/expr.c
@@ -0,0 +1,12 @@
+void foo(int x, int y)
+{
+    if ((x*x - y*y > 0) ||
+        (x == 1 || y == 1) &&
+        (x != 2 && y != 2)
+    ) {
+        return;
+    }
+
+    int z = (x + y) *
+        (x - y);
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/func.c b/pack/ant/start/nvim-treesitter/tests/indent/c/func.c
new file mode 100644
index 0000000..0c1ede8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/func.c
@@ -0,0 +1,33 @@
+int f1(int x) {
+    return 1;
+}
+
+int f2(int x)
+{
+    return 1;
+}
+
+int f3(
+    int x
+) {
+    return 1;
+}
+
+int f4(
+    int x,
+    int y
+) {
+    return 1;
+}
+
+int f5(int x,
+       int y)
+{
+    return 1;
+}
+
+int
+f6(int x, int y)
+{
+    return 1;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/if_else.c b/pack/ant/start/nvim-treesitter/tests/indent/c/if_else.c
new file mode 100644
index 0000000..e71aa32
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/if_else.c
@@ -0,0 +1,59 @@
+int foo(int x){
+    if (x > 10)
+        return 10;
+
+    if (x > 10)
+        return 10;
+    else
+        return 10;
+
+    if (x > 20)
+        return 20;
+    else if (x > 15)
+        return 15;
+    else
+        return 10;
+}
+
+int bar(int x){
+    if (x > 20)
+        return 10;
+    else {
+        return 10;
+    }
+
+    if (x > 20)
+        return 10;
+    else if (x > 10) {
+        return 10;
+    }
+}
+
+int baz(int x){
+    if (x > 20)
+        return x;
+    else if(x > 10) {
+        if(x > 10) {
+            if(x > 10)
+                return 10;
+            if(x > 5) {
+                return 5;
+            }
+        }
+    }
+
+    if (x > 20)
+        if (x > 19)
+            if(x > 18)
+                return x;
+
+    if (x > 20)
+        return x;
+    else if (x > 19) {
+        if (x > 18)
+            return x;
+        else
+            x++;
+    }
+    return 0;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/issue-1568.c b/pack/ant/start/nvim-treesitter/tests/indent/c/issue-1568.c
new file mode 100644
index 0000000..c5d7566
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/issue-1568.c
@@ -0,0 +1,6 @@
+int main() {
+    if (1) {
+        foobar();
+    } else {
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/issue-2086.c b/pack/ant/start/nvim-treesitter/tests/indent/c/issue-2086.c
new file mode 100644
index 0000000..e4d8796
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/issue-2086.c
@@ -0,0 +1,3 @@
+{
+    statement;
+    statement;
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/issue-4079.c b/pack/ant/start/nvim-treesitter/tests/indent/c/issue-4079.c
new file mode 100644
index 0000000..fd1490c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/issue-4079.c
@@ -0,0 +1,7 @@
+int main(){
+    for(;;)
+}
+
+int foo(){
+    while(1)
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/issue-4117.c b/pack/ant/start/nvim-treesitter/tests/indent/c/issue-4117.c
new file mode 100644
index 0000000..12e05c6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/issue-4117.c
@@ -0,0 +1,6 @@
+int main(){
+    if(1){
+    } 
+    else {
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/issue-4525.c b/pack/ant/start/nvim-treesitter/tests/indent/c/issue-4525.c
new file mode 100644
index 0000000..35fecce
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/issue-4525.c
@@ -0,0 +1,23 @@
+#include <stdint.h>
+#include <inttypes.h>
+#include <stdio.h>
+
+char *a = "a" "b" "c" D;
+
+static int a, b, c;
+a = b = c = 0;
+
+static int d = 0, e = 0, f = 0;
+
+int main(void) {
+    printf("String" PRIu64 "\n", (uint64_t)0);
+    printf("String" AND_ERROR_NODE "and string");
+    fflush(stdout);
+    a = 0; b = 0; c = 0;
+    int x = 0; int y = 0; int z = 0;
+    foo(1, 2);
+    x++;
+    a = b
+        = c
+        = d;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/label.c b/pack/ant/start/nvim-treesitter/tests/indent/c/label.c
new file mode 100644
index 0000000..36b40e2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/label.c
@@ -0,0 +1,7 @@
+int foo(int x)
+{
+    goto error;
+    return 0;
+error:
+    return 1;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/loop.c b/pack/ant/start/nvim-treesitter/tests/indent/c/loop.c
new file mode 100644
index 0000000..facaebb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/loop.c
@@ -0,0 +1,16 @@
+void foo(int x)
+{
+    while (x > 0) {
+        x--;
+        continue;
+    }
+
+    for (int i = 0; i < 5; ++i) {
+        x++;
+        break;
+    }
+
+    do {
+        x++;
+    } while (x < 0);
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/no_braces.c b/pack/ant/start/nvim-treesitter/tests/indent/c/no_braces.c
new file mode 100644
index 0000000..9cc6398
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/no_braces.c
@@ -0,0 +1,13 @@
+int foo(int x) {
+    if (x > 10)
+        return 10;
+    else
+        return x;
+
+    while (1)
+        x++;
+
+    for (int i = 0; i < 3; ++i)
+        x--;
+}
+
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/preproc_cond.c b/pack/ant/start/nvim-treesitter/tests/indent/c/preproc_cond.c
new file mode 100644
index 0000000..b85440a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/preproc_cond.c
@@ -0,0 +1,10 @@
+void foo(int x)
+{
+    x = x + 1;
+#if 1
+    x = x + 2;
+#else
+    x = x + 3;
+#endif
+    x = x + 4;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/preproc_func.c b/pack/ant/start/nvim-treesitter/tests/indent/c/preproc_func.c
new file mode 100644
index 0000000..f1f38fe
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/preproc_func.c
@@ -0,0 +1,9 @@
+#define FOO(x) do { \
+        x = x + 1;  \
+        x = x / 2;  \
+    } while (x > 0);
+
+void foo(int x)
+{
+    FOO(x);
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/string.c b/pack/ant/start/nvim-treesitter/tests/indent/c/string.c
new file mode 100644
index 0000000..2d5177e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/string.c
@@ -0,0 +1,5 @@
+const char *a = "hello \
+world";
+
+const char *b = "hello "
+    "world";
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/struct.c b/pack/ant/start/nvim-treesitter/tests/indent/c/struct.c
new file mode 100644
index 0000000..8cc2b6b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/struct.c
@@ -0,0 +1,11 @@
+struct foo {
+    int a;
+    struct bar {
+        int x;
+    } b;
+};
+
+union baz {
+    struct foo;
+    int x;
+};
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/switch.c b/pack/ant/start/nvim-treesitter/tests/indent/c/switch.c
new file mode 100644
index 0000000..4003bdb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/switch.c
@@ -0,0 +1,16 @@
+void foo(int x) {
+    switch (x) {
+        case 1:
+            x += 1;
+            break;
+        case 2: x += 2;
+            break;
+        case 3: x += 3; break;
+        case 4: {
+            x += 4;
+            break;
+        }
+        default:
+            x = -x;
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/ternary.c b/pack/ant/start/nvim-treesitter/tests/indent/c/ternary.c
new file mode 100644
index 0000000..2e40b38
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/ternary.c
@@ -0,0 +1,6 @@
+void foo(int x)
+{
+    int y = (x > 10) ? 10
+        : (x < -10) ? -10
+        : x;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c/unfinished_comment.c b/pack/ant/start/nvim-treesitter/tests/indent/c/unfinished_comment.c
new file mode 100644
index 0000000..fb48bfb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c/unfinished_comment.c
@@ -0,0 +1,2 @@
+/*
+ *
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/c_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/c_spec.lua
new file mode 100644
index 0000000..4e2826a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/c_spec.lua
@@ -0,0 +1,93 @@
+local Runner = require("tests.indent.common").Runner
+local XFAIL = require("tests.indent.common").XFAIL
+
+local runner = Runner:new(it, "tests/indent/c", {
+  tabstop = 4,
+  shiftwidth = 4,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent C:", function()
+  describe("whole file:", function()
+    runner:whole_file(".", {
+      expected_failures = {
+        "./preproc_func.c",
+        "./unfinished_comment.c",
+      },
+    })
+  end)
+
+  describe("new line:", function()
+    runner:new_line("array.c", { on_line = 2, text = "0,", indent = 4 })
+    runner:new_line("compound_lit.c", { on_line = 7, text = ".z = 5,", indent = 8 })
+    runner:new_line("cond.c", { on_line = 3, text = "x++;", indent = 8 })
+    runner:new_line("cond.c", { on_line = 6, text = "x++;", indent = 8 })
+    runner:new_line("cond.c", { on_line = 8, text = "x++;", indent = 8 })
+    runner:new_line("cond.c", { on_line = 9, text = "x++;", indent = 4 })
+    runner:new_line("expr.c", { on_line = 10, text = "2 *", indent = 8 })
+    runner:new_line("func.c", { on_line = 17, text = "int z,", indent = 4 })
+    runner:new_line("label.c", { on_line = 3, text = "normal:", indent = 0 })
+    runner:new_line("loop.c", { on_line = 3, text = "x++;", indent = 8 })
+    runner:new_line("preproc_cond.c", { on_line = 5, text = "x++;", indent = 4 })
+    runner:new_line("preproc_func.c", { on_line = 3, text = "x++; \\", indent = 8 }, "expected failure", XFAIL)
+    runner:new_line("string.c", { on_line = 1, text = "brave new \\", indent = 0 })
+    runner:new_line("string.c", { on_line = 4, text = '"brave new "', indent = 4 })
+    runner:new_line("struct.c", { on_line = 4, text = "int y;", indent = 8 })
+    runner:new_line("switch.c", { on_line = 3, text = "x++;", indent = 12 })
+    runner:new_line("ternary.c", { on_line = 4, text = ": (x == 0) : 0", indent = 8 })
+    runner:new_line("issue-1568.c", { on_line = 4, text = "x++;", indent = 8 })
+    runner:new_line("issue-2086.c", { on_line = 3, text = "}", indent = 0 })
+    runner:new_line("issue-4079.c", { on_line = 2, text = "return;", indent = 8 })
+    runner:new_line("issue-4079.c", { on_line = 2, text = "{", indent = 4 })
+    runner:new_line("issue-4079.c", { on_line = 6, text = "{", indent = 4 })
+    runner:new_line("issue-4117.c", { on_line = 3, text = "else", indent = 4 })
+    -- the line after inserted one will be left with wrong indent but we only care about the inserted one
+    for _, line in ipairs { 2, 4, 7, 10 } do
+      runner:new_line("no_braces.c", { on_line = line, text = "x++;", indent = 8 })
+    end
+    for _, line in ipairs { 2, 5, 7, 10, 12, 14, 20, 22, 25, 27, 28, 33 } do
+      runner:new_line("if_else.c", { on_line = line, text = "x++;", indent = 8 })
+    end
+    for _, line in ipairs { 3, 6, 8, 13, 15, 20, 23 } do
+      runner:new_line("if_else.c", { on_line = line, text = "else", indent = 4 })
+    end
+    for _, info in ipairs {
+      { 36, 12 },
+      { 37, 16 },
+      { 38, 12 },
+      { 39, 16 },
+      { 41, 12 },
+      { 42, 8 },
+      { 45, 8 },
+      { 46, 12 },
+      { 47, 16 },
+      { 48, 4 },
+      { 52, 8 },
+      { 53, 12 },
+      { 54, 12 },
+    } do
+      runner:new_line("if_else.c", { on_line = info[1], text = "x++;", indent = info[2] })
+    end
+    -- dedent braces on new line
+    for _, line in ipairs { 10, 12, 14 } do
+      runner:new_line("if_else.c", { on_line = line, text = "{}", indent = 4 })
+    end
+
+    for _, info in ipairs {
+      { 8, 0 },
+      { 10, 0 },
+      { 13, 4 },
+      { 14, 4 },
+      { 15, 4 },
+      { 16, 4 },
+      { 17, 4 },
+      { 18, 4 },
+      { 20, 8 },
+      { 21, 8 },
+      { 22, 4 },
+    } do
+      runner:new_line("issue-4525.c", { on_line = info[1], text = "x++;", indent = info[2] })
+    end
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/capnp/test.capnp b/pack/ant/start/nvim-treesitter/tests/indent/capnp/test.capnp
new file mode 100644
index 0000000..dd23223
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/capnp/test.capnp
@@ -0,0 +1,1057 @@
+# Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
+# Licensed under the MIT License:
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+@0xd508eebdc2dc42b8;
+
+using Cxx = import "c++.capnp";
+
+# Use a namespace likely to cause trouble if the generated code doesn't use fully-qualified
+# names for stuff in the capnproto namespace.
+$Cxx.namespace("capnproto_test::capnp::test");
+
+enum TestEnum {
+  foo @0;
+  bar @1;
+  baz @2;
+  qux @3;
+  quux @4;
+  corge @5;
+  grault @6;
+  garply @7;
+}
+
+struct TestAllTypes {
+  voidField      @0  : Void;
+  boolField      @1  : Bool;
+  int8Field      @2  : Int8;
+  int16Field     @3  : Int16;
+  int32Field     @4  : Int32;
+  int64Field     @5  : Int64;
+  uInt8Field     @6  : UInt8;
+  uInt16Field    @7  : UInt16;
+  uInt32Field    @8  : UInt32;
+  uInt64Field    @9  : UInt64;
+  float32Field   @10 : Float32;
+  float64Field   @11 : Float64;
+  textField      @12 : Text;
+  dataField      @13 : Data;
+  structField    @14 : TestAllTypes;
+  enumField      @15 : TestEnum;
+  interfaceField @16 : Void;  # TODO
+
+  voidList      @17 : List(Void);
+  boolList      @18 : List(Bool);
+  int8List      @19 : List(Int8);
+  int16List     @20 : List(Int16);
+  int32List     @21 : List(Int32);
+  int64List     @22 : List(Int64);
+  uInt8List     @23 : List(UInt8);
+  uInt16List    @24 : List(UInt16);
+  uInt32List    @25 : List(UInt32);
+  uInt64List    @26 : List(UInt64);
+  float32List   @27 : List(Float32);
+  float64List   @28 : List(Float64);
+  textList      @29 : List(Text);
+  dataList      @30 : List(Data);
+  structList    @31 : List(TestAllTypes);
+  enumList      @32 : List(TestEnum);
+  interfaceList @33 : List(Void);  # TODO
+}
+
+struct TestDefaults {
+  voidField      @0  : Void    = void;
+  boolField      @1  : Bool    = true;
+  int8Field      @2  : Int8    = -123;
+  int16Field     @3  : Int16   = -12345;
+  int32Field     @4  : Int32   = -12345678;
+  int64Field     @5  : Int64   = -123456789012345;
+  uInt8Field     @6  : UInt8   = 234;
+  uInt16Field    @7  : UInt16  = 45678;
+  uInt32Field    @8  : UInt32  = 3456789012;
+  uInt64Field    @9  : UInt64  = 12345678901234567890;
+  float32Field   @10 : Float32 = 1234.5;
+  float64Field   @11 : Float64 = -123e45;
+  textField      @12 : Text    = "foo";
+  dataField      @13 : Data    = 0x"62 61 72"; # "bar"
+  structField    @14 : TestAllTypes = (
+    voidField      = void,
+    boolField      = true,
+    int8Field      = -12,
+    int16Field     = 3456,
+    int32Field     = -78901234,
+    int64Field     = 56789012345678,
+    uInt8Field     = 90,
+    uInt16Field    = 1234,
+    uInt32Field    = 56789012,
+    uInt64Field    = 345678901234567890,
+    float32Field   = -1.25e-10,
+    float64Field   = 345,
+    textField      = "baz",
+    dataField      = "qux",
+    structField    = (
+      textField = "nested",
+      structField = (textField = "really nested")),
+    enumField      = baz,
+    # interfaceField can't have a default
+
+    voidList      = [void, void, void],
+    boolList      = [false, true, false, true, true],
+    int8List      = [12, -34, -0x80, 0x7f],
+    int16List     = [1234, -5678, -0x8000, 0x7fff],
+    int32List     = [12345678, -90123456, -0x80000000, 0x7fffffff],
+    int64List     = [
+      123456789012345, -678901234567890, 
+      -0x8000000000000000, 0x7fffffffffffffff],
+    uInt8List     = [12, 34, 0, 0xff],
+    uInt16List    = [1234, 5678, 0, 0xffff],
+    uInt32List    = [12345678, 90123456, 0, 0xffffffff],
+    uInt64List    = [123456789012345, 678901234567890, 0, 0xffffffffffffffff],
+    float32List   = [0, 1234567, 1e37, -1e37, 1e-37, -1e-37],
+    float64List   = [0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306],
+    textList      = ["quux", "corge", "grault"],
+    dataList      = ["garply", "waldo", "fred"],
+    structList    = [
+      (textField = "x " "structlist"
+                    " 1"),
+      (textField = "x structlist 2"),
+      (textField = "x structlist 3")],
+    enumList      = [qux, bar, grault]
+    # interfaceList can't have a default
+  );
+  enumField      @15 : TestEnum = corge;
+  interfaceField @16 : Void;  # TODO
+
+  voidList      @17 : List(Void)    = [void, void, void, void, void, void];
+  boolList      @18 : List(Bool)    = [true, false, false, true];
+  int8List      @19 : List(Int8)    = [111, -111];
+  int16List     @20 : List(Int16)   = [11111, -11111];
+  int32List     @21 : List(Int32)   = [111111111, -111111111];
+  int64List     @22 : List(Int64)   = [1111111111111111111, -1111111111111111111];
+  uInt8List     @23 : List(UInt8)   = [111, 222] ;
+  uInt16List    @24 : List(UInt16)  = [33333, 44444];
+  uInt32List    @25 : List(UInt32)  = [3333333333];
+  uInt64List    @26 : List(UInt64)  = [11111111111111111111];
+  float32List   @27 : List(Float32) = [5555.5, inf, -inf, nan];
+  float64List   @28 : List(Float64) = [7777.75, inf, -inf, nan];
+  textList      @29 : List(Text)    = ["plugh", "xyzzy", "thud"];
+  dataList      @30 : List(Data)    = ["oops", "exhausted", "rfc3092"];
+  structList    @31 : List(TestAllTypes) = [
+    (textField = "structlist 1"),
+    (textField = "structlist 2"),
+    (textField = "structlist 3")];
+  enumList      @32 : List(TestEnum) = [foo, garply];
+  interfaceList @33 : List(Void);  # TODO
+}
+
+struct TestAnyPointer {
+  anyPointerField @0 :AnyPointer;
+
+  # Do not add any other fields here!  
+  # Some tests rely on anyPointerField being the last pointer
+  # in the struct.
+}
+
+struct TestAnyOthers {
+  anyStructField @0 :AnyStruct;
+  anyListField @1 :AnyList;
+  capabilityField @2 :Capability;
+}
+
+struct TestOutOfOrder {
+  foo @3 :Text;
+  bar @2 :Text;
+  baz @8 :Text;
+  qux @0 :Text;
+  quux @6 :Text;
+  corge @4 :Text;
+  grault @1 :Text;
+  garply @7 :Text;
+  waldo @5 :Text;
+}
+
+struct TestUnion {
+  union0 @0! :union {
+    # Pack union 0 under ideal conditions: there is no unused padding space prior to it.
+    u0f0s0  @4: Void;
+    u0f0s1  @5: Bool;
+    u0f0s8  @6: Int8;
+    u0f0s16 @7: Int16;
+    u0f0s32 @8: Int32;
+    u0f0s64 @9: Int64;
+    u0f0sp  @10: Text;
+
+    # Pack more stuff into union0 -- should go in same space.
+    u0f1s0  @11: Void;
+    u0f1s1  @12: Bool;
+    u0f1s8  @13: Int8;
+    u0f1s16 @14: Int16;
+    u0f1s32 @15: Int32;
+    u0f1s64 @16: Int64;
+    u0f1sp  @17: Text;
+  }
+
+  # Pack one bit in order to make pathological situation for union1.
+  bit0 @18: Bool;
+
+  union1 @1! :union {
+    # Pack pathologically bad case.  Each field takes up new space.
+    u1f0s0  @19: Void;
+    u1f0s1  @20: Bool;
+    u1f1s1  @21: Bool;
+    u1f0s8  @22: Int8;
+    u1f1s8  @23: Int8;
+    u1f0s16 @24: Int16;
+    u1f1s16 @25: Int16;
+    u1f0s32 @26: Int32;
+    u1f1s32 @27: Int32;
+    u1f0s64 @28: Int64;
+    u1f1s64 @29: Int64;
+    u1f0sp  @30: Text;
+    u1f1sp  @31: Text;
+
+    # Pack more stuff into union1
+    # each should go into the same space as corresponding u1f0s*.
+    u1f2s0  @32: Void;
+    u1f2s1  @33: Bool;
+    u1f2s8  @34: Int8;
+    u1f2s16 @35: Int16;
+    u1f2s32 @36: Int32;
+    u1f2s64 @37: Int64;
+    u1f2sp  @38: Text;
+  }
+
+  # Fill in the rest of that bitfield from earlier.
+  bit2 @39: Bool;
+  bit3 @40: Bool;
+  bit4 @41: Bool;
+  bit5 @42: Bool;
+  bit6 @43: Bool;
+  bit7 @44: Bool;
+
+  # Interleave two unions to be really annoying.
+  # Also declare in reverse order to make sure 
+  # union discriminant values are sorted by field number and not by declaration order.
+  union2 @2! :union {
+    u2f0s64 @54: Int64;
+    u2f0s32 @52: Int32;
+    u2f0s16 @50: Int16;
+    u2f0s8 @47: Int8;
+    u2f0s1 @45: Bool;
+  }
+
+  union3 @3! :union {
+    u3f0s64 @55: Int64;
+    u3f0s32 @53: Int32;
+    u3f0s16 @51: Int16;
+    u3f0s8 @48: Int8;
+    u3f0s1 @46: Bool;
+  }
+
+  byte0 @49: UInt8;
+}
+
+struct TestUnnamedUnion {
+  before @0 :Text;
+
+  union {
+    foo @1 :UInt16;
+    bar @3 :UInt32;
+  }
+
+  middle @2 :UInt16;
+
+  after @4 :Text;
+}
+
+struct TestUnionInUnion {
+  # There is no reason to ever do this.
+  outer :union {
+    inner :union {
+      foo @0 :Int32;
+      bar @1 :Int32;
+    }
+    baz @2 :Int32;
+  }
+}
+
+struct TestGroups {
+  groups :union {
+    foo :group {
+      corge @0 :Int32;
+      grault @2 :Int64;
+      garply @8 :Text;
+    }
+    bar :group {
+      corge @3 :Int32;
+      grault @4 :Text;
+      garply @5 :Int64;
+    }
+    baz :group {
+      corge @1 :Int32;
+      grault @6 :Text;
+      garply @7 :Text;
+    }
+  }
+}
+
+struct TestInterleavedGroups {
+  group1 :group {
+    foo @0 :UInt32;
+    bar @2 :UInt64;
+    union {
+      qux @4 :UInt16;
+      corge :group {
+        grault @6 :UInt64;
+        garply @8 :UInt16;
+        plugh @14 :Text;
+        xyzzy @16 :Text;
+      }
+
+      fred @12 :Text;
+    }
+
+    waldo @10 :Text;
+  }
+
+  group2 :group {
+    foo @1 :UInt32;
+    bar @3 :UInt64;
+    union {
+      qux @5 :UInt16;
+      corge :group {
+        grault @7 :UInt64;
+        garply @9 :UInt16;
+        plugh @15 :Text;
+        xyzzy @17 :Text;
+      }
+
+      fred @13 :Text;
+    }
+
+    waldo @11 :Text;
+  }
+}
+
+struct TestUnionDefaults {
+  s16s8s64s8Set @0 :TestUnion =
+    (union0 = (u0f0s16 = 321), union1 = (u1f0s8 = 123), union2 = (u2f0s64 = 12345678901234567),
+     union3 = (u3f0s8 = 55));
+  s0sps1s32Set @1 :TestUnion =
+    (union0 = (u0f1s0 = void), union1 = (u1f0sp = "foo"), union2 = (u2f0s1 = true),
+     union3 = (u3f0s32 = 12345678));
+
+  unnamed1 @2 :TestUnnamedUnion = (foo = 123);
+  unnamed2 @3 :TestUnnamedUnion = (bar = 321, before = "foo", after = "bar");
+}
+
+struct TestNestedTypes {
+  enum NestedEnum {
+    foo @0;
+    bar @1;
+  }
+
+  struct NestedStruct {
+    enum NestedEnum {
+      baz @0;
+      qux @1;
+      quux @2;
+    }
+
+    outerNestedEnum @0 :TestNestedTypes.NestedEnum = bar;
+    innerNestedEnum @1 :NestedEnum = quux;
+  }
+
+  nestedStruct @0 :NestedStruct;
+
+  outerNestedEnum @1 :NestedEnum = bar;
+  innerNestedEnum @2 :NestedStruct.NestedEnum = quux;
+}
+
+struct TestUsing {
+  using OuterNestedEnum = TestNestedTypes.NestedEnum;
+  using TestNestedTypes.NestedStruct.NestedEnum;
+
+  outerNestedEnum @1 :OuterNestedEnum = bar;
+  innerNestedEnum @0 :NestedEnum = quux;
+}
+
+struct TestLists {
+  # Small structs, when encoded as list, will be encoded as primitive lists rather than struct
+  # lists, to save space.
+  struct Struct0  { f @0 :Void; }
+  struct Struct1  { f @0 :Bool; }
+  struct Struct8  { f @0 :UInt8; }
+  struct Struct16 { f @0 :UInt16; }
+  struct Struct32 { f @0 :UInt32; }
+  struct Struct64 { f @0 :UInt64; }
+  struct StructP  { f @0 :Text; }
+
+  # Versions of the above which cannot be encoded as primitive lists.
+  struct Struct0c  { f @0 :Void; pad @1 :Text; }
+  struct Struct1c  { f @0 :Bool; pad @1 :Text; }
+  struct Struct8c  { f @0 :UInt8; pad @1 :Text; }
+  struct Struct16c { f @0 :UInt16; pad @1 :Text; }
+  struct Struct32c { f @0 :UInt32; pad @1 :Text; }
+  struct Struct64c { f @0 :UInt64; pad @1 :Text; }
+  struct StructPc  { f @0 :Text; pad @1 :UInt64; }
+
+  list0  @0 :List(Struct0);
+  list1  @1 :List(Struct1);
+  list8  @2 :List(Struct8);
+  list16 @3 :List(Struct16);
+  list32 @4 :List(Struct32);
+  list64 @5 :List(Struct64);
+  listP  @6 :List(StructP);
+
+  int32ListList @7 :List(List(Int32));
+  textListList @8 :List(List(Text));
+  structListList @9 :List(List(TestAllTypes));
+}
+
+struct TestFieldZeroIsBit {
+  bit @0 :Bool;
+  secondBit @1 :Bool = true;
+  thirdField @2 :UInt8 = 123;
+}
+
+struct TestListDefaults {
+  lists @0 :TestLists = (
+    list0  = [(f = void), (f = void)],
+    list1  = [(f = true), (f = false), (f = true), (f = true)],
+    list8  = [(f = 123), (f = 45)],
+    list16 = [(f = 12345), (f = 6789)],
+    list32 = [(f = 123456789), (f = 234567890)],
+    list64 = [(f = 1234567890123456), (f = 2345678901234567)],
+    listP  = [(f = "foo"), (f = "bar")],
+    int32ListList = [[1, 2, 3], [4, 5], [12341234]],
+    textListList = [["foo", "bar"], ["baz"], ["qux", "corge"]],
+    structListList = [[(int32Field = 123), (int32Field = 456)], [(int32Field = 789)]]);
+}
+
+struct TestLateUnion {
+  # Test what happens if the unions are not the first ordinals in the struct.  
+  # At one point this was broken for the dynamic API.
+
+  foo @0 :Int32;
+  bar @1 :Text;
+  baz @2 :Int16;
+
+  theUnion @3! :union {
+    qux @4 :Text;
+    corge @5 :List(Int32);
+    grault @6 :Float32;
+  }
+
+  anotherUnion @7! :union {
+    qux @8 :Text;
+    corge @9 :List(Int32);
+    grault @10 :Float32;
+  }
+}
+
+struct TestOldVersion {
+  # A subset of TestNewVersion.
+  old1 @0 :Int64;
+  old2 @1 :Text;
+  old3 @2 :TestOldVersion;
+}
+
+struct TestNewVersion {
+  # A superset of TestOldVersion.
+  old1 @0 :Int64;
+  old2 @1 :Text;
+  old3 @2 :TestNewVersion;
+  new1 @3 :Int64 = 987;
+  new2 @4 :Text = "baz";
+}
+
+struct TestOldUnionVersion {
+  union {
+    a @0 :Void;
+    b @1 :UInt64;
+  }
+}
+
+struct TestNewUnionVersion {
+  union {
+    a :union {
+      a0 @0 :Void;
+      a1 @2 :UInt64;
+    }
+    b @1 :UInt64;
+  }
+}
+
+struct TestStructUnion {
+  un @0! :union {
+    struct @1 :SomeStruct;
+    object @2 :TestAnyPointer;
+  }
+
+  struct SomeStruct {
+    someText @0 :Text;
+    moreText @1 :Text;
+  }
+}
+
+struct TestPrintInlineStructs {
+  someText @0 :Text;
+
+  structList @1 :List(InlineStruct);
+  struct InlineStruct {
+    int32Field @0 :Int32;
+    textField @1 :Text;
+  }
+}
+
+struct TestWholeFloatDefault {
+  # At one point, these failed to compile in C++ because it would produce literals like "123f",
+  # which is not valid; it needs to be "123.0f".
+  field @0 :Float32 = 123;
+  bigField @1 :Float32 = 2e30;
+  const constant :Float32 = 456;
+  const bigConstant :Float32 = 4e30;
+}
+
+struct TestGenerics(Foo, Bar) {
+  foo @0 :Foo;
+  rev @1 :TestGenerics(Bar, Foo);
+
+  union {
+    uv @2:Void;
+    ug :group {
+      ugfoo @3:Int32;
+    }
+  }
+
+  list @4 :List(Inner);
+  # At one time this failed to compile with MSVC due to poor expression SFINAE support.
+
+  struct Inner {
+    foo @0 :Foo;
+    bar @1 :Bar;
+  }
+
+  struct Inner2(Baz) {
+    bar @0 :Bar;
+    baz @1 :Baz;
+    innerBound @2 :Inner;
+    innerUnbound @3 :TestGenerics.Inner;
+
+    struct DeepNest(Qux) {
+      foo @0 :Foo;
+      bar @1 :Bar;
+      baz @2 :Baz;
+      qux @3 :Qux;
+
+      interface DeepNestInterface(Quux) {
+        # At one time this failed to compile.
+        call @0 () -> ();
+      }
+    }
+  }
+
+  interface Interface(Qux) {
+    call @0 Inner2(Text) -> (qux :Qux, gen :TestGenerics(TestAllTypes, TestAnyPointer));
+  }
+
+  annotation ann(struct) :Foo;
+
+  using AliasFoo = Foo;
+  using AliasInner = Inner;
+  using AliasInner2 = Inner2;
+  using AliasInner2Text = Inner2(Text);
+  using AliasRev = TestGenerics(Bar, Foo);
+
+  struct UseAliases {
+    foo @0 :AliasFoo;
+    inner @1 :AliasInner;
+    inner2 @2 :AliasInner2;
+    inner2Bind @3 :AliasInner2(Text);
+    inner2Text @4 :AliasInner2Text;
+    revFoo @5 :AliasRev.AliasFoo;
+  }
+}
+
+struct BoxedText { text @0 :Text; }
+using BrandedAlias = TestGenerics(BoxedText, Text);
+
+struct TestGenericsWrapper(Foo, Bar) {
+  value @0 :TestGenerics(Foo, Bar);
+}
+
+struct TestGenericsWrapper2 {
+  value @0 :TestGenericsWrapper(Text, TestAllTypes);
+}
+
+interface TestImplicitMethodParams {
+  call @0 [T, U] (foo :T, bar :U) -> TestGenerics(T, U);
+}
+
+interface TestImplicitMethodParamsInGeneric(V) {
+  call @0 [T, U] (foo :T, bar :U) -> TestGenerics(T, U);
+}
+
+struct TestGenericsUnion(Foo, Bar) {
+  # At one point this failed to compile.
+
+  union {
+    foo @0 :Foo;
+    bar @1 :Bar;
+  }
+}
+
+struct TestUseGenerics $TestGenerics(Text, Data).ann("foo") {
+  basic @0 :TestGenerics(TestAllTypes, TestAnyPointer);
+  inner @1 :TestGenerics(TestAllTypes, TestAnyPointer).Inner;
+  inner2 @2 :TestGenerics(TestAllTypes, TestAnyPointer).Inner2(Text);
+  unspecified @3 :TestGenerics;
+  unspecifiedInner @4 :TestGenerics.Inner2(Text);
+  wrapper @8 :TestGenericsWrapper(TestAllTypes, TestAnyPointer);
+  cap @18 :TestGenerics(TestInterface, Text);
+  genericCap @19 :TestGenerics(TestAllTypes, List(UInt32)).Interface(Data);
+
+  default @5 :TestGenerics(TestAllTypes, Text) =
+    (foo = (int16Field = 123), rev = (foo = "text", rev = (foo = (int16Field = 321))));
+  defaultInner @6 :TestGenerics(TestAllTypes, Text).Inner =
+    (foo = (int16Field = 123), bar = "text");
+  defaultUser @7 :TestUseGenerics = (basic = (foo = (int16Field = 123)));
+  defaultWrapper @9 :TestGenericsWrapper(Text, TestAllTypes) =
+    (value = (foo = "text", rev = (foo = (int16Field = 321))));
+  defaultWrapper2 @10 :TestGenericsWrapper2 =
+    (value = (value = (foo = "text", rev = (foo = (int16Field = 321)))));
+
+  aliasFoo @11 :TestGenerics(TestAllTypes, TestAnyPointer).AliasFoo = (int16Field = 123);
+  aliasInner @12 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner
+    = (foo = (int16Field = 123));
+  aliasInner2 @13 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner2
+    = (innerBound = (foo = (int16Field = 123)));
+  aliasInner2Bind @14 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner2(List(UInt32))
+    = (baz = [12, 34], innerBound = (foo = (int16Field = 123)));
+  aliasInner2Text @15 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner2Text
+    = (baz = "text", innerBound = (foo = (int16Field = 123)));
+  aliasRev @16 :TestGenerics(TestAnyPointer, Text).AliasRev.AliasFoo = "text";
+
+  useAliases @17 :TestGenerics(TestAllTypes, List(UInt32)).UseAliases = (
+    foo = (int16Field = 123),
+    inner = (foo = (int16Field = 123)),
+    inner2 = (innerBound = (foo = (int16Field = 123))),
+    inner2Bind = (baz = "text", innerBound = (foo = (int16Field = 123))),
+    inner2Text = (baz = "text", innerBound = (foo = (int16Field = 123))),
+    revFoo = [12, 34, 56]);
+}
+
+struct TestEmptyStruct {}
+
+struct TestConstants {
+  const voidConst      :Void    = void;
+  const boolConst      :Bool    = true;
+  const int8Const      :Int8    = -123;
+  const int16Const     :Int16   = -12345;
+  const int32Const     :Int32   = -12345678;
+  const int64Const     :Int64   = -123456789012345;
+  const uint8Const     :UInt8   = 234;
+  const uint16Const    :UInt16  = 45678;
+  const uint32Const    :UInt32  = 3456789012;
+  const uint64Const    :UInt64  = 12345678901234567890;
+  const float32Const   :Float32 = 1234.5;
+  const float64Const   :Float64 = -123e45;
+  const textConst      :Text    = "foo";
+  const dataConst      :Data    = "bar";
+  const structConst    :TestAllTypes = (
+    voidField      = void,
+    boolField      = true,
+    int8Field      = -12,
+    int16Field     = 3456,
+    int32Field     = -78901234,
+    int64Field     = 56789012345678,
+    uInt8Field     = 90,
+    uInt16Field    = 1234,
+    uInt32Field    = 56789012,
+    uInt64Field    = 345678901234567890,
+    float32Field   = -1.25e-10,
+    float64Field   = 345,
+    textField      = "baz",
+    dataField      = "qux",
+    structField    = (
+      textField = "nested",
+      structField = (textField = "really nested")),
+    enumField      = baz,
+    # interfaceField can't have a default
+
+    voidList      = [void, void, void],
+    boolList      = [false, true, false, true, true],
+    int8List      = [12, -34, -0x80, 0x7f],
+    int16List     = [1234, -5678, -0x8000, 0x7fff],
+    int32List     = [12345678, -90123456, -0x80000000, 0x7fffffff],
+    int64List     = [
+      123456789012345, 
+      -678901234567890, 
+      -0x8000000000000000, 
+      0x7fffffffffffffff],
+    uInt8List     = [12, 34, 0, 0xff],
+    uInt16List    = [1234, 5678, 0, 0xffff],
+    uInt32List    = [12345678, 90123456, 0, 0xffffffff],
+    uInt64List    = [123456789012345, 678901234567890, 0, 0xffffffffffffffff],
+    float32List   = [0, 1234567, 1e37, -1e37, 1e-37, -1e-37],
+    float64List   = [0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306],
+    textList      = ["quux", "corge", "grault"],
+    dataList      = ["garply", "waldo", "fred"],
+    structList    = [
+      (textField = "x " "structlist"
+                    " 1"),
+      (textField = "x structlist 2"),
+      (textField = "x structlist 3")],
+    enumList      = [qux, bar, grault]
+    # interfaceList can't have a default
+  );
+  const enumConst      :TestEnum = corge;
+
+  const voidListConst      :List(Void)    = [void, void, void, void, void, void];
+  const boolListConst      :List(Bool)    = [true, false, false, true];
+  const int8ListConst      :List(Int8)    = [111, -111];
+  const int16ListConst     :List(Int16)   = [11111, -11111];
+  const int32ListConst     :List(Int32)   = [111111111, -111111111];
+  const int64ListConst     :List(Int64)   = [1111111111111111111, -1111111111111111111];
+  const uint8ListConst     :List(UInt8)   = [111, 222] ;
+  const uint16ListConst    :List(UInt16)  = [33333, 44444];
+  const uint32ListConst    :List(UInt32)  = [3333333333];
+  const uint64ListConst    :List(UInt64)  = [11111111111111111111];
+  const float32ListConst   :List(Float32) = [5555.5, inf, -inf, nan];
+  const float64ListConst   :List(Float64) = [7777.75, inf, -inf, nan];
+  const textListConst      :List(Text)    = ["plugh", "xyzzy", "thud"];
+  const dataListConst      :List(Data)    = ["oops", "exhausted", "rfc3092"];
+  const structListConst    :List(TestAllTypes) = [
+    (textField = "structlist 1"),
+    (textField = "structlist 2"),
+    (textField = "structlist 3")];
+  const enumListConst      :List(TestEnum) = [foo, garply];
+}
+
+const globalInt :UInt32 = 12345;
+const globalText :Text = "foobar";
+const globalStruct :TestAllTypes = (int32Field = 54321);
+const globalPrintableStruct :TestPrintInlineStructs = (someText = "foo");
+const derivedConstant :TestAllTypes = (
+  uInt32Field = .globalInt,
+  textField = TestConstants.textConst,
+  structField = TestConstants.structConst,
+  int16List = TestConstants.int16ListConst,
+  structList = TestConstants.structListConst);
+
+const genericConstant :TestGenerics(TestAllTypes, Text) =
+  (foo = (int16Field = 123), rev = (foo = "text", rev = (foo = (int16Field = 321))));
+
+const embeddedData :Data = embed "testdata/packed";
+const embeddedText :Text = embed "testdata/short.txt";
+const embeddedStruct :TestAllTypes = embed "testdata/binary";
+
+const nonAsciiText :Text = "♫ é ✓";
+
+const blockText :Text =
+  `foo bar baz
+  `"qux" `corge` 'grault'
+  "regular\"quoted\"line"
+  `garply\nwaldo\tfred\"plugh\"xyzzy\'thud
+  ;
+
+struct TestAnyPointerConstants {
+  anyKindAsStruct @0 :AnyPointer;
+  anyStructAsStruct @1 :AnyStruct;
+  anyKindAsList @2 :AnyPointer;
+  anyListAsList @3 :AnyList;
+}
+
+const anyPointerConstants :TestAnyPointerConstants = (
+  anyKindAsStruct = TestConstants.structConst,
+  anyStructAsStruct = TestConstants.structConst,
+  anyKindAsList = TestConstants.int32ListConst,
+  anyListAsList = TestConstants.int32ListConst,
+);
+
+struct TestListOfAny {
+  capList @0 :List(Capability);
+  #listList @1 :List(AnyList); 
+  # TODO(0.10): Make List(AnyList) work correctly in C++ generated code.
+}
+
+interface TestInterface {
+  foo @0 (i :UInt32, j :Bool) -> (x :Text);
+  bar @1 () -> ();
+  baz @2 (s: TestAllTypes);
+}
+
+interface TestExtends extends(TestInterface) {
+  qux @0 ();
+  corge @1 TestAllTypes -> ();
+  grault @2 () -> TestAllTypes;
+}
+
+interface TestExtends2 extends(TestExtends) {}
+
+interface TestPipeline {
+  getCap @0 (n: UInt32, inCap :TestInterface) -> (s: Text, outBox :Box);
+  testPointers @1 (cap :TestInterface, obj :AnyPointer, list :List(TestInterface)) -> ();
+  getAnyCap @2 (n: UInt32, inCap :Capability) -> (s: Text, outBox :AnyBox);
+
+  getCapPipelineOnly @3 () -> (outBox :Box);
+  # Never returns, but uses setPipeline() to make the pipeline work.
+
+  struct Box {
+    cap @0 :TestInterface;
+  }
+  struct AnyBox {
+    cap @0 :Capability;
+  }
+}
+
+interface TestCallOrder {
+  getCallSequence @0 (expected: UInt32) -> (n: UInt32);
+  # First call returns 0, next returns 1, ...
+  #
+  # The input `expected` is ignored but useful for disambiguating debug logs.
+}
+
+interface TestTailCallee $Cxx.allowCancellation {
+  struct TailResult {
+    i @0 :UInt32;
+    t @1 :Text;
+    c @2 :TestCallOrder;
+  }
+
+  foo @0 (i :Int32, t :Text) -> TailResult;
+}
+
+interface TestTailCaller {
+  foo @0 (i :Int32, callee :TestTailCallee) -> TestTailCallee.TailResult;
+}
+
+interface TestStreaming $Cxx.allowCancellation {
+  doStreamI @0 (i :UInt32) -> stream;
+  doStreamJ @1 (j :UInt32) -> stream;
+  finishStream @2 () -> (totalI :UInt32, totalJ :UInt32);
+  # Test streaming. finishStream() returns 
+  # the totals of the values streamed to the other calls.
+}
+
+interface TestHandle {}
+
+interface TestMoreStuff extends(TestCallOrder) {
+  # Catch-all type that contains lots of testing methods.
+
+  callFoo @0 (cap :TestInterface) -> (s: Text);
+  # Call `cap.foo()`, check the result, and return "bar".
+
+  callFooWhenResolved @1 (cap :TestInterface) -> (s: Text);
+  # Like callFoo but waits for `cap` to resolve first.
+
+  neverReturn @2 (cap :TestInterface) -> (capCopy :TestInterface) $Cxx.allowCancellation;
+  # Doesn't return.  You should cancel it.
+
+  hold @3 (cap :TestInterface) -> ();
+  # Returns immediately but holds on to the capability.
+
+  callHeld @4 () -> (s: Text);
+  # Calls the capability previously held using `hold` (and keeps holding it).
+
+  getHeld @5 () -> (cap :TestInterface);
+  # Returns the capability previously held using `hold` (and keeps holding it).
+
+  echo @6 (cap :TestCallOrder) -> (cap :TestCallOrder);
+  # Just returns the input cap.
+
+  expectCancel @7 (cap :TestInterface) -> () $Cxx.allowCancellation;
+  # evalLater()-loops forever, holding `cap`.  Must be canceled.
+
+  methodWithDefaults @8 (
+    a :Text, 
+    b :UInt32 = 123, 
+    c :Text = "foo"
+  ) -> (d :Text, e :Text = "bar");
+
+  methodWithNullDefault @12 (a :Text, b :TestInterface = null);
+
+  getHandle @9 () -> (handle :TestHandle);
+  # Get a new handle. Tests have an out-of-band way to check
+  # the current number of live handles, so this can be used to test garbage collection.
+
+  getNull @10 () -> (nullCap :TestMoreStuff);
+  # Always returns a null capability.
+
+  getEnormousString @11 () -> (str :Text);
+  # Attempts to return an 100MB string. Should always fail.
+
+  writeToFd @13 (fdCap1 :TestInterface, fdCap2 :TestInterface)
+             -> (fdCap3 :TestInterface, secondFdPresent :Bool);
+  # Expects fdCap1 and fdCap2 wrap socket file descriptors.
+  # Writes "foo" to the first and "bar" to the second. 
+  # Also creates a socketpair, writes "baz" to one end, and returns the other end.
+
+  throwException @14 ();
+  throwRemoteException @15 ();
+}
+
+interface TestMembrane {
+  makeThing @0 () -> (thing :Thing);
+  callPassThrough @1 (thing :Thing, tailCall :Bool) -> Result;
+  callIntercept @2 (thing :Thing, tailCall :Bool) -> Result;
+  loopback @3 (thing :Thing) -> (thing :Thing);
+
+  waitForever @4 () $Cxx.allowCancellation;
+
+  interface Thing {
+    passThrough @0 () -> Result;
+    intercept @1 () -> Result;
+  }
+
+  struct Result {
+    text @0 :Text;
+  }
+}
+
+struct TestContainMembrane {
+  cap @0 :TestMembrane.Thing;
+  list @1 :List(TestMembrane.Thing);
+}
+
+struct TestTransferCap {
+  list @0 :List(Element);
+  struct Element {
+    text @0 :Text;
+    cap @1 :TestInterface;
+  }
+}
+
+interface TestKeywordMethods {
+  delete @0 ();
+  class @1 ();
+  void @2 ();
+  return @3 ();
+}
+
+interface TestAuthenticatedBootstrap(VatId) {
+  getCallerId @0 () -> (caller :VatId);
+}
+
+struct TestSturdyRef {
+  hostId @0 :TestSturdyRefHostId;
+  objectId @1 :AnyPointer;
+}
+
+struct TestSturdyRefHostId {
+  host @0 :Text;
+}
+
+struct TestSturdyRefObjectId {
+  tag @0 :Tag;
+  enum Tag {
+    testInterface @0;
+    testExtends @1;
+    testPipeline @2;
+    testTailCallee @3;
+    testTailCaller @4;
+    testMoreStuff @5;
+  }
+}
+
+struct TestProvisionId {}
+struct TestRecipientId {}
+struct TestThirdPartyCapId {}
+struct TestJoinResult {}
+
+struct TestNameAnnotation $Cxx.name("RenamedStruct") {
+  union {
+    badFieldName @0 :Bool $Cxx.name("goodFieldName");
+    bar @1 :Int8;
+  }
+
+  enum BadlyNamedEnum $Cxx.name("RenamedEnum") {
+    foo @0;
+    bar @1;
+    baz @2 $Cxx.name("qux");
+  }
+
+  anotherBadFieldName @2 :BadlyNamedEnum $Cxx.name("anotherGoodFieldName");
+
+  struct NestedStruct $Cxx.name("RenamedNestedStruct") {
+    badNestedFieldName @0 :Bool $Cxx.name("goodNestedFieldName");
+    anotherBadNestedFieldName @1 :NestedStruct $Cxx.name("anotherGoodNestedFieldName");
+
+    enum DeeplyNestedEnum $Cxx.name("RenamedDeeplyNestedEnum") {
+      quux @0;
+      corge @1;
+      grault @2 $Cxx.name("garply");
+    }
+  }
+
+  badlyNamedUnion :union $Cxx.name("renamedUnion") {
+    badlyNamedGroup :group $Cxx.name("renamedGroup") {
+      foo @3 :Void;
+      bar @4 :Void;
+    }
+    baz @5 :NestedStruct $Cxx.name("qux");
+  }
+}
+
+interface TestNameAnnotationInterface $Cxx.name("RenamedInterface") {
+  badlyNamedMethod @0 (
+    badlyNamedParam :UInt8 $Cxx.name("renamedParam")
+  ) $Cxx.name("renamedMethod");
+}
+
+struct TestImpliedFirstField {
+  struct TextStruct {
+    text @0 :Text;
+    i @1 :UInt32 = 321;
+  }
+
+  textStruct @0 :TextStruct = "foo";
+  textStructList @1 :List(TextStruct);
+
+  intGroup :group {
+    i @2 :UInt32;
+    str @3 :Text = "corge";
+  }
+}
+
+const testImpliedFirstField :TestImpliedFirstField = (
+  textStruct = "bar",
+  textStructList = ["baz", (text = "qux", i = 123)],
+  intGroup = 123
+);
+
+struct TestCycleANoCaps {
+  foo @0 :TestCycleBNoCaps;
+}
+
+struct TestCycleBNoCaps {
+  foo @0 :List(TestCycleANoCaps);
+  bar @1 :TestAllTypes;
+}
+
+struct TestCycleAWithCaps {
+  foo @0 :TestCycleBWithCaps;
+}
+
+struct TestCycleBWithCaps {
+  foo @0 :List(TestCycleAWithCaps);
+  bar @1 :TestInterface;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/capnp_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/capnp_spec.lua
new file mode 100644
index 0000000..7c8418b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/capnp_spec.lua
@@ -0,0 +1,30 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/capnp", {
+  tabstop = 2,
+  shiftwidth = 2,
+  expandtab = true,
+})
+
+describe("indent Cap'n Proto:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("test.capnp", { on_line = 31, text = "foo @0;", indent = 2 })
+    run:new_line("test.capnp", { on_line = 96, text = "boolField      = true,", indent = 4 })
+    run:new_line("test.capnp", { on_line = 340, text = "grault @7 :UInt64;", indent = 8 })
+    run:new_line("test.capnp", {
+      on_line = 573,
+      text = "call @0 Inner2(Text) -> (qux :Qux, gen :TestGenerics(TestAllTypes, TestAnyPointer));",
+      indent = 4,
+    })
+    run:new_line("test.capnp", { on_line = 617, text = "foo @0 :Foo;", indent = 4 })
+    run:new_line("test.capnp", { on_line = 654, text = "foo = (int16Field = 123),", indent = 4 })
+    run:new_line("test.capnp", { on_line = 695, text = 'textField = "nested",', indent = 6 })
+    run:new_line("test.capnp", { on_line = 970, text = "testTailCaller @4;", indent = 4 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/common.lua b/pack/ant/start/nvim-treesitter/tests/indent/common.lua
new file mode 100644
index 0000000..6cfedaf
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/common.lua
@@ -0,0 +1,202 @@
+local M = {}
+
+local assert = require "luassert"
+local say = require "say"
+local scan_dir = require("plenary.scandir").scan_dir
+local Path = require "plenary.path"
+
+M.XFAIL = "xfail"
+
+local function same_indent(state, arguments)
+  local before = arguments[1]
+  local after = arguments[2]
+
+  local ok = true
+  local errors = { before = {}, after = {} }
+  for line = 1, #before do
+    if #string.match(before[line], "^%s*") ~= #string.match(after[line], "^%s*") then
+      if before[line] and after[line] then
+        -- store the actual indentation length for each line
+        errors.before[line] = #string.match(before[line], "^%s*")
+        errors.after[line] = #string.match(after[line], "^%s*")
+      end
+      ok = false
+    end
+  end
+
+  -- we will always use only a single argument, passing the other one in fmtargs
+  arguments.fmtargs = { { errors = errors, other = after } }
+  arguments.fmtargs[2] = { errors = errors, other = after }
+
+  return ok
+end
+
+local function format_indent(arg, fmtargs)
+  if not arg or not fmtargs then
+    return
+  end
+  -- find minimal width if any line is longer
+  local width = 40
+  for _, line in ipairs(fmtargs.other) do
+    width = #line > width and #line or width
+  end
+
+  width = width + 3
+  local header_fmt = "%8s %2s%-" .. tostring(width + 1) .. "s %s"
+  local fmt = "%8s %2s |%-" .. tostring(width) .. "s |%s"
+
+  local output = { header_fmt:format("", "", "Found:", "Expected:") }
+
+  for i, line in ipairs(arg) do
+    if fmtargs.errors.before[i] then
+      local indents = string.format("%d vs %d", fmtargs.errors.after[i], fmtargs.errors.before[i])
+      table.insert(output, fmt:format(indents, "=>", fmtargs.other[i], line))
+    else
+      table.insert(output, fmt:format("", "", fmtargs.other[i], line))
+    end
+  end
+
+  return table.concat(output, "\n")
+end
+
+say:set_namespace "en"
+say:set("assertion.same_indent.positive", "Incorrect indentation\n%s")
+say:set("assertion.same_indent.negative", "Incorrect indentation\n%s")
+assert:register(
+  "assertion",
+  "same_indent",
+  same_indent,
+  "assertion.same_indent.positive",
+  "assert.same_indent.negative"
+)
+
+-- Custom assertion better suited for indentation diffs
+local function compare_indent(before, after, xfail)
+  assert:add_formatter(format_indent)
+  if xfail then
+    io.stdout:write "Warning! Known failure of this test! Please help to fix it! "
+    assert.is_not.same_indent(before, after)
+  else
+    assert.is.same_indent(before, after)
+  end
+  assert:remove_formatter(format_indent)
+end
+
+local function set_buf_indent_opts(opts)
+  local optnames = { "tabstop", "shiftwidth", "softtabstop", "expandtab", "filetype", "lispoptions" }
+  for _, opt in ipairs(optnames) do
+    if opts[opt] ~= nil then
+      vim.bo[opt] = opts[opt]
+    end
+  end
+end
+
+function M.run_indent_test(file, runner, opts)
+  assert.are.same(1, vim.fn.filereadable(file), string.format('File "%s" not readable', file))
+
+  -- load reference file
+  vim.cmd(string.format("edit %s", file))
+  vim.bo.indentexpr = "nvim_treesitter#indent()"
+  local before = vim.api.nvim_buf_get_lines(0, 0, -1, true)
+
+  assert.are.same("nvim_treesitter#indent()", vim.bo.indentexpr)
+  set_buf_indent_opts(opts)
+
+  -- perform the test
+  runner()
+
+  -- get file content after the test
+  local after = vim.api.nvim_buf_get_lines(0, 0, -1, true)
+
+  -- clear any changes to avoid 'No write since last change (add ! to override)'
+  vim.cmd "edit!"
+
+  return before, after
+end
+
+function M.indent_whole_file(file, opts, xfail)
+  local before, after = M.run_indent_test(file, function()
+    vim.cmd "silent normal gg=G"
+  end, opts)
+
+  compare_indent(before, after, xfail)
+end
+
+-- Open a file, use `normal o` to insert a new line and compare results
+-- @param file path to the initial file
+-- @param spec a table with keys:
+--   on_line: line on which `normal o` is executed
+--   text: text inserted in the new line
+--   indent: expected indent before the inserted text (string or int)
+-- @param opts buffer options passed to set_buf_indent_opts
+function M.indent_new_line(file, spec, opts, xfail)
+  local before, after = M.run_indent_test(file, function()
+    -- move to the line and input the new one
+    vim.cmd(string.format("normal! %dG", spec.on_line))
+    vim.cmd(string.format("normal! o%s", spec.text))
+  end, opts)
+
+  local indent = type(spec.indent) == "string" and spec.indent or string.rep(" ", spec.indent)
+  table.insert(before, spec.on_line + 1, indent .. spec.text)
+
+  compare_indent(before, after, xfail)
+
+  before, after = M.run_indent_test(file, function()
+    -- move to the line and input the new one
+    vim.cmd(string.format("normal! %dG$", spec.on_line))
+    vim.cmd(string.format(vim.api.nvim_replace_termcodes("normal! a<cr>%s", true, true, true), spec.text))
+  end, opts)
+
+  indent = type(spec.indent) == "string" and spec.indent or string.rep(" ", spec.indent)
+  table.insert(before, spec.on_line + 1, indent .. spec.text)
+
+  compare_indent(before, after, xfail)
+end
+
+local Runner = {}
+Runner.__index = Runner
+
+-- Helper to avoid boilerplate when defining tests
+-- @param it  the "it" function that busted defines globally in spec files
+-- @param base_dir  all other paths will be resolved relative to this directory
+-- @param buf_opts  buffer options passed to set_buf_indent_opts
+function Runner:new(it, base_dir, buf_opts)
+  local runner = {}
+  runner.it = it
+  runner.base_dir = Path:new(base_dir)
+  runner.buf_opts = buf_opts
+  return setmetatable(runner, self)
+end
+
+function Runner:whole_file(dirs, opts)
+  opts = opts or {}
+  local expected_failures = opts.expected_failures or {}
+  expected_failures = vim.tbl_map(function(f)
+    return Path:new(f):make_relative(self.base_dir.filename)
+  end, expected_failures)
+  dirs = type(dirs) == "table" and dirs or { dirs }
+  dirs = vim.tbl_map(function(dir)
+    dir = self.base_dir / Path:new(dir)
+    assert.is.same(1, vim.fn.isdirectory(dir.filename))
+    return dir.filename
+  end, dirs)
+  local files = require("nvim-treesitter.compat").flatten(vim.tbl_map(scan_dir, dirs))
+  for _, file in ipairs(files) do
+    local relpath = Path:new(file):make_relative(self.base_dir.filename)
+    self.it(relpath, function()
+      M.indent_whole_file(file, self.buf_opts, vim.tbl_contains(expected_failures, relpath))
+    end)
+  end
+end
+
+function Runner:new_line(file, spec, title, xfail)
+  title = title and title or tostring(spec.on_line)
+  self.it(string.format("%s[%s]", file, title), function()
+    local path = self.base_dir / file
+    M.indent_new_line(path.filename, spec, self.buf_opts, xfail)
+  end)
+end
+
+M.Runner = Runner
+
+return M
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/cpp/access.cpp b/pack/ant/start/nvim-treesitter/tests/indent/cpp/access.cpp
new file mode 100644
index 0000000..abdb846
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/cpp/access.cpp
@@ -0,0 +1,6 @@
+class Foo {
+public:
+    int x;
+private:
+    int y;
+};
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/cpp/class.cpp b/pack/ant/start/nvim-treesitter/tests/indent/cpp/class.cpp
new file mode 100644
index 0000000..cd83821
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/cpp/class.cpp
@@ -0,0 +1,7 @@
+class Foo {
+    int x;
+    class Bar {
+        int y;
+    };
+    Bar z;
+};
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/cpp/class_newline.cpp b/pack/ant/start/nvim-treesitter/tests/indent/cpp/class_newline.cpp
new file mode 100644
index 0000000..084d302
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/cpp/class_newline.cpp
@@ -0,0 +1,9 @@
+class Foo
+{
+    int x;
+    class Bar
+    {
+        int y;
+    };
+    Bar z;
+};
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/cpp/initializer_list.cpp b/pack/ant/start/nvim-treesitter/tests/indent/cpp/initializer_list.cpp
new file mode 100644
index 0000000..d34ed02
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/cpp/initializer_list.cpp
@@ -0,0 +1,17 @@
+class Foo {
+
+    Foo(int a, int b, int c, int d)
+        : m_a(a)
+        , m_b(b)
+        , m_c(c)
+        , m_d(d) {}
+
+    Foo(int a, int b, int c) :
+        m_a(a),
+        m_b(b),
+        m_c(c)
+    {}
+
+    int m_a, m_b, m_c, m_d;
+};
+
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/cpp/stream.cpp b/pack/ant/start/nvim-treesitter/tests/indent/cpp/stream.cpp
new file mode 100644
index 0000000..a619dfa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/cpp/stream.cpp
@@ -0,0 +1,7 @@
+#include <iostream>
+
+void foo(int x) {
+    std::cout << x
+        << x + 1
+        << x + 2;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/cpp_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/cpp_spec.lua
new file mode 100644
index 0000000..7ac69e2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/cpp_spec.lua
@@ -0,0 +1,51 @@
+local Runner = require("tests.indent.common").Runner
+local XFAIL = require("tests.indent.common").XFAIL
+
+-- will use both c/ and cpp/
+local run = Runner:new(it, "tests/indent", {
+  tabstop = 4,
+  shiftwidth = 4,
+  softtabstop = 0,
+  expandtab = true,
+  filetype = "cpp",
+})
+
+describe("indent C++:", function()
+  describe("whole file:", function()
+    run:whole_file({ "c/", "cpp/" }, {
+      expected_failures = {
+        -- C
+        "c/preproc_func.c",
+        "c/unfinished_comment.c",
+      },
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("cpp/access.cpp", { on_line = 3, text = "protected:", indent = 0 })
+    run:new_line("cpp/class.cpp", { on_line = 2, text = "using T = int;", indent = 4 })
+    run:new_line("cpp/stream.cpp", { on_line = 5, text = "<< x + 3", indent = 8 })
+
+    -- TODO: find a clean way to import these from c_spec.lua
+    run:new_line("c/array.c", { on_line = 2, text = "0,", indent = 4 })
+    run:new_line("c/cond.c", { on_line = 3, text = "x++;", indent = 8 })
+    run:new_line("c/cond.c", { on_line = 6, text = "x++;", indent = 8 })
+    run:new_line("c/cond.c", { on_line = 8, text = "x++;", indent = 8 })
+    run:new_line("c/cond.c", { on_line = 9, text = "x++;", indent = 4 })
+    run:new_line("c/expr.c", { on_line = 10, text = "2 *", indent = 8 })
+    run:new_line("c/func.c", { on_line = 17, text = "int z,", indent = 4 })
+    run:new_line("c/label.c", { on_line = 3, text = "normal:", indent = 0 })
+    run:new_line("c/loop.c", { on_line = 3, text = "x++;", indent = 8 })
+    run:new_line("c/preproc_cond.c", { on_line = 5, text = "x++;", indent = 4 })
+    run:new_line("c/preproc_func.c", { on_line = 3, text = "x++; \\", indent = 8 }, "expected failure", XFAIL)
+    run:new_line("c/string.c", { on_line = 1, text = "brave new \\", indent = 0 })
+    run:new_line("c/string.c", { on_line = 4, text = '"brave new "', indent = 4 })
+    run:new_line("c/struct.c", { on_line = 4, text = "int y;", indent = 8 })
+    run:new_line("c/switch.c", { on_line = 3, text = "x++;", indent = 12 })
+    run:new_line("c/ternary.c", { on_line = 4, text = ": (x == 0) : 0", indent = 8 })
+    -- the line after inserted one will be left with wrong indent but we only care about the inserted one
+    run:new_line("c/no_braces.c", { on_line = 4, text = "x++;", indent = 8 })
+    run:new_line("c/no_braces.c", { on_line = 7, text = "x++;", indent = 8 })
+    run:new_line("c/no_braces.c", { on_line = 10, text = "x++;", indent = 8 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/css/next_rule.css b/pack/ant/start/nvim-treesitter/tests/indent/css/next_rule.css
new file mode 100644
index 0000000..ae18f1b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/css/next_rule.css
@@ -0,0 +1,3 @@
+.testo {
+  color: green;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/css/open_block.css b/pack/ant/start/nvim-treesitter/tests/indent/css/open_block.css
new file mode 100644
index 0000000..cc79c2c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/css/open_block.css
@@ -0,0 +1 @@
+.testo {
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/css_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/css_spec.lua
new file mode 100644
index 0000000..46c7e1a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/css_spec.lua
@@ -0,0 +1,22 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/css", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent CSS:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("open_block.css", { on_line = 1, text = "}", indent = 0 })
+    run:new_line("open_block.css", { on_line = 1, text = "color: green;", indent = 2 })
+    run:new_line("next_rule.css", { on_line = 3, text = ".next {", indent = 0 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/dart/class.dart b/pack/ant/start/nvim-treesitter/tests/indent/dart/class.dart
new file mode 100644
index 0000000..0ad2111
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/dart/class.dart
@@ -0,0 +1,8 @@
+void main() {
+}
+
+class Test {
+  List<String> get progress => [
+        '0',
+      ];
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/dart/class_function_argument.dart b/pack/ant/start/nvim-treesitter/tests/indent/dart/class_function_argument.dart
new file mode 100644
index 0000000..30db12f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/dart/class_function_argument.dart
@@ -0,0 +1,13 @@
+class Something {
+  final int number;
+  final Function(int) write;
+
+  Something(this.number, this.write);
+}
+
+void test() {
+  Something(
+    1,
+    (int number) {
+  );
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/dart/multiple_arguments.dart b/pack/ant/start/nvim-treesitter/tests/indent/dart/multiple_arguments.dart
new file mode 100644
index 0000000..63a4a04
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/dart/multiple_arguments.dart
@@ -0,0 +1,13 @@
+// Example method that causes an issue with indentation on usage
+void someMethod(
+  void onSuccess(),
+  void onError(Exception ex, StackTrace stackTrace),
+) {
+  try {} catch (_, __) {}
+}
+
+void main() {
+  someMethod(() {
+  }, (Exception ex, StackTrace stackTrace) {
+  });
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/dart/switch.dart b/pack/ant/start/nvim-treesitter/tests/indent/dart/switch.dart
new file mode 100644
index 0000000..489c7b2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/dart/switch.dart
@@ -0,0 +1,30 @@
+void test() {
+  switch(a) {
+    case 1:
+  }
+}
+
+void test() {
+  switch(a) {
+    default:
+  }
+}
+
+void test_break_dedent() {
+  switch(x) {
+    case 1:
+      break;
+  }
+  switch(y) {
+    case 2:
+      return;
+  }
+}
+
+
+void test_multi_case() {
+  switch(x) { 
+    case 1:
+    case 2:
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/dart/try.dart b/pack/ant/start/nvim-treesitter/tests/indent/dart/try.dart
new file mode 100644
index 0000000..8b78d7d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/dart/try.dart
@@ -0,0 +1,13 @@
+void test() {
+  try{
+  } catch(e) {
+  }
+}
+
+// Issue #4632
+class Test {
+  void test(){
+    try {
+    }
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/dart_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/dart_spec.lua
new file mode 100644
index 0000000..c1d0187
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/dart_spec.lua
@@ -0,0 +1,46 @@
+local Runner = require("tests.indent.common").Runner
+local XFAIL = require("tests.indent.common").XFAIL
+
+local run = Runner:new(it, "tests/indent/dart", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 2,
+  expandtab = true,
+})
+
+describe("indent Lua:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {
+        "./multiple_arguments.dart",
+        "./class.dart",
+        "./class_function_argument.dart",
+      },
+    })
+  end)
+end)
+
+describe("new line:", function()
+  run:new_line("class.dart", { on_line = 4, text = "int five;", indent = 2 })
+  run:new_line("class.dart", { on_line = 6, text = "'100'", indent = 8 }, "expected failure", XFAIL)
+  run:new_line("class.dart", { on_line = 7, text = "int five = 5", indent = 2 }, "expected failure", XFAIL)
+  run:new_line("try.dart", { on_line = 2, text = "var x;", indent = 4 })
+  for _, content in ipairs { "var x;", "var x" } do
+    run:new_line("try.dart", { on_line = 10, text = content, indent = 6 })
+  end
+  run:new_line("switch.dart", { on_line = 3, text = "x = 1;", indent = 6 })
+  run:new_line("switch.dart", { on_line = 9, text = "x = 1;", indent = 6 })
+  run:new_line("switch.dart", { on_line = 3, text = "case 2:", indent = 4 })
+  run:new_line("switch.dart", { on_line = 16, text = "abc;", indent = 4 })
+  run:new_line("switch.dart", { on_line = 20, text = "abc;", indent = 4 })
+  run:new_line("switch.dart", { on_line = 28, text = "y++;", indent = 6 })
+
+  run:new_line("multiple_arguments.dart", { on_line = 10, text = "var x;", indent = 4 })
+  run:new_line(
+    "multiple_arguments.dart",
+    { on_line = 11, text = "var x;", indent = 4 },
+    "expected failure issue #4637",
+    XFAIL
+  )
+  run:new_line("class_function_argument.dart", { on_line = 11, text = "}", indent = 4 })
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/dot/test.dot b/pack/ant/start/nvim-treesitter/tests/indent/dot/test.dot
new file mode 100644
index 0000000..b3fe35f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/dot/test.dot
@@ -0,0 +1,8 @@
+digraph {
+  node [
+    shape=ellipse,
+  ];
+  subgraph sub {
+    a1 -> a2 -> a3;
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/dot_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/dot_spec.lua
new file mode 100644
index 0000000..ac78f8d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/dot_spec.lua
@@ -0,0 +1,25 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/dot", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent dot:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("test.dot", { on_line = 1, text = "node [", indent = 2 })
+    run:new_line("test.dot", { on_line = 2, text = "shape=ellipse,", indent = 4 })
+    run:new_line("test.dot", { on_line = 4, text = "subgraph sub {", indent = 2 })
+    run:new_line("test.dot", { on_line = 5, text = "a1 -> a2 -> a3;", indent = 4 })
+    run:new_line("test.dot", { on_line = 6, text = "}", indent = 2 })
+    run:new_line("test.dot", { on_line = 7, text = "}", indent = 0 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ecma/array-issue3382.js b/pack/ant/start/nvim-treesitter/tests/indent/ecma/array-issue3382.js
new file mode 100644
index 0000000..3ae39ef
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ecma/array-issue3382.js
@@ -0,0 +1,2 @@
+let a = [
+]
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ecma/binary_expression.js b/pack/ant/start/nvim-treesitter/tests/indent/ecma/binary_expression.js
new file mode 100644
index 0000000..132fee9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ecma/binary_expression.js
@@ -0,0 +1,4 @@
+if_this_is_correct &&
+  run_this_thing()
+    .filter()
+    .map()
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ecma/callback.js b/pack/ant/start/nvim-treesitter/tests/indent/ecma/callback.js
new file mode 100644
index 0000000..a4e1e53
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ecma/callback.js
@@ -0,0 +1,6 @@
+const itemById = Array.from(
+  new Set()
+).reduce((byId, item) => {
+  byId[item.id] = item
+  return result;
+}, {})
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ecma/class.js b/pack/ant/start/nvim-treesitter/tests/indent/ecma/class.js
new file mode 100644
index 0000000..e22cdef
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ecma/class.js
@@ -0,0 +1,20 @@
+class IndentTest {
+  async isEqual(paramOne, paramTwo) {
+    if (paramOne === paramTwo) {
+      return true
+    }
+
+    return false
+  }
+
+  async isNotEqual(
+    paramOne,
+    paramTwo,
+  ) {
+    if (paramOne !== paramTwo) {
+      return true
+    }
+
+    return false
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ecma/func.js b/pack/ant/start/nvim-treesitter/tests/indent/ecma/func.js
new file mode 100644
index 0000000..a615214
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ecma/func.js
@@ -0,0 +1,51 @@
+const arrow_func = (
+  a,
+  b,
+  c
+) => {
+  log(a, b, c)
+}
+
+const arrow_func_without_brace = (a, b, c) =>
+  log(
+    a,
+    b,
+    c
+  )
+
+function func_def(
+  a,
+  b,
+  { c = '' }
+) {
+  log(a, b, c)
+}
+
+func_call(
+  a,
+  (b) => b
+)
+
+chained_func_call()
+  .map()
+  .filter()
+
+func_call(
+  chained_func_call()
+    .map()
+    .filter()
+)
+
+function prepare_list_fetcher(filter) {
+  return Object.assign(
+    async () =>
+      (
+        await http.get('/list', {
+          params: {
+            filter: filter,
+          },
+        })
+      ).data,
+    { key: ['/list', filter] }
+  )
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ecma/if_else.js b/pack/ant/start/nvim-treesitter/tests/indent/ecma/if_else.js
new file mode 100644
index 0000000..990ccd1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ecma/if_else.js
@@ -0,0 +1,19 @@
+if (cond1) {
+  do_1()
+
+  if (cond1a) {
+    do_1a()
+  } else {
+    do_1_fallback()
+  }
+} else if (cond2) {
+  do_2()
+} else {
+  do_fallback()
+}
+
+if (true)
+  console.log('hi')
+console.log('hi')
+
+if (true)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ecma/issue-2515.js b/pack/ant/start/nvim-treesitter/tests/indent/ecma/issue-2515.js
new file mode 100644
index 0000000..a1f1586
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ecma/issue-2515.js
@@ -0,0 +1,16 @@
+function test() {
+  return [
+    {
+      test: "test",
+      test_one: "test",
+    },
+    {
+      test: "test",
+      test_one: "test",
+    },
+    {
+      test: "test",
+      test_one: "test",
+    },
+  ];
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ecma/new-line-after-class.js b/pack/ant/start/nvim-treesitter/tests/indent/ecma/new-line-after-class.js
new file mode 100644
index 0000000..2e2439c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ecma/new-line-after-class.js
@@ -0,0 +1,2 @@
+class A {
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ecma/object.js b/pack/ant/start/nvim-treesitter/tests/indent/ecma/object.js
new file mode 100644
index 0000000..ca09d23
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ecma/object.js
@@ -0,0 +1,5 @@
+const obj = {
+  a: 1,
+  b: "2",
+  ["c"]: `three`
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ecma/switch.js b/pack/ant/start/nvim-treesitter/tests/indent/ecma/switch.js
new file mode 100644
index 0000000..590b7d3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ecma/switch.js
@@ -0,0 +1,8 @@
+switch (variable) {
+  case 'case1':
+    foo();
+    break;
+
+  default:
+    bar();
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ecma/ternary.js b/pack/ant/start/nvim-treesitter/tests/indent/ecma/ternary.js
new file mode 100644
index 0000000..479e411
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ecma/ternary.js
@@ -0,0 +1,6 @@
+const value =
+  condition
+    ? typeof number === 'string'
+      ? Number(number)
+      : number
+    : null;
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ecma/try_catch.js b/pack/ant/start/nvim-treesitter/tests/indent/ecma/try_catch.js
new file mode 100644
index 0000000..b5e9f85
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ecma/try_catch.js
@@ -0,0 +1,8 @@
+try {
+  throw Error()
+} catch (err) {
+  throw error
+} finally {
+  console.log("42")
+}
+
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ecma/variable.js b/pack/ant/start/nvim-treesitter/tests/indent/ecma/variable.js
new file mode 100644
index 0000000..80d34be
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ecma/variable.js
@@ -0,0 +1,6 @@
+let a =
+  if_this_is_right() && then_this()
+
+a = func_call()
+  .map()
+  .filter()
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gdscript/basic_blocks.gd b/pack/ant/start/nvim-treesitter/tests/indent/gdscript/basic_blocks.gd
new file mode 100644
index 0000000..3bc0485
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gdscript/basic_blocks.gd
@@ -0,0 +1,16 @@
+extends Node
+
+func _ready():
+	var x := 2
+	for i in range(x):
+		prints(i)
+
+	while x > 0:
+		print(x)
+
+	if x > 0:
+		print("if test")
+	elif x < 0:
+		print("if test")
+	else:
+		print("if test")
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gdscript_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/gdscript_spec.lua
new file mode 100644
index 0000000..c1770f4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gdscript_spec.lua
@@ -0,0 +1,20 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/gdscript", {
+  tabstop = 4,
+  shiftwidth = 4,
+  softtabstop = 0,
+  expandtab = false,
+})
+
+describe("indent GDScript:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("basic_blocks.gd", { on_line = 1, text = "var member := 0", indent = 0 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gleam/anonymous_function.gleam b/pack/ant/start/nvim-treesitter/tests/indent/gleam/anonymous_function.gleam
new file mode 100644
index 0000000..bcbdc23
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gleam/anonymous_function.gleam
@@ -0,0 +1,7 @@
+fn() {
+  fn() {
+    fn() {
+      True
+    }
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gleam/assert.gleam b/pack/ant/start/nvim-treesitter/tests/indent/gleam/assert.gleam
new file mode 100644
index 0000000..2b21146
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gleam/assert.gleam
@@ -0,0 +1,4 @@
+pub fn main() {
+  assert Ok(i) = 
+    parse_int("123")
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gleam/binary_expression.gleam b/pack/ant/start/nvim-treesitter/tests/indent/gleam/binary_expression.gleam
new file mode 100644
index 0000000..6f59bc4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gleam/binary_expression.gleam
@@ -0,0 +1,4 @@
+pub fn main() {
+  True &&
+    False
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gleam/case.gleam b/pack/ant/start/nvim-treesitter/tests/indent/gleam/case.gleam
new file mode 100644
index 0000000..60238ce
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gleam/case.gleam
@@ -0,0 +1,10 @@
+pub fn main() {
+  case 1 {
+    1 -> "One"
+    2 -> {
+      case 2 {
+        2 -> "Two"
+      }
+    }
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gleam/constant.gleam b/pack/ant/start/nvim-treesitter/tests/indent/gleam/constant.gleam
new file mode 100644
index 0000000..6a38ba6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gleam/constant.gleam
@@ -0,0 +1,2 @@
+pub const foo = 
+  "bar"
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gleam/function.gleam b/pack/ant/start/nvim-treesitter/tests/indent/gleam/function.gleam
new file mode 100644
index 0000000..60c2277
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gleam/function.gleam
@@ -0,0 +1,15 @@
+import gleam/io
+
+pub fn main() {
+  io.println("Hello from main!")
+}
+
+fn hidden() {
+  io.println("Hello from hidden!")
+}
+
+pub external fn inspect(a) -> a = 
+  "Elixir.IO" "inspect"
+
+external fn inspect(a) -> a = 
+  "Elixir.IO" "inspect"
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gleam/import.gleam b/pack/ant/start/nvim-treesitter/tests/indent/gleam/import.gleam
new file mode 100644
index 0000000..c334bf9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gleam/import.gleam
@@ -0,0 +1,4 @@
+import foo.{
+  Bar, 
+  baz,
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gleam/let.gleam b/pack/ant/start/nvim-treesitter/tests/indent/gleam/let.gleam
new file mode 100644
index 0000000..532b3f6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gleam/let.gleam
@@ -0,0 +1,4 @@
+pub fn main() {
+  let string = 
+    "string"
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gleam/list.gleam b/pack/ant/start/nvim-treesitter/tests/indent/gleam/list.gleam
new file mode 100644
index 0000000..d6da4da
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gleam/list.gleam
@@ -0,0 +1,11 @@
+pub fn main() {
+  [
+    a,
+    ..[
+      b,
+      ..[
+        c,
+      ]
+    ]
+  ]
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gleam/pipe.gleam b/pack/ant/start/nvim-treesitter/tests/indent/gleam/pipe.gleam
new file mode 100644
index 0000000..8d38bb9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gleam/pipe.gleam
@@ -0,0 +1,4 @@
+pub fn main() {
+  one()
+  |> two()
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gleam/todo.gleam b/pack/ant/start/nvim-treesitter/tests/indent/gleam/todo.gleam
new file mode 100644
index 0000000..407a85a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gleam/todo.gleam
@@ -0,0 +1,5 @@
+pub fn main() {
+  todo(
+    "Foo"
+  )
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gleam/tuple.gleam b/pack/ant/start/nvim-treesitter/tests/indent/gleam/tuple.gleam
new file mode 100644
index 0000000..d583035
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gleam/tuple.gleam
@@ -0,0 +1,11 @@
+pub fn main() {
+  #(
+    a,
+    #(
+      b,
+      #(
+        c
+      )
+    )
+  )
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gleam/type.gleam b/pack/ant/start/nvim-treesitter/tests/indent/gleam/type.gleam
new file mode 100644
index 0000000..bbe75f6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gleam/type.gleam
@@ -0,0 +1,18 @@
+pub type Cat {
+  Cat(name: String, cuteness: Int)
+}
+
+type User {
+  LoggedIn(name: String)
+  Guest
+}
+
+pub opaque type Counter {
+  Counter(value: Int)
+}
+
+pub type Headers =
+  List(#(String, String))
+
+type Headers =
+  List(#(String, String))
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/gleam_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/gleam_spec.lua
new file mode 100644
index 0000000..8de57fd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/gleam_spec.lua
@@ -0,0 +1,127 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/gleam", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 2,
+  expandtab = true,
+})
+
+describe("indent Gleam:", function()
+  describe("whole file:", function()
+    run:whole_file "."
+  end)
+  describe("new line:", function()
+    run:new_line("type.gleam", { on_line = 1, text = "//", indent = 2 })
+    run:new_line("type.gleam", { on_line = 2, text = "//", indent = 2 })
+    run:new_line("type.gleam", { on_line = 3, text = "//", indent = 0 })
+    run:new_line("type.gleam", { on_line = 4, text = "//", indent = 0 })
+    run:new_line("type.gleam", { on_line = 5, text = "//", indent = 2 })
+    run:new_line("type.gleam", { on_line = 6, text = "//", indent = 2 })
+    run:new_line("type.gleam", { on_line = 7, text = "//", indent = 2 })
+    run:new_line("type.gleam", { on_line = 8, text = "//", indent = 0 })
+    run:new_line("type.gleam", { on_line = 9, text = "//", indent = 0 })
+    run:new_line("type.gleam", { on_line = 10, text = "//", indent = 2 })
+    run:new_line("type.gleam", { on_line = 11, text = "//", indent = 2 })
+    run:new_line("type.gleam", { on_line = 12, text = "//", indent = 0 })
+    run:new_line("type.gleam", { on_line = 13, text = "//", indent = 0 })
+    run:new_line("type.gleam", { on_line = 14, text = "//", indent = 2 })
+    run:new_line("type.gleam", { on_line = 15, text = "//", indent = 0 })
+    run:new_line("type.gleam", { on_line = 16, text = "//", indent = 0 })
+    run:new_line("type.gleam", { on_line = 17, text = "//", indent = 2 })
+    run:new_line("type.gleam", { on_line = 18, text = "//", indent = 0 })
+
+    run:new_line("function.gleam", { on_line = 1, text = "//", indent = 0 })
+    run:new_line("function.gleam", { on_line = 2, text = "//", indent = 0 })
+    run:new_line("function.gleam", { on_line = 3, text = "//", indent = 2 })
+    run:new_line("function.gleam", { on_line = 4, text = "//", indent = 2 })
+    run:new_line("function.gleam", { on_line = 5, text = "//", indent = 0 })
+    run:new_line("function.gleam", { on_line = 6, text = "//", indent = 0 })
+    run:new_line("function.gleam", { on_line = 7, text = "//", indent = 2 })
+    run:new_line("function.gleam", { on_line = 8, text = "//", indent = 2 })
+    run:new_line("function.gleam", { on_line = 9, text = "//", indent = 0 })
+    run:new_line("function.gleam", { on_line = 10, text = "//", indent = 0 })
+    run:new_line("function.gleam", { on_line = 11, text = "//", indent = 2 })
+    run:new_line("function.gleam", { on_line = 12, text = "//", indent = 2 })
+    run:new_line("function.gleam", { on_line = 13, text = "//", indent = 2 })
+    run:new_line("function.gleam", { on_line = 14, text = "//", indent = 2 })
+    run:new_line("function.gleam", { on_line = 15, text = "//", indent = 2 })
+
+    run:new_line("list.gleam", { on_line = 1, text = "//", indent = 2 })
+    run:new_line("list.gleam", { on_line = 2, text = "//", indent = 4 })
+    run:new_line("list.gleam", { on_line = 3, text = "//", indent = 4 })
+    run:new_line("list.gleam", { on_line = 4, text = "//", indent = 6 })
+    run:new_line("list.gleam", { on_line = 5, text = "//", indent = 6 })
+    run:new_line("list.gleam", { on_line = 6, text = "//", indent = 8 })
+    run:new_line("list.gleam", { on_line = 7, text = "//", indent = 8 })
+    run:new_line("list.gleam", { on_line = 8, text = "//", indent = 6 })
+    run:new_line("list.gleam", { on_line = 9, text = "//", indent = 4 })
+    run:new_line("list.gleam", { on_line = 10, text = "//", indent = 2 })
+    run:new_line("list.gleam", { on_line = 11, text = "//", indent = 0 })
+
+    run:new_line("tuple.gleam", { on_line = 1, text = "//", indent = 2 })
+    run:new_line("tuple.gleam", { on_line = 2, text = "//", indent = 4 })
+    run:new_line("tuple.gleam", { on_line = 3, text = "//", indent = 4 })
+    run:new_line("tuple.gleam", { on_line = 4, text = "//", indent = 6 })
+    run:new_line("tuple.gleam", { on_line = 5, text = "//", indent = 6 })
+    run:new_line("tuple.gleam", { on_line = 6, text = "//", indent = 8 })
+    run:new_line("tuple.gleam", { on_line = 7, text = "//", indent = 8 })
+    run:new_line("tuple.gleam", { on_line = 8, text = "//", indent = 6 })
+    run:new_line("tuple.gleam", { on_line = 9, text = "//", indent = 4 })
+    run:new_line("tuple.gleam", { on_line = 10, text = "//", indent = 2 })
+    run:new_line("tuple.gleam", { on_line = 11, text = "//", indent = 0 })
+
+    run:new_line("case.gleam", { on_line = 1, text = "//", indent = 2 })
+    run:new_line("case.gleam", { on_line = 2, text = "//", indent = 4 })
+    run:new_line("case.gleam", { on_line = 3, text = "//", indent = 4 })
+    run:new_line("case.gleam", { on_line = 4, text = "//", indent = 6 })
+    run:new_line("case.gleam", { on_line = 5, text = "//", indent = 8 })
+    run:new_line("case.gleam", { on_line = 6, text = "//", indent = 8 })
+    run:new_line("case.gleam", { on_line = 7, text = "//", indent = 6 })
+    run:new_line("case.gleam", { on_line = 8, text = "//", indent = 4 })
+    run:new_line("case.gleam", { on_line = 9, text = "//", indent = 2 })
+    run:new_line("case.gleam", { on_line = 10, text = "//", indent = 0 })
+
+    run:new_line("let.gleam", { on_line = 1, text = "//", indent = 2 })
+    run:new_line("let.gleam", { on_line = 2, text = "//", indent = 4 })
+    run:new_line("let.gleam", { on_line = 3, text = "//", indent = 4 })
+    run:new_line("let.gleam", { on_line = 4, text = "//", indent = 0 })
+
+    run:new_line("pipe.gleam", { on_line = 1, text = "//", indent = 2 })
+    run:new_line("pipe.gleam", { on_line = 2, text = "//", indent = 2 })
+    run:new_line("pipe.gleam", { on_line = 3, text = "//", indent = 2 })
+    run:new_line("pipe.gleam", { on_line = 4, text = "//", indent = 0 })
+
+    run:new_line("binary_expression.gleam", { on_line = 1, text = "//", indent = 2 })
+    run:new_line("binary_expression.gleam", { on_line = 2, text = "//", indent = 4 })
+    run:new_line("binary_expression.gleam", { on_line = 3, text = "//", indent = 4 })
+    run:new_line("binary_expression.gleam", { on_line = 4, text = "//", indent = 0 })
+
+    run:new_line("import.gleam", { on_line = 1, text = "//", indent = 2 })
+    run:new_line("import.gleam", { on_line = 2, text = "//", indent = 2 })
+    run:new_line("import.gleam", { on_line = 3, text = "//", indent = 2 })
+    run:new_line("import.gleam", { on_line = 4, text = "//", indent = 0 })
+
+    run:new_line("constant.gleam", { on_line = 1, text = "//", indent = 2 })
+    run:new_line("constant.gleam", { on_line = 2, text = "//", indent = 2 })
+
+    run:new_line("assert.gleam", { on_line = 1, text = "//", indent = 2 })
+    run:new_line("assert.gleam", { on_line = 2, text = "//", indent = 4 })
+    run:new_line("assert.gleam", { on_line = 3, text = "//", indent = 2 })
+    run:new_line("assert.gleam", { on_line = 4, text = "//", indent = 0 })
+
+    run:new_line("todo.gleam", { on_line = 1, text = "//", indent = 2 })
+    run:new_line("todo.gleam", { on_line = 2, text = "//", indent = 4 })
+    run:new_line("todo.gleam", { on_line = 3, text = "//", indent = 4 })
+    run:new_line("todo.gleam", { on_line = 4, text = "//", indent = 2 })
+    run:new_line("todo.gleam", { on_line = 5, text = "//", indent = 0 })
+
+    run:new_line("anonymous_function.gleam", { on_line = 1, text = "//", indent = 2 })
+    run:new_line("anonymous_function.gleam", { on_line = 2, text = "//", indent = 4 })
+    run:new_line("anonymous_function.gleam", { on_line = 3, text = "//", indent = 6 })
+    run:new_line("anonymous_function.gleam", { on_line = 4, text = "//", indent = 6 })
+    run:new_line("anonymous_function.gleam", { on_line = 5, text = "//", indent = 4 })
+    run:new_line("anonymous_function.gleam", { on_line = 6, text = "//", indent = 2 })
+    run:new_line("anonymous_function.gleam", { on_line = 7, text = "//", indent = 0 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/go/const_declaration.go b/pack/ant/start/nvim-treesitter/tests/indent/go/const_declaration.go
new file mode 100644
index 0000000..cc3c2e6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/go/const_declaration.go
@@ -0,0 +1,7 @@
+package main
+
+const (
+	ExampleOne = iota
+	ExampleTwo
+	ExampleThree
+)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/go/issue-2369-newline.go b/pack/ant/start/nvim-treesitter/tests/indent/go/issue-2369-newline.go
new file mode 100644
index 0000000..42dd00b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/go/issue-2369-newline.go
@@ -0,0 +1,8 @@
+// https://github.com/nvim-treesitter/nvim-treesitter/issues/2369
+package main
+
+import "fmt"
+
+func new_line() {
+	fmt.Println("Hello, World!")
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/go/issue-2369.go b/pack/ant/start/nvim-treesitter/tests/indent/go/issue-2369.go
new file mode 100644
index 0000000..f512814
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/go/issue-2369.go
@@ -0,0 +1,19 @@
+// https://github.com/nvim-treesitter/nvim-treesitter/issues/2369
+package main
+
+import "fmt"
+
+func goodIndent(param string) {
+	fmt.Println("typing o here works as expected")
+}
+
+func badIndent(
+	param string, // this is the difference
+) {
+	fmt.Println("typing o here triggers bad indent")
+	foo(bar,
+		baz,
+		call,
+		stop,
+		please)
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/go/issue-3288.go b/pack/ant/start/nvim-treesitter/tests/indent/go/issue-3288.go
new file mode 100644
index 0000000..330dd67
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/go/issue-3288.go
@@ -0,0 +1,22 @@
+package main
+
+func correct(word string) {
+	switch word {
+
+	} // <---
+	select {
+
+	} // <---
+}
+
+func test() {
+	cases := []struct {
+		first, second string
+	} {
+		{"Hello", "World"},   
+	}
+
+	for range cases {
+		println("random stuff")
+	}
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/go/multiple-vars.go b/pack/ant/start/nvim-treesitter/tests/indent/go/multiple-vars.go
new file mode 100644
index 0000000..f89a82e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/go/multiple-vars.go
@@ -0,0 +1,19 @@
+package main
+
+var (
+	thing    = 1
+	thingTwo = 2
+) // <-- This paren should be at 0 instead of indented
+
+var (
+	thing    = 1
+	thingTwo = 2
+)
+
+func main() {
+	// It should be
+	var (
+		thing    = 1
+		thingTwo = 2
+	)
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/go/select.go b/pack/ant/start/nvim-treesitter/tests/indent/go/select.go
new file mode 100644
index 0000000..e3610f8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/go/select.go
@@ -0,0 +1,16 @@
+// issue #4248
+package main
+
+import (
+	"context"
+	"fmt"
+)
+
+func test(ch byte) {
+	ctx := context.TODO()
+	select {
+	case <-ctx.Done():
+		fmt.Println("indentation")
+	default:
+	}
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/go/switch.go b/pack/ant/start/nvim-treesitter/tests/indent/go/switch.go
new file mode 100644
index 0000000..9b6e74d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/go/switch.go
@@ -0,0 +1,20 @@
+// issue #2166
+package main
+
+import (
+	"fmt"
+)
+
+func test(ch byte) {
+	fmt.Println("hey!")
+	switch ch {
+	case 'l':
+		return
+	}
+
+	var i interface{}
+	switch i.(type) {
+	case int:
+		return
+	}
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/go_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/go_spec.lua
new file mode 100644
index 0000000..4d604f3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/go_spec.lua
@@ -0,0 +1,24 @@
+local Runner = require("tests.indent.common").Runner
+--local XFAIL = require("tests.indent.common").XFAIL
+
+local run = Runner:new(it, "tests/indent/go", {
+  tabstop = 4,
+  shiftwidth = 4,
+  softtabstop = 4,
+  expandtab = false,
+})
+
+describe("indent Go:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new lines:", function()
+    run:new_line("issue-2369.go", { on_line = 13, text = "// some comment", indent = 1 })
+    run:new_line("issue-2369-newline.go", { on_line = 8, text = "// comment", indent = 0 })
+    run:new_line("const_declaration.go", { on_line = 3, text = "Constant", indent = 1 })
+    run:new_line("const_declaration.go", { on_line = 7, text = "func main() {", indent = 0 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/graphql/issue-1981.graphql b/pack/ant/start/nvim-treesitter/tests/indent/graphql/issue-1981.graphql
new file mode 100644
index 0000000..79aa7f8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/graphql/issue-1981.graphql
@@ -0,0 +1,6 @@
+query Me {
+  me {
+    id
+    fullName
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/graphql_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/graphql_spec.lua
new file mode 100644
index 0000000..9fc9896
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/graphql_spec.lua
@@ -0,0 +1,19 @@
+local Runner = require("tests.indent.common").Runner
+--local XFAIL = require("tests.indent.common").XFAIL
+
+local run = Runner:new(it, "tests/indent/graphql", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent GraphQL:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function() end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/html/issue-3986.html b/pack/ant/start/nvim-treesitter/tests/indent/html/issue-3986.html
new file mode 100644
index 0000000..2e6d9f0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/html/issue-3986.html
@@ -0,0 +1,4 @@
+<div>
+  <div>
+  </div>
+</div>
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/html/script_style.html b/pack/ant/start/nvim-treesitter/tests/indent/html/script_style.html
new file mode 100644
index 0000000..b00f3f4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/html/script_style.html
@@ -0,0 +1,12 @@
+<head>
+  <style>
+  a {
+    stroke-linecap: round;
+  }
+  </style>
+</head>
+<body>
+  <script>
+  const foo = "bar"
+  </script>
+</body>
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/html/self_closing_tag.html b/pack/ant/start/nvim-treesitter/tests/indent/html/self_closing_tag.html
new file mode 100644
index 0000000..79376b8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/html/self_closing_tag.html
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title></title>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link href="css/style.css" rel="stylesheet">
+  </head>
+  <body>
+    <br/>
+    <button 
+      id = "123"
+  </body>
+</html>
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/html/start_tag.html b/pack/ant/start/nvim-treesitter/tests/indent/html/start_tag.html
new file mode 100644
index 0000000..96c83be
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/html/start_tag.html
@@ -0,0 +1,8 @@
+<meta charset="UTF-8">
+
+<html lang="en">
+  <head>
+    <meta 
+      charset="UTF-8"
+  </head>
+</html>
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/html_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/html_spec.lua
new file mode 100644
index 0000000..b946536
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/html_spec.lua
@@ -0,0 +1,28 @@
+local Runner = require("tests.indent.common").Runner
+local runner = Runner:new(it, "tests/indent/html", {
+  tabstop = 2,
+  shiftwidth = 2,
+  expandtab = true,
+})
+
+describe("indent HTML:", function()
+  describe("whole file:", function()
+    runner:whole_file "."
+  end)
+
+  describe("new line:", function()
+    runner:new_line("start_tag.html", { on_line = 1, text = "anything", indent = 0 })
+    runner:new_line("start_tag.html", { on_line = 4, text = "anything", indent = 4 })
+    runner:new_line("start_tag.html", { on_line = 6, text = "charset = utf-8", indent = 6 })
+    runner:new_line("start_tag.html", { on_line = 6, text = ">", indent = 4 })
+    runner:new_line("start_tag.html", { on_line = 6, text = "/>", indent = 4 })
+    runner:new_line("issue-3986.html", { on_line = 3, text = "indent once", indent = 2 })
+    runner:new_line("self_closing_tag.html", { on_line = 10, text = "Something", indent = 4 })
+    runner:new_line("self_closing_tag.html", { on_line = 12, text = "disabled", indent = 6 })
+    runner:new_line("self_closing_tag.html", { on_line = 12, text = "/>", indent = 4 })
+    runner:new_line("script_style.html", { on_line = 5, text = "body", indent = 2 })
+    runner:new_line("script_style.html", { on_line = 6, text = "<div></div>", indent = 2 })
+    runner:new_line("script_style.html", { on_line = 9, text = "const x = 1", indent = 2 })
+    runner:new_line("script_style.html", { on_line = 11, text = "Text", indent = 2 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/java/annotation.java b/pack/ant/start/nvim-treesitter/tests/indent/java/annotation.java
new file mode 100644
index 0000000..bd37d09
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/java/annotation.java
@@ -0,0 +1,3 @@
+abstract public @interface Foo {
+  abstract public String Bar();
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/java/annotation_2.java b/pack/ant/start/nvim-treesitter/tests/indent/java/annotation_2.java
new file mode 100644
index 0000000..aa5f459
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/java/annotation_2.java
@@ -0,0 +1,8 @@
+@ContextConfiguration(
+  classes = {
+    WireMockConfig.class,
+  }
+)
+public class Foo {
+
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/java/class_with_annotation.java b/pack/ant/start/nvim-treesitter/tests/indent/java/class_with_annotation.java
new file mode 100644
index 0000000..19d62f9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/java/class_with_annotation.java
@@ -0,0 +1,3 @@
+@Nothing
+public class Testo {
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/java/constructor_with_arguments_on_multiple_lines.java b/pack/ant/start/nvim-treesitter/tests/indent/java/constructor_with_arguments_on_multiple_lines.java
new file mode 100644
index 0000000..bb97d4c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/java/constructor_with_arguments_on_multiple_lines.java
@@ -0,0 +1,6 @@
+public class Testo {
+  public Testo(
+    String a
+  ) {
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/java/enum.java b/pack/ant/start/nvim-treesitter/tests/indent/java/enum.java
new file mode 100644
index 0000000..1d2f5b2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/java/enum.java
@@ -0,0 +1,4 @@
+public enum Foo {
+  THING_A,
+  THING_C;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/java/enum_with_annotation.java b/pack/ant/start/nvim-treesitter/tests/indent/java/enum_with_annotation.java
new file mode 100644
index 0000000..52edd76
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/java/enum_with_annotation.java
@@ -0,0 +1,3 @@
+@Nothing
+public enum Testo {
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/java/interface.java b/pack/ant/start/nvim-treesitter/tests/indent/java/interface.java
new file mode 100644
index 0000000..b8fde7b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/java/interface.java
@@ -0,0 +1,2 @@
+public interface Foo {
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/java/issue_2571.java b/pack/ant/start/nvim-treesitter/tests/indent/java/issue_2571.java
new file mode 100644
index 0000000..b165d23
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/java/issue_2571.java
@@ -0,0 +1,6 @@
+// https://github.com/nvim-treesitter/nvim-treesitter/issues/2571
+class Testo {
+  void foo() {
+    System.out.println("foo");
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/java/issue_2583.java b/pack/ant/start/nvim-treesitter/tests/indent/java/issue_2583.java
new file mode 100644
index 0000000..5d8feed
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/java/issue_2583.java
@@ -0,0 +1,6 @@
+// https://github.com/nvim-treesitter/nvim-treesitter/issues/2583
+public class Testo {
+  void foo() {
+    new StringBuilder().append("a",
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/java/javadoc.java b/pack/ant/start/nvim-treesitter/tests/indent/java/javadoc.java
new file mode 100644
index 0000000..3da0ba4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/java/javadoc.java
@@ -0,0 +1,5 @@
+public class Foo {
+  /**
+   */
+  void foo() {}
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/java/method.java b/pack/ant/start/nvim-treesitter/tests/indent/java/method.java
new file mode 100644
index 0000000..ecf62bd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/java/method.java
@@ -0,0 +1,2 @@
+public class Method {
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/java/method_chaining.java b/pack/ant/start/nvim-treesitter/tests/indent/java/method_chaining.java
new file mode 100644
index 0000000..3245f46
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/java/method_chaining.java
@@ -0,0 +1,6 @@
+public class Foo {
+  void foo() {
+    new StringBuilder()
+      .append("a")
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/java/method_with_arguments_on_multiple_lines.java b/pack/ant/start/nvim-treesitter/tests/indent/java/method_with_arguments_on_multiple_lines.java
new file mode 100644
index 0000000..7eb7db1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/java/method_with_arguments_on_multiple_lines.java
@@ -0,0 +1,6 @@
+public class Testo {
+  void hello(
+    String a
+  ) {
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/java_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/java_spec.lua
new file mode 100644
index 0000000..1d10046
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/java_spec.lua
@@ -0,0 +1,39 @@
+local Runner = require("tests.indent.common").Runner
+local XFAIL = require("tests.indent.common").XFAIL
+
+local run = Runner:new(it, "tests/indent/java", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent Java:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("method.java", { on_line = 1, text = "void foo() {}", indent = 2 })
+    run:new_line("issue_2571.java", { on_line = 5, text = "void bar() {}", indent = 2 })
+    run:new_line("enum.java", { on_line = 2, text = "THING_B,", indent = 2 })
+    run:new_line("class_with_annotation.java", { on_line = 2, text = "void foo() {}", indent = 2 })
+    run:new_line("enum_with_annotation.java", { on_line = 2, text = "THING;", indent = 2 })
+    run:new_line("interface.java", { on_line = 1, text = "void foo();", indent = 2 })
+    run:new_line("javadoc.java", { on_line = 2, text = "* Sample javadoc line", indent = 3 })
+    run:new_line(
+      "issue_2583.java",
+      { on_line = 3, text = "int x = 1;", indent = 4 },
+      "fails because tree is in a broken state",
+      XFAIL
+    )
+    run:new_line("issue_2583.java", { on_line = 4, text = "int x = 1;", indent = 4 })
+    run:new_line("method_chaining.java", { on_line = 4, text = '.append("b");', indent = 6 })
+    run:new_line("constructor_with_arguments_on_multiple_lines.java", { on_line = 4, text = "}", indent = 2 })
+    run:new_line("method_with_arguments_on_multiple_lines.java", { on_line = 4, text = "}", indent = 2 })
+    run:new_line("annotation.java", { on_line = 1, text = "abstract public Foo(){}", indent = 2 })
+    run:new_line("annotation_2.java", { on_line = 2, text = "Bar.class", indent = 4 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/javascript_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/javascript_spec.lua
new file mode 100644
index 0000000..5659b22
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/javascript_spec.lua
@@ -0,0 +1,125 @@
+local Runner = require("tests.indent.common").Runner
+-- local XFAIL = require("tests.indent.common").XFAIL
+
+local run = Runner:new(it, "tests/indent", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 0,
+  expandtab = true,
+  filetype = "javascript",
+})
+
+describe("indent JavaScript:", function()
+  describe("whole file:", function()
+    run:whole_file({ "ecma/" }, {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    for _, info in ipairs {
+      { 1, 2 },
+      { 2, 4 },
+      { 3, 4 },
+    } do
+      run:new_line("ecma/binary_expression.js", { on_line = info[1], text = "//", indent = info[2] }, info[3], info[4])
+    end
+
+    run:new_line("ecma/new-line-after-class.js", { on_line = 2, text = "", indent = 0 })
+
+    for _, info in ipairs {
+      { 4, 2 },
+      { 6, 0 },
+    } do
+      run:new_line("ecma/callback.js", { on_line = info[1], text = "//", indent = info[2] }, info[3], info[4])
+    end
+
+    for _, info in ipairs {
+      { 1, 2 },
+      { 2, 4 },
+      { 3, 6 },
+      { 5, 4 },
+      { 8, 2 },
+      { 11, 4 },
+      { 13, 4 },
+    } do
+      run:new_line("ecma/class.js", { on_line = info[1], text = "//", indent = info[2] }, info[3], info[4])
+    end
+
+    for _, info in ipairs {
+      { 2, 2 },
+      { 5, 2 },
+      { 7, 0 },
+      { 12, 4 },
+      { 18, 2 },
+      { 19, 2 },
+      { 20, 2 },
+      { 25, 2 },
+      { 42, 8 },
+      { 43, 10 },
+      { 44, 12 },
+      { 48, 4 },
+      { 49, 4 },
+      { 50, 2 },
+    } do
+      run:new_line("ecma/func.js", { on_line = info[1], text = "//", indent = info[2] }, info[3], info[4])
+    end
+
+    for _, info in ipairs {
+      { 1, 2 },
+      { 2, 2 },
+      { 3, 2 },
+      { 5, 4 },
+      { 6, 4 },
+      { 8, 2 },
+      { 9, 2 },
+      { 12, 2 },
+      { 13, 0 },
+      { 16, 0 },
+      { 19, 2 },
+    } do
+      run:new_line("ecma/if_else.js", { on_line = info[1], text = "hello()", indent = info[2] }, info[3], info[4])
+    end
+
+    for _, info in ipairs {
+      { 2, 2 },
+      { 5, 0 },
+    } do
+      run:new_line("ecma/object.js", { on_line = info[1], text = "//", indent = info[2] }, info[3], info[4])
+    end
+
+    for _, info in ipairs {
+      { 3, 6 },
+      { 4, 6 },
+    } do
+      run:new_line("ecma/ternary.js", { on_line = info[1], text = "//", indent = info[2] }, info[3], info[4])
+    end
+
+    for _, info in ipairs {
+      { 1, 2 },
+      { 2, 2 },
+      { 3, 2 },
+      { 4, 2 },
+      { 5, 2 },
+      { 6, 2 },
+      { 7, 0 },
+    } do
+      run:new_line("ecma/try_catch.js", { on_line = info[1], text = "hello()", indent = info[2] }, info[3], info[4])
+    end
+
+    for _, info in ipairs {
+      { 1, 2 },
+      { 2, 0 },
+    } do
+      run:new_line("ecma/variable.js", { on_line = info[1], text = "hello()", indent = info[2] }, info[3], info[4])
+    end
+
+    for _, line in ipairs { 2, 6 } do
+      run:new_line("ecma/issue-2515.js", { on_line = line, text = "{}", indent = 4 })
+    end
+
+    for _, info in ipairs { { line = 2, indent = 0 } } do
+      run:new_line("ecma/array-issue3382.js", { on_line = info.line, text = "foo();", indent = info.indent })
+    end
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/jsx/element_attributes.jsx b/pack/ant/start/nvim-treesitter/tests/indent/jsx/element_attributes.jsx
new file mode 100644
index 0000000..45aeeac
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/jsx/element_attributes.jsx
@@ -0,0 +1,18 @@
+export default function Home() {
+  return (
+    <>
+      <Button
+        style={{ 
+          color: 'blue', 
+        }}
+        disabled
+      >
+      </Button>
+      <Button
+        style={{
+          color: 'blue',
+        }}
+      />
+    </>
+  )
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/jsx/issue-3986.jsx b/pack/ant/start/nvim-treesitter/tests/indent/jsx/issue-3986.jsx
new file mode 100644
index 0000000..8306e39
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/jsx/issue-3986.jsx
@@ -0,0 +1,10 @@
+export default function Home() {
+  return (
+    <>
+      <div>
+        <p>This is a test</p>
+      </div>
+      <Button/>
+    </>
+  )
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/jsx/jsx_expression.jsx b/pack/ant/start/nvim-treesitter/tests/indent/jsx/jsx_expression.jsx
new file mode 100644
index 0000000..a45896c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/jsx/jsx_expression.jsx
@@ -0,0 +1,16 @@
+export default function Home() {
+  return (
+    <>
+      <Button
+        style={
+        }
+      >
+      </Button>
+      <Button
+        style={{
+          color: 'blue',
+        }}
+      />
+    </>
+  )
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/jsx_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/jsx_spec.lua
new file mode 100644
index 0000000..e75b21f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/jsx_spec.lua
@@ -0,0 +1,43 @@
+local Runner = require("tests.indent.common").Runner
+local runner = Runner:new(it, "tests/indent/jsx", {
+  tabstop = 2,
+  shiftwidth = 2,
+  expandtab = true,
+  filetype = "jsx",
+})
+
+describe("indent JSX Elements:", function()
+  describe("whole file:", function()
+    runner:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    for _, info in ipairs {
+      { 5, 8 },
+      { 6, 6 },
+      { 7, 6 },
+      { 8, 4 },
+      { 9, 2 },
+    } do
+      runner:new_line("issue-3986.jsx", { on_line = info[1], text = "text", indent = info[2] })
+    end
+    for _, info in ipairs {
+      { 4, 8 },
+      { 6, 10 },
+      { 9, 8 },
+      { 11, 8 },
+    } do
+      runner:new_line("element_attributes.jsx", { on_line = info[1], text = "disabled", indent = info[2] })
+    end
+
+    for _, info in ipairs {
+      { 5, 10 },
+      { 7, 8 },
+      { 11, 10 },
+    } do
+      runner:new_line("jsx_expression.jsx", { on_line = info[1], text = "{disabled}", indent = info[2] })
+    end
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/julia/argument_list.jl b/pack/ant/start/nvim-treesitter/tests/indent/julia/argument_list.jl
new file mode 100644
index 0000000..747a36e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/julia/argument_list.jl
@@ -0,0 +1,13 @@
+function test(a::Number,
+              b::Float64,
+              c::Union{Float64, Integer},
+              d::Bool)
+end
+
+function test(
+    a::Number,
+    b::Float64,
+    c::Union{Float64, Integer},
+    d::Bool
+)
+end
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/julia/assignment.jl b/pack/ant/start/nvim-treesitter/tests/indent/julia/assignment.jl
new file mode 100644
index 0000000..39b8e4e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/julia/assignment.jl
@@ -0,0 +1,21 @@
+my_variable =
+    1 + 2 - 3 *
+    4 / 5 %
+    6 + (
+        1 + 2 +
+        3
+    ) +
+    7 + 8 +
+    9
+
+function test()
+    my_variable =
+        1 + 2 - 3 *
+        4 / 5 %
+        6 + (
+            1 + 2 +
+            3
+        ) +
+        7 + 8 +
+        9
+end
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/julia/curly_expression.jl b/pack/ant/start/nvim-treesitter/tests/indent/julia/curly_expression.jl
new file mode 100644
index 0000000..de22067
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/julia/curly_expression.jl
@@ -0,0 +1,15 @@
+function test(a::Union{Number,
+                       String,
+                       Nothing},
+              b::Number)
+end
+
+function test(
+    a::Union{
+        Number,
+        String,
+        Nothing
+    },
+    b::Number
+)
+end
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/julia/parameter_list.jl b/pack/ant/start/nvim-treesitter/tests/indent/julia/parameter_list.jl
new file mode 100644
index 0000000..fc9e6d2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/julia/parameter_list.jl
@@ -0,0 +1,15 @@
+function test(a, b, c, d, e)
+    vcat(a,
+         b,
+         c,
+         d,
+         e)
+
+    vcat(
+        a,
+        b,
+        c,
+        d,
+        e
+    )
+end
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/julia_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/julia_spec.lua
new file mode 100644
index 0000000..5386853
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/julia_spec.lua
@@ -0,0 +1,17 @@
+local Runner = require("tests.indent.common").Runner
+-- local XFAIL = require("tests.indent.common").XFAIL
+
+local run = Runner:new(it, "tests/indent/julia", {
+  tabstop = 4,
+  shiftwidth = 4,
+  softtabstop = 4,
+  expandtab = true,
+})
+
+describe("indent Julia:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/lua/comment.lua b/pack/ant/start/nvim-treesitter/tests/indent/lua/comment.lua
new file mode 100644
index 0000000..9f3624e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/lua/comment.lua
@@ -0,0 +1,7 @@
+-- some
+-- comment
+
+--[[
+  another
+  comment
+--]]
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/lua/cond.lua b/pack/ant/start/nvim-treesitter/tests/indent/lua/cond.lua
new file mode 100644
index 0000000..9d0266a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/lua/cond.lua
@@ -0,0 +1,14 @@
+local x = 10
+
+if x > 3 then
+  x = 3
+elseif x < 3 then
+  x = -3
+else
+  if x > 0 then
+    x = 1
+  end
+  x = 0
+end
+
+if x > 2 then
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/lua/func.lua b/pack/ant/start/nvim-treesitter/tests/indent/lua/func.lua
new file mode 100644
index 0000000..e2c3c03
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/lua/func.lua
@@ -0,0 +1,11 @@
+function foo(x)
+  local bar = function(a, b, c)
+    return a + b + c
+  end
+  return bar(
+    x,
+    1,
+    2)
+end
+
+function hi()
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/lua/loop.lua b/pack/ant/start/nvim-treesitter/tests/indent/lua/loop.lua
new file mode 100644
index 0000000..7f5402d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/lua/loop.lua
@@ -0,0 +1,14 @@
+local x = 1
+
+while x < 10 do
+  x = x + 1
+  break
+end
+
+for i = 1,3 do
+  x = x + i
+end
+
+repeat
+  x = x + 1
+until x > 100
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/lua/method_index_expr.lua b/pack/ant/start/nvim-treesitter/tests/indent/lua/method_index_expr.lua
new file mode 100644
index 0000000..3f0ad1f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/lua/method_index_expr.lua
@@ -0,0 +1,3 @@
+Node.new()
+  :call()
+  :build()
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/lua/nested-table.lua b/pack/ant/start/nvim-treesitter/tests/indent/lua/nested-table.lua
new file mode 100644
index 0000000..cf507d1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/lua/nested-table.lua
@@ -0,0 +1,7 @@
+local a = {
+  {
+    {
+      1
+    },
+  },
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/lua/no-indent-after-paren-pairs.lua b/pack/ant/start/nvim-treesitter/tests/indent/lua/no-indent-after-paren-pairs.lua
new file mode 100644
index 0000000..2243b40
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/lua/no-indent-after-paren-pairs.lua
@@ -0,0 +1,6 @@
+-- Issue #2476
+require("treesitter").setup(
+)
+
+local table = {
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/lua/string.lua b/pack/ant/start/nvim-treesitter/tests/indent/lua/string.lua
new file mode 100644
index 0000000..f44fc72
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/lua/string.lua
@@ -0,0 +1,9 @@
+local s = [[
+a
+  multiline
+    string
+]]
+
+print [[
+test
+]]
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/lua/table.lua b/pack/ant/start/nvim-treesitter/tests/indent/lua/table.lua
new file mode 100644
index 0000000..d53504b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/lua/table.lua
@@ -0,0 +1,10 @@
+local a = {
+  x = 1,
+  y = 2,
+  z = {
+    1, 2, 3,
+  },
+  ['hello world'] = {
+    1, 2, 3
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/lua_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/lua_spec.lua
new file mode 100644
index 0000000..6d99a0f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/lua_spec.lua
@@ -0,0 +1,49 @@
+local Runner = require("tests.indent.common").Runner
+--local XFAIL = require("tests.indent.common").XFAIL
+
+local run = Runner:new(it, "tests/indent/lua", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent Lua:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("comment.lua", { on_line = 1, text = "line", indent = "-- " })
+    run:new_line("comment.lua", { on_line = 5, text = "multiline", indent = "  " })
+    run:new_line("func.lua", { on_line = 1, text = "x = x + 1", indent = 2 })
+    run:new_line("func.lua", { on_line = 2, text = "y = y + 1", indent = 4 })
+    run:new_line("func.lua", { on_line = 4, text = "y = y + 1", indent = 2 })
+    run:new_line("func.lua", { on_line = 5, text = "3,", indent = 4 })
+    run:new_line("func.lua", { on_line = 9, text = "x = x + 1", indent = 0 })
+    run:new_line("func.lua", { on_line = 11, text = "x = x + 1", indent = 2 })
+    run:new_line("string.lua", { on_line = 1, text = "x", indent = 0 })
+    run:new_line("string.lua", { on_line = 2, text = "x", indent = 0 })
+    run:new_line("string.lua", { on_line = 3, text = "x", indent = 2 })
+    run:new_line("string.lua", { on_line = 4, text = "x", indent = 4 })
+    run:new_line("string.lua", { on_line = 9, text = "x", indent = 0 })
+    run:new_line("table.lua", { on_line = 1, text = "b = 0,", indent = 2 })
+    run:new_line("table.lua", { on_line = 5, text = "4,", indent = 4 })
+    run:new_line("table.lua", { on_line = 7, text = "4,", indent = 4 })
+    run:new_line("loop.lua", { on_line = 4, text = "x = x + 1", indent = 2 })
+    run:new_line("cond.lua", { on_line = 5, text = "x = x + 1", indent = 2 })
+    run:new_line("cond.lua", { on_line = 7, text = "x = x + 1", indent = 2 })
+    run:new_line("cond.lua", { on_line = 8, text = "x = x + 1", indent = 4 })
+    run:new_line("cond.lua", { on_line = 10, text = "x = x + 1", indent = 2 })
+    run:new_line("cond.lua", { on_line = 12, text = "x = x + 1", indent = 0 })
+    run:new_line("cond.lua", { on_line = 14, text = "x = x + 1", indent = 2 })
+    run:new_line("cond.lua", { on_line = 14, text = "end", indent = 0 })
+    run:new_line("no-indent-after-paren-pairs.lua", { on_line = 3, text = "x = x + 1", indent = 0 })
+    run:new_line("no-indent-after-paren-pairs.lua", { on_line = 6, text = "x = x + 1", indent = 0 })
+    run:new_line("nested-table.lua", { on_line = 5, text = "{}", indent = 4 })
+    run:new_line("method_index_expr.lua", { on_line = 1, text = ":test()", indent = 2 })
+    run:new_line("method_index_expr.lua", { on_line = 3, text = "local a = 1", indent = 0 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/meson/cond.meson b/pack/ant/start/nvim-treesitter/tests/indent/meson/cond.meson
new file mode 100644
index 0000000..a4b0b71
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/meson/cond.meson
@@ -0,0 +1,16 @@
+# vim: ft=meson
+
+if a == b
+endif
+
+if a == b
+  foo()
+endif
+
+if a == b
+  foo()
+elif a != b
+  foo()
+else
+  foo()
+endif
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/meson/dict.meson b/pack/ant/start/nvim-treesitter/tests/indent/meson/dict.meson
new file mode 100644
index 0000000..d48689f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/meson/dict.meson
@@ -0,0 +1,15 @@
+# vim: ft=meson
+
+foo = {
+  'a': 1,
+  'b': 2,
+}
+
+bar = {
+  'a': 1,
+  'b': 2}
+
+baz = {'a': 1,
+  'b': 2
+}
+
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/meson/func.meson b/pack/ant/start/nvim-treesitter/tests/indent/meson/func.meson
new file mode 100644
index 0000000..3e83e0f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/meson/func.meson
@@ -0,0 +1,13 @@
+# vim: ft=meson
+
+executable('progname',
+)
+
+executable('progname',
+  sources: 'prog.c',
+  c_args: '-DFOO=1'
+)
+
+executable('progname',
+  sources: 'prog.c',
+  c_args: '-DFOO=1')
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/meson/list.meson b/pack/ant/start/nvim-treesitter/tests/indent/meson/list.meson
new file mode 100644
index 0000000..0dd17d2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/meson/list.meson
@@ -0,0 +1,14 @@
+# vim: ft=meson
+
+foo = [
+  'a',
+  'b',
+]
+
+bar = [
+  'a',
+  'b']
+
+baz = ['a',
+  'b'
+]
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/meson/loop.meson b/pack/ant/start/nvim-treesitter/tests/indent/meson/loop.meson
new file mode 100644
index 0000000..ae9c4b7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/meson/loop.meson
@@ -0,0 +1,8 @@
+# vim: ft=meson
+
+foreach elem : list
+endforeach
+
+foreach elem : list
+  foo()
+endforeach
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/meson/meson.build b/pack/ant/start/nvim-treesitter/tests/indent/meson/meson.build
new file mode 100644
index 0000000..b7e6e05
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/meson/meson.build
@@ -0,0 +1,34 @@
+project('simple', 'c')
+
+src = [
+  'source1.c',
+  'source2.c',
+]
+
+if 1 == 2
+  if meson.is_cross_build()
+    src += [
+      'src1.c',
+      'src2.c']
+  endif
+endif
+
+inc = include_directories([
+  'dir1/',
+])
+
+
+dep = declare_dependency(
+  sources : src,
+  include_directories : inc,
+)
+
+executable('myexe', src,
+  include_directories : [
+    'd1',
+    [
+      'd2',
+      'd3',
+    ]
+  ],
+  dependencies: dep)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/meson/method.meson b/pack/ant/start/nvim-treesitter/tests/indent/meson/method.meson
new file mode 100644
index 0000000..8c17be8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/meson/method.meson
@@ -0,0 +1,8 @@
+# vim: ft=meson
+
+myobj
+  .do_something('now')
+
+myobj.do_something('now')
+  .do_something('now')
+  .do_something('now')
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/meson/ternary.meson b/pack/ant/start/nvim-treesitter/tests/indent/meson/ternary.meson
new file mode 100644
index 0000000..d3dec04
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/meson/ternary.meson
@@ -0,0 +1,11 @@
+# vim: ft=meson
+
+x = cond ?
+  iftrue :
+  iffalse
+
+x = cond
+  ? iftrue
+  : iffalse
+
+x = cond ?
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/meson_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/meson_spec.lua
new file mode 100644
index 0000000..bc2372e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/meson_spec.lua
@@ -0,0 +1,28 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/meson", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent Meson:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("cond.meson", { on_line = 3, text = "foo()", indent = 2 })
+    run:new_line("cond.meson", { on_line = 6, text = "foo()", indent = 2 })
+    run:new_line("cond.meson", { on_line = 7, text = "foo()", indent = 2 })
+    run:new_line("cond.meson", { on_line = 12, text = "foo()", indent = 2 })
+    run:new_line("cond.meson", { on_line = 14, text = "foo()", indent = 2 })
+    run:new_line("dict.meson", { on_line = 13, text = ",'x':1,", indent = 2 })
+    run:new_line("loop.meson", { on_line = 3, text = "foo()", indent = 2 })
+    run:new_line("loop.meson", { on_line = 7, text = "foo()", indent = 2 })
+    run:new_line("ternary.meson", { on_line = 11, text = "x : y", indent = 2 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/nickel/indent-newline.ncl b/pack/ant/start/nvim-treesitter/tests/indent/nickel/indent-newline.ncl
new file mode 100644
index 0000000..f6a8b61
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/nickel/indent-newline.ncl
@@ -0,0 +1,14 @@
+{
+  key1 = 1,
+  key2 = [
+    2
+  ],
+  key3 = {
+    key4 = 4
+  }
+}
+
+# no indent after this line
+{
+  another = 1
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/nickel_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/nickel_spec.lua
new file mode 100644
index 0000000..d178dab
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/nickel_spec.lua
@@ -0,0 +1,25 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/nickel", {
+  shiftwidth = 2,
+  expandtab = true,
+})
+
+describe("indent Nickel:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("indent-newline.ncl", { on_line = 1, text = "stmt", indent = 2 })
+    run:new_line("indent-newline.ncl", { on_line = 2, text = "stmt", indent = 2 })
+    run:new_line("indent-newline.ncl", { on_line = 3, text = "stmt", indent = 4 })
+    run:new_line("indent-newline.ncl", { on_line = 4, text = "]", indent = 2 })
+    run:new_line("indent-newline.ncl", { on_line = 5, text = "stmt", indent = 2 })
+    run:new_line("indent-newline.ncl", { on_line = 6, text = "stmt", indent = 4 })
+    run:new_line("indent-newline.ncl", { on_line = 7, text = "}", indent = 2 })
+    run:new_line("indent-newline.ncl", { on_line = 11, text = "stmt", indent = 0 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/nix/conds.nix b/pack/ant/start/nvim-treesitter/tests/indent/nix/conds.nix
new file mode 100644
index 0000000..4307fc8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/nix/conds.nix
@@ -0,0 +1,134 @@
+{ lib }:
+with lib.lists;
+with lib.types;
+with lib.attrsets;
+with lib.strings; {
+  doubleFromSystem = { cpu, kernel, abi, ... }:
+    if abi == abis.cygnus then
+      "${cpu.name}-cygwin"
+    else if kernel.families ? darwin then
+      "${cpu.name}-darwin"
+    else
+      "${cpu.name}-${kernelName kernel}";
+
+  tripleFromSystem = { cpu, vendor, kernel, abi, ... }@sys:
+    assert isSystem sys;
+    let
+      optExecFormat = lib.optionalString (kernel.name == "netbsd"
+        && gnuNetBSDDefaultExecFormat cpu != kernel.execFormat)
+        kernel.execFormat.name;
+      optAbi = lib.optionalString (abi != abis.unknown) "-${abi.name}";
+    in "${cpu.name}-${vendor.name}-${
+      kernelName kernel
+    }${optExecFormat}${optAbi}";
+
+  mkSystemFromSkeleton = { cpu,
+    # Optional, but fallback too complex for here.
+    # Inferred below instead.
+    vendor ? assert false; null, kernel,
+    # Also inferred below
+    abi ? assert false; null, }@args:
+    let
+      getCpu = name: cpuTypes.${name} or (throw "Unknown CPU type: ${name}");
+      getVendor = name: vendors.${name} or (throw "Unknown vendor: ${name}");
+      getKernel = name: kernels.${name} or (throw "Unknown kernel: ${name}");
+      getAbi = name: abis.${name} or (throw "Unknown ABI: ${name}");
+
+      parsed = {
+        cpu = getCpu args.cpu;
+        vendor = if args ? vendor then
+          getVendor args.vendor
+        else if isDarwin parsed then
+          vendors.apple
+        else if isWindows parsed then
+          vendors.pc
+        else
+          vendors.unknown;
+        kernel = if hasPrefix "darwin" args.kernel then
+          getKernel "darwin"
+        else if hasPrefix "netbsd" args.kernel then
+          getKernel "netbsd"
+        else
+          getKernel args.kernel;
+        abi = if args ? abi then
+          getAbi args.abi
+        else if isLinux parsed || isWindows parsed then
+          if isAarch32 parsed then
+            if lib.versionAtLeast (parsed.cpu.version or "0") "6" then
+              abis.gnueabihf
+            else
+              abis.gnueabi
+          else if isPower64 parsed && isBigEndian parsed then
+            abis.gnuabielfv2
+          else
+            abis.gnu
+        else
+          abis.unknown;
+      };
+    in mkSystem parsed;
+
+  mkSkeletonFromList = l:
+    {
+      "1" = if elemAt l 0 == "avr" then {
+        cpu = elemAt l 0;
+        kernel = "none";
+        abi = "unknown";
+      } else
+        throw "Target specification with 1 components is ambiguous";
+      "2" = # We only do 2-part hacks for things Nix already supports
+        if elemAt l 1 == "cygwin" then {
+          cpu = elemAt l 0;
+          kernel = "windows";
+          abi = "cygnus";
+        } else if elemAt l 1 == "windows" then {
+          cpu = elemAt l 0;
+          kernel = "windows";
+          abi = "msvc";
+        } else if (elemAt l 1) == "elf" then {
+          cpu = elemAt l 0;
+          vendor = "unknown";
+          kernel = "none";
+          abi = elemAt l 1;
+        } else {
+          cpu = elemAt l 0;
+          kernel = elemAt l 1;
+        };
+      "3" =
+        # cpu-kernel-environment
+        if elemAt l 1 == "linux"
+        || elem (elemAt l 2) [ "eabi" "eabihf" "elf" "gnu" ] then {
+          cpu = elemAt l 0;
+          kernel = elemAt l 1;
+          abi = elemAt l 2;
+          vendor = "unknown";
+        } else if elemAt l 1 == "apple"
+        || elem (elemAt l 2) [ "wasi" "redox" "mmixware" "ghcjs" "mingw32" ]
+        || hasPrefix "freebsd" (elemAt l 2) || hasPrefix "netbsd" (elemAt l 2)
+        || hasPrefix "genode" (elemAt l 2) then {
+          cpu = elemAt l 0;
+          vendor = elemAt l 1;
+          kernel = if elemAt l 2 == "mingw32" then
+            "windows" # autotools breaks on -gnu for window
+          else
+            elemAt l 2;
+        } else
+          throw "Target specification with 3 components is ambiguous";
+      "4" = {
+        cpu = elemAt l 0;
+        vendor = elemAt l 1;
+        kernel = elemAt l 2;
+        abi = elemAt l 3;
+      };
+    }.${toString (length l)} or (throw
+      "system string has invalid number of hyphen-separated components");
+
+  # GNU build systems assume that older NetBSD architectures are using a.out.
+  gnuNetBSDDefaultExecFormat = cpu:
+    if (cpu.family == "arm" && cpu.bits == 32)
+    || (cpu.family == "sparc" && cpu.bits == 32)
+    || (cpu.family == "m68k" && cpu.bits == 32)
+    || (cpu.family == "x86" && cpu.bits == 32) then
+      execFormats.aout
+    else
+      execFormats.elf;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/nix/general.nix b/pack/ant/start/nvim-treesitter/tests/indent/nix/general.nix
new file mode 100644
index 0000000..f79214b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/nix/general.nix
@@ -0,0 +1,130 @@
+{ lib }:
+with lib.lists;
+with lib.types;
+with lib.attrsets;
+with lib.strings;
+with (import ./inspect.nix { inherit lib; }).predicates;
+
+let
+  inherit (lib.options) mergeOneOption;
+
+  setTypes = type:
+    mapAttrs (name: value:
+      assert type.check value;
+      setType type.name ({ inherit name; } // value));
+
+in rec {
+
+  ################################################################################
+
+  types.openSignificantByte = mkOptionType {
+    name = "significant-byte";
+    description = "Endianness";
+    merge = mergeOneOption;
+  };
+
+  types.significantByte = enum (attrValues significantBytes);
+
+  significantBytes = setTypes types.openSignificantByte {
+    bigEndian = { };
+    littleEndian = { };
+  };
+
+  ################################################################################
+
+  # Reasonable power of 2
+  types.bitWidth = enum [ 8 16 32 64 128 ];
+
+  ################################################################################
+
+  types.openCpuType = mkOptionType {
+    name = "cpu-type";
+    description = "instruction set architecture name and information";
+    merge = mergeOneOption;
+    check = x:
+      types.bitWidth.check x.bits && (if 8 < x.bits then
+        types.significantByte.check x.significantByte
+      else
+        !(x ? significantByte));
+  };
+
+  types.cpuType = enum (attrValues cpuTypes);
+
+  cpuTypes = with significantBytes;
+    setTypes types.openCpuType {
+      arm = {
+        bits = 32;
+        significantByte = littleEndian;
+        family = "arm";
+      };
+      armv5tel = {
+        bits = 32;
+        significantByte = littleEndian;
+        family = "arm";
+        version = "5";
+        arch = "armv5t";
+      };
+    };
+
+  isCompatible = a: b:
+    with cpuTypes;
+    lib.any lib.id [
+      # x86
+      (b == i386 && isCompatible a i486)
+      (b == i486 && isCompatible a i586)
+      (b == i586 && isCompatible a i686)
+
+      # ARMv6
+      (b == armv6l && isCompatible a armv6m)
+      (b == armv6m && isCompatible a armv7l)
+    ];
+
+  ################################################################################
+
+  types.openVendor = mkOptionType {
+    name = "vendor";
+    description = "vendor for the platform";
+    merge = mergeOneOption;
+  };
+
+  abis = setTypes types.openAbi {
+    cygnus = { };
+    msvc = { };
+
+    # Other architectures should use ELF in embedded situations.
+    elf = { };
+
+    androideabi = { };
+    android = {
+      assertions = [{
+        assertion = platform: !platform.isAarch32;
+        message = ''
+          The "android" ABI is not for 32-bit ARM. Use "androideabi" instead.
+        '';
+      }];
+    };
+  };
+
+  ################################################################################
+
+  types.parsedPlatform = mkOptionType {
+    name = "system";
+    description =
+      "fully parsed representation of llvm- or nix-style platform tuple";
+    merge = mergeOneOption;
+    check = { cpu, vendor, kernel, abi, }:
+      types.cpuType.check cpu && types.vendor.check vendor
+      && types.kernel.check kernel && types.abi.check abi;
+  };
+
+  isSystem = isType "system";
+
+  mkSystem = components:
+    assert types.parsedPlatform.check components;
+    setType "system" components;
+
+  mkSystemFromString = s:
+    mkSystemFromSkeleton (mkSkeletonFromList (lib.splitString "-" s));
+
+  ################################################################################
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/nix_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/nix_spec.lua
new file mode 100644
index 0000000..709a0a1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/nix_spec.lua
@@ -0,0 +1,40 @@
+local Runner = require("tests.indent.common").Runner
+
+local runner = Runner:new(it, "tests/indent/nix", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 2,
+  expandtab = true,
+})
+
+describe("indent Nix:", function()
+  describe("whole file:", function()
+    runner:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    for _, info in ipairs {
+      { 14, 2 },
+      { 16, 2 },
+      { 48, 4 },
+      { 112, 6 },
+    } do
+      runner:new_line("general.nix", { on_line = info[1], text = "x = 1;", indent = info[2] })
+    end
+
+    for _, info in ipairs {
+      { 115, 6 },
+      { 113, 10 },
+      { 6, 4 },
+      { 12, 2 },
+      { 16, 6 },
+      { 35, 6 },
+      { 23, 2 },
+      { 21, 6 },
+    } do
+      runner:new_line("conds.nix", { on_line = info[1], text = "x = 1;", indent = info[2] })
+    end
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/php/enum-indent.php b/pack/ant/start/nvim-treesitter/tests/indent/php/enum-indent.php
new file mode 100644
index 0000000..6d8093b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/php/enum-indent.php
@@ -0,0 +1,4 @@
+<?php
+
+enum Test: int
+{
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/php/example.php b/pack/ant/start/nvim-treesitter/tests/indent/php/example.php
new file mode 100644
index 0000000..6b0ec56
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/php/example.php
@@ -0,0 +1,12 @@
+<?php
+
+class example
+{
+    public int $variable;
+    // indentation works correctly here
+
+    public function foo()
+    {
+        // indentation works correctly here
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/php/example2.php b/pack/ant/start/nvim-treesitter/tests/indent/php/example2.php
new file mode 100644
index 0000000..4f739f8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/php/example2.php
@@ -0,0 +1,6 @@
+<?php
+function()
+{
+    $foo = 'bar';
+    // indentation with `o` is correct
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/php/issue-2497.php b/pack/ant/start/nvim-treesitter/tests/indent/php/issue-2497.php
new file mode 100644
index 0000000..2da7d3a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/php/issue-2497.php
@@ -0,0 +1,14 @@
+<?php
+
+use Illuminate\Support\Facades\Route;
+
+Route::get('/', function () {
+    return view('welcome');
+});
+
+Route::get(
+    '/',
+    1,
+    aaaaaaaaaaaaaaaaaaaaaaaaa,
+    2
+);
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/php/issue-3591.php b/pack/ant/start/nvim-treesitter/tests/indent/php/issue-3591.php
new file mode 100644
index 0000000..598948f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/php/issue-3591.php
@@ -0,0 +1,6 @@
+<?php
+
+function test() {
+    $array = [
+    ]
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/php/issue-4848.php b/pack/ant/start/nvim-treesitter/tests/indent/php/issue-4848.php
new file mode 100644
index 0000000..8d112ea
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/php/issue-4848.php
@@ -0,0 +1,66 @@
+<?php
+
+if (
+) {
+}
+
+return (
+);
+
+return true
+    ;
+
+return fn () => (
+);
+
+return fn (
+) => (
+);
+
+return function (
+) {
+};
+
+return function () {
+};
+
+return match (
+) {
+};
+
+return match () {
+};
+
+return new class
+{
+    public function up()
+    {
+    }
+
+    public function down(
+    ) {
+    }
+};
+
+$this->foo()
+    ->bar(
+    )
+    ->baz();
+
+$this->get()
+    ->each(function () {
+    })
+    ->each(
+        function (
+        ) {
+        },
+    );
+
+return $this->get()
+    ->each(function () {
+    })
+    ->each(
+        function (
+        ) {
+        },
+    );
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/php/issue-6888.php b/pack/ant/start/nvim-treesitter/tests/indent/php/issue-6888.php
new file mode 100644
index 0000000..a0bcb37
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/php/issue-6888.php
@@ -0,0 +1,12 @@
+<?php
+enum DaysOfWeek: int
+{
+    case Sunday = 0;
+    case Monday = 1;
+}
+
+class Foo {
+    public int $id;
+    public string $brand;
+}
+?>
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/php/property-hooks.php b/pack/ant/start/nvim-treesitter/tests/indent/php/property-hooks.php
new file mode 100644
index 0000000..e4aea4f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/php/property-hooks.php
@@ -0,0 +1,13 @@
+<?php
+
+class Foo
+{
+    private string $_baz;
+
+    public string $baz {
+        &get => $this->_baz;
+        set {
+            $this->_baz = strtoupper($value);
+        }
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/php/unfinished-call.php b/pack/ant/start/nvim-treesitter/tests/indent/php/unfinished-call.php
new file mode 100644
index 0000000..396d717
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/php/unfinished-call.php
@@ -0,0 +1,6 @@
+<?php
+
+Route::get(
+    '/',
+    1,
+    aaaaaaaaaaaaaaaaaaaaaaaaa,
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/php_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/php_spec.lua
new file mode 100644
index 0000000..c3f84e6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/php_spec.lua
@@ -0,0 +1,76 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/php", {
+  tabstop = 4,
+  shiftwidth = 4,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent PHP:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("example.php", { on_line = 11, text = "// new line starts 1 indentation to far", indent = 4 })
+    run:new_line(
+      "example2.php",
+      { on_line = 5, text = "indentation with `enter` in insert mode is not correct", indent = 4 }
+    )
+    run:new_line("issue-2497.php", { on_line = 5, text = "$a =", indent = 4 })
+    run:new_line("unfinished-call.php", { on_line = 6, text = "$a =", indent = 4 })
+    run:new_line("issue-3591.php", { on_line = 4, text = "$a =", indent = 8 })
+    run:new_line("enum-indent.php", { on_line = 4, text = "case", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 3, text = "true", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 4, text = "return;", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 7, text = "true", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 10, text = "|| false", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 11, text = "$a = 0;", indent = 0 })
+    run:new_line("issue-4848.php", { on_line = 13, text = "true", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 16, text = "$a,", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 17, text = "true", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 20, text = "$a,", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 21, text = "return $a;", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 24, text = "return;", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 27, text = "true", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 28, text = "true => null,", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 31, text = "true => null,", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 35, text = "function a() {}", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 37, text = "return;", indent = 8 })
+    run:new_line("issue-4848.php", { on_line = 40, text = "$a,", indent = 8 })
+    run:new_line("issue-4848.php", { on_line = 41, text = "return $a;", indent = 8 })
+    run:new_line("issue-4848.php", { on_line = 45, text = "->foo()", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 46, text = "$a,", indent = 8 })
+    run:new_line("issue-4848.php", { on_line = 47, text = "->foo()", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 48, text = "$a;", indent = 0 })
+    run:new_line("issue-4848.php", { on_line = 50, text = "->foo()", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 51, text = "return $a;", indent = 8 })
+    run:new_line("issue-4848.php", { on_line = 52, text = "->foo()", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 53, text = "$a,", indent = 8 })
+    run:new_line("issue-4848.php", { on_line = 54, text = "$a,", indent = 12 })
+    run:new_line("issue-4848.php", { on_line = 55, text = "return $a;", indent = 12 })
+    run:new_line("issue-4848.php", { on_line = 56, text = "$a,", indent = 8 })
+    run:new_line("issue-4848.php", { on_line = 57, text = "$a;", indent = 0 })
+    run:new_line("issue-4848.php", { on_line = 59, text = "->foo()", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 60, text = "return $a;", indent = 8 })
+    run:new_line("issue-4848.php", { on_line = 61, text = "->foo()", indent = 4 })
+    run:new_line("issue-4848.php", { on_line = 62, text = "$a,", indent = 8 })
+    run:new_line("issue-4848.php", { on_line = 63, text = "$a,", indent = 12 })
+    run:new_line("issue-4848.php", { on_line = 64, text = "return $a;", indent = 12 })
+    run:new_line("issue-4848.php", { on_line = 65, text = "$a,", indent = 8 })
+    run:new_line("issue-4848.php", { on_line = 66, text = "$a;", indent = 0 })
+    run:new_line("issue-6888.php", { on_line = 2, text = "$a;", indent = 0 })
+    run:new_line("issue-6888.php", { on_line = 3, text = "case Funday = 2;", indent = 4 })
+    run:new_line("issue-6888.php", { on_line = 6, text = "$a;", indent = 0 })
+    run:new_line("issue-6888.php", { on_line = 8, text = "$a;", indent = 4 })
+    run:new_line("issue-6888.php", { on_line = 11, text = "$a;", indent = 0 })
+    run:new_line("property-hooks.php", { on_line = 7, text = "get;", indent = 8 })
+    run:new_line("property-hooks.php", { on_line = 8, text = "set;", indent = 8 })
+    run:new_line("property-hooks.php", { on_line = 9, text = "$a;", indent = 12 })
+    run:new_line("property-hooks.php", { on_line = 11, text = "get;", indent = 8 })
+    run:new_line("property-hooks.php", { on_line = 12, text = "get;", indent = 4 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/aligned_indent.py b/pack/ant/start/nvim-treesitter/tests/indent/python/aligned_indent.py
new file mode 100644
index 0000000..bdba846
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/aligned_indent.py
@@ -0,0 +1,25 @@
+def aligned_indent(arg1,
+                   arg2):
+    pass
+
+def aligned_indent2(
+    arg1,
+    arg2
+):
+    pass
+
+aligned_indent(1,
+               2)
+
+
+aligned_indent(1,
+               2
+               )
+
+aligned_indent(
+    1,
+    2
+)
+
+foodsadsa(sdada,
+          2
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/aligned_indent_2.py b/pack/ant/start/nvim-treesitter/tests/indent/python/aligned_indent_2.py
new file mode 100644
index 0000000..124f714
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/aligned_indent_2.py
@@ -0,0 +1,12 @@
+if True:
+    print(1, 2, 3)
+
+if True:
+    print(
+        1,
+        2,
+        3
+    )
+    print(1,
+          2,
+          3)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/basic_blocks.py b/pack/ant/start/nvim-treesitter/tests/indent/python/basic_blocks.py
new file mode 100644
index 0000000..4f36359
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/basic_blocks.py
@@ -0,0 +1,14 @@
+from os import (
+    path,
+    name as OsName
+)
+
+def foo(x):
+    pass
+
+class Foo:
+    def __init__(self):
+        pass
+
+    def foo(self):
+        pass
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/basic_collections.py b/pack/ant/start/nvim-treesitter/tests/indent/python/basic_collections.py
new file mode 100644
index 0000000..1582b90
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/basic_collections.py
@@ -0,0 +1,23 @@
+# list
+a = [
+    1, 2,
+    3
+]
+
+# set
+b = {
+    3,
+    4,
+}
+
+# dict
+c = {
+    'a': 'b',
+    'c': 1,
+}
+
+# tuple
+d = (
+    1,
+    2,
+)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/branches.py b/pack/ant/start/nvim-treesitter/tests/indent/python/branches.py
new file mode 100644
index 0000000..00c47a2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/branches.py
@@ -0,0 +1,31 @@
+a = [
+    1, 2, 3]
+
+b = [
+    x + 1
+    for x in range(3)]
+
+c = [[[
+    1
+]]]
+
+d = [[[
+    4]]]
+
+e = [[
+    1], 2, 3]
+
+def foo(x, y):
+    pass
+
+foo(
+    a,
+    b)
+
+if (a and
+        b):
+    pass
+
+if (a
+        and b):
+    pass
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/break_continue.py b/pack/ant/start/nvim-treesitter/tests/indent/python/break_continue.py
new file mode 100644
index 0000000..aabd677
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/break_continue.py
@@ -0,0 +1,9 @@
+def f():
+    for x in range(1, 2):
+        if x == 1:
+            break
+
+def f():
+    for x in range(1, 2):
+        if x == 1:
+            continue
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/comprehensions.py b/pack/ant/start/nvim-treesitter/tests/indent/python/comprehensions.py
new file mode 100644
index 0000000..53c3961
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/comprehensions.py
@@ -0,0 +1,25 @@
+# list
+a = [
+    x + 1 for x in range(3)
+]
+
+# dict
+b = {
+    x: x + 1 for x in range(3)
+}
+
+# generator
+c = (
+    x * x for x in range(3)
+)
+
+# set
+d = {
+    x + x for x in range(3)
+}
+
+# other styles
+e = [
+    x + 1 for x
+    in range(3)
+]
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/control_flow.py b/pack/ant/start/nvim-treesitter/tests/indent/python/control_flow.py
new file mode 100644
index 0000000..387756f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/control_flow.py
@@ -0,0 +1,35 @@
+if a == a:
+    x = 1
+elif b:
+    x = 2
+else:
+    x = 3
+
+while False:
+    pass
+
+for _ in range(3):
+    pass
+
+with open('/tmp/f', 'w') as f:
+    pass
+
+try:
+    pass
+except:
+    pass
+finally:
+    pass
+
+while (a > 4 and
+       b > 5):
+    pass
+
+try:
+
+def foo():
+    print('indentme')
+
+    # comment
+    if True:
+        pass
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_def.py b/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_def.py
new file mode 100644
index 0000000..943fbfa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_def.py
@@ -0,0 +1,6 @@
+def foo(a,
+        b,
+        c):
+    pass
+
+def foobar(a,
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_dict.py b/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_dict.py
new file mode 100644
index 0000000..dec92b1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_dict.py
@@ -0,0 +1,6 @@
+
+d = {1:4,
+     2:3,
+     4:5}
+
+d2 = {1:3,
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_funcall.py b/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_funcall.py
new file mode 100644
index 0000000..e86720e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_funcall.py
@@ -0,0 +1,5 @@
+
+f(1,2,3,
+  4,5,6)
+
+g(1,2,3,
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_list.py b/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_list.py
new file mode 100644
index 0000000..09823bb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_list.py
@@ -0,0 +1,5 @@
+l = [1,
+     2,
+     3]
+
+l2 = [1,
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_set.py b/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_set.py
new file mode 100644
index 0000000..31338de
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_set.py
@@ -0,0 +1,5 @@
+s = {1,
+     2,
+     3}
+
+s2 = {1,
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_tuple.py b/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_tuple.py
new file mode 100644
index 0000000..fda59c8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_tuple.py
@@ -0,0 +1,7 @@
+(
+    a,
+    b,
+    c,
+)
+
+(a,
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_tuple_align.py b/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_tuple_align.py
new file mode 100644
index 0000000..fda59c8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/error_state_tuple_align.py
@@ -0,0 +1,7 @@
+(
+    a,
+    b,
+    c,
+)
+
+(a,
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/hanging_indent.py b/pack/ant/start/nvim-treesitter/tests/indent/python/hanging_indent.py
new file mode 100644
index 0000000..4d46ebe
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/hanging_indent.py
@@ -0,0 +1,6 @@
+def hanging_indent(
+        arg1, arg2):
+    pass
+
+hanging_indent(
+    1, 2)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/if_else.py b/pack/ant/start/nvim-treesitter/tests/indent/python/if_else.py
new file mode 100644
index 0000000..d128597
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/if_else.py
@@ -0,0 +1,3 @@
+def test_branch_else():
+    if True:
+        x = 1
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/join_lines.py b/pack/ant/start/nvim-treesitter/tests/indent/python/join_lines.py
new file mode 100644
index 0000000..491b2cc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/join_lines.py
@@ -0,0 +1,8 @@
+a = 2 \
+    + 2
+
+b = 'hello' \
+    'world'
+
+c = lambda x: \
+    x + 3
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/line_after_indent.py b/pack/ant/start/nvim-treesitter/tests/indent/python/line_after_indent.py
new file mode 100644
index 0000000..ba24dc0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/line_after_indent.py
@@ -0,0 +1,65 @@
+(
+    a, 
+    b
+)
+
+foo.bar(
+    a, b
+)
+
+foo = [
+    1, 
+    2, 
+    3
+]
+
+foo = {
+    "a": 1,
+    "b": 2,
+    "c": 3
+}
+
+foo = {
+    1,
+    2,
+    3,
+}
+
+foo = (
+    1 + 2
+)
+
+(
+    a for a in range(0, 10)
+)
+
+foo = [
+    a for a in range(0, 10)
+]
+
+foo = {
+    a for a in range(0, 10)
+}
+
+foo = {
+    a: b for a, b in items
+}
+
+foo.bar(
+    "baz")
+
+[
+    a + b for (
+        a, 
+        b
+    ) 
+    in items
+]
+
+[
+    a + b for [
+        a,
+        b
+    ]
+    in items
+]
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/match_case.py b/pack/ant/start/nvim-treesitter/tests/indent/python/match_case.py
new file mode 100644
index 0000000..88b56af
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/match_case.py
@@ -0,0 +1,15 @@
+a = 0
+
+def test_match_case():
+    match a:
+        case 1:
+            return
+
+
+def test_match():
+    match a:
+
+
+def test_case():
+    match a:
+        case b:
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/nested_collections.py b/pack/ant/start/nvim-treesitter/tests/indent/python/nested_collections.py
new file mode 100644
index 0000000..292a65a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/nested_collections.py
@@ -0,0 +1,41 @@
+a = [
+    1,
+    [
+        2,
+        [
+            3
+        ]
+    ]
+]
+
+b = [
+    1, [[
+        3
+    ],
+    ]
+]
+
+c = [[[
+    3
+]]]
+
+d = {
+    'a': [
+        2, 3
+    ],
+    'c': (
+        [1, 2, 3],
+        [
+            2,
+            4
+        ], {
+            6,
+            8
+        }
+    )
+}
+
+e = (1, 2,
+     3, 4,
+     5, 6
+     )
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/parenthesized_conditions.py b/pack/ant/start/nvim-treesitter/tests/indent/python/parenthesized_conditions.py
new file mode 100644
index 0000000..d30f2b1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/parenthesized_conditions.py
@@ -0,0 +1,35 @@
+if (
+    True
+    or 1
+    or False
+):
+    pass
+
+if (
+    True
+    or 1
+        or False):
+    pass
+
+if (True
+    or 1
+        or False):
+    pass
+
+while (
+    False
+    or 1
+    or False
+):
+    pass
+
+while (
+    False
+    or 1
+        or False):
+    pass
+
+while (False
+       or 1
+       or False):
+    pass
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/return_dedent.py b/pack/ant/start/nvim-treesitter/tests/indent/python/return_dedent.py
new file mode 100644
index 0000000..8171bc9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/return_dedent.py
@@ -0,0 +1,39 @@
+def a():
+    return
+
+def a():
+    return True
+
+def a():
+    return (1, 2, 3)
+
+def a():
+    return x.y.z
+
+def a():
+    return (
+        1, 2, 3
+    )
+
+def a():
+    return b(
+        1, 2, 3
+    )
+
+def a():
+    return [1, 2, 3]
+
+def a():
+    return {1, 2, 3}
+
+def a():
+    return {
+        "a": 1,
+        "b": 2,
+        "c": 3
+    }
+
+def a():
+    return [
+        a for a in range (1, 3)
+    ]
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python/strings.py b/pack/ant/start/nvim-treesitter/tests/indent/python/strings.py
new file mode 100644
index 0000000..0eb088f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python/strings.py
@@ -0,0 +1,17 @@
+a = """
+    String A
+"""
+
+b = """
+String B
+"""
+
+c = """
+    String C
+    """
+
+d = """
+    String D
+String D
+        String D
+    """
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/python_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/python_spec.lua
new file mode 100644
index 0000000..193b990
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/python_spec.lua
@@ -0,0 +1,101 @@
+local Runner = require("tests.indent.common").Runner
+local XFAIL = require("tests.indent.common").XFAIL
+
+local run = Runner:new(it, "tests/indent/python", {
+  tabstop = 4,
+  shiftwidth = 4,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent Python:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("aligned_indent.py", { on_line = 1, text = "arg3,", indent = 19 })
+    run:new_line("aligned_indent_2.py", { on_line = 2, text = "x", indent = 4 })
+    run:new_line("aligned_indent_2.py", { on_line = 9, text = "x", indent = 4 })
+    run:new_line("aligned_indent_2.py", { on_line = 12, text = "x", indent = 4 })
+    run:new_line("basic_blocks.py", { on_line = 1, text = "wait,", indent = 4 })
+    run:new_line("basic_blocks.py", { on_line = 6, text = "x += 1", indent = 4 })
+    run:new_line("basic_blocks.py", { on_line = 7, text = "x += 1", indent = 4 })
+    run:new_line("basic_blocks.py", { on_line = 10, text = "x += 1", indent = 8 })
+    run:new_line("basic_blocks.py", { on_line = 14, text = "x += 1", indent = 8 })
+    run:new_line("basic_collections.py", { on_line = 3, text = "4,", indent = 4 })
+    run:new_line("comprehensions.py", { on_line = 8, text = "if x != 2", indent = 4 })
+    run:new_line("control_flow.py", { on_line = 2, text = "x = 4", indent = 4 })
+    run:new_line("control_flow.py", { on_line = 4, text = "x = 4", indent = 4 })
+    run:new_line("control_flow.py", { on_line = 6, text = "x = 4", indent = 4 })
+    run:new_line("control_flow.py", { on_line = 9, text = "x = 4", indent = 4 })
+    run:new_line("control_flow.py", { on_line = 12, text = "x = 4", indent = 4 })
+    run:new_line("control_flow.py", { on_line = 15, text = "x = 4", indent = 4 })
+    run:new_line("control_flow.py", { on_line = 18, text = "x = 4", indent = 4 })
+    run:new_line("control_flow.py", { on_line = 20, text = "x = 4", indent = 4 })
+    run:new_line("control_flow.py", { on_line = 22, text = "x = 4", indent = 4 })
+    run:new_line("control_flow.py", { on_line = 24, text = "c < 6 and", indent = 7 })
+    run:new_line("control_flow.py", { on_line = 26, text = "x = 4", indent = 4 })
+    run:new_line("control_flow.py", { on_line = 28, text = "x = 4", indent = 4 })
+    run:new_line("control_flow.py", { on_line = 31, text = "try:", indent = 4 })
+    run:new_line("branches.py", { on_line = 25, text = "x > 9 and", indent = 4 })
+    run:new_line("branches.py", { on_line = 29, text = "and x > 9", indent = 4 })
+    run:new_line("hanging_indent.py", { on_line = 1, text = "arg0,", indent = 4 })
+    run:new_line("hanging_indent.py", { on_line = 5, text = "0,", indent = 4 })
+    run:new_line("error_state_def.py", { on_line = 6, text = "b,", indent = 11 })
+    run:new_line("error_state_tuple.py", { on_line = 7, text = "b,", indent = 1 })
+    run:new_line("error_state_tuple_align.py", { on_line = 7, text = "b,", indent = 1 })
+    run:new_line("error_state_list.py", { on_line = 5, text = "3,", indent = 6 })
+    run:new_line("error_state_dict.py", { on_line = 6, text = "9:10,", indent = 6 })
+    run:new_line("error_state_set.py", { on_line = 5, text = "9,", indent = 6 })
+    run:new_line("error_state_funcall.py", { on_line = 5, text = "6,", indent = 2 })
+    run:new_line("if_else.py", { on_line = 5, text = "else:", indent = 4 })
+    run:new_line("if_else.py", { on_line = 5, text = "elif False:", indent = 4 })
+    run:new_line(
+      "join_lines.py",
+      { on_line = 1, text = "+ 1 \\", indent = 4 },
+      "fails due two not working query at python/indent.scm:30",
+      XFAIL
+    )
+    run:new_line(
+      "join_lines.py",
+      { on_line = 4, text = "+ 1 \\", indent = 4 },
+      "fails due two not working query at python/indent.scm:30",
+      XFAIL
+    )
+    run:new_line("join_lines.py", { on_line = 7, text = "+ 1 \\", indent = 4 })
+    run:new_line("nested_collections.py", { on_line = 5, text = "0,", indent = 12 })
+    run:new_line("nested_collections.py", { on_line = 6, text = ",0", indent = 12 })
+    run:new_line("nested_collections.py", { on_line = 29, text = "[1, 2],", indent = 12 })
+    run:new_line("nested_collections.py", { on_line = 39, text = "0,", indent = 5 })
+    run:new_line("strings.py", { on_line = 14, text = "x", indent = 4 })
+    run:new_line("strings.py", { on_line = 15, text = "x", indent = 0 })
+    run:new_line("strings.py", { on_line = 16, text = "x", indent = 8 })
+    run:new_line("line_after_indent.py", { on_line = 4, text = "x", indent = 0 })
+    run:new_line("line_after_indent.py", { on_line = 8, text = "x", indent = 0 })
+    run:new_line("line_after_indent.py", { on_line = 4, text = "x", indent = 0 })
+    run:new_line("line_after_indent.py", { on_line = 14, text = "x", indent = 0 })
+    run:new_line("line_after_indent.py", { on_line = 20, text = "x", indent = 0 })
+    run:new_line("line_after_indent.py", { on_line = 26, text = "x", indent = 0 })
+    run:new_line("line_after_indent.py", { on_line = 30, text = "x", indent = 0 })
+    run:new_line("line_after_indent.py", { on_line = 34, text = "x", indent = 0 })
+    run:new_line("line_after_indent.py", { on_line = 38, text = "x", indent = 0 })
+    run:new_line("line_after_indent.py", { on_line = 42, text = "x", indent = 0 })
+    run:new_line("line_after_indent.py", { on_line = 46, text = "x", indent = 0 })
+    run:new_line("line_after_indent.py", { on_line = 49, text = "x", indent = 0 })
+    run:new_line("line_after_indent.py", { on_line = 55, text = "x", indent = 4 })
+    run:new_line("line_after_indent.py", { on_line = 63, text = "x", indent = 4 })
+    run:new_line("match_case.py", { on_line = 4, text = "pass", indent = 8 })
+    run:new_line("match_case.py", { on_line = 5, text = "pass", indent = 12 })
+    run:new_line("match_case.py", { on_line = 10, text = "pass", indent = 8 })
+    run:new_line("match_case.py", { on_line = 15, text = "pass", indent = 12 })
+    run:new_line("break_continue.py", { on_line = 4, text = "pass", indent = 8 })
+    run:new_line("break_continue.py", { on_line = 9, text = "pass", indent = 8 })
+
+    for _, line in ipairs { 2, 5, 8, 11, 16, 21, 24, 27, 34, 39 } do
+      run:new_line("return_dedent.py", { on_line = line, text = "x", indent = 0 })
+    end
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ql/module.ql b/pack/ant/start/nvim-treesitter/tests/indent/ql/module.ql
new file mode 100644
index 0000000..0aa986f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ql/module.ql
@@ -0,0 +1,3 @@
+module Test {
+  predicate test() {}
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ql_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/ql_spec.lua
new file mode 100644
index 0000000..cfdce90
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ql_spec.lua
@@ -0,0 +1,24 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/ql", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent Lua:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+end)
+
+describe("new line:", function()
+  run:new_line("module.ql", { on_line = 1, text = "predicate foo() {}", indent = 2 })
+end)
+
+describe("new line:", function()
+  run:new_line("module.ql", { on_line = 2, text = "predicate foo() {}", indent = 2 })
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/query/test.scm b/pack/ant/start/nvim-treesitter/tests/indent/query/test.scm
new file mode 100644
index 0000000..56d7556
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/query/test.scm
@@ -0,0 +1,50 @@
+; vim:ft=query
+; format-ignore
+(fenced_code_block (fenced_code_block_delimiter) @label
+  (info_string
+    (language) @_lang)
+  (#offset! @label 0 1 0 -1)
+  (#ft-conceal! @_lang))
+
+([
+  (list_marker_minus)
+  (list_marker_plus)
+  (list_marker_star)
+] @markup.list
+  (#offset-first-n! @markup.list 1)
+  (#set! conceal "•"))
+
+(list
+  (list_item
+    (list
+      (list_item
+        ([
+          (list_marker_minus)
+          (list_marker_plus)
+          (list_marker_star)
+        ] @markup.list
+          (#offset-first-n! @markup.list 1)
+          (#set! conceal "◦"))))))
+
+; comment
+(while_statement
+  [
+    "while"
+    "do"
+  ] @open.loop
+  "end" @close.loop) @scope.loop
+
+[
+  "toplevel"
+  "list"
+] @variable
+
+[
+  (parent
+    (child))+
+  (parent
+    (child))*
+  (parent
+    (child))?
+] @cap
+((
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/query_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/query_spec.lua
new file mode 100644
index 0000000..ca2ccde
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/query_spec.lua
@@ -0,0 +1,28 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/query", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 2,
+  expandtab = true,
+  lispoptions = "expr:1",
+})
+
+describe("indent Query:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {})
+  end)
+  describe("new line:", function()
+    run:new_line("test.scm", { on_line = 3, text = "(node)", indent = 2 })
+    run:new_line("test.scm", { on_line = 5, text = "(node)", indent = 2 })
+    run:new_line("test.scm", { on_line = 12, text = "(node)", indent = 2 })
+    run:new_line("test.scm", { on_line = 25, text = "(#my-directive!)", indent = 10 })
+    run:new_line("test.scm", { on_line = 34, text = '"more"', indent = 2 })
+    run:new_line("test.scm", { on_line = 35, text = "(node)", indent = 0 })
+    run:new_line("test.scm", { on_line = 40, text = "(node)", indent = 0 })
+    run:new_line("test.scm", { on_line = 44, text = "(node)", indent = 2 })
+    run:new_line("test.scm", { on_line = 46, text = "(node)", indent = 2 })
+    run:new_line("test.scm", { on_line = 48, text = "(node)", indent = 2 })
+    run:new_line("test.scm", { on_line = 50, text = "node_name", indent = 2 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/r/aligned_indent.R b/pack/ant/start/nvim-treesitter/tests/indent/r/aligned_indent.R
new file mode 100644
index 0000000..8efcf97
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/r/aligned_indent.R
@@ -0,0 +1,4 @@
+func <- function(x,
+                 y) {
+
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/r/comment.R b/pack/ant/start/nvim-treesitter/tests/indent/r/comment.R
new file mode 100644
index 0000000..4396e17
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/r/comment.R
@@ -0,0 +1,2 @@
+# some
+# comment
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/r/cond.R b/pack/ant/start/nvim-treesitter/tests/indent/r/cond.R
new file mode 100644
index 0000000..8651929
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/r/cond.R
@@ -0,0 +1,12 @@
+x <- 10
+
+if (x > 3) {
+  x <- 3
+} else if (x < 3) {
+  x <- -3
+} else {
+  if (x > 0) {
+    x <- 1
+  }
+  x <- 0
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/r/func.R b/pack/ant/start/nvim-treesitter/tests/indent/r/func.R
new file mode 100644
index 0000000..2048dd8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/r/func.R
@@ -0,0 +1,18 @@
+foo <- function(x) {
+  bar <- function(a, b, c) {
+    return(a + b + c)
+  }
+  return(
+    bar(
+      x,
+      1,
+      2
+    )
+  )
+}
+
+baz <- function(l) {
+  inner(l, function(x) {
+
+  })
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/r/incomplete_pipe.R b/pack/ant/start/nvim-treesitter/tests/indent/r/incomplete_pipe.R
new file mode 100644
index 0000000..199cc83
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/r/incomplete_pipe.R
@@ -0,0 +1,2 @@
+mtcars %>%
+  head() %>%
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/r/loop.R b/pack/ant/start/nvim-treesitter/tests/indent/r/loop.R
new file mode 100644
index 0000000..610bf6a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/r/loop.R
@@ -0,0 +1,17 @@
+x <- 1
+
+while (x < 10) {
+  x <- x + 1
+  break
+}
+
+for (i in 1:3) {
+  x <- x + 1
+}
+
+repeat {
+  x <- x + 1
+  if (x > 100) {
+    break
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/r/pipe.R b/pack/ant/start/nvim-treesitter/tests/indent/r/pipe.R
new file mode 100644
index 0000000..6e19f82
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/r/pipe.R
@@ -0,0 +1,10 @@
+mtcars |>
+  head(
+    n = 6L
+  ) |>
+  subset(
+    cyl > 3
+  )
+
+mtcars %>%
+  head()
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/r_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/r_spec.lua
new file mode 100644
index 0000000..08df5e1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/r_spec.lua
@@ -0,0 +1,42 @@
+local Runner = require("tests.indent.common").Runner
+--local XFAIL = require("tests.indent.common").XFAIL
+
+local run = Runner:new(it, "tests/indent/r", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent R:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {})
+  end)
+
+  describe("new line:", function()
+    run:new_line("comment.R", { on_line = 1, text = "# new comment", indent = 0 })
+
+    run:new_line("cond.R", { on_line = 1, text = "x <- x + 1", indent = 0 })
+    run:new_line("cond.R", { on_line = 4, text = "x <- x + 1", indent = 2 })
+    run:new_line("cond.R", { on_line = 5, text = "x <- x + 1", indent = 2 })
+    run:new_line("cond.R", { on_line = 8, text = "x <- x + 1", indent = 4 })
+
+    run:new_line("func.R", { on_line = 1, text = "x <- x + 1", indent = 2 })
+    run:new_line("func.R", { on_line = 2, text = "a <- a + 1", indent = 4 })
+    run:new_line("func.R", { on_line = 6, text = "0,", indent = 6 })
+    run:new_line("func.R", { on_line = 6, text = "0,", indent = 6 })
+    run:new_line("func.R", { on_line = 16, text = "x <- x + 1", indent = 4 })
+
+    run:new_line("loop.R", { on_line = 1, text = "x <- x + 1", indent = 0 })
+    run:new_line("loop.R", { on_line = 3, text = "x <- x + 1", indent = 2 })
+    run:new_line("loop.R", { on_line = 8, text = "x <- x + 1", indent = 2 })
+    run:new_line("loop.R", { on_line = 14, text = "print('lol')", indent = 4 })
+
+    run:new_line("pipe.R", { on_line = 1, text = "head(n = 10L) |>", indent = 2 })
+    run:new_line("pipe.R", { on_line = 9, text = "head()", indent = 2 })
+
+    run:new_line("incomplete_pipe.R", { on_line = 2, text = "head %>%", indent = 2 })
+
+    run:new_line("aligned_indent.R", { on_line = 1, text = "z,", indent = 17 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rescript/basic.res b/pack/ant/start/nvim-treesitter/tests/indent/rescript/basic.res
new file mode 100644
index 0000000..c5138a7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rescript/basic.res
@@ -0,0 +1,23 @@
+@genType
+type person = {
+  name: string,
+  age: int,
+}
+
+@genType
+type renderMe<'a> = React.component<{
+  "randomString": string,
+  "poly": 'a,
+}>
+
+@genType.import("./hookExample") @react.component
+external make: (
+  ~person: person,
+  ~children: React.element,
+  ~renderMe: renderMe<'a>,
+) => React.element = "makeRenamed"
+
+@genType.import("./hookExample")
+external foo: (~person: person) => string = "foo"
+
+let hi = 'a'
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rescript/complex.res b/pack/ant/start/nvim-treesitter/tests/indent/rescript/complex.res
new file mode 100644
index 0000000..1f21c33
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rescript/complex.res
@@ -0,0 +1,151 @@
+let hit = ({hit, children}: DocSearch.hitComponent) => {
+  let toTitle = str =>
+    str->Js.String2.charAt(0)->Js.String2.toUpperCase ++ Js.String2.sliceToEnd(str, ~from=1)
+
+  let description = switch hit.url
+    ->Js.String2.split("/")
+    ->Js.Array2.sliceFrom(1)
+    ->Belt.List.fromArray {
+    | list{"blog" as r | "community" as r, ..._} => r->toTitle
+    | list{"docs", doc, version, ...rest} =>
+      let path = rest->Belt.List.toArray
+
+      let info =
+        path
+        ->Js.Array2.slice(~start=0, ~end_=Js.Array2.length(path) - 1)
+        ->Js.Array2.map(path =>
+          switch path {
+          | "api" => "API"
+          | other => toTitle(other)
+        }
+        )
+
+      [doc->toTitle, version->toTitle]->Js.Array2.concat(info)->Js.Array2.joinWith(" / ")
+    | _ => ""
+  }
+
+  <Next.Link href={hit.url} className="flex flex-col w-full">
+    <span className="text-gray-60 captions px-4 pt-3 pb-1 block">
+      {description->React.string}
+    </span>
+    children
+  </Next.Link>
+}
+
+let transformItems = (items: DocSearch.transformItems) => {
+  items->Belt.Array.keepMap(item => {
+    let url = try Webapi.URL.make(item.url)->Some catch {
+      | Js.Exn.Error(obj) =>
+        Js.Console.error2(`Failed to parse URL ${item.url}`, obj)
+        None
+    }
+    switch url {
+    | Some({pathname, hash}) => {...item, url: pathname ++ hash}->Some
+    | None => None
+  }
+  })
+}
+
+@react.component
+let make = () => {
+  let (state, setState) = React.useState(_ => Inactive)
+  let router = Next.Router.useRouter()
+
+  let version = switch Url.parse(router.route).version {
+    | Version(v) => v
+    | _ => "latest"
+  }
+
+  let handleCloseModal = () => {
+    let () = switch ReactDOM.querySelector(".DocSearch-Modal") {
+      | Some(modal) =>
+        switch ReactDOM.querySelector("body") {
+        | Some(body) =>
+          open Webapi
+          body->Element.classList->ClassList.remove("DocSearch--active")
+          modal->Element.addEventListener("transitionend", () => {
+            setState(_ => Inactive)
+          })
+        | None => setState(_ => Inactive)
+      }
+      | None => ()
+    }
+  }
+
+  React.useEffect(() => {
+    let isEditableTag = el =>
+      switch el->tagName {
+      | "TEXTAREA" | "SELECT" | "INPUT" => true
+      | _ => false
+    }
+
+    let focusSearch = e => {
+      switch activeElement {
+      | Some(el) if el->isEditableTag || el->isContentEditable => ()
+      | _ =>
+        setState(_ => Active)
+        e->keyboardEventPreventDefault
+    }
+    }
+
+    let handleGlobalKeyDown = e => {
+      switch e.key {
+      | "/" => focusSearch(e)
+      | "k" if e.ctrlKey || e.metaKey => focusSearch(e)
+      | "Escape" => handleCloseModal()
+      | _ => ()
+    }
+    }
+    addKeyboardEventListener("keydown", handleGlobalKeyDown)
+    Some(() => removeKeyboardEventListener("keydown", handleGlobalKeyDown))
+  }, [setState])
+
+  let onClick = _ => {
+    setState(_ => Active)
+  }
+
+  let onClose = React.useCallback(() => {
+    handleCloseModal()
+  }, [setState])
+
+  <>
+    <button onClick type_="button" className="text-gray-60 hover:text-fire-50 p-2">
+      <Icon.MagnifierGlass className="fill-current" />
+    </button>
+    {switch state {
+      | Active =>
+        switch ReactDOM.querySelector("body") {
+        | Some(element) =>
+          ReactDOM.createPortal(
+            <DocSearch
+              apiKey
+              appId
+              indexName
+              onClose
+              searchParameters={facetFilters: ["version:" ++ version]}
+              initialScrollY={window->scrollY}
+              transformItems={transformItems}
+              hitComponent=hit
+            />
+            element,
+          )
+        | None => React.null
+      }
+      | Inactive => React.null
+    }}
+  </>
+}
+
+let comparable = (type key, ~cmp) => {
+  module N = MakeComparable({
+    type t = key
+    let cmp = cmp
+  })
+  module(N: Comparable with type t = key)
+}
+
+<Next.Link href={hit.url} className="flex flex-col w-full">
+<span className="text-gray-60 captions px-4 pt-3 pb-1 block">
+  {description->React.string}
+  children
+</Next.Link>
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rescript/conditional.res b/pack/ant/start/nvim-treesitter/tests/indent/rescript/conditional.res
new file mode 100644
index 0000000..db8328f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rescript/conditional.res
@@ -0,0 +1,104 @@
+include UseClient
+include UseQuery
+include UseMutation
+include UseSubscription
+
+type hookResponse<'ret> = Types.Hooks.hookResponse<'ret> = {
+  operation: Types.operation,
+  fetching: bool,
+  data: option<'ret>,
+  error: option<CombinedError.t>,
+  response: Types.Hooks.response<'ret>,
+  extensions: option<Js.Json.t>,
+  stale: bool,
+}
+
+Js.Array2.slice(~start=0, ~end_=Js.Array2.length(moduleRoute) - 1)
+
+let pathModule = Path.join([dir, version, `${moduleName}.json`])
+
+let {Api.LocMsg.row: row, column, shortMsg} = locMsg
+
+let message = `${"error"->red}: failed to compile examples from ${kind} ${test.id->cyan}\n${errorMessage}`
+
+let version = (evt->ReactEvent.Form.target)["value"]
+
+let rehypePlugins =
+  [Rehype.WithOptions([Plugin(Rehype.slug), SlugOption({prefix: slugPrefix ++ "-"})])]->Some
+
+module Item = {
+  type t = {
+    name: string,
+    sellIn: int,
+    quality: int,
+  }
+
+  let make = (~name, ~sellIn, ~quality): t => {
+    name,
+    sellIn,
+    quality,
+  }
+}
+
+let updateQuality = (items: array<Item.t>) => {
+  items->Js.Array2.map(item => {
+    let newItem = ref(item)
+
+    call(
+      asdf,
+      asdf
+    )
+
+    if (
+      newItem.contents.name != "Aged Brie" && 5 > 2 &&
+      newItem.contents.name != "Backstage passes to a TAFKAL80ETC concert"
+    ) {
+      if newItem.contents.quality > 0 {
+        if newItem.contents.name != "Sulfuras, Hand of Ragnaros" {
+          newItem := {...newItem.contents, quality: newItem.contents.quality - 1}
+        }
+      }
+    } else if newItem.contents.quality < 50 {
+      newItem := {...newItem.contents, quality: newItem.contents.quality + 1}
+
+      if newItem.contents.name == "Backstage passes to a TAFKAL80ETC concert" {
+        if newItem.contents.sellIn < 11 {
+          if newItem.contents.quality < 50 {
+            newItem := {...newItem.contents, quality: newItem.contents.quality + 1}
+          }
+        }
+
+        if newItem.contents.sellIn < 6 {
+          if newItem.contents.quality < 50 {
+            newItem := {...newItem.contents, quality: newItem.contents.quality + 1}
+          }
+        }
+      }
+    }
+
+    if newItem.contents.name != "Sulfuras, Hand of Ragnaros" {
+      newItem := {...newItem.contents, sellIn: newItem.contents.sellIn - 1}
+    }
+
+    if newItem.contents.sellIn < 0 {
+      if newItem.contents.name != "Aged Brie" {
+        if newItem.contents.name != "Backstage passes to a TAFKAL80ETC concert" {
+          if newItem.contents.quality > 0 {
+            if newItem.contents.name != "Sulfuras, Hand of Ragnaros" {
+              newItem := {...newItem.contents, quality: newItem.contents.quality - 1}
+            }
+          }
+        } else {
+          newItem := {
+            ...newItem.contents,
+            quality: newItem.contents.quality - newItem.contents.quality,
+          }
+        }
+      } else if newItem.contents.quality < 50 {
+        newItem := {...newItem.contents, quality: newItem.contents.quality + 1}
+      }
+    }
+
+    newItem.contents
+  })
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rescript_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/rescript_spec.lua
new file mode 100644
index 0000000..5b1f06a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rescript_spec.lua
@@ -0,0 +1,33 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/rescript", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent ReScript:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {})
+  end)
+
+  describe("new line:", function()
+    run:new_line("basic.res", { on_line = 5, text = "x", indent = 0 })
+    run:new_line("basic.res", { on_line = 9, text = '"another": here,', indent = 2 })
+    run:new_line("basic.res", { on_line = 10, text = "}", indent = 0 })
+    run:new_line("basic.res", { on_line = 14, text = "~test: test,", indent = 2 })
+    run:new_line("basic.res", { on_line = 18, text = "x", indent = 0 })
+
+    run:new_line("complex.res", { on_line = 3, text = "x", indent = 2 })
+    run:new_line("complex.res", { on_line = 5, text = "x", indent = 4 })
+    run:new_line("complex.res", { on_line = 17, text = "|", indent = 10 })
+    run:new_line("complex.res", { on_line = 25, text = "x", indent = 2 })
+    run:new_line("complex.res", { on_line = 60, text = "x", indent = 6 })
+    run:new_line("complex.res", { on_line = 120, text = "x", indent = 14 })
+    run:new_line("complex.res", { on_line = 136, text = "x", indent = 2 })
+
+    run:new_line("conditional.res", { on_line = 6, text = "test: bool,", indent = 2 })
+    run:new_line("conditional.res", { on_line = 95, text = "x", indent = 10 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-assignment.rb b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-assignment.rb
new file mode 100644
index 0000000..d0ae21e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-assignment.rb
@@ -0,0 +1,2 @@
+ret =
+  2
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-brackets.rb b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-brackets.rb
new file mode 100644
index 0000000..ba16536
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-brackets.rb
@@ -0,0 +1,5 @@
+def indent_brackets
+  {
+    {}
+  }
+end
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-ensure.rb b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-ensure.rb
new file mode 100644
index 0000000..fce2779
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-ensure.rb
@@ -0,0 +1,2 @@
+begin
+end
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-parens.rb b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-parens.rb
new file mode 100644
index 0000000..821743e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-parens.rb
@@ -0,0 +1,5 @@
+def indent_parens
+  (
+    ()
+  )
+end
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-parenthesized-statements.rb b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-parenthesized-statements.rb
new file mode 100644
index 0000000..72873dd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-parenthesized-statements.rb
@@ -0,0 +1,2 @@
+(
+)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-rescue.rb b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-rescue.rb
new file mode 100644
index 0000000..fce2779
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-rescue.rb
@@ -0,0 +1,2 @@
+begin
+end
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-square-brackets.rb b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-square-brackets.rb
new file mode 100644
index 0000000..8746d22
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-square-brackets.rb
@@ -0,0 +1,5 @@
+def indent_square_brackets
+  [
+    []
+  ]
+end
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-unless.rb b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-unless.rb
new file mode 100644
index 0000000..50bc2b4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ruby/indent-unless.rb
@@ -0,0 +1,2 @@
+unless true
+end
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ruby/period-issue-3364.rb b/pack/ant/start/nvim-treesitter/tests/indent/ruby/period-issue-3364.rb
new file mode 100644
index 0000000..6582750
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ruby/period-issue-3364.rb
@@ -0,0 +1,7 @@
+class User < ApplicationRecord
+  def foo
+    if true
+      self.
+    end
+  end
+end
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/ruby_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/ruby_spec.lua
new file mode 100644
index 0000000..b669b89
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/ruby_spec.lua
@@ -0,0 +1,22 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/ruby", {
+  shiftwidth = 2,
+  expandtab = true,
+})
+
+describe("indent Ruby:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = { "./period-issue-3364.rb" },
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("indent-unless.rb", { on_line = 1, text = "stmt", indent = 2 })
+    run:new_line("indent-assignment.rb", { on_line = 1, text = "1 +", indent = 2 })
+    run:new_line("indent-parenthesized-statements.rb", { on_line = 1, text = "stmt", indent = 2 })
+    run:new_line("indent-rescue.rb", { on_line = 1, text = "rescue", indent = 0 })
+    run:new_line("indent-ensure.rb", { on_line = 1, text = "ensure", indent = 0 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/array.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/array.rs
new file mode 100644
index 0000000..68344e0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/array.rs
@@ -0,0 +1,11 @@
+const X: [i32; 2] = [
+    1,
+    2,
+];
+
+fn foo() {
+    let _x = [
+        1,
+        2,
+    ];
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/comment.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/comment.rs
new file mode 100644
index 0000000..8f59213
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/comment.rs
@@ -0,0 +1,13 @@
+/// Function foo
+///
+/// Description of
+/// function foo.
+fn foo(x: i32, y: i32) -> i32 {
+    x + y
+}
+
+impl A {
+    /// Do some stuff!! (put cursor here and press enter)
+    fn a();
+}
+
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/cond.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/cond.rs
new file mode 100644
index 0000000..eb96a48
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/cond.rs
@@ -0,0 +1,17 @@
+fn foo(mut x: i32) -> i32 {
+    if x > 10 {
+        return 10;
+    } else if x == 10 {
+        return 9;
+    } else {
+        x += 10;
+    }
+
+    if x < 0 {
+        if x == -1 {
+            return 0;
+        }
+    }
+
+    0
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/enum.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/enum.rs
new file mode 100644
index 0000000..996f07d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/enum.rs
@@ -0,0 +1,11 @@
+enum Foo {
+    X,
+    Y(
+        char,
+        char,
+    ),
+    Z {
+        x: u32,
+        y: u32,
+    },
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/func.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/func.rs
new file mode 100644
index 0000000..4c9d40b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/func.rs
@@ -0,0 +1,10 @@
+fn foo() -> i32 {
+    1
+}
+
+fn foo(
+    x: i32,
+    y: i32
+) -> i32 {
+    x + y
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/if_let_cond.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/if_let_cond.rs
new file mode 100644
index 0000000..0d6e2ef
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/if_let_cond.rs
@@ -0,0 +1,7 @@
+fn foo() -> i32 {
+    if let Some(v) = Some(2) {
+        1
+    } else {
+        2
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/impl.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/impl.rs
new file mode 100644
index 0000000..2525c2e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/impl.rs
@@ -0,0 +1,7 @@
+struct Foo;
+
+impl Foo {
+    fn foo() -> i32 {
+        1
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/loop.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/loop.rs
new file mode 100644
index 0000000..eb845bc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/loop.rs
@@ -0,0 +1,19 @@
+fn foo(mut x: i32) {
+    while x > 0 {
+        x -= 1;
+    }
+
+    for i in 0..3 {
+        x += 1;
+    }
+
+    loop {
+        x += 1;
+
+        if x < 100 {
+            continue;
+        }
+
+        break;
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/macro.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/macro.rs
new file mode 100644
index 0000000..e42cf13
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/macro.rs
@@ -0,0 +1,13 @@
+macro_rules! foo {
+    ($a:ident, $b:ident, $c:ident) => {
+        struct a { value: $a };
+        struct b { value: $b };
+    };
+    ($a:ident) => {
+        struct a { value: $a };
+    };
+}
+
+foo! {
+    A
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/match.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/match.rs
new file mode 100644
index 0000000..438ba6d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/match.rs
@@ -0,0 +1,11 @@
+fn foo(x: i32) -> i32 {
+    match x {
+        0 => 1,
+        1 => {
+            2
+        },
+        2 | 3 => {
+            4
+        }
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/mod.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/mod.rs
new file mode 100644
index 0000000..cc7f2c8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/mod.rs
@@ -0,0 +1,8 @@
+mod foo {
+    const X: i32 = 1;
+
+    mod bar {
+
+        const Y: i32 = 1;
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/string.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/string.rs
new file mode 100644
index 0000000..4d60663
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/string.rs
@@ -0,0 +1,12 @@
+fn foo() {
+    let a = "hello
+world";
+
+    let b = "hello\
+        world";
+
+    let c = r#"
+        hello
+        world
+    "#;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/struct.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/struct.rs
new file mode 100644
index 0000000..f382897
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/struct.rs
@@ -0,0 +1,4 @@
+struct Foo {
+    x: u32,
+    y: u32,
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/trait.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/trait.rs
new file mode 100644
index 0000000..fb5fc7e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/trait.rs
@@ -0,0 +1,11 @@
+struct Foo;
+
+trait Bar {
+    fn bar();
+}
+
+impl Bar for Foo {
+    fn bar() {
+
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/tuple.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/tuple.rs
new file mode 100644
index 0000000..9001f77
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/tuple.rs
@@ -0,0 +1,8 @@
+fn foo() {
+    for (
+        a,
+        b
+    ) in c.iter() {
+        // ...
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust/where.rs b/pack/ant/start/nvim-treesitter/tests/indent/rust/where.rs
new file mode 100644
index 0000000..08c1b19
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust/where.rs
@@ -0,0 +1,21 @@
+fn foo<T>(t: T) -> i32
+where
+    T: Debug,
+{
+    1
+}
+
+fn foo<T>(t: T) -> i32 where
+    T: Debug,
+{
+    1
+}
+
+struct Foo<T>(T);
+
+impl<T> Write for Foo<T>
+where
+    T: Debug,
+{
+
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/rust_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/rust_spec.lua
new file mode 100644
index 0000000..795765b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/rust_spec.lua
@@ -0,0 +1,66 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/rust", {
+  tabstop = 4,
+  shiftwidth = 4,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent Rust:", function()
+  describe("whole file:", function()
+    run:whole_file "."
+  end)
+
+  describe("new line:", function()
+    run:new_line("array.rs", { on_line = 2, text = "0,", indent = 4 })
+    run:new_line("array.rs", { on_line = 8, text = "0,", indent = 8 })
+    run:new_line("comment.rs", { on_line = 3, text = "a", indent = "/// " })
+    run:new_line("comment.rs", { on_line = 10, text = "a", indent = "    /// " })
+    run:new_line("cond.rs", { on_line = 11, text = "x += 1;", indent = 12 })
+    run:new_line("cond.rs", { on_line = 2, text = "x += 1;", indent = 8 })
+    run:new_line("cond.rs", { on_line = 4, text = "x += 1;", indent = 8 })
+    run:new_line("cond.rs", { on_line = 6, text = "x += 1;", indent = 8 })
+    run:new_line("cond.rs", { on_line = 8, text = "x += 1;", indent = 4 })
+    run:new_line("if_let_cond.rs", { on_line = 2, text = "let a = 1;", indent = 8 })
+    run:new_line("if_let_cond.rs", { on_line = 4, text = "let a = 1;", indent = 8 })
+    run:new_line("if_let_cond.rs", { on_line = 6, text = "let a = 1;", indent = 4 })
+    run:new_line("enum.rs", { on_line = 2, text = "Q,", indent = 4 })
+    run:new_line("enum.rs", { on_line = 4, text = "i32,", indent = 8 })
+    run:new_line("enum.rs", { on_line = 8, text = "z: u32,", indent = 8 })
+    run:new_line("enum.rs", { on_line = 11, text = "let _x = 1;", indent = 0 })
+    run:new_line("func.rs", { on_line = 1, text = "let _x = 1;", indent = 4 })
+    run:new_line("func.rs", { on_line = 3, text = "let _x = 1;", indent = 0 })
+    run:new_line("func.rs", { on_line = 6, text = "z: i32,", indent = 4 })
+    run:new_line("impl.rs", { on_line = 3, text = "const FOO: u32 = 1;", indent = 4 })
+    run:new_line("impl.rs", { on_line = 4, text = "let _x = 1;", indent = 8 })
+    run:new_line("impl.rs", { on_line = 6, text = "let _x = 1;", indent = 4 })
+    run:new_line("impl.rs", { on_line = 7, text = "let _x = 1;", indent = 0 })
+    run:new_line("loop.rs", { on_line = 10, text = "x += 1;", indent = 8 })
+    run:new_line("loop.rs", { on_line = 2, text = "x += 1;", indent = 8 })
+    run:new_line("loop.rs", { on_line = 6, text = "x += 1;", indent = 8 })
+    run:new_line("macro.rs", { on_line = 1, text = "() => {},", indent = 4 })
+    run:new_line("macro.rs", { on_line = 12, text = "B C", indent = 4 })
+    run:new_line("macro.rs", { on_line = 2, text = "struct $c;", indent = 8 })
+    run:new_line("match.rs", { on_line = 2, text = "-1 => -1,", indent = 8 })
+    run:new_line("match.rs", { on_line = 7, text = "let y = 1;", indent = 12 })
+    run:new_line("match.rs", { on_line = 10, text = "let y = 1;", indent = 4 })
+    run:new_line("mod.rs", { on_line = 1, text = "const Z: i32 = 1;", indent = 4 })
+    run:new_line("mod.rs", { on_line = 2, text = "const Z: i32 = 1;", indent = 4 })
+    run:new_line("mod.rs", { on_line = 6, text = "const Z: i32 = 1;", indent = 8 })
+    run:new_line("mod.rs", { on_line = 7, text = "const Z: i32 = 1;", indent = 4 })
+    run:new_line("string.rs", { on_line = 2, text = "brave new", indent = 0 })
+    run:new_line("string.rs", { on_line = 5, text = "brave new \\", indent = 8 })
+    run:new_line("string.rs", { on_line = 9, text = "brave new \\", indent = 8 })
+    run:new_line("struct.rs", { on_line = 1, text = "z: i32,", indent = 4 })
+    run:new_line("struct.rs", { on_line = 2, text = "z: i32,", indent = 4 })
+    run:new_line("struct.rs", { on_line = 4, text = "let y = 1;", indent = 0 })
+    run:new_line("trait.rs", { on_line = 4, text = "fn baz();", indent = 4 })
+    run:new_line("trait.rs", { on_line = 5, text = "let y = 1;", indent = 0 })
+    run:new_line("trait.rs", { on_line = 7, text = "fn baz();", indent = 4 })
+    run:new_line("trait.rs", { on_line = 8, text = "()", indent = 8 })
+    run:new_line("where.rs", { on_line = 17, text = "T: Debug,", indent = 4 })
+    run:new_line("where.rs", { on_line = 2, text = "T: Debug,", indent = 4 })
+    run:new_line("where.rs", { on_line = 9, text = "T: Debug,", indent = 4 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/smali/array_and_switch.smali b/pack/ant/start/nvim-treesitter/tests/indent/smali/array_and_switch.smali
new file mode 100644
index 0000000..3ee3f6d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/smali/array_and_switch.smali
@@ -0,0 +1,58 @@
+.class public Lbaksmali/test/class;
+.super Ljava/lang/Object;
+
+.source "baksmali_test_class.smali"
+
+.method public testMethod(ILjava/lang/String;)Ljava/lang/String;
+	.registers 3
+	.annotation runtime Lorg/junit/Test;
+	.end annotation
+	.annotation system Lyet/another/annotation;
+		somevalue = 1234
+		anothervalue = 3.14159
+	.end annotation
+
+	const-string v0, "testing\n123"
+
+	goto switch:
+
+	sget v0, Lbaksmali/test/class;->staticField:I
+
+	switch:
+	packed-switch v0, pswitch:
+
+	try_start:
+	const/4 v0, 7
+	const v0, 10
+	nop
+	try_end:
+	.catch Ljava/lang/Exception; {try_start: .. try_end:} handler:
+	.catchall {try_start: .. try_end:} handler2:
+
+	handler:
+
+	Label10:
+	Label11:
+	Label12:
+	Label13:
+	return-object v0
+
+
+
+	.array-data 4
+		1 2 3 4 5 6 200
+	.end array-data
+
+	pswitch:
+	.packed-switch 10
+		Label10:
+		Label11:
+		Label12:
+		Label13:
+	.end packed-switch
+
+	handler2:
+
+	return-void
+
+.end method
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/smali/field.smali b/pack/ant/start/nvim-treesitter/tests/indent/smali/field.smali
new file mode 100644
index 0000000..ae48b7b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/smali/field.smali
@@ -0,0 +1,12 @@
+.class public Lbaksmali/test/class;
+.super Ljava/lang/Object;
+
+.source "baksmali_test_class.smali"
+
+.field public static annotationStaticField:Lsome/annotation; = .subannotation Lsome/annotation;
+	value1 = "test"
+	value2 = .subannotation Lsome/annotation;
+		value1 = "test2"
+		value2 = Lsome/enum;
+	.end subannotation
+.end subannotation
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/smali/method.smali b/pack/ant/start/nvim-treesitter/tests/indent/smali/method.smali
new file mode 100644
index 0000000..2c139b0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/smali/method.smali
@@ -0,0 +1,8 @@
+.class public Lbaksmali/test/class;
+.super Ljava/lang/Object;
+
+.source "baksmali_test_class.smali"
+
+.method public debugTest(IIIII)V
+	.registers 10
+.end method
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/smali/parameter.smali b/pack/ant/start/nvim-treesitter/tests/indent/smali/parameter.smali
new file mode 100644
index 0000000..2e54da2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/smali/parameter.smali
@@ -0,0 +1,55 @@
+.class public Lbaksmali/test/class;
+.super Ljava/lang/Object;
+
+.source "baksmali_test_class.smali"
+
+.method public debugTest(IIIII)V
+	.registers 10
+
+	.parameter "Blah"
+	.parameter
+	.parameter "BlahWithAnnotations"
+		.annotation runtime Lsome/annotation;
+			something = "some value"
+			somethingelse = 1234
+		.end annotation
+		.annotation runtime La/second/annotation;
+		.end annotation
+	.end parameter
+	.parameter
+		.annotation runtime Lsome/annotation;
+			something = "some value"
+			somethingelse = 1234
+		.end annotation
+	.end parameter
+	.parameter "LastParam"
+
+	.prologue
+
+	nop
+	nop
+
+	.source "somefile.java"
+	.line 101
+
+	nop
+
+
+	.line 50
+
+	.local v0, aNumber:I
+	const v0, 1234
+	.end local v0
+
+	.source "someotherfile.java"
+	.line 900
+
+	const-string v0, "1234"
+
+	.restart local v0
+	const v0, 6789
+	.end local v0
+
+	.epilogue
+
+.end method
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/smali_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/smali_spec.lua
new file mode 100644
index 0000000..cddc4f9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/smali_spec.lua
@@ -0,0 +1,25 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/smali", {
+  tabstop = 4,
+  shiftwidth = 4,
+  expandtab = false,
+})
+
+describe("indent Smali:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("field.smali", { on_line = 7, text = 'value1 = "test"', indent = 1 })
+    run:new_line("field.smali", { on_line = 10, text = "value2 = Lsome/enum;", indent = 2 })
+    run:new_line("array_and_switch.smali", { on_line = 43, text = "1 2 3 4 5 6 200", indent = 2 })
+    run:new_line("array_and_switch.smali", { on_line = 48, text = "Label10:", indent = 2 })
+    run:new_line("method.smali", { on_line = 7, text = ".registers 10", indent = 1 })
+    run:new_line("parameter.smali", { on_line = 20, text = ".annotation runtime Lsome/annotation;", indent = 3 })
+    run:new_line("parameter.smali", { on_line = 21, text = 'something = "some value"', indent = 3 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/sql/case.sql b/pack/ant/start/nvim-treesitter/tests/indent/sql/case.sql
new file mode 100644
index 0000000..eee85a3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/sql/case.sql
@@ -0,0 +1,8 @@
+select
+    case
+        when a = 1 then '1'
+        when a = 2 then '2'
+        when a = 3 then '3'
+        else '0'
+    end as stmt1
+from tab;
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/sql/compound.sql b/pack/ant/start/nvim-treesitter/tests/indent/sql/compound.sql
new file mode 100644
index 0000000..e645c6e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/sql/compound.sql
@@ -0,0 +1,3 @@
+begin
+    create table foo (bar int);
+end;
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/sql/create.sql b/pack/ant/start/nvim-treesitter/tests/indent/sql/create.sql
new file mode 100644
index 0000000..9773884
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/sql/create.sql
@@ -0,0 +1,4 @@
+create table my_table (
+    id bigint,
+    date date
+);
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/sql/cte.sql b/pack/ant/start/nvim-treesitter/tests/indent/sql/cte.sql
new file mode 100644
index 0000000..55426cc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/sql/cte.sql
@@ -0,0 +1,7 @@
+with data as (
+    select
+        a,
+        b
+    from tab
+)
+select * from data;
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/sql/insert.sql b/pack/ant/start/nvim-treesitter/tests/indent/sql/insert.sql
new file mode 100644
index 0000000..36fa7c0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/sql/insert.sql
@@ -0,0 +1,5 @@
+insert into mytable
+    (column1, column2)
+values
+    ('john', 123),
+    ('jane', 124);
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/sql/select.sql b/pack/ant/start/nvim-treesitter/tests/indent/sql/select.sql
new file mode 100644
index 0000000..85f0cc5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/sql/select.sql
@@ -0,0 +1,4 @@
+select
+    a,
+    b
+from tab;
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/sql/subquery.sql b/pack/ant/start/nvim-treesitter/tests/indent/sql/subquery.sql
new file mode 100644
index 0000000..a559d7e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/sql/subquery.sql
@@ -0,0 +1,9 @@
+select
+    id
+from foo
+where id < (
+    select
+        id
+    from bar
+    limit 1
+);
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/sql_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/sql_spec.lua
new file mode 100644
index 0000000..2fdfc9b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/sql_spec.lua
@@ -0,0 +1,19 @@
+local Runner = require("tests.indent.common").Runner
+--local XFAIL = require("tests.indent.common").XFAIL
+
+local run = Runner:new(it, "tests/indent/sql", {
+  tabstop = 4,
+  shiftwidth = 4,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent SQL:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function() end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/swift/declarations.swift b/pack/ant/start/nvim-treesitter/tests/indent/swift/declarations.swift
new file mode 100644
index 0000000..67a7e55
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/swift/declarations.swift
@@ -0,0 +1,56 @@
+@wrapper
+@modifier(
+  *
+)
+class EquilateralTriangle: NamedShape {
+  var sideLength: Double = 0.0
+
+  @attr
+  init(
+    sideLength: Double, 
+    name: String
+  ) {
+    self.sideLength = sideLength
+  }
+  deinit {
+  }
+
+  var perimeter: Double {
+    willSet {
+    }
+    didSet {
+
+    }
+  }
+
+  @funcattr
+  override func simpleDescription(a: int, b: int) -> String {
+    return "An equilateral triangle with sides of length \(sideLength)."
+  }
+}
+
+@attr
+protocol ExampleProtocol {
+  var simpleDescription: String { get }
+  mutating func adjust()
+}
+
+@available(*)
+func test() {
+
+}
+
+@attr(*)
+typealias Foo = Bar
+
+@attr
+struct Foo<
+  Bar
+> {
+  @Provider
+  var test = 1
+
+  subscript(index: Int) -> Int {
+    var foo = 2
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/swift/expressions.swift b/pack/ant/start/nvim-treesitter/tests/indent/swift/expressions.swift
new file mode 100644
index 0000000..4f7292a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/swift/expressions.swift
@@ -0,0 +1,17 @@
+func Test() {
+  (1 + 2)
+
+  [
+    1,
+    2,
+    3,
+    4,
+    5
+  ].split()
+
+  let x = [
+    1: 2,
+    3: 4,
+  ]
+
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/swift/statements.swift b/pack/ant/start/nvim-treesitter/tests/indent/swift/statements.swift
new file mode 100644
index 0000000..df6e46c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/swift/statements.swift
@@ -0,0 +1,34 @@
+func Test() {
+  if true {
+    return
+  } else if true {
+    return
+  }
+
+  switch x {
+  case "1":
+    print("x")
+  default:
+    print("y")
+  @unknown default:
+    print("z")
+  }
+
+  for a in b {
+  }
+
+  while true{
+  }
+
+  repeat {
+
+  } while (true)
+
+  guard let name = person["name"] else {
+    return
+  }
+
+  return (
+    x + 1
+  )
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/swift_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/swift_spec.lua
new file mode 100644
index 0000000..501cbfa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/swift_spec.lua
@@ -0,0 +1,22 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/swift", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 2,
+  expandtab = true,
+})
+
+describe("indent Swift:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {})
+  end)
+  describe("new line:", function()
+    run:new_line("declarations.swift", { on_line = 6, text = "var x = 1", indent = 2 })
+    run:new_line("declarations.swift", { on_line = 12, text = "var textInsideInit = true", indent = 4 })
+    run:new_line("declarations.swift", { on_line = 19, text = "var textInsideWillSet = 1", indent = 6 })
+    run:new_line("declarations.swift", { on_line = 22, text = "var textInsideDidSet = 1", indent = 6 })
+    run:new_line("declarations.swift", { on_line = 27, text = "var textInsideOverrideFunc", indent = 4 })
+    run:new_line("declarations.swift", { on_line = 33, text = "var InsideProtocol: String { get }", indent = 2 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/t32/if_block.cmm b/pack/ant/start/nvim-treesitter/tests/indent/t32/if_block.cmm
new file mode 100644
index 0000000..4bda7c6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/t32/if_block.cmm
@@ -0,0 +1,49 @@
+IF &a
+  STOP
+
+IF (TRUE())
+(
+  BREAK
+)
+
+IF (&b+CouNT())
+(
+  continue
+)
+
+IF FOUND()
+  STOP
+ELSE
+  CONTinue
+
+IF &c
+  CONTinue
+ELSE IF FALSE()
+  Break
+ELSE
+  stop
+
+IF &d
+(
+  STOP
+)
+ELSE IF &e
+; comment A
+(
+  CONTINUE
+)
+ELSE
+; comment B
+(
+  BREAK
+)
+
+IF &f
+  IF &g
+    stop
+  ELSE
+    IF &h
+    (
+      continue
+    )
+
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/t32/repeat_block.cmm b/pack/ant/start/nvim-treesitter/tests/indent/t32/repeat_block.cmm
new file mode 100644
index 0000000..6384183
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/t32/repeat_block.cmm
@@ -0,0 +1,27 @@
+RePeaT 10. PRINT "A"
+
+RePeaT &a
+  print
+
+REPEAT 0xaAfF09
+(
+  cont
+)
+
+RPT
+(
+  b
+)
+
+rpt
+(
+  s
+)
+WHILE &a
+
+REPEAT TRUE()
+; comment
+(
+  cont
+)
+
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/t32/subroutine_block.cmm b/pack/ant/start/nvim-treesitter/tests/indent/t32/subroutine_block.cmm
new file mode 100644
index 0000000..24891c6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/t32/subroutine_block.cmm
@@ -0,0 +1,23 @@
+printA:
+(
+  PRINT "A"
+  RETURN
+)
+
+sUBROUtINE printB
+(
+  ENTRY &in
+
+  PRINT "&in"
+  RETURN
+)
+
+SUBROUTINE printC
+// comment
+(
+  PARAMETERS &a &b
+
+  PRINT "&a"+"&b"
+  ENDDO
+)
+
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/t32/while_block.cmm b/pack/ant/start/nvim-treesitter/tests/indent/t32/while_block.cmm
new file mode 100644
index 0000000..bfcbd45
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/t32/while_block.cmm
@@ -0,0 +1,14 @@
+WHILE &a
+  Step
+
+WHILE (sYmbol.EXIT(main))
+(
+  Step
+  Break
+)
+
+WHILE (FALSE())
+// comment
+(
+  ECHO "test"
+)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/t32_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/t32_spec.lua
new file mode 100644
index 0000000..88d2661
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/t32_spec.lua
@@ -0,0 +1,138 @@
+local Runner = require("tests.indent.common").Runner
+local XFAIL = require("tests.indent.common").XFAIL
+
+local runner = Runner:new(it, "tests/indent/t32", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent t32:", function()
+  describe("whole file:", function()
+    runner:whole_file "."
+  end)
+
+  describe("new line:", function()
+    runner:new_line("if_block.cmm", { on_line = 2, text = "GOTO start", indent = 0 }, "command after IF", XFAIL)
+
+    runner:new_line("if_block.cmm", { on_line = 5, text = "GOTO start", indent = 2 }, "command in IF then block")
+
+    runner:new_line("if_block.cmm", { on_line = 4, text = "(", indent = 0 }, "block after IF")
+
+    for ii, test in ipairs {
+      { 1, 2 },
+      { 14, 2 },
+      { 19, 2 },
+      { 21, 2 },
+      { 41, 2 },
+      { 42, 4 },
+    } do
+      runner:new_line(
+        "if_block.cmm",
+        { on_line = test[1], text = "&x=1.", indent = test[2] },
+        "command in IF then[" .. ii .. "]"
+      )
+    end
+
+    -- Insertion of a command right before the existing block results in
+    -- incorrect syntax. The parse either detect an error or incorrectly
+    -- assumes "ELSE IF" is a command.
+    for ii, test in ipairs {
+      { 26, 2 },
+      { 30, 2 },
+    } do
+      runner:new_line(
+        "if_block.cmm",
+        { on_line = test[1], text = 'PRINT ""', indent = test[2] },
+        "displace block in IF then[" .. ii .. "]",
+        XFAIL
+      )
+    end
+
+    runner:new_line("if_block.cmm", { on_line = 45, text = "&x=1.", indent = 6 }, "command in IF then", XFAIL)
+
+    for ii, test in ipairs {
+      { 16, 2 },
+      { 21, 2 },
+      { 23, 2 },
+      { 44, 4 },
+    } do
+      runner:new_line(
+        "if_block.cmm",
+        { on_line = test[1], text = "CONTinue\n", indent = test[2] },
+        "command in IF else[" .. ii .. "]"
+      )
+    end
+
+    runner:new_line("while_block.cmm", { on_line = 2, text = "&x=1.", indent = 2 }, "command after WHILE")
+
+    runner:new_line("while_block.cmm", { on_line = 4, text = "&x=1.", indent = 0 }, "command after WHILE")
+
+    runner:new_line("while_block.cmm", { on_line = 1, text = "(\n", indent = 0 }, "block in WHILE then")
+
+    for ii, test in ipairs {
+      { 5, 2 },
+      { 12, 2 },
+    } do
+      runner:new_line(
+        "while_block.cmm",
+        { on_line = test[1], text = "&x=1.", indent = test[2] },
+        "command in WHILE then block[" .. ii .. "]"
+      )
+    end
+
+    for ii, test in ipairs {
+      { 1, 0 },
+      { 4, 2 },
+    } do
+      runner:new_line(
+        "repeat_block.cmm",
+        { on_line = test[1], text = "&x=1.", indent = test[2] },
+        "command after RePeaT[" .. ii .. "]"
+      )
+    end
+
+    runner:new_line("repeat_block.cmm", { on_line = 3, text = "(\n", indent = 0 }, "block in RePeaT then")
+
+    for ii, test in ipairs {
+      { 7, 2 },
+      { 18, 2 },
+      { 24, 2 },
+    } do
+      runner:new_line(
+        "repeat_block.cmm",
+        { on_line = test[1], text = "&x=1.", indent = test[2] },
+        "command in RePeaT then block [" .. ii .. "]"
+      )
+    end
+
+    runner:new_line("subroutine_block.cmm", { on_line = 1, text = "(\n", indent = 0 }, "block after call label")
+
+    for ii, test in ipairs {
+      { 2, 2 },
+      { 3, 2 },
+      { 8, 2 },
+      { 12, 2 },
+      { 19, 2 },
+    } do
+      runner:new_line(
+        "subroutine_block.cmm",
+        { on_line = test[1], text = "&x=1.", indent = test[2] },
+        "command in subroutine block[" .. ii .. "]"
+      )
+    end
+
+    for ii, test in ipairs {
+      { 5, 2 },
+      { 13, 2 },
+      { 23, 2 },
+    } do
+      runner:new_line(
+        "subroutine_block.cmm",
+        { on_line = test[1], text = "&x=1.", indent = test[2] },
+        "command after subroutine block[" .. ii .. "]"
+      )
+    end
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/terraform/function_call.tf b/pack/ant/start/nvim-treesitter/tests/indent/terraform/function_call.tf
new file mode 100644
index 0000000..44c477e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/terraform/function_call.tf
@@ -0,0 +1,6 @@
+test {
+  x = f(
+    a,
+    b,
+  )
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/terraform/indent-in-multiline-objects.tf b/pack/ant/start/nvim-treesitter/tests/indent/terraform/indent-in-multiline-objects.tf
new file mode 100644
index 0000000..00ee9c9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/terraform/indent-in-multiline-objects.tf
@@ -0,0 +1,6 @@
+test {
+  x = {
+    1: "foo",
+    2: "bar",
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/terraform/indent-in-multiline-tuples.tf b/pack/ant/start/nvim-treesitter/tests/indent/terraform/indent-in-multiline-tuples.tf
new file mode 100644
index 0000000..4024878
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/terraform/indent-in-multiline-tuples.tf
@@ -0,0 +1,6 @@
+test {
+  x = [
+    1,
+    2,
+  ]
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/terraform/multiline-comments.tf b/pack/ant/start/nvim-treesitter/tests/indent/terraform/multiline-comments.tf
new file mode 100644
index 0000000..494aaba
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/terraform/multiline-comments.tf
@@ -0,0 +1,7 @@
+test {
+  /*
+    foo
+    bar
+    baz
+  */
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/terraform/multiple-attributes.tf b/pack/ant/start/nvim-treesitter/tests/indent/terraform/multiple-attributes.tf
new file mode 100644
index 0000000..da6a85f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/terraform/multiple-attributes.tf
@@ -0,0 +1,4 @@
+test {
+  x = ["foo", "bar"]
+  y = {"fizz": "buzz"}
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/terraform/multiple-blocks.tf b/pack/ant/start/nvim-treesitter/tests/indent/terraform/multiple-blocks.tf
new file mode 100644
index 0000000..b9826c8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/terraform/multiple-blocks.tf
@@ -0,0 +1,6 @@
+test {
+  x = "foo"
+}
+test {
+  y = "bar"
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/terraform/nested_blocks.tf b/pack/ant/start/nvim-treesitter/tests/indent/terraform/nested_blocks.tf
new file mode 100644
index 0000000..7be6492
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/terraform/nested_blocks.tf
@@ -0,0 +1,5 @@
+test {
+  nest {
+    x = "bar"
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/terraform/no-indent-after-brace.tf b/pack/ant/start/nvim-treesitter/tests/indent/terraform/no-indent-after-brace.tf
new file mode 100644
index 0000000..e670ad8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/terraform/no-indent-after-brace.tf
@@ -0,0 +1,4 @@
+# Issue #2590
+locals {
+  titles = ["test0", "test1"]
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/terraform_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/terraform_spec.lua
new file mode 100644
index 0000000..49fa22c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/terraform_spec.lua
@@ -0,0 +1,35 @@
+local Runner = require("tests.indent.common").Runner
+--local XFAIL = require("tests.indent.common").XFAIL
+
+local run = Runner:new(it, "tests/indent/terraform", {
+  tabstop = 2,
+  shiftwidth = 2,
+  expandtab = true,
+})
+
+describe("indent Terraform:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("no-indent-after-brace.tf", { on_line = 4, text = "# Wow, no indent here please", indent = 0 })
+    run:new_line("indent-in-multiline-tuples.tf", { on_line = 4, text = "3,", indent = 4 })
+    run:new_line("indent-in-multiline-tuples.tf", { on_line = 3, text = "# as elements", indent = 4 })
+    run:new_line("indent-in-multiline-tuples.tf", { on_line = 5, text = "# as outer block", indent = 2 })
+    run:new_line("indent-in-multiline-tuples.tf", { on_line = 1, text = "# as outer block", indent = 2 })
+    run:new_line("indent-in-multiline-objects.tf", { on_line = 4, text = '3: "baz",', indent = 4 })
+    run:new_line("indent-in-multiline-objects.tf", { on_line = 3, text = "# as elements", indent = 4 })
+    run:new_line("indent-in-multiline-objects.tf", { on_line = 5, text = "# as outer block", indent = 2 })
+    run:new_line("indent-in-multiline-objects.tf", { on_line = 1, text = "# as outer block", indent = 2 })
+    run:new_line("multiple-attributes.tf", { on_line = 2, text = "a = 1", indent = 2 })
+    run:new_line("multiple-attributes.tf", { on_line = 3, text = "a = 1", indent = 2 })
+    run:new_line("multiple-attributes.tf", { on_line = 4, text = "a = 1", indent = 0 })
+    run:new_line("nested_blocks.tf", { on_line = 3, text = "a = 1", indent = 4 })
+    run:new_line("nested_blocks.tf", { on_line = 4, text = "a = 1", indent = 2 })
+    run:new_line("function_call.tf", { on_line = 4, text = "c,", indent = 4 })
+    run:new_line("function_call.tf", { on_line = 5, text = "a = 1", indent = 2 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/tiger/classes.tig b/pack/ant/start/nvim-treesitter/tests/indent/tiger/classes.tig
new file mode 100644
index 0000000..542a40e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/tiger/classes.tig
@@ -0,0 +1,14 @@
+class A {
+  var a := 12
+
+  method method() : int = 1
+}
+
+type B = class extends A {
+  var b := 27
+
+  method another_method() = (
+    print("called");
+    self.b + self.method()
+  )
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/tiger/control-flow.tig b/pack/ant/start/nvim-treesitter/tests/indent/tiger/control-flow.tig
new file mode 100644
index 0000000..abbadfa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/tiger/control-flow.tig
@@ -0,0 +1,22 @@
+(
+  if
+    12
+  then
+    27
+  else
+    42
+  ;
+
+  for
+    i := 12
+  to
+    27
+  do
+    42
+  ;
+
+  while
+    0
+  do
+    break
+)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/tiger/functions.tig b/pack/ant/start/nvim-treesitter/tests/indent/tiger/functions.tig
new file mode 100644
index 0000000..22ce051
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/tiger/functions.tig
@@ -0,0 +1,14 @@
+primitive long_parameter_list(
+  a: int,
+  b: string,
+  c: type
+)
+
+function f() =
+  (
+    long_parameter_list(
+      1,
+      "2",
+      nil
+    )
+  )
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/tiger/groupings.tig b/pack/ant/start/nvim-treesitter/tests/indent/tiger/groupings.tig
new file mode 100644
index 0000000..870e0da
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/tiger/groupings.tig
@@ -0,0 +1,10 @@
+let
+  var a := 42
+in
+  (
+    12;
+    27;
+    42
+  );
+  a
+end
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/tiger/values-and-expressions.tig b/pack/ant/start/nvim-treesitter/tests/indent/tiger/values-and-expressions.tig
new file mode 100644
index 0000000..5131c30
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/tiger/values-and-expressions.tig
@@ -0,0 +1,30 @@
+let
+  type array_of_int = array of int
+
+  type record = {
+    a: int,
+    b: string,
+    c: type
+  }
+
+  var a :=
+    "a string"
+in
+  array[
+    12
+  ]
+  ;
+
+  array_of_int[
+    27
+  ]
+  of
+    42
+  ;
+
+  record {
+    a = 1,
+    b = "2",
+    c = nil
+  }
+end
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/tiger_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/tiger_spec.lua
new file mode 100644
index 0000000..c1f252f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/tiger_spec.lua
@@ -0,0 +1,113 @@
+local Runner = require("tests.indent.common").Runner
+
+local runner = Runner:new(it, "tests/indent/tiger", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent Tiger:", function()
+  describe("whole file:", function()
+    runner:whole_file "."
+  end)
+
+  describe("new line:", function()
+    runner:new_line("classes.tig", { on_line = 1, text = "var a := 0", indent = 2 }, "class declaration beginning")
+    runner:new_line("classes.tig", { on_line = 2, text = "var a := 0", indent = 2 }, "class declaration after field")
+    runner:new_line("classes.tig", { on_line = 4, text = "var a := 0", indent = 2 }, "class declaration after method")
+    runner:new_line("classes.tig", { on_line = 5, text = "var a := 0", indent = 0 }, "after class declaration")
+    runner:new_line("classes.tig", { on_line = 7, text = "var a := 0", indent = 2 }, "class type beginning")
+    runner:new_line("classes.tig", { on_line = 8, text = "var a := 0", indent = 2 }, "class type after field")
+    runner:new_line("classes.tig", { on_line = 10, text = "self.a := 0", indent = 4 }, "inside method")
+    runner:new_line("classes.tig", { on_line = 13, text = "var a := 0", indent = 2 }, "class type after method")
+    runner:new_line("classes.tig", { on_line = 14, text = "var a := 0", indent = 0 }, "after class type")
+
+    runner:new_line("control-flow.tig", { on_line = 2, text = "true", indent = 4 }, "if condition")
+    runner:new_line("control-flow.tig", { on_line = 4, text = "true", indent = 4 }, "if consequence")
+    runner:new_line("control-flow.tig", { on_line = 4, text = "true", indent = 4 }, "if alternative")
+    runner:new_line("control-flow.tig", { on_line = 10, text = "start := 0", indent = 4 }, "for index start")
+    runner:new_line("control-flow.tig", { on_line = 12, text = "the_end", indent = 4 }, "for index end")
+    runner:new_line("control-flow.tig", { on_line = 14, text = "break", indent = 4 }, "for body")
+    runner:new_line("control-flow.tig", { on_line = 18, text = "true", indent = 4 }, "while condition")
+    runner:new_line("control-flow.tig", { on_line = 20, text = "break", indent = 4 }, "while body")
+
+    runner:new_line("functions.tig", { on_line = 1, text = "parameter: int,", indent = 2 }, "parameter list beginning")
+    runner:new_line("functions.tig", { on_line = 2, text = "parameter: int,", indent = 2 }, "parameter list middle")
+    runner:new_line("functions.tig", { on_line = 4, text = ",parameter: int", indent = 2 }, "parameter list end")
+    runner:new_line("functions.tig", { on_line = 5, text = "var a := 0", indent = 0 }, "after parameter list")
+    runner:new_line("functions.tig", { on_line = 7, text = "print(a)", indent = 2 }, "function body")
+    runner:new_line("functions.tig", { on_line = 9, text = "a,", indent = 6 }, "function call beginning")
+    runner:new_line("functions.tig", { on_line = 10, text = "a,", indent = 6 }, "function call middle")
+    runner:new_line("functions.tig", { on_line = 12, text = ",a", indent = 6 }, "function call end")
+    runner:new_line("functions.tig", { on_line = 13, text = "; print(a)", indent = 4 }, "after function call")
+    runner:new_line("functions.tig", { on_line = 14, text = "var a := 12", indent = 0 }, "after function declaration")
+
+    runner:new_line("groupings.tig", { on_line = 2, text = "var b := 0", indent = 2 }, "let declarations")
+    runner:new_line("groupings.tig", { on_line = 3, text = "a := a + 1", indent = 2 }, "after 'in'")
+    runner:new_line("groupings.tig", { on_line = 4, text = "a := a + 1;", indent = 4 }, "sequence")
+    runner:new_line("groupings.tig", { on_line = 8, text = "a := a + 1;", indent = 2 }, "after sequence")
+    runner:new_line("groupings.tig", { on_line = 10, text = "+ 1", indent = 0 }, "after 'end'")
+
+    runner:new_line(
+      "values-and-expressions.tig",
+      { on_line = 4, text = "field: record,", indent = 4 },
+      "record type beginning"
+    )
+    runner:new_line(
+      "values-and-expressions.tig",
+      { on_line = 5, text = "field: record,", indent = 4 },
+      "record type middle"
+    )
+    runner:new_line(
+      "values-and-expressions.tig",
+      { on_line = 7, text = ",field: record", indent = 4 },
+      "record type end"
+    )
+    runner:new_line("values-and-expressions.tig", { on_line = 8, text = "var a := 0", indent = 2 }, "after record type")
+    runner:new_line(
+      "values-and-expressions.tig",
+      { on_line = 10, text = "0", indent = 4 },
+      "variable declaration init value"
+    )
+    runner:new_line(
+      "values-and-expressions.tig",
+      { on_line = 11, text = "+ a", indent = 4 },
+      "variable declaration init follow-up"
+    )
+    runner:new_line("values-and-expressions.tig", { on_line = 13, text = "a", indent = 4 }, "array index")
+    runner:new_line("values-and-expressions.tig", { on_line = 14, text = "+ a", indent = 4 }, "array index follow-up")
+    runner:new_line("values-and-expressions.tig", { on_line = 15, text = "+ a", indent = 2 }, "after array value")
+    runner:new_line("values-and-expressions.tig", { on_line = 18, text = "a", indent = 4 }, "array expression size")
+    runner:new_line(
+      "values-and-expressions.tig",
+      { on_line = 20, text = "of", indent = 4 },
+      "array expression after size"
+    )
+    runner:new_line(
+      "values-and-expressions.tig",
+      { on_line = 21, text = "a", indent = 4 },
+      "array expression init value"
+    )
+    runner:new_line(
+      "values-and-expressions.tig",
+      { on_line = 25, text = "field = 0,", indent = 4 },
+      "record expression beginning"
+    )
+    runner:new_line(
+      "values-and-expressions.tig",
+      { on_line = 26, text = "field = 0,", indent = 4 },
+      "record expression middle"
+    )
+    runner:new_line(
+      "values-and-expressions.tig",
+      { on_line = 28, text = ",field = 0", indent = 4 },
+      "record expression end"
+    )
+    runner:new_line(
+      "values-and-expressions.tig",
+      { on_line = 29, text = "a := 0", indent = 2 },
+      "after record expression"
+    )
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/usd/prim.usd b/pack/ant/start/nvim-treesitter/tests/indent/usd/prim.usd
new file mode 100644
index 0000000..4bfbff9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/usd/prim.usd
@@ -0,0 +1,6 @@
+#usda 1.0
+
+def "foo" (
+)
+{
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/usd_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/usd_spec.lua
new file mode 100644
index 0000000..c4e8198
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/usd_spec.lua
@@ -0,0 +1,21 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/usd", {
+  tabstop = 4,
+  shiftwidth = 4,
+  softtabstop = 4,
+  expandtab = true,
+})
+
+describe("indent USD:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("prim.usd", { on_line = 3, text = "active = false", indent = 4 })
+    run:new_line("prim.usd", { on_line = 5, text = "custom int foo = 10", indent = 4 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/vue/template_indent.vue b/pack/ant/start/nvim-treesitter/tests/indent/vue/template_indent.vue
new file mode 100644
index 0000000..95d891f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/vue/template_indent.vue
@@ -0,0 +1,3 @@
+<template>
+  Foo
+</template>
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/vue_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/vue_spec.lua
new file mode 100644
index 0000000..09527e4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/vue_spec.lua
@@ -0,0 +1,24 @@
+local Runner = require("tests.indent.common").Runner
+-- local XFAIL = require("tests.indent.common").XFAIL
+
+local run = Runner:new(it, "tests/indent", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent Vue:", function()
+  describe("whole file:", function()
+    run:whole_file({ "vue/" }, {})
+  end)
+
+  describe("new line:", function()
+    for _, info in ipairs {
+      { 1, 2 },
+      { 3, 0 },
+    } do
+      run:new_line("vue/template_indent.vue", { on_line = info[1], text = "Foo", indent = info[2] }, info[3], info[4])
+    end
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/wgsl/basic.wgsl b/pack/ant/start/nvim-treesitter/tests/indent/wgsl/basic.wgsl
new file mode 100644
index 0000000..7dd50f8
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/wgsl/basic.wgsl
@@ -0,0 +1,43 @@
+struct Vertex {
+  @location(0) position: vec3<f32>,
+  @location(1) color: vec4<f32>,
+};
+
+@vertex
+fn vertex(vertex: Vertex) -> VertexOutput {
+  var out: VertexOutput;
+  out.a = 1;
+  if (1) {
+    out.a = 3;
+  }
+  if (2) {
+    dsa;
+  }
+
+  loop {
+    if (i >= 4) { break; }
+  }
+  out.b = 2;
+  return out;
+}
+
+@vertex
+fn vertex(vertex: Vertex,
+  foo: dso,
+  foo: dsa
+) -> VertexOutput {
+  var out: VertexOutput;
+  out.a = 1;
+  out.b = 2;
+  return out;
+}
+
+@vertex
+fn vertex(vertex: Vertex,
+  foo: dso,
+  foo: dsa) -> VertexOutput {
+  var out: VertexOutput;
+  out.a = 1;
+  out.b = 2;
+  return out;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/wgsl_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/wgsl_spec.lua
new file mode 100644
index 0000000..55d59ac
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/wgsl_spec.lua
@@ -0,0 +1,19 @@
+local Runner = require("tests.indent.common").Runner
+--local XFAIL = require("tests.indent.common").XFAIL
+
+local run = Runner:new(it, "tests/indent/wgsl", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent WGSL:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function() end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/yaml/autoindent-mapping-pair.yaml b/pack/ant/start/nvim-treesitter/tests/indent/yaml/autoindent-mapping-pair.yaml
new file mode 100644
index 0000000..8dadeee
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/yaml/autoindent-mapping-pair.yaml
@@ -0,0 +1,2 @@
+- key1: value1
+  key2: value2
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/yaml/indent-sequence-items.yaml b/pack/ant/start/nvim-treesitter/tests/indent/yaml/indent-sequence-items.yaml
new file mode 100644
index 0000000..8dadeee
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/yaml/indent-sequence-items.yaml
@@ -0,0 +1,2 @@
+- key1: value1
+  key2: value2
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/yaml_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/yaml_spec.lua
new file mode 100644
index 0000000..91c60c2
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/yaml_spec.lua
@@ -0,0 +1,20 @@
+local Runner = require("tests.indent.common").Runner
+--local XFAIL = require("tests.indent.common").XFAIL
+
+local run = Runner:new(it, "tests/indent/yaml", {
+  shiftwidth = 2,
+  expandtab = true,
+})
+
+describe("indent YAML:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("indent-sequence-items.yaml", { on_line = 2, text = "key3: value3", indent = 2 })
+    run:new_line("autoindent-mapping-pair.yaml", { on_line = 1, text = "key3: value3", indent = 2 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/yang/module.yang b/pack/ant/start/nvim-treesitter/tests/indent/yang/module.yang
new file mode 100644
index 0000000..29c911f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/yang/module.yang
@@ -0,0 +1,58 @@
+module test-module {
+  yang-version 1.1;
+  namespace "http://example.com";
+  prefix test;
+
+  import ietf-inet-types { prefix inet; }
+  import tailf-ncs {
+    prefix ncs;
+  }
+
+  description "Multi-line strings has indentation
+               aligned with the first line.";
+
+  typedef foo {
+    type enumeration {
+      enum "foo";
+      enum "bar";
+    }
+  }
+
+  ncs:plan-outline test-nano-service {
+    description "Testing indentation of extension statements.";
+
+    ncs:component-type "ncs:self" {
+      ncs:state "ncs:init" {
+        ncs:create {
+          ncs:nano-callback;
+        }
+      }
+      ncs:state "ncs:ready";
+    }
+
+    ncs:component-type "alloc:resource-allocator" {
+      ncs:state "ncs:init";
+      ncs:state "alloc:resources-allocated";
+      ncs:state "ncs:ready";
+    }
+  }
+
+  container test {
+  }
+
+  augment /alloc:resource-allocator {
+    description "Augmentation for the resource allocator mock services.";
+
+    list test-nano-service {
+      key "id";
+
+      leaf id {
+        type string;
+        description
+          "I'm a multi-line string
+
+           Starting on the next line from the statement.";
+      }
+    }
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/yang_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/yang_spec.lua
new file mode 100644
index 0000000..618d260
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/yang_spec.lua
@@ -0,0 +1,23 @@
+local Runner = require("tests.indent.common").Runner
+
+local run = Runner:new(it, "tests/indent/yang", {
+  tabstop = 2,
+  shiftwidth = 2,
+  softtabstop = 0,
+  expandtab = true,
+})
+
+describe("indent YANG:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("module.yang", { on_line = 12, text = "// Aligned indentation ended", indent = 2 })
+    run:new_line("module.yang", { on_line = 37, text = "// Test", indent = 4 })
+    run:new_line("module.yang", { on_line = 40, text = "// Test", indent = 4 })
+    run:new_line("module.yang", { on_line = 52, text = "Aligned string!", indent = 11 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/yuck/indent.yuck b/pack/ant/start/nvim-treesitter/tests/indent/yuck/indent.yuck
new file mode 100644
index 0000000..c224548
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/yuck/indent.yuck
@@ -0,0 +1,17 @@
+(defwidget name
+  :widget parameter
+  (box one
+    :box1 parameter
+    (box two
+      :box2 parameter
+    )
+  )
+)
+
+(defwidget name
+  :widget parameter
+  (box one
+  )
+)
+
+(defwidget name
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/yuck_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/yuck_spec.lua
new file mode 100644
index 0000000..6ce15de
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/yuck_spec.lua
@@ -0,0 +1,19 @@
+local Runner = require("tests.indent.common").Runner
+local run = Runner:new(it, "tests/indent/yuck", {
+  tabstop = 2,
+  shiftwidth = 2,
+  expandtab = true,
+})
+
+describe("indent yuck", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new line:", function()
+    run:new_line("indent.yuck", { on_line = 13, text = ":box1 parameter", indent = 4 })
+    run:new_line("indent.yuck", { on_line = 17, text = ")", indent = 0 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/zig/pr-3269.zig b/pack/ant/start/nvim-treesitter/tests/indent/zig/pr-3269.zig
new file mode 100644
index 0000000..65b6b64
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/zig/pr-3269.zig
@@ -0,0 +1,10 @@
+// https://github.com/nvim-treesitter/nvim-treesitter/pull/3269
+const std = @import("std");
+
+pub fn main() anyerror!void {
+    std.log.info("All your codebase are belong to us.", .{});
+}
+
+test "basic test" {
+    try std.testing.expectEqual(10, 3 + 7);
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/indent/zig_spec.lua b/pack/ant/start/nvim-treesitter/tests/indent/zig_spec.lua
new file mode 100644
index 0000000..c064d9a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/indent/zig_spec.lua
@@ -0,0 +1,22 @@
+local Runner = require("tests.indent.common").Runner
+--local XFAIL = require("tests.indent.common").XFAIL
+
+local run = Runner:new(it, "tests/indent/zig", {
+  tabstop = 4,
+  shiftwidth = 4,
+  softtabstop = 4,
+  expandtab = true,
+})
+
+describe("indent Zig:", function()
+  describe("whole file:", function()
+    run:whole_file(".", {
+      expected_failures = {},
+    })
+  end)
+
+  describe("new lines:", function()
+    run:new_line("pr-3269.zig", { on_line = 5, text = "return;", indent = 4 })
+    run:new_line("pr-3269.zig", { on_line = 6, text = "", indent = 0 })
+  end)
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/bash/double-parens.sh b/pack/ant/start/nvim-treesitter/tests/query/highlights/bash/double-parens.sh
new file mode 100644
index 0000000..8d841d1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/bash/double-parens.sh
@@ -0,0 +1,6 @@
+if (( $(tree-sitter parse test/Petalisp/**/*.lisp -q | wc -l) > 2 )); then
+#  ^ @punctuation.special
+#                                                                  ^ @punctuation.special
+#                                                           ^ @punctuation.bracket
+   exit 1 
+fi
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/c/enums-as-constants.c b/pack/ant/start/nvim-treesitter/tests/query/highlights/c/enums-as-constants.c
new file mode 100644
index 0000000..8e64744
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/c/enums-as-constants.c
@@ -0,0 +1,21 @@
+enum Foo{
+    a,
+//  ^ @constant
+    aa,
+//  ^ @constant
+    C,
+};
+
+void foo(enum Foo f){
+    switch ( f ) {
+        case a:
+         //  ^ @constant
+            break;
+        case aa:
+         //  ^ @constant
+            break;
+        case C:
+            break;
+        default:
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/capnp/test.capnp b/pack/ant/start/nvim-treesitter/tests/query/highlights/capnp/test.capnp
new file mode 100644
index 0000000..b70e913
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/capnp/test.capnp
@@ -0,0 +1,633 @@
+# Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
+# Licensed under the MIT License:
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+@0xd508eebdc2dc42b8;
+# <- @keyword.directive
+#                  ^ @punctuation.delimiter
+
+using Cxx = import "c++.capnp";
+# <- @keyword.import
+#     ^^^ @type
+#         ^ @operator
+#           ^^^^^^ @keyword.import
+#                  ^^^^^^^^^^^ @string.special.path
+
+# Use a namespace likely to cause trouble if the generated code doesn't use fully-qualified
+# names for stuff in the capnproto namespace.
+$Cxx.namespace("capnproto_test::capnp::test");
+
+enum TestEnum {
+# <- @keyword.type
+#    ^^^^^^^^ @type
+  foo @0;
+# ^^^ @constant
+#     ^^ @label
+  bar @1;
+  baz @2;
+  qux @3;
+  quux @4;
+  corge @5;
+  grault @6;
+  garply @7;
+}
+# <- @punctuation.bracket
+
+struct TestAllTypes {
+# <- @keyword.type
+  voidField      @0  : Void;
+# ^^^^^^^^^ @variable.member
+#                    ^ @punctuation.special
+#                      ^^^^ @type.builtin
+  boolField      @1  : Bool;
+  int8Field      @2  : Int8;
+  int16Field     @3  : Int16;
+  int32Field     @4  : Int32;
+  int64Field     @5  : Int64;
+  uInt8Field     @6  : UInt8;
+  uInt16Field    @7  : UInt16;
+  uInt32Field    @8  : UInt32;
+  uInt64Field    @9  : UInt64;
+  float32Field   @10 : Float32;
+  float64Field   @11 : Float64;
+  textField      @12 : Text;
+  dataField      @13 : Data;
+  structField    @14 : TestAllTypes;
+  enumField      @15 : TestEnum;
+  interfaceField @16 : Void;  # TODO
+
+  voidList      @17 : List(Void);
+  boolList      @18 : List(Bool);
+  int8List      @19 : List(Int8);
+  int16List     @20 : List(Int16);
+  int32List     @21 : List(Int32);
+  int64List     @22 : List(Int64);
+  uInt8List     @23 : List(UInt8);
+  uInt16List    @24 : List(UInt16);
+  uInt32List    @25 : List(UInt32);
+  uInt64List    @26 : List(UInt64);
+  float32List   @27 : List(Float32);
+  float64List   @28 : List(Float64);
+  textList      @29 : List(Text);
+  dataList      @30 : List(Data);
+  structList    @31 : List(TestAllTypes);
+  enumList      @32 : List(TestEnum);
+  interfaceList @33 : List(Void);  # TODO
+}
+
+struct TestInterleavedGroups {
+  group1 :group {
+    foo @0 :UInt32;
+    bar @2 :UInt64;
+    union {
+#   ^^^^^ @keyword.type
+      qux @4 :UInt16;
+      corge :group {
+#     ^^^^^ @type
+        grault @6 :UInt64;
+        garply @8 :UInt16;
+        plugh @14 :Text;
+        xyzzy @16 :Text;
+      }
+
+      fred @12 :Text;
+    }
+
+    waldo @10 :Text;
+  }
+
+  group2 :group {
+#         ^^^^^ @keyword.type
+    foo @1 :UInt32;
+    bar @3 :UInt64;
+    union {
+      qux @5 :UInt16;
+      corge :group {
+        grault @7 :UInt64;
+        garply @9 :UInt16;
+        plugh @15 :Text;
+        xyzzy @17 :Text;
+      }
+
+      fred @13 :Text;
+    }
+
+    waldo @11 :Text;
+  }
+}
+
+struct TestUnionDefaults {
+  s16s8s64s8Set @0 :TestUnion =
+      (union0 = (u0f0s16 = 321), union1 = (u1f0s8 = 123), union2 = (u2f0s64 = 12345678901234567),
+#                          ^^^ @number
+       union3 = (u3f0s8 = 55));
+  s0sps1s32Set @1 :TestUnion =
+      (union0 = (u0f1s0 = void), union1 = (u1f0sp = "foo"), union2 = (u2f0s1 = true),
+#                                                   ^^^^^ @string
+#                                                                              ^^^^ @boolean
+       union3 = (u3f0s32 = 12345678));
+
+  unnamed1 @2 :TestUnnamedUnion = (foo = 123);
+  unnamed2 @3 :TestUnnamedUnion = (bar = 321, before = "foo", after = "bar");
+}
+
+struct TestUsing {
+  using OuterNestedEnum = TestNestedTypes.NestedEnum;
+# ^^^^^ @keyword.import
+  using TestNestedTypes.NestedStruct.NestedEnum;
+
+  outerNestedEnum @1 :OuterNestedEnum = bar;
+  innerNestedEnum @0 :NestedEnum = quux;
+}
+
+struct TestListDefaults {
+  lists @0 :TestLists = (
+      list0  = [(f = void), (f = void)],
+#                    ^^^^ @constant.builtin
+      list1  = [(f = true), (f = false), (f = true), (f = true)],
+      list8  = [(f = 123), (f = 45)],
+      list16 = [(f = 12345), (f = 6789)],
+      list32 = [(f = 123456789), (f = 234567890)],
+      list64 = [(f = 1234567890123456), (f = 2345678901234567)],
+      listP  = [(f = "foo"), (f = "bar")],
+      int32ListList = [[1, 2, 3], [4, 5], [12341234]],
+      textListList = [["foo", "bar"], ["baz"], ["qux", "corge"]],
+      structListList = [[(int32Field = 123), (int32Field = 456)], [(int32Field = 789)]]);
+}
+
+struct TestWholeFloatDefault {
+  # At one point, these failed to compile in C++ because it would produce literals like "123f",
+  # which is not valid; it needs to be "123.0f".
+  field @0 :Float32 = 123;
+  bigField @1 :Float32 = 2e30;
+  const constant :Float32 = 456;
+  const bigConstant :Float32 = 4e30;
+#                              ^^^^ @number.float
+}
+
+struct TestGenerics(Foo, Bar) {
+  foo @0 :Foo;
+  rev @1 :TestGenerics(Bar, Foo);
+
+  union {
+    uv @2:Void;
+    ug :group {
+      ugfoo @3:Int32;
+    }
+  }
+
+  list @4 :List(Inner);
+  # At one time this failed to compile with MSVC due to poor expression SFINAE support.
+
+  struct Inner {
+    foo @0 :Foo;
+    bar @1 :Bar;
+  }
+
+  struct Inner2(Baz) {
+    bar @0 :Bar;
+    baz @1 :Baz;
+    innerBound @2 :Inner;
+    innerUnbound @3 :TestGenerics.Inner;
+
+    struct DeepNest(Qux) {
+      foo @0 :Foo;
+      bar @1 :Bar;
+      baz @2 :Baz;
+      qux @3 :Qux;
+
+      interface DeepNestInterface(Quux) {
+#     ^^^^^^^^^ @keyword.type
+        # At one time this failed to compile.
+        call @0 () -> ();
+#       ^^^^ @function.method
+#                  ^^ @punctuation.delimiter
+      }
+    }
+  }
+
+  interface Interface(Qux) {
+    call @0 Inner2(Text) -> (qux :Qux, gen :TestGenerics(TestAllTypes, TestAnyPointer));
+#                            ^^^ @variable.parameter
+#                                      ^^^ @variable.parameter
+  }
+
+  annotation ann(struct) :Foo;
+# ^^^^^^^^^^ @keyword.type
+#            ^^^ @function.method
+#                ^^^^^^ @variable.parameter.builtin
+
+  using AliasFoo = Foo;
+  using AliasInner = Inner;
+  using AliasInner2 = Inner2;
+  using AliasInner2Text = Inner2(Text);
+  using AliasRev = TestGenerics(Bar, Foo);
+
+  struct UseAliases {
+    foo @0 :AliasFoo;
+    inner @1 :AliasInner;
+    inner2 @2 :AliasInner2;
+    inner2Bind @3 :AliasInner2(Text);
+    inner2Text @4 :AliasInner2Text;
+    revFoo @5 :AliasRev.AliasFoo;
+  }
+}
+
+struct BoxedText { text @0 :Text; }
+using BrandedAlias = TestGenerics(BoxedText, Text);
+
+struct TestGenericsWrapper(Foo, Bar) {
+  value @0 :TestGenerics(Foo, Bar);
+}
+
+struct TestGenericsWrapper2 {
+  value @0 :TestGenericsWrapper(Text, TestAllTypes);
+}
+
+interface TestImplicitMethodParams {
+  call @0 [T, U] (foo :T, bar :U) -> TestGenerics(T, U);
+#          ^ @type
+#                      ^ @type
+}
+
+interface TestImplicitMethodParamsInGeneric(V) {
+  call @0 [T, U] (foo :T, bar :U) -> TestGenerics(T, U);
+}
+
+struct TestGenericsUnion(Foo, Bar) {
+  # At one point this failed to compile.
+
+  union {
+    foo @0 :Foo;
+    bar @1 :Bar;
+  }
+}
+
+struct TestUseGenerics $TestGenerics(Text, Data).ann("foo") {
+#                      ^ @punctuation.special
+#                       ^^^^^^^^^^^^ @attribute
+#                                               ^ @punctuation.delimiter
+#                                                ^^^ @attribute
+  basic @0 :TestGenerics(TestAllTypes, TestAnyPointer);
+  inner @1 :TestGenerics(TestAllTypes, TestAnyPointer).Inner;
+  inner2 @2 :TestGenerics(TestAllTypes, TestAnyPointer).Inner2(Text);
+  unspecified @3 :TestGenerics;
+  unspecifiedInner @4 :TestGenerics.Inner2(Text);
+  wrapper @8 :TestGenericsWrapper(TestAllTypes, TestAnyPointer);
+  cap @18 :TestGenerics(TestInterface, Text);
+  genericCap @19 :TestGenerics(TestAllTypes, List(UInt32)).Interface(Data);
+
+  default @5 :TestGenerics(TestAllTypes, Text) =
+      (foo = (int16Field = 123), rev = (foo = "text", rev = (foo = (int16Field = 321))));
+  defaultInner @6 :TestGenerics(TestAllTypes, Text).Inner =
+      (foo = (int16Field = 123), bar = "text");
+  defaultUser @7 :TestUseGenerics = (basic = (foo = (int16Field = 123)));
+  defaultWrapper @9 :TestGenericsWrapper(Text, TestAllTypes) =
+      (value = (foo = "text", rev = (foo = (int16Field = 321))));
+  defaultWrapper2 @10 :TestGenericsWrapper2 =
+      (value = (value = (foo = "text", rev = (foo = (int16Field = 321)))));
+
+  aliasFoo @11 :TestGenerics(TestAllTypes, TestAnyPointer).AliasFoo = (int16Field = 123);
+  aliasInner @12 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner
+      = (foo = (int16Field = 123));
+  aliasInner2 @13 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner2
+      = (innerBound = (foo = (int16Field = 123)));
+  aliasInner2Bind @14 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner2(List(UInt32))
+      = (baz = [12, 34], innerBound = (foo = (int16Field = 123)));
+  aliasInner2Text @15 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner2Text
+      = (baz = "text", innerBound = (foo = (int16Field = 123)));
+  aliasRev @16 :TestGenerics(TestAnyPointer, Text).AliasRev.AliasFoo = "text";
+
+  useAliases @17 :TestGenerics(TestAllTypes, List(UInt32)).UseAliases = (
+      foo = (int16Field = 123),
+      inner = (foo = (int16Field = 123)),
+      inner2 = (innerBound = (foo = (int16Field = 123))),
+      inner2Bind = (baz = "text", innerBound = (foo = (int16Field = 123))),
+      inner2Text = (baz = "text", innerBound = (foo = (int16Field = 123))),
+      revFoo = [12, 34, 56]);
+}
+
+struct TestEmptyStruct {}
+
+struct TestConstants {
+  const voidConst      :Void    = void;
+# ^^^^^ @keyword.modifier
+  const boolConst      :Bool    = true;
+  const int8Const      :Int8    = -123;
+  const int16Const     :Int16   = -12345;
+  const int32Const     :Int32   = -12345678;
+  const int64Const     :Int64   = -123456789012345;
+  const uint8Const     :UInt8   = 234;
+  const uint16Const    :UInt16  = 45678;
+  const uint32Const    :UInt32  = 3456789012;
+  const uint64Const    :UInt64  = 12345678901234567890;
+  const float32Const   :Float32 = 1234.5;
+  const float64Const   :Float64 = -123e45;
+  const textConst      :Text    = "foo";
+  const dataConst      :Data    = "bar";
+  const structConst    :TestAllTypes = (
+      voidField      = void,
+      boolField      = true,
+      int8Field      = -12,
+      int16Field     = 3456,
+      int32Field     = -78901234,
+      int64Field     = 56789012345678,
+      uInt8Field     = 90,
+      uInt16Field    = 1234,
+      uInt32Field    = 56789012,
+      uInt64Field    = 345678901234567890,
+      float32Field   = -1.25e-10,
+      float64Field   = 345,
+      textField      = "baz",
+      dataField      = "qux",
+      structField    = (
+          textField = "nested",
+          structField = (textField = "really nested")),
+      enumField      = baz,
+      # interfaceField can't have a default
+
+      voidList      = [void, void, void],
+      boolList      = [false, true, false, true, true],
+      int8List      = [12, -34, -0x80, 0x7f],
+      int16List     = [1234, -5678, -0x8000, 0x7fff],
+      int32List     = [12345678, -90123456, -0x80000000, 0x7fffffff],
+      int64List     = [123456789012345, -678901234567890, -0x8000000000000000, 0x7fffffffffffffff],
+      uInt8List     = [12, 34, 0, 0xff],
+      uInt16List    = [1234, 5678, 0, 0xffff],
+      uInt32List    = [12345678, 90123456, 0, 0xffffffff],
+      uInt64List    = [123456789012345, 678901234567890, 0, 0xffffffffffffffff],
+      float32List   = [0, 1234567, 1e37, -1e37, 1e-37, -1e-37],
+      float64List   = [0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306],
+      textList      = ["quux", "corge", "grault"],
+      dataList      = ["garply", "waldo", "fred"],
+      structList    = [
+          (textField = "x " "structlist"
+                       " 1"),
+          (textField = "x structlist 2"),
+          (textField = "x structlist 3")],
+      enumList      = [qux, bar, grault]
+      # interfaceList can't have a default
+      );
+  const enumConst      :TestEnum = corge;
+
+  const voidListConst      :List(Void)    = [void, void, void, void, void, void];
+  const boolListConst      :List(Bool)    = [true, false, false, true];
+  const int8ListConst      :List(Int8)    = [111, -111];
+  const int16ListConst     :List(Int16)   = [11111, -11111];
+  const int32ListConst     :List(Int32)   = [111111111, -111111111];
+  const int64ListConst     :List(Int64)   = [1111111111111111111, -1111111111111111111];
+  const uint8ListConst     :List(UInt8)   = [111, 222] ;
+  const uint16ListConst    :List(UInt16)  = [33333, 44444];
+  const uint32ListConst    :List(UInt32)  = [3333333333];
+  const uint64ListConst    :List(UInt64)  = [11111111111111111111];
+  const float32ListConst   :List(Float32) = [5555.5, inf, -inf, nan];
+  const float64ListConst   :List(Float64) = [7777.75, inf, -inf, nan];
+  const textListConst      :List(Text)    = ["plugh", "xyzzy", "thud"];
+  const dataListConst      :List(Data)    = ["oops", "exhausted", "rfc3092"];
+  const structListConst    :List(TestAllTypes) = [
+      (textField = "structlist 1"),
+      (textField = "structlist 2"),
+      (textField = "structlist 3")];
+  const enumListConst      :List(TestEnum) = [foo, garply];
+}
+
+const globalInt :UInt32 = 12345;
+const globalText :Text = "foobar";
+const globalStruct :TestAllTypes = (int32Field = 54321);
+const globalPrintableStruct :TestPrintInlineStructs = (someText = "foo");
+const derivedConstant :TestAllTypes = (
+    uInt32Field = .globalInt,
+    textField = TestConstants.textConst,
+    structField = TestConstants.structConst,
+    int16List = TestConstants.int16ListConst,
+    structList = TestConstants.structListConst);
+
+const genericConstant :TestGenerics(TestAllTypes, Text) =
+    (foo = (int16Field = 123), rev = (foo = "text", rev = (foo = (int16Field = 321))));
+
+const embeddedData :Data = embed "testdata/packed";
+#                          ^^^^^ @keyword.import
+const embeddedText :Text = embed "testdata/short.txt";
+const embeddedStruct :TestAllTypes = embed "testdata/binary";
+
+const nonAsciiText :Text = "♫ é ✓";
+
+const blockText :Text =
+    `foo bar baz
+    `"qux" `corge` 'grault'
+    "regular\"quoted\"line"
+    `garply\nwaldo\tfred\"plugh\"xyzzy\'thud
+    ;
+
+struct TestAnyPointerConstants {
+  anyKindAsStruct @0 :AnyPointer;
+  anyStructAsStruct @1 :AnyStruct;
+  anyKindAsList @2 :AnyPointer;
+  anyListAsList @3 :AnyList;
+}
+
+const anyPointerConstants :TestAnyPointerConstants = (
+  anyKindAsStruct = TestConstants.structConst,
+  anyStructAsStruct = TestConstants.structConst,
+  anyKindAsList = TestConstants.int32ListConst,
+  anyListAsList = TestConstants.int32ListConst,
+);
+
+interface TestInterface {
+  foo @0 (i :UInt32, j :Bool) -> (x :Text);
+#                                 ^ @variable.parameter
+  bar @1 () -> ();
+  baz @2 (s: TestAllTypes);
+}
+
+interface TestExtends extends(TestInterface) {
+#                     ^^^^^^^ @keyword
+  qux @0 ();
+  corge @1 TestAllTypes -> ();
+  grault @2 () -> TestAllTypes;
+}
+
+interface TestTailCallee $Cxx.allowCancellation {
+  struct TailResult {
+    i @0 :UInt32;
+    t @1 :Text;
+    c @2 :TestCallOrder;
+  }
+
+  foo @0 (i :Int32, t :Text) -> TailResult;
+}
+
+interface TestTailCaller {
+  foo @0 (i :Int32, callee :TestTailCallee) -> TestTailCallee.TailResult;
+}
+
+interface TestStreaming $Cxx.allowCancellation {
+  doStreamI @0 (i :UInt32) -> stream;
+  doStreamJ @1 (j :UInt32) -> stream;
+  finishStream @2 () -> (totalI :UInt32, totalJ :UInt32);
+  # Test streaming. finishStream() returns the totals of the values streamed to the other calls.
+}
+
+interface TestHandle {}
+
+interface TestMoreStuff extends(TestCallOrder) {
+  # Catch-all type that contains lots of testing methods.
+
+  callFoo @0 (cap :TestInterface) -> (s: Text);
+  # Call `cap.foo()`, check the result, and return "bar".
+
+  callFooWhenResolved @1 (cap :TestInterface) -> (s: Text);
+  # Like callFoo but waits for `cap` to resolve first.
+
+  neverReturn @2 (cap :TestInterface) -> (capCopy :TestInterface) $Cxx.allowCancellation;
+  # Doesn't return.  You should cancel it.
+
+  hold @3 (cap :TestInterface) -> ();
+  # Returns immediately but holds on to the capability.
+
+  callHeld @4 () -> (s: Text);
+  # Calls the capability previously held using `hold` (and keeps holding it).
+
+  getHeld @5 () -> (cap :TestInterface);
+  # Returns the capability previously held using `hold` (and keeps holding it).
+
+  echo @6 (cap :TestCallOrder) -> (cap :TestCallOrder);
+  # Just returns the input cap.
+
+  expectCancel @7 (cap :TestInterface) -> () $Cxx.allowCancellation;
+  # evalLater()-loops forever, holding `cap`.  Must be canceled.
+
+  methodWithDefaults @8 (a :Text, b :UInt32 = 123, c :Text = "foo") -> (d :Text, e :Text = "bar");
+
+  methodWithNullDefault @12 (a :Text, b :TestInterface = null);
+
+  getHandle @9 () -> (handle :TestHandle);
+  # Get a new handle. Tests have an out-of-band way to check the current number of live handles, so
+  # this can be used to test garbage collection.
+
+  getNull @10 () -> (nullCap :TestMoreStuff);
+  # Always returns a null capability.
+
+  getEnormousString @11 () -> (str :Text);
+  # Attempts to return an 100MB string. Should always fail.
+
+  writeToFd @13 (fdCap1 :TestInterface, fdCap2 :TestInterface)
+             -> (fdCap3 :TestInterface, secondFdPresent :Bool);
+  # Expects fdCap1 and fdCap2 wrap socket file descriptors. Writes "foo" to the first and "bar" to
+  # the second. Also creates a socketpair, writes "baz" to one end, and returns the other end.
+
+  throwException @14 ();
+  throwRemoteException @15 ();
+}
+
+interface TestMembrane {
+  makeThing @0 () -> (thing :Thing);
+  callPassThrough @1 (thing :Thing, tailCall :Bool) -> Result;
+  callIntercept @2 (thing :Thing, tailCall :Bool) -> Result;
+  loopback @3 (thing :Thing) -> (thing :Thing);
+
+  waitForever @4 () $Cxx.allowCancellation;
+
+  interface Thing {
+    passThrough @0 () -> Result;
+    intercept @1 () -> Result;
+  }
+
+  struct Result {
+    text @0 :Text;
+  }
+}
+
+struct TestNameAnnotation $Cxx.name("RenamedStruct") {
+  union {
+    badFieldName @0 :Bool $Cxx.name("goodFieldName");
+    bar @1 :Int8;
+  }
+
+  enum BadlyNamedEnum $Cxx.name("RenamedEnum") {
+    foo @0;
+    bar @1;
+    baz @2 $Cxx.name("qux");
+  }
+
+  anotherBadFieldName @2 :BadlyNamedEnum $Cxx.name("anotherGoodFieldName");
+
+  struct NestedStruct $Cxx.name("RenamedNestedStruct") {
+    badNestedFieldName @0 :Bool $Cxx.name("goodNestedFieldName");
+    anotherBadNestedFieldName @1 :NestedStruct $Cxx.name("anotherGoodNestedFieldName");
+
+    enum DeeplyNestedEnum $Cxx.name("RenamedDeeplyNestedEnum") {
+      quux @0;
+      corge @1;
+      grault @2 $Cxx.name("garply");
+    }
+  }
+
+  badlyNamedUnion :union $Cxx.name("renamedUnion") {
+    badlyNamedGroup :group $Cxx.name("renamedGroup") {
+      foo @3 :Void;
+      bar @4 :Void;
+    }
+    baz @5 :NestedStruct $Cxx.name("qux");
+  }
+}
+
+interface TestNameAnnotationInterface $Cxx.name("RenamedInterface") {
+  badlyNamedMethod @0 (badlyNamedParam :UInt8 $Cxx.name("renamedParam")) $Cxx.name("renamedMethod");
+}
+
+struct TestImpliedFirstField {
+  struct TextStruct {
+    text @0 :Text;
+    i @1 :UInt32 = 321;
+  }
+
+  textStruct @0 :TextStruct = "foo";
+  textStructList @1 :List(TextStruct);
+
+  intGroup :group {
+    i @2 :UInt32;
+    str @3 :Text = "corge";
+  }
+}
+
+const testImpliedFirstField :TestImpliedFirstField = (
+  textStruct = "bar",
+  textStructList = ["baz", (text = "qux", i = 123)],
+  intGroup = 123
+);
+
+struct TestCycleANoCaps {
+  foo @0 :TestCycleBNoCaps;
+}
+
+struct TestCycleBNoCaps {
+  foo @0 :List(TestCycleANoCaps);
+  bar @1 :TestAllTypes;
+}
+
+struct TestCycleAWithCaps {
+  foo @0 :TestCycleBWithCaps;
+}
+
+struct TestCycleBWithCaps {
+  foo @0 :List(TestCycleAWithCaps);
+  bar @1 :TestInterface;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/clojure/test.clj b/pack/ant/start/nvim-treesitter/tests/query/highlights/clojure/test.clj
new file mode 100644
index 0000000..7401019
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/clojure/test.clj
@@ -0,0 +1,114 @@
+(ns test {:clj-kondo/ignore true})
+; <- @punctuation.bracket
+; ^ @keyword.import
+;    ^ @module
+
+ ; asdf
+;^^^^^^ @comment
+
+ #_ abc
+;^^^^^^ @comment
+
+(func obj)
+;^^^^ @function.call
+;     ^^^ @variable
+
+ #(+ % %1 %& %a)
+;^ @punctuation.special
+;  ^ @function.call
+;    ^ ^^ ^^ @variable.builtin
+;            ^^ @variable
+
+ abc#
+;^^^^ @variable
+
+ &
+;^ @variable.parameter
+
+ ->abc
+;^^^^^ @constructor
+
+ ->>abc
+;^^^^^^ @variable
+
+ *1 *2 *3 *e
+;^^ ^^ ^^ ^^ @variable.builtin
+
+ .method
+;^^^^^^^ @function.method
+
+(.method foo)
+;^^^^^^^ @function.method
+
+(.-field foo)
+;^^^^^^^ @variable.member
+
+ Abc/member
+;^^^^^^^^^^ @variable.member
+
+(Abc/method)
+;^^^^^^^^^^ @function.method
+
+ Abc
+;^^^ @type
+
+ abc.
+;^^^^ @type
+
+ ^abc
+;^ @punctuation.special
+
+^java.io.File file
+; <- @punctuation.special
+;^^^^^^^^^^^^ @type
+;             ^^^^ @variable
+
+^java.io.File java.io.File.
+; <- @punctuation.special
+;^^^^^^^^^^^^ @type
+;             ^^^^ @variable
+
+^java.io.File file.
+; <- @punctuation.special
+;^^^^^^^^^^^^ @type
+;             ^^^^ @variable
+
+(^java.io.File file)
+;^ @punctuation.special
+; ^^^^^^^^^^^^ @type
+;              ^^^^ @function.call
+
+(^java.io.File .file foo)
+;^ @punctuation.special
+; ^^^^^^^^^^^^ @type
+;              ^^^^ @function.method
+;                    ^^^@variable
+
+(^java.io.File .-file foo)
+;^ @punctuation.special
+; ^^^^^^^^^^^^ @type
+;              ^^^^ @variable.member
+;                     ^^^@variable
+
+(^java.io.File Abc/method foo)
+;^ @punctuation.special
+; ^^^^^^^^^^^^ @type
+;              ^^^^^^^^^^ @function.method
+;                         ^^^ @variable
+
+ (defn foo [arg1] (+ arg1 1))
+;^         ^    ^ ^        ^^ @punctuation.bracket
+; ^^^^ @keyword.function
+;      ^^^ @function
+;           ^^^^     ^^^^ @variable
+;                  ^ @operator
+;                         ^ @number
+
+ clojure.core/dfn
+;^^^^^^^^^^^^^^^^ @variable
+
+ clojure.core/defn
+;^^^^^^^^^^^^^^^^ @keyword.function
+
+ any-ns/defn
+;^^^^^^^^^^^ @keyword.function
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/cpp/concepts.cpp b/pack/ant/start/nvim-treesitter/tests/query/highlights/cpp/concepts.cpp
new file mode 100644
index 0000000..3189813
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/cpp/concepts.cpp
@@ -0,0 +1,22 @@
+
+template <class T, class U>
+concept Derived = std::is_base_of<U, T>::value;
+//  ^ @keyword.type
+//       ^ @type.definition
+
+template<typename T>
+concept Hashable = requires(T a) {
+//                   ^ @keyword
+//                            ^ @variable.parameter
+//                          ^ @type
+    { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
+ typename CommonType<T, U>; // CommonType<T, U> is valid and names a type
+    { CommonType<T, U>{std::forward<T>(t)} }; 
+    { CommonType<T, U>{std::forward<U>(u)} }; 
+};
+
+
+template<typename T>
+    requires requires (T x) { x + x; } // ad-hoc constraint, note keyword used twice
+//                 ^ @keyword
+T add(T a, T b) { return a + b; }
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/cpp/enums-as-constants.cpp b/pack/ant/start/nvim-treesitter/tests/query/highlights/cpp/enums-as-constants.cpp
new file mode 100644
index 0000000..d6b93d5
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/cpp/enums-as-constants.cpp
@@ -0,0 +1,25 @@
+enum class Foo{
+    a,
+//  ^ @constant
+    aa,
+//  ^ @constant
+    C,
+//  ^ @constant
+};
+
+void foo(Foo f){
+    switch ( f ) {
+        case Foo::a:
+         //  ^ @type
+         //   ^ @module
+         //       ^ @constant
+            break;
+        case Foo::aa:
+         //        ^ @constant
+            break;
+        case Foo::C:
+         //       ^ @constant
+            break;
+        default:
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/cpp/static-namespace-functions.cpp b/pack/ant/start/nvim-treesitter/tests/query/highlights/cpp/static-namespace-functions.cpp
new file mode 100644
index 0000000..3d16c43
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/cpp/static-namespace-functions.cpp
@@ -0,0 +1,14 @@
+// Issue #2396
+
+int main()
+{
+  B::foo();
+  //  ^ @function.call
+  Foo::A::foo();
+  //       ^ @function.call
+  Foo::a::A::foo();
+  //          ^ @function.call
+  Foo::a::A::B::foo();
+  //             ^ @function.call
+  return 0;
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/cpp/test.cpp b/pack/ant/start/nvim-treesitter/tests/query/highlights/cpp/test.cpp
new file mode 100644
index 0000000..4a4c623
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/cpp/test.cpp
@@ -0,0 +1,19 @@
+#include <iostream>
+#include <cstdlib>
+//    ^ @keyword.import
+//       ^ @string
+
+auto main( int argc, char** argv ) -> int
+// ^ @type.builtin
+      //       ^ @variable.parameter
+      //    ^ @type.builtin
+      //    ^ @type.builtin
+      //                  ^ @operator
+{
+    std::cout << "Hello world!" << std::endl;
+    //  ^ @punctuation.delimiter
+    
+    return EXIT_SUCCESS;
+    // ^ @keyword.return
+    //      ^ @constant
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/ecma/const.js b/pack/ant/start/nvim-treesitter/tests/query/highlights/ecma/const.js
new file mode 100644
index 0000000..2b778fd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/ecma/const.js
@@ -0,0 +1,13 @@
+_FOO = 4
+// <- @constant
+__A__ = 2
+// <- @constant
+_ = 2
+// <- @variable
+A_B_C = 4
+// <- @constant
+_1 = 1
+// <- @variable
+
+const A = 2
+//    ^ @constant
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/ecma/test.ts b/pack/ant/start/nvim-treesitter/tests/query/highlights/ecma/test.ts
new file mode 100644
index 0000000..fa926f9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/ecma/test.ts
@@ -0,0 +1,32 @@
+class H {
+  pub_field = "Hello";
+  //  ^ @variable.member
+
+  #priv_field = "World!";
+  //   ^ @variable.member
+
+  #private_method() {
+    //  ^ @function.method
+    return `${this.pub_field} -- ${this.#priv_field}`;
+    //                                      ^ @variable.member
+    //                ^ @variable.member
+  }
+
+  public_method() {
+    //  ^ @function.method
+    return this.#private_method();
+    //                ^ @function.method.call
+  }
+
+  ok() {
+    return this.public_method();
+    //                ^ @function.method.call
+  }
+}
+
+function doSomething(options) {
+  const {
+    enable: on,
+    //    ^ @punctuation.delimiter
+  } = options
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/fusion/afx.fusion b/pack/ant/start/nvim-treesitter/tests/query/highlights/fusion/afx.fusion
new file mode 100644
index 0000000..4ccb817
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/fusion/afx.fusion
@@ -0,0 +1,17 @@
+property = afx`
+  <!-- some comment -->
+<!--   ^@comment -->
+
+  <div attribute="value">text</div>
+<!-- ^@tag -->
+<!--   ^@tag.attribute -->
+<!--              ^@string -->
+<!--                         ^@punctuation.bracket -->
+<!--                           ^@tag -->
+
+  <Namespace:Type {...spread} some={(a) => true} />
+<!-- ^@tag -->
+<!--                  ^@variable -->
+<!--                                 ^@variable -->
+<!--                                        ^@boolean -->
+`
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/fusion/basic.fusion b/pack/ant/start/nvim-treesitter/tests/query/highlights/fusion/basic.fusion
new file mode 100644
index 0000000..5f3cc34
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/fusion/basic.fusion
@@ -0,0 +1,60 @@
+include: SomeFile.fusion
+//<- @keyword.import
+//       ^ @string.special.url
+
+namespace: ns = Neos.Fusion.Space
+//<- @keyword.type
+//         ^ @module
+//            ^ @operator
+//              ^ @module
+
+prototype(MyType) < prototype(ns:SuperType) {
+//<-keyword
+//       ^ @punctuation.bracket
+//        ^ @type
+//              ^ @punctuation.bracket
+//                ^ @operator
+//                            ^ @module
+//                                ^ @type
+
+  deleteProp >
+  //         ^ @operator
+
+  string = 'value'
+  //<- @property
+  //     ^ @operator
+  //        ^ @string
+
+  number = 10.2
+  //       ^ @number
+
+  null = null
+  //     ^ @constant.builtin
+
+  boolean = true
+  //        ^ @boolean
+
+  property.inner = "value"
+  //<- @property
+  //       ^ @property
+
+  property.@meta = "value"
+  //<- @property
+  //       ^ @attribute
+
+  property.type = SomeType
+  //<- @property
+  //              ^ @type
+
+  property.aliasedType = ns:SomeType
+  //<- @property
+  //                     ^ @module
+  //                        ^ @type
+
+  property.fullQualifiedType = SomeNamespace:SomeType
+  //<- @property
+  //                           ^ @module
+  //                                         ^ @type
+
+}
+
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/fusion/expressions.fusion b/pack/ant/start/nvim-treesitter/tests/query/highlights/fusion/expressions.fusion
new file mode 100644
index 0000000..b1822dd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/fusion/expressions.fusion
@@ -0,0 +1,82 @@
+string = ${'foo'}
+//          ^string
+
+string = ${'foo \'bar\' baz'}
+//                ^string
+
+string = ${"foo"}
+//          ^string
+
+string = ${"foo ${test}"}
+//               ^string
+
+boolean = ${true}
+//          ^boolean
+
+number = ${1}
+//         ^number
+
+number = ${1.2}
+//         ^number
+
+propertyPath = ${property.path}
+//               ^variable
+//                        ^variable
+
+thisorProps = ${this.path}
+//              ^variable.builtin
+//                   ^variable
+
+thisorProps = ${props.path}
+//              ^variable.builtin
+//                    ^variable
+
+array = ${[]}
+//        ^punctuation.bracket
+
+array = ${[true, 'string', 1, [true]]}
+//        ^punctuation.bracket
+//         ^boolean
+//                ^string
+//                         ^number
+//                            ^punctuation.bracket
+//                             ^boolean
+
+object = ${{}}
+//         ^punctuation.bracket
+
+object = ${{first: 'value', second: true, third: [], fourth: object.path }}
+//          ^property
+//                  ^string
+//                          ^property
+//                                  ^boolean
+//                                        ^property
+//                                               ^punctuation.bracket
+//                                                   ^property
+//                                                                  ^variable
+
+result = ${methodCall()}
+//         ^function
+
+result = ${Some.methodCall(param, param)}
+//              ^function
+//                         ^variable
+//                                ^variable
+
+arrowFunction =  ${map(foo, (bar, buz) => bar * buz)}
+//                 ^function
+//                           ^variable
+//                                ^variable
+
+logic = ${!foo && !(bar || baz) and not 'string'}
+//        ^operator
+//             ^operator
+//                ^operator
+//                      ^operator
+//                              ^operator
+
+ternary = ${ check ? true : false}
+//                 ^@keyword.conditional.ternary
+//                        ^@keyword.conditional.ternary
+
+
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/gitattributes/test.gitattributes b/pack/ant/start/nvim-treesitter/tests/query/highlights/gitattributes/test.gitattributes
new file mode 100644
index 0000000..4595b94
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/gitattributes/test.gitattributes
@@ -0,0 +1,37 @@
+[attr]nodiff -diff -merge
+# <- @keyword.directive
+#     ^^^^^^ @property
+#            ^ @operator
+#             ^^^^ @variable.builtin
+#                  ^ @operator
+#                   ^^^^^ @variable.builtin
+
+vendor/** linguist-vendored=true
+#     ^ @punctuation.delimiter
+#      ^^ @character.special
+#         ^^^^^^^^^^^^^^^^^ @variable.parameter
+#                          ^ @operator
+#                           ^^^^ @boolean
+
+  [^._]-[[:lower:]] !something
+# ^ @punctuation.bracket
+#  ^ @operator
+#   ^^ @string.special
+#     ^ @punctuation.bracket
+#       ^ @punctuation.bracket
+#        ^^^^^^^^^ @constant
+#                 ^ @punctuation.bracket
+#                   ^ @operator
+#                    ^^^^^^^^^^ @variable.parameter
+
+"_\u4E00\t\56txt" encoding=UTF-16
+# <- @punctuation.special
+# ^^^^^^ @string.escape
+#       ^^ @string.escape
+#         ^^^ @string.escape
+#               ^ @punctuation.special
+#                 ^^^^^^^^ @variable.builtin
+#                         ^ @operator
+#                          ^^^^^^ @string
+
+# vim:ft=gitattributes:
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/assert.gleam b/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/assert.gleam
new file mode 100644
index 0000000..8be3992
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/assert.gleam
@@ -0,0 +1,13 @@
+pub fn main() {
+  assert Ok(i) = parse_int("123")
+  // <- @keyword.exception
+  //     ^^ @constructor
+  //       ^ @punctuation.bracket
+  //        ^ @variable
+  //         ^ @punctuation.bracket
+  //           ^ @operator
+  //             ^^^^^^^^^ @function.call
+  //                      ^ @punctuation.bracket
+  //                       ^^^^^ @string
+  //                            ^ @punctuation.bracket
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/function.gleam b/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/function.gleam
new file mode 100644
index 0000000..15fc5cc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/function.gleam
@@ -0,0 +1,127 @@
+pub fn add(x: Int, y: Int) -> Int {
+// <- @keyword.modifier
+//  ^^ @keyword.function
+//     ^^^ @function
+//        ^ @punctuation.bracket
+//         ^ @variable.parameter
+//          ^ @punctuation.delimiter
+//            ^^^ @type
+//               ^ @punctuation.delimiter
+//                 ^ @variable.parameter
+//                  ^ @punctuation.delimiter
+//                    ^^^ @type
+//                       ^ @punctuation.bracket
+//                         ^ @punctuation.delimiter
+//                            ^^^ @type
+//                                ^ @punctuation.bracket
+}
+// <- @punctuation.bracket
+
+pub fn twice(f: fn(t) -> t, x: t) -> t {
+// <- @keyword.modifier
+//  ^ @keyword.function
+//     ^^^^^ @function
+//          ^ @punctuation.bracket
+//           ^ @variable.parameter
+//            ^ @punctuation.delimiter
+//              ^^ @keyword.function
+//                ^ @punctuation.bracket
+//                 ^ @type
+//                  ^ @punctuation.bracket
+//                    ^^ @punctuation.delimiter
+//                       ^ @type
+//                        ^ @punctuation.delimiter
+//                          ^ @variable.parameter
+//                           ^ @punctuation.delimiter
+//                             ^ @type
+//                              ^ @punctuation.bracket
+//                                ^^ @punctuation.delimiter
+//                                   ^ @type
+//                                     ^ @punctuation.bracket
+}
+// <- @punctuation.bracket
+
+fn list_of_two(my_value: a) -> List(a) {
+// <- @keyword.function
+// ^ @function
+//            ^ @punctuation.bracket
+//             ^ @variable.parameter
+//                     ^ @punctuation.delimiter
+//                       ^ @type
+//                        ^ @punctuation.bracket
+//                          ^ @punctuation.delimiter
+//                             ^^^^ @type
+//                                 ^ @punctuation.bracket
+//                                  ^ @type
+//                                   ^ @punctuation.bracket
+//                                     ^ @punctuation.bracket
+}
+// <- @punctuation.bracket
+
+fn replace(
+// <- @keyword.function
+// ^^^^^^^ @function
+//        ^ @punctuation.bracket
+  in string: String,
+  // <- @label
+  // ^^^^^^ @variable.parameter
+  //       ^ @punctuation.delimiter
+  //         ^^^^^^ @type
+  //               ^ @punctuation.delimiter
+  each pattern: String,
+  // <- @label
+  //   ^^^^^^^ @variable.parameter
+  //          ^ @punctuation.delimiter
+  //            ^^^^^^ @type
+  //                  ^ @punctuation.delimiter
+  with replacement: String,
+  // <- @label
+  //   ^^^^^^^^^^^ @variable.parameter
+  //              ^ @punctuation.delimiter
+  //                ^^^^^^ @type
+  //                      ^ @punctuation.delimiter
+) {
+  replace(in: "A,B,C", each: ",", with: " ")
+  // <- @function.call
+  //     ^ @punctuation.bracket
+  //      ^^ @label
+  //        ^ @punctuation.delimiter
+  //          ^^^^^^^ @string
+  //                 ^ @punctuation.delimiter
+  //                   ^^^^ @label
+  //                       ^ @punctuation.delimiter
+  //                         ^^^ @string
+  //                            ^ @punctuation.delimiter
+  //                              ^^^^ @label
+  //                                  ^ @punctuation.delimiter
+  //                                    ^^^ @string
+  //                                       ^ @punctuation.bracket
+}
+// <- @punctuation.bracket
+
+pub external fn random_float() -> Float = "rand" "uniform"
+// <- @keyword.modifier
+//  ^^^^^^^^ @keyword.modifier
+//           ^^ @keyword.function
+//              ^^^^^^^^^^^^ @function
+//                          ^ @punctuation.bracket
+//                           ^ @punctuation.bracket
+//                             ^^ @punctuation.delimiter
+//                                ^^^^^ @type
+//                                      ^ @operator
+//                                        ^^^^^^ @module
+//                                               ^^^^^^^^^ @function
+
+pub external fn inspect(a) -> a = "Elixir.IO" "inspect"
+// <- @keyword.modifier
+//  ^^^^^^^^ @keyword.modifier
+//           ^^ @keyword.function
+//              ^^^^^^^ @function
+//                     ^ @punctuation.bracket
+//                      ^ @type
+//                       ^ @punctuation.bracket
+//                         ^^ @punctuation.delimiter
+//                            ^ @type
+//                              ^ @operator
+//                                ^^^^^^^^^^^ @module
+//                                            ^^^^^^^^^ @function
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/import.gleam b/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/import.gleam
new file mode 100644
index 0000000..ac452d1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/import.gleam
@@ -0,0 +1,22 @@
+import gleam/io
+// <- @keyword.import
+//     ^ @module
+//          ^ @operator
+//           ^ @module
+
+import cat as kitten
+// <- @keyword.import
+//     ^ @module
+//         ^ @keyword
+//            ^ @module
+
+import animal/cat.{Cat, stroke}
+// <- @keyword.import
+//     ^ @module
+//           ^ @operator
+//               ^ @punctuation.delimiter
+//                ^ @punctuation.bracket
+//                 ^^^ @type
+//                    ^ @punctuation.delimiter
+//                      ^^^^^^ @function
+//                            ^ @punctuation.bracket
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/pipe.gleam b/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/pipe.gleam
new file mode 100644
index 0000000..c696b02
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/pipe.gleam
@@ -0,0 +1,18 @@
+pub fn run() {
+  1
+  // <- @number
+  |> add(_, 2)
+  // <- @operator
+  // ^^^ @function.call
+  //    ^ @punctuation.bracket
+  //     ^ @comment
+  //      ^ @punctuation.delimiter
+  //        ^ @number
+  //         ^ @punctuation.bracket
+  |> add(3)
+  // <- @operator
+  // ^^^ @function.call
+  //    ^ @punctuation.bracket
+  //     ^ @number
+  //      ^ @punctuation.bracket
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/todo.gleam b/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/todo.gleam
new file mode 100644
index 0000000..b7384ec
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/todo.gleam
@@ -0,0 +1,7 @@
+fn favourite_number() -> Int {
+  todo("We're going to decide which number is best tomorrow")
+  // <- @keyword
+  //  ^ @punctuation.bracket
+  //   ^ @string
+  //                                                        ^ @punctuation.bracket
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/type.gleam b/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/type.gleam
new file mode 100644
index 0000000..5b0aa02
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/gleam/type.gleam
@@ -0,0 +1,84 @@
+pub type Cat {
+// <- @keyword.modifier
+//  ^^^^ @keyword.type
+//       ^^^ @type
+//           ^ @punctuation.bracket
+  Cat(name: String, cuteness: Int)
+  // <- @constructor
+  // ^ @punctuation.bracket
+  //  ^^^^ @variable.member
+  //      ^ @punctuation.delimiter
+  //        ^^^^^^ @type
+  //              ^ @punctuation.delimiter
+  //                ^^^^^^^^ @variable.member
+  //                        ^ @punctuation.delimiter
+  //                          ^^^ @type
+  //                             ^ @punctuation.bracket
+}
+
+fn cats() {
+  Cat(name: "Nubi", cuteness: 2001)
+  // <- @type
+  // ^ @punctuation.bracket
+  //  ^^^^ @variable.member
+  //      ^ @punctuation.delimiter
+  //        ^^^^^^ @string
+  //              ^ @punctuation.delimiter
+  //                ^^^^^^^^ @variable.member
+  //                        ^ @punctuation.delimiter
+  //                          ^^^^ @number
+  //                              ^ @punctuation.bracket
+  Cat("Ginny", 1950)
+  // <- @constructor
+  // ^ @punctuation.bracket
+  //  ^^^^^^^ @string
+  //         ^ @punctuation.delimiter
+  //           ^^^^ @number
+  //               ^ @punctuation.bracket
+}
+
+type Box(inner_type) {
+// <- @keyword.type
+//   ^^^ @type
+//      ^ @punctuation.bracket
+//       ^^^^^^^^^^ @type
+//                 ^ @punctuation.bracket
+//                   ^ @punctuation.bracket
+  Box(inner: inner_type)
+  // <- @constructor
+  // ^ @punctuation.bracket
+  //  ^^^^^ @variable.member
+  //       ^ @punctuation.delimiter
+  //         ^^^^^^^^^^ @type
+  //                   ^ @punctuation.bracket
+}
+
+pub opaque type Counter {
+// <- @keyword.modifier
+//  ^^^^^^ @keyword.modifier
+//         ^^^^ @keyword.type
+//              ^^^^^^^ @type
+//                      ^ @punctuation.bracket
+  Counter(value: Int)
+}
+
+pub fn have_birthday(person) {
+  Person(..person, age: person.age + 1, is_happy: True)
+  // <- @constructor
+  //    ^ @punctuation.bracket
+  //     ^^ @operator
+  //       ^^^^^^ @variable
+  //             ^ @punctuation.delimiter
+  //               ^^^ @variable.member
+  //                  ^ @punctuation.delimiter
+  //                    ^^^^^^ @variable
+  //                          ^ @punctuation.delimiter
+  //                           ^^^ @variable.member
+  //                               ^ @operator
+  //                                 ^ @number
+  //                                  ^ @punctuation.delimiter
+  //                                    ^^^^^^^^ @variable.member
+  //                                            ^ @punctuation.delimiter
+  //                                              ^^^^ @boolean
+  //                                                  ^ @punctuation.bracket
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/as-foreach.hack b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/as-foreach.hack
new file mode 100644
index 0000000..6110271
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/as-foreach.hack
@@ -0,0 +1,6 @@
+foreach (($array as vec[]) as $item) {}
+// ^ @keyword.repeat
+//                   ^ @type
+
+# Our expectation test for the code below intentionally includes an ERROR.
+foreach ($array as vec[] as $item) {}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/async-functions.hack b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/async-functions.hack
new file mode 100644
index 0000000..41779d7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/async-functions.hack
@@ -0,0 +1,8 @@
+async function func0(): void {}
+//                        ^ @type.builtin
+async function func1<T1 as int>() {}
+//                         ^ @type.builtin
+//                      ^ @keyword.operator
+						
+
+async ($x) ==> $x + 1;
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/attribute-type.hack b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/attribute-type.hack
new file mode 100644
index 0000000..0bd12df
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/attribute-type.hack
@@ -0,0 +1,15 @@
+<<A1>>
+newtype T1 = ?shape(
+//     TODO: ?operator (? not captureable at the moment)
+  ?'int' => int
+//       ^ @operator
+);
+
+<<A3(1), A2(2,3,)>>
+//       ^ @attribute
+type T2 = (function(T1): string);
+//    ^ @type
+//          TODO: keyword.function (currently not in AST)
+
+<<A4(1), A5, A6(1,3,4)>>
+newtype T3 as int = int;
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/generics.hack b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/generics.hack
new file mode 100644
index 0000000..50bd50e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/generics.hack
@@ -0,0 +1,24 @@
+class Box<T> {
+  //      ^ @type
+  //   ^ @type
+  protected T $data;
+  // ^ @keyword.modifier
+  //        ^ @type
+
+  public function __construct(T $data) {
+  //                          ^ @type
+  //                             ^ @variable.parameter
+  //        ^ @keyword.function
+  // ^ @keyword.modifier
+  //                    ^ @function.method
+    $this->data = $data;
+  }
+
+  public function getData(): T {
+                // ^ @function.method
+  // ^ @keyword.modifier
+    return $this->data;
+              // ^ @operator
+          // ^ @variable.builtin
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/heredoc-dollar.hack b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/heredoc-dollar.hack
new file mode 100644
index 0000000..8ea2473
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/heredoc-dollar.hack
@@ -0,0 +1,4 @@
+<<<EOT
+	$('a') abc $(function{return;})
+EOT;
+// <- @comment      ^ @comment
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/shapes.hack b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/shapes.hack
new file mode 100644
index 0000000..f111689
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/shapes.hack
@@ -0,0 +1,12 @@
+class C extends Superclass implements Iface {
+//      ^ @keyword          ^ @keyword
+  use Trait;
+  // <- @keyword.import
+  const type X = shape(
+  // <- @keyword ^ @type.builtin
+    "a" => int,
+  // ^ @string
+    "b" => string,
+  //       ^ @type.builtin
+  );
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/use.hack b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/use.hack
new file mode 100644
index 0000000..ab17d11
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/use.hack
@@ -0,0 +1,28 @@
+use const Space\Const\C;
+//  ^ @keyword
+//                    ^ @constant
+use function Space\Func\F as E;
+//                           ^ @function
+//                      ^ @function
+use type Space\Type\T;
+//  ^ @keyword.type
+use namespace Space\Name\N as M;
+//  ^ @keyword.type
+//             ^ @module
+
+use namespace Space\Name2\N2, Space\Nothing\N3 as N8, type Space\Type2\N4,;
+//                        ^ @module
+//                                                                      ^ @type
+use namespace Space\Name\N10\{A as A2, B\};
+//                        ^ @module
+//                                     ^ @module
+//                                 ^ @module
+use namespace Space\Name\{\C, Slash as Forward};
+
+use \What\Is\This\{function A as A2, B, const H\S\L as stdlib, function F};
+
+use type \{kind,};
+use Q\B\{kind2,};
+//    ^ @module
+use type Q\B\{kind3,};
+// <- @keyword.import
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/using.hack b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/using.hack
new file mode 100644
index 0000000..c3a7be1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/using.hack
@@ -0,0 +1,3 @@
+using ($new = new Object(), $file = new File('using', '+using')) {}
+// <- @keyword
+//                                       ^ @type
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/xhp.hack b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/xhp.hack
new file mode 100644
index 0000000..57563a1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/hack/xhp.hack
@@ -0,0 +1,10 @@
+$user_name = 'Fred';
+echo "<tt>Hello <strong>$user_name</tt></strong>";
+
+// XHP: Typechecked, well-formed, and secure
+$user_name = 'Andrew';
+$xhp = <tt>Hello <strong>{$user_name}</strong></tt>;
+//       ^ @tag
+//                 ^ @tag
+//            ^ @string
+echo await $xhp->toStringAsync();
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/haskell/test.hs b/pack/ant/start/nvim-treesitter/tests/query/highlights/haskell/test.hs
new file mode 100644
index 0000000..f719981
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/haskell/test.hs
@@ -0,0 +1,343 @@
+{-# LANGUAGE QuasiQuotes #-}
+-- ^ @keyword.directive
+
+{-| Main module -}
+ -- ^ @comment.documentation
+module Main 
+-- ^ @keyword.import
+     -- ^ @module
+  ( main
+   -- ^ @variable
+  ) where
+   -- ^ @keyword
+
+import Prelude hiding (show)
+-- ^ @keyword.import
+      -- ^ @module
+              -- ^ @keyword
+                      -- ^ @variable
+import Data.Map (fromList)
+      -- ^ @module
+import qualified Data.Map as Map
+                -- ^ @module
+                           -- ^ @module
+import qualified Chronos
+                -- ^ @module
+import qualified Chronos as C
+                -- ^ @module
+                         -- ^ @module
+import FooMod (BarTy (barField))
+                      -- ^ @variable.member
+
+x = mempty { field = 5 }
+           -- ^ @variable.member
+
+data ADT
+-- ^ @keyword
+  = A Int
+ -- ^ @constructor
+    -- ^ @type
+  | B
+ -- ^ @constructor
+  deriving (Eq, Show)
+  -- ^ @keyword
+         -- ^ @type
+               -- ^ @type
+mkA x = A x
+       -- ^ @variable
+mkAQualified x = SomeModule.A x
+                           -- ^ @variable
+
+class Ord a => PartialOrd a
+    -- ^ @type
+       -- ^ @variable
+                -- ^ @type
+                       -- ^ @variable
+
+instance Ord ADT where
+      -- ^ @type
+          -- ^ @type
+
+newtype Rec
+-- ^ @keyword
+     -- ^ @type
+  = Rec
+  -- ^ @constructor
+    { field :: Double
+ -- ^ @punctuation.bracket
+    -- ^ @variable.member
+              -- ^ @type
+    }
+ -- ^ @punctuation.bracket
+    deriving Eq
+           -- ^ @type
+recordWildCard Rec { field } = field
+                    -- ^ @variable.member
+recordDotSyntax rec = rec.field
+                        -- ^ @variable.member
+
+
+main :: IO ()
+-- ^ @function
+  -- ^ @operator
+     -- ^ @type
+        -- ^ @type
+main = undefined
+-- ^ @function
+      -- ^ @keyword.exception
+
+someFunc0 :: Int -> Int
+              -- ^ @operator
+someFunc0 x = someFunc1 x
+       -- ^ @variable.parameter
+            -- ^ @function.call
+  where
+  -- ^ @keyword
+    someFunc1 _ = 5
+    -- ^ @function
+               -- ^ @number
+scopedTypeParam (x :: Int) = someFunc x
+              -- ^ @variable.parameter
+                   -- ^ @type
+scopedTypeParam (Just x :: Int) = someFunc x
+              -- ^ @constructor
+                   -- ^ @variable.parameter
+                         -- ^ @type
+scopedTypeParam (f :: Int -> Int) = someFunc x
+              -- ^ @function
+
+someInfix :: Integral a => a -> Double
+            -- ^ @type
+                   -- ^ @variable
+                      -- ^ @operator
+                        -- ^ @variable
+                              -- ^ @type
+someInfix x = fromIntegral x `myAdd` floatVal
+                -- ^ @function.call
+                        -- ^ @variable
+                             -- ^ @operator
+                                    -- ^ @variable
+  where
+    myAdd :: Num a => a -> a
+    -- ^ @function
+    myAdd x y = x + y
+             -- ^ @variable
+                 -- ^ @variable
+    floatVal :: Double
+    -- ^ @variable
+    floatVal = 5.5
+    -- ^ @variable
+            -- ^ @number.float
+    intVal :: Int
+    -- ^ @variable
+    intVal = getInt 5
+    -- ^ @variable
+    boolVal :: Bool
+    -- ^ @variable
+    boolVal = bool False True $ 1 + 2 == 3
+    -- ^ @variable
+    refVal = boolVal
+    -- ^ @variable
+    namespacedRecord = NS.Rec { field = bar }
+    -- ^ @variable
+    record = Rec { field = bar }
+    -- ^ @variable
+    constructorRef = A
+    -- ^ @function
+    isInt :: Either Double Int -> Bool
+    -- ^ @function
+    isInt eith@Left{} = False
+        -- ^ @variable.parameter
+    isInt eith@(Left x) = False
+    -- ^ @function
+                  -- ^ @variable.parameter
+    isInt (Left x) = False
+             -- ^ @variable.parameter
+    isInt (Right _) = True
+    -- ^ @function
+
+someIOaction :: IO ()
+-- ^ @function
+anotherIOaction :: IO ()
+anotherIOaction = do
+-- ^ @function
+               -- ^ @keyword
+  foo <- SomeModule.someFun <$> getArgs
+-- ^ @variable
+            -- ^ @module
+                   -- ^ @function.call
+                          -- ^ @operator
+  _ <- someFunc0 =<< someIOAction
+        -- ^ @function.call
+  let bar = SomeModule.doSomething $ "a" "b"
+    -- ^ @variable
+            -- ^ @module
+                        -- ^ @function.call
+                                -- ^ @operator
+      func x y = x + y - 7
+    -- ^ @function
+        -- ^ @variable.parameter
+              -- ^ @variable
+                  -- ^ @variable
+      gunc x y = func x $ y + 7
+                   -- ^ @variable
+                       -- ^ @variable
+      valueFromList = HashSet.fromList []
+      -- ^ @variable
+  when foo $ putStrLn $ T.showt =<< bar
+ -- ^ @function.call
+     -- ^ @variable
+            -- ^ @function.call
+                        -- ^ @function.call
+
+  pure $ func 1 2
+  -- ^ @function.call
+        -- ^ @function.call
+
+intVal :: Int
+intVal = 5
+-- ^ @variable
+
+intFun :: Int -> Int
+intFun = 5
+-- ^ @function
+
+undefinedFun :: Int -> Int
+undefinedFun = undefined
+-- ^ @function
+
+mbInt :: Maybe Int
+-- ^ @variable
+mbInt = Just 5
+-- ^ @variable
+
+tupleVal :: (a, b)
+-- ^@variable
+tupleVal = (1, "x")
+-- ^@variable
+
+listVal :: [a]
+-- ^@variable
+listVal = [1, 2]
+-- ^@variable
+-- ^@variable
+condVal = if otherwise
+-- ^@variable
+            then False
+            else True
+
+getLambda x = \y -> x `SomeModule.someInfix` y
+            -- ^ @variable.parameter
+                      -- ^ @module
+                                  -- ^ @operator
+lambdaTyped = \(y :: Int) -> x
+             -- ^ @variable.parameter
+lambdaPattern = \(Just x) -> x
+                    -- ^ @variable.parameter
+lambdaPatternTyped = \(Just x :: Int) -> x
+                         -- ^ @variable.parameter
+
+isVowel = (`elem` "AEIOU")
+          -- ^ @operator
+isVowelQualified = (`SomeModule.elem` "AEIOU")
+                      -- ^ @module
+                              -- ^ @operator
+
+hasVowels = ("AEIOU" `elem`)
+                   -- ^ @operator
+hasVowelsQualified = ("AEIOU" `SomeModule.elem`)
+                            -- ^ @module
+                                       -- ^ @operator
+
+quasiQuotedString = [qq|Some string|]
+-- ^ @variable
+                   -- ^ @function.call
+                      -- ^ @string
+quasiQuotedString2 = [SomeModule.qq|Some string|]
+                        -- ^ @module
+                              -- ^ @function.call
+
+composition f g = f . g
+               -- ^ @function
+                   -- ^ @function
+qualifiedComposition = SomeModule.f . SomeModule.g
+                               -- ^ @function
+                                              -- ^ @function
+takeMVarOrThrow = evaluate <=< takeMVar
+                  -- ^ @function
+                              -- ^ @function
+modifyMVarOrThrow v f = modifyMVar v $ f >=> evaluate
+                                -- ^ @variable
+                                    -- ^ @function
+                                           -- ^ @function
+assertNonEmpty xs = xs `shouldSatisfy` not . null
+                 -- ^ @variable
+                                     -- ^ @function
+                                            -- ^ @function
+appliedComposition f g var = (f . g) var
+                           -- ^ @function.call
+                               -- ^ @function.call
+appliedComposition f g var = (NS.f . NS.g) var
+                              -- ^ @function.call
+                                     -- ^ @function.call
+param1 |*| param2 = Qu $ param1 * param2
+-- ^ @variable.parameter
+         -- ^ @variable.parameter
+(param1 :: Int) |*| (param2 :: Int) = Qu $ param1 * param2
+-- ^ @variable.parameter
+                   -- ^ @variable.parameter
+(Qu a) |/| (SomeModule.Qu b) = a / b
+ -- ^ @variable.parameter
+                       -- ^ @variable.parameter
+(Qu a :: Int) |/| (SomeModule.Qu b :: Int) = a / b
+ -- ^ @variable.parameter
+                              -- ^ @variable.parameter
+(Qu a, b, c :: Int) |/| x = undefined
+ -- ^ @variable.parameter
+    -- ^ @variable.parameter
+       -- ^ @variable.parameter
+[Qu a, b, c :: Int] >< x = undefined
+ -- ^ @variable.parameter
+    -- ^ @variable.parameter
+       -- ^ @variable.parameter
+listParam [a, b :: Int, Just c] = undefined
+        -- ^ @variable.parameter
+           -- ^ @variable.parameter
+                          -- ^ @variable.parameter
+tupleParam (a :: Int, b, Just c) = undefined
+         -- ^ @variable.parameter
+                   -- ^ @variable.parameter
+                           -- ^ @variable.parameter
+listLambda = \[a, a :: Int, Just c] -> undefined
+            -- ^ @variable.parameter
+               -- ^ @variable.parameter
+                              -- ^ @variable.parameter
+tupleLambda = \(a, b :: Int, Just c) -> undefined
+             -- ^ @variable.parameter
+                -- ^ @variable.parameter
+nestedDestructure (Left (Just a)) = undefined
+                           -- ^ @variable.parameter
+typeApplication x y = someFun @ty x y
+                               -- ^ @variable
+                                 -- ^ @variable
+encrypt key pass = encrypt (defaultOAEPParams SHA1) key pass
+                                                 -- ^ @variable
+                                                      -- ^ @variable
+recordUpdate x y rec = someFun rec {field = 5} (x, x) y
+                                             -- ^ @variable
+                                                   -- ^ @variable
+viewPattern (func -> var) = 5
+           -- ^ @function.call
+                   -- ^ @variable.parameter
+g (func :: a -> b) x = func y
+  -- ^ @variable.parameter
+  -- ^ @function
+lambdaAlias :: LambdaAlias
+lambdaAlias _ _ _ = undefined
+  -- ^ @function
+spec :: Spec
+spec = describe "test ns" $ it "test case" pending
+-- ^ @variable
+
+composed = f . g
+-- ^ @function
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/hocon/test.conf b/pack/ant/start/nvim-treesitter/tests/query/highlights/hocon/test.conf
new file mode 100644
index 0000000..55f4c03
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/hocon/test.conf
@@ -0,0 +1,59 @@
+HOCON = Human-Optimized Config Object Notation
+// ^ @variable.member
+//        ^ @string
+//                       ^ @string
+//                              ^ @string
+//                                    ^ @string
+
+"it's": "a JSON\nsuperset",
+//       ^ @string
+//             ^ @string.escape
+//                        ^ @punctuation.delimiter
+
+features: [
+//      ^ @operator
+//        ^ @punctuation.bracket
+    less noisy / less pedantic syntax
+//             ^ @string
+    ability to refer to another part of the configuration
+    import/include another configuration file into the current file
+    a mapping to a flat properties list such as Java's system properties
+    ability to get values from environment variables
+    # ability to write comments
+//  ^@ comment
+//     ^ @comment
+    // this is also a comment 
+//  ^ @comment
+//     ^ @comment
+]
+
+specs url: "https://github.com/lightbend/config/blob/master/HOCON.md"
+includes: { 
+  include required(file("~/prog/tree-sitter-hocon/grammar.js")) 
+//         ^ @keyword
+//^ @keyword.import
+//                ^ @punctuation.bracket
+//                                                           ^ @punctuation.bracket
+  override = true
+//            ^ @boolean
+}
+
+it's: ${it's}. A ${HOCON}
+//    ^ @punctuation.special
+//     ^ @punctuation.special
+//          ^ @punctuation.special
+//           ^ @string
+//             ^ @string
+//                ^ @punctuation.special
+//                      ^ @punctuation.special
+
+this.is.a."long.key" = null,
+//  ^ @punctuation.delimiter
+//     ^ @punctuation.delimiter
+//       ^ @punctuation.delimiter
+//                      ^ @constant.builtin
+week  = 7 days 
+//      ^ @number
+//         ^ @keyword
+
+
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/julia/test.jl b/pack/ant/start/nvim-treesitter/tests/query/highlights/julia/test.jl
new file mode 100644
index 0000000..445efaa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/julia/test.jl
@@ -0,0 +1,26 @@
+function load_data(::Symbol; ::Int) :: Tuple
+# <- @keyword.function
+#        ^ @function.call
+#                 ^ @punctuation.bracket
+#                  ^^ @punctuation.delimiter
+#                    ^ @type.builtin
+#                          ^ @punctuation.delimiter
+#                            ^^ @punctuation.delimiter
+#                              ^^^ @type.builtin
+#                                 ^ @punctuation.bracket
+#                                   ^^ @punctuation.delimiter
+#                                      ^ @type.builtin
+    dataset = CIFAR10(; Tx = Float32, split = split)
+#   ^^^^^^^ @variable
+#           ^ @operator
+#             ^ @function.call
+#                          ^ @operator
+#                            ^ @type.builtin
+    X = reshape(dataset.features[:, :, :, begin:n_obs], :, n_obs) # flattening the image pixels
+#                                         ^^^^^ @variable.builtin
+    y = categorical2onehot(dataset.targets[begin:n_obs], N_LABELS)
+#                                          ^^^^^ @variable.builtin
+    return X, y
+#   ^^^^^^ @keyword.return
+end
+# <- @keyword.function
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/latex/test.tex b/pack/ant/start/nvim-treesitter/tests/query/highlights/latex/test.tex
new file mode 100644
index 0000000..9e65b90
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/latex/test.tex
@@ -0,0 +1,33 @@
+% vim:ft=latex
+% !TeX
+% ^ @keyword.directive
+%& filename
+%  ^ @keyword.directive
+      \begin{equation} \frac{4}{2} + 128 \text{hello} \sum_{n=1}^{\text{hi\_hi\^hi}} n \end{equation}
+%                            ^ @markup.math    ^ @none             ^ @function
+
+\begin{equation} 
+  a = b % Comment here
+%         ^ @comment
+% ^ @markup.math
+\end{equation}
+\begin{equation} 
+  a = b % Comment here
+%         ^ @comment
+  b = c
+\end{equation}
+\text{
+hi $here$ is some text % with a comment
+%                        ^ @comment
+%   ^ @markup.math
+}
+\textbf{
+here is some text $5 + 2$ % with a comment
+%                           ^ @comment
+%                  ^ @markup.math
+}
+\textit{
+here is some text $5 + 2$ % with a comment
+%                           ^ @comment
+%                  ^ @markup.math
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/lua/test.lua b/pack/ant/start/nvim-treesitter/tests/query/highlights/lua/test.lua
new file mode 100644
index 0000000..55818bb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/lua/test.lua
@@ -0,0 +1,18 @@
+-- luacheck: ignore
+local a = { 1, 2, 3, 4, 5 }
+--          ^ @number     ^ @punctuation.bracket
+--    ^ @variable
+
+local _ = next(a)
+--          ^ @function.builtin
+-- ^ @keyword
+
+_ = next(a)
+--   ^ @function.builtin
+
+next(a)
+-- ^ @function.builtin
+
+-- Checking for incorrect hlgroup of injected luap
+string.match(s, "\0%d[^\n]+")
+--                       ^ @!constant
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/markdown/test.md b/pack/ant/start/nvim-treesitter/tests/query/highlights/markdown/test.md
new file mode 100644
index 0000000..01acfcc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/markdown/test.md
@@ -0,0 +1,28 @@
+# H1
+<!-- <- @markup.heading.1 -->
+
+## H2
+<!-- <- @markup.heading.2 -->
+
+- Item 1
+- Item 2
+<!-- <- @markup.list -->
+
+1. Item 1
+2. Item 2
+<!-- <- @markup.list -->
+
+----![image_description](https://example.com/image.jpg "awesome image title")
+<!--  ^ @markup.link.label                                                    -->
+<!--                              ^ @markup.link.url                              -->
+<!--                                                      ^ @markup.link.label  -->
+<!--^ @markup.link                                                 -->
+<!-- ^ @markup.link                                                -->
+<!--                    ^ @markup.link                             -->
+
+[link_text](#local_reference "link go brr...")
+<!-- ^ @markup.link.label                                                     -->
+<!--                 ^ @markup.link.url                                           -->
+<!--                            ^ @markup.link.label                            -->
+<!-- <- @markup.link                                               -->
+<!--       ^ @markup.link                                          -->
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/nix/test.nix b/pack/ant/start/nvim-treesitter/tests/query/highlights/nix/test.nix
new file mode 100644
index 0000000..296a5a9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/nix/test.nix
@@ -0,0 +1,21 @@
+{
+  func1 = param: builtins.readFile param;
+  # ^ @function
+        # ^ @variable.parameter
+                # ^ @constant.builtin
+                         # ^ @function.builtin
+  func2 = { p1, p2 }: p2;
+  # ^ @function
+          # ^ @variable.parameter
+  readFile' = readFile;
+              # ^ @function.builtin
+  x = func1 ./path/to/file.nix;
+# ^ @variable.member
+      # ^ @function.call
+              # ^ @string.special.path
+  hi = if true then 9 else throw "an error ${here + "string"}";
+                           # ^ @keyword.exception
+                                  # ^ @string
+                                             # ^ @variable
+                                                     # ^ @string
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/pascal/test.pas b/pack/ant/start/nvim-treesitter/tests/query/highlights/pascal/test.pas
new file mode 100644
index 0000000..3a6cc78
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/pascal/test.pas
@@ -0,0 +1,39 @@
+program foobar;
+// ^ @keyword
+
+var
+// <- @keyword
+  foo: bar;
+// ^ @variable
+//     ^ @type
+  foo: foo.bar<t>;
+// ^ @variable
+//     ^ @type
+//         ^ @type
+//             ^ @type
+begin
+// ^ @keyword
+  foo := bar;
+// ^ @variable
+//       ^ @variable
+  foo;
+// ^ @function
+  foo();
+// ^ @function
+  foo(bar(xyz));
+// ^ @function
+//    ^ @function
+//        ^ @variable
+  xx + yy;
+// ^ @variable
+//     ^ @variable
+  xx := y + z + func(a, b, c);
+// ^ @variable
+//      ^ @variable
+//          ^ @variable
+//              ^ @function
+//                   ^ @variable
+//                      ^ @variable
+//                         ^ @variable
+end.
+// <- @keyword
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/php/keywords.php b/pack/ant/start/nvim-treesitter/tests/query/highlights/php/keywords.php
new file mode 100644
index 0000000..6b938c4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/php/keywords.php
@@ -0,0 +1,97 @@
+<?php
+
+namespace Foo\Bar;
+//^^^^^^^ @keyword.type
+//        ^^^ @module
+//            ^^^ @module
+
+use Foo\Baz as Baaz;
+//^ @keyword.import
+//  ^^^ @module
+//      ^^^ @type
+//          ^^ @keyword.operator
+//             ^^^^ @type.definition
+
+use function Foo\foo as fooo;
+//  ^^^^^^^^ @keyword.function
+//               ^^^ @function
+//                      ^^^^ @function
+
+use const Foo\FOO as FOOO;
+//  ^^^^^ @keyword.modifier
+//            ^^^ @constant
+//                   ^^^^ @constant
+
+use Foo\Baz\{
+//  ^^^ @module
+//      ^^^ @module
+  Bar,
+//^^^ @type
+  function foo,
+//^^^^^^^^ @keyword.function
+//         ^^^ @function
+  const FOO,
+//^^^^^ @keyword.modifier
+//      ^^^ @constant
+};
+
+abstract class A
+{
+  protected readonly static $a;
+//^^^^^^^^^ @keyword.modifier
+//          ^^^^^^^^ @keyword.modifier
+//                   ^^^^^^ @keyword.modifier
+  public static function foo(): static {}
+//^^^^^^ @keyword.modifier
+//       ^^^^^^ @keyword.modifier
+//              ^^^^^^^^ @keyword.function
+//                       ^^^ @function.method
+//                              ^^^^^^ @type.builtin
+}
+
+class B extends A implements T
+//    ^ @type
+//      ^^^^^^^ @keyword
+//                ^^^^^^^^^^ @keyword
+{
+  use T, U {
+//^^^ @keyword.import
+    U::small insteadof T;
+//  ^ @type
+//     ^^^^^ @function.method
+//           ^^^^^^^^^ @keyword
+//                     ^ @type
+    T::big as protected tBig;
+//  ^ @type
+//     ^^^ @function.method
+//         ^^ @keyword.operator
+//            ^^^^^^^^^ @keyword.modifier
+//                      ^^^^ @function.method
+    big as private tBig;
+//  ^^^ @function.method
+//      ^^ @keyword.operator
+//         ^^^^^^^^^ @keyword.modifier
+//                 ^^^^ @function.method
+  }
+  public function foo(callable $call): self
+//                    ^^^^^^^^ @type.builtin
+//                                     ^^^^ @type.builtin
+  {
+    static $a;
+//  ^^^^^^ @keyword.modifier
+    yield $a;
+//  ^^^^^ @keyword.return
+    yield from $a;
+//        ^^^^ @keyword.return
+    print "a";
+//  ^^^^^ @keyword
+    print("a");
+//  ^^^^^ @keyword
+    exit;
+//  ^^^^ @keyword.return
+    exit();
+//  ^^^^ @function.builtin
+    exit(1);
+//  ^^^^ @function.builtin
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/php/types.php b/pack/ant/start/nvim-treesitter/tests/query/highlights/php/types.php
new file mode 100644
index 0000000..67a1c2f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/php/types.php
@@ -0,0 +1,22 @@
+<?php
+
+function b(int $a, string $b): Foo\Dog {}
+//         ^^^ @type.builtin
+//             ^^ @variable.parameter
+//                 ^^^^^^ @type.builtin
+//                             ^^^ @module
+//                                 ^^^ @type
+
+function a(array $b) {
+//         ^^^^^ @type.builtin
+  echo (int) $foo;
+//      ^^^ @type.builtin
+}
+
+class A {
+  public function foo(self $a): self {}
+//                    ^^^^ @type.builtin
+//                              ^^^^ @type.builtin
+  private function baz(): static {}
+//                        ^^^^^^ @type.builtin
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/php/variables.php b/pack/ant/start/nvim-treesitter/tests/query/highlights/php/variables.php
new file mode 100644
index 0000000..7d6c624
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/php/variables.php
@@ -0,0 +1,30 @@
+<?php
+
+class A {
+  public function foo(self $a): self {
+//                          ^ @variable.parameter
+    new self();
+//      ^^^^ @constructor
+    new static();
+//      ^^^^^^ @constructor
+    new parent();
+//      ^^^^^^ @constructor
+    $this->foo();
+//   ^^^^ @variable.builtin
+//         ^^^ @function.method.call
+    self::foo();
+//  ^^^^ @variable.builtin
+//        ^^^ @function.call
+    static::foo();
+//  ^^^^^^ @variable.builtin
+    parent::foo();
+//  ^^^^^^ @variable.builtin
+    $this->foo;
+//         ^^^ @variable.member
+    $this->foo(a: 5);
+//             ^ @variable.parameter
+    A::$foo::$bar;
+//      ^^^ @variable.member
+//            ^^^ @variable.member
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/prisma/test.prisma b/pack/ant/start/nvim-treesitter/tests/query/highlights/prisma/test.prisma
new file mode 100644
index 0000000..5517e9e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/prisma/test.prisma
@@ -0,0 +1,63 @@
+generator client {
+// ^ keyword
+  provider = "go run github.com/prisma/prisma-client-go"
+  // ^ variable
+}
+
+datasource db {
+  provider = "postgresql"
+  //           ^ string
+  url      = env("DATABASE_URL")
+  //          ^ function
+}
+
+model User {
+  email      String
+  //          ^ type
+  username   String   @id
+  //                  ^ operator
+  password   String
+  fullName   String   @map("full_name")
+  //                    ^ function
+  avatarUrl  String   @map("avatar_url")
+  about      String?
+  //               ^ type
+  createdAt  DateTime @default(now()) @map("created_at")
+  updatedAt  DateTime @updatedAt @map("updated_at")
+
+  @@map("user")
+}
+
+model Reaction {
+  //           ^ punctuation.bracket
+  id        Int      @id @default(autoincrement())
+  //                             ^ punctuation.bracket
+  postId    Int      @map("post_id")
+  userId    String   @map("user_id")
+  type      ReactionType
+  createdAt DateTime @default(now()) @map("created_at")
+  updatedAt DateTime @updatedAt @map("updated_at")
+
+  post      Post     @relation(fields: [postId], references: [id])
+  //                             ^ property
+  user      User     @relation(fields: [userId], references: [username])
+  //                                   ^ punctuation.bracket
+
+  @@map("reaction")
+}
+
+enum ReactionType {
+// ^ keyword.type
+  LIKE
+  HAHA
+  SAD
+  ANGRY
+  // ^ constant
+}
+
+view ReactionView {
+// ^ keyword
+  id     Int @unique
+  postId Int
+  userId String
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/python/fields.py b/pack/ant/start/nvim-treesitter/tests/query/highlights/python/fields.py
new file mode 100644
index 0000000..deb2806
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/python/fields.py
@@ -0,0 +1,12 @@
+class Fields:
+    def __init__(self, fields: list[int]) -> None:
+#                                   ^^^ @type.builtin
+#                                            ^^^^ @constant.builtin
+        self.fields = fields
+#            ^^^^^^ @variable.member
+        self.__dunderfield__ = None
+#            ^^^^^^^^^^^^^^^ @variable.member
+        self._FunKyFielD = 0
+#            ^^^^^^^^^^^ @variable.member
+        self.NOT_A_FIELD = "IM NOT A FIELD"
+#            ^^^^^^^^^^^ @constant
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/python/future_import.py b/pack/ant/start/nvim-treesitter/tests/query/highlights/python/future_import.py
new file mode 100644
index 0000000..6790b9b
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/python/future_import.py
@@ -0,0 +1,4 @@
+from __future__ import print_function
+# ^ @keyword.import
+#     ^ @constant.builtin
+#                  ^ @keyword.import
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/python/pattern_matching.py b/pack/ant/start/nvim-treesitter/tests/query/highlights/python/pattern_matching.py
new file mode 100644
index 0000000..2762781
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/python/pattern_matching.py
@@ -0,0 +1,51 @@
+match command.split():
+# ^ @keyword.conditional
+    case ["quit"]:
+    # ^ @keyword.conditional
+        print("Goodbye!")
+        quit_game()
+    case ["look"]:
+    # ^ @keyword.conditional
+        current_room.describe()
+    case ["get", obj]:
+    # ^ @keyword.conditional
+        character.get(obj, current_room)
+    case ["go", direction]:
+    # ^ @keyword.conditional
+        current_room = current_room.neighbor(direction)
+    # The rest of your commands go here
+
+match command.split():
+# ^ @keyword.conditional
+    case ["drop", *objects]:
+    # ^ @keyword.conditional
+        for obj in objects:
+            character.drop(obj, current_room)
+
+match command.split():
+# ^ @keyword.conditional
+    case ["quit"]: ... # Code omitted for brevity
+    case ["go", direction]: pass
+    case ["drop", *objects]: pass
+    case _:
+        print(f"Sorry, I couldn't understand {command!r}")
+                                                   # ^^ @@function.macro
+
+match command.split():
+# ^ @keyword.conditional
+    case ["north"] | ["go", "north"]:
+    # ^ @keyword.conditional
+        current_room = current_room.neighbor("north")
+    case ["get", obj] | ["pick", "up", obj] | ["pick", obj, "up"]:
+    # ^ @keyword.conditional
+        pass
+
+match = 2
+#   ^ @variable
+match, a = 2, 3
+#   ^ @variable
+match: int = secret
+#   ^ @variable
+x, match: str = 2, "hey, what's up?"
+# <- @variable
+#   ^ @variable
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/python/raise_from.py b/pack/ant/start/nvim-treesitter/tests/query/highlights/python/raise_from.py
new file mode 100644
index 0000000..fb30f42
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/python/raise_from.py
@@ -0,0 +1,6 @@
+try:
+    print(1 / 0)
+except Exception:
+    raise RuntimeError from None
+    # ^ @keyword.exception
+    #                   ^ @keyword.exception
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/python/yield_from.py b/pack/ant/start/nvim-treesitter/tests/query/highlights/python/yield_from.py
new file mode 100644
index 0000000..6ada002
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/python/yield_from.py
@@ -0,0 +1,7 @@
+from foo import bar
+# ^ @keyword.import
+#           ^ @keyword.import
+def generator():
+    yield from bar(42)
+    # ^ @keyword.return
+    #       ^ @keyword.return
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/r/test.r b/pack/ant/start/nvim-treesitter/tests/query/highlights/r/test.r
new file mode 100644
index 0000000..5fa36cc
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/r/test.r
@@ -0,0 +1,47 @@
+init <- 1
+# ^ @variable
+#     ^ @operator
+#       ^ @number.float
+
+r"{(\1\2)}" -> `%r%`
+#  ^ @string
+#           ^ @operator
+#               ^ @variable
+
+
+foo <- c(1L, 2L)
+#      ^ @function.call
+#        ^ @number
+
+b <- list(TRUE, FALSE, NA, Inf)
+#          ^ @boolean
+#                ^ @boolean
+#                      ^ @constant.builtin
+#                           ^ @constant.builtin
+
+b <- list(name = "r", version = R.version$major)
+#          ^ @variable.parameter
+#                 ^ @string
+#                                        ^ @operator
+#                                           ^ @variable.member
+
+Lang$new(name = "r")$print()
+#     ^ @function.method.call
+
+for(i in 1:10) {
+# <- @keyword.repeat
+#      ^ @keyword.repeat
+}
+
+add <- function(a, b = 1, ...) {
+#        ^ @keyword.function
+#               ^ @variable.parameter
+#                  ^ @variable.parameter
+#                         ^ @constant.builtin
+  return(a + b)
+# ^ @keyword.return
+}
+
+base::letters
+# ^ @module
+#        ^ @variable
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/rust/for.rs b/pack/ant/start/nvim-treesitter/tests/query/highlights/rust/for.rs
new file mode 100644
index 0000000..e8c085f
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/rust/for.rs
@@ -0,0 +1,15 @@
+struct Foo;
+
+// Issue https://github.com/nvim-treesitter/nvim-treesitter/issues/3641
+// Distinguish between for in loop or impl_item
+impl Drop for Foo {
+    //     ^ @keyword
+   fn drop(&mut self) {}
+}
+
+fn main() {
+    for i in 0..128 {
+    // <- @keyword.repeat
+        println!("{i}");
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/rust/super-crate-imports.rs b/pack/ant/start/nvim-treesitter/tests/query/highlights/rust/super-crate-imports.rs
new file mode 100644
index 0000000..9326309
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/rust/super-crate-imports.rs
@@ -0,0 +1,12 @@
+use crate::a;
+//  ^ @module
+//  ^ !keyword
+use crate::{b, c};
+//  ^ @module
+//  ^ !keyword
+use super::a;
+//  ^ @module
+//  ^ !keyword
+use super::{b, c};
+//  ^ @module
+//  ^ !keyword
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/smali/baksmali_test_class.smali b/pack/ant/start/nvim-treesitter/tests/query/highlights/smali/baksmali_test_class.smali
new file mode 100644
index 0000000..1d2a4cb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/smali/baksmali_test_class.smali
@@ -0,0 +1,261 @@
+.class public Lbaksmali/test/class;
+# <- @keyword
+#      ^^^^^^ @keyword.modifier
+.super Ljava/lang/Object;
+#      ^ @character.special
+#       ^^^^ @type.builtin
+#           ^ @punctuation.delimiter
+
+.source "baksmali_test_class.smali"
+# <- @keyword.import
+
+.implements Lsome/interface;
+.implements Lsome/other/interface;
+
+
+.annotation build Lsome/annotation;
+#           ^^^^^ @keyword.modifier
+#                  ^^^^ @type
+#                                 ^ @punctuation.delimiter
+    value1 = "test"
+#   ^^^^^^ @variable.member
+#          ^ @operator
+#            ^^^^^^ @string
+    value2 = .subannotation Lsome/annotation;
+        value1 = "test2"
+        value2 = Lsome/enum;
+    .end subannotation
+.end annotation
+
+.annotation system Lsome/annotation;
+.end annotation
+
+
+
+.field public static aStaticFieldWithoutAnInitializer:I
+#                                                    ^ @punctuation.delimiter
+#                                                     ^ @type.builtin
+
+.field public static longStaticField:J = 0x300000000L
+#                                        ^^^^^^^^^^^^ @number
+.field public static longNegStaticField:J = -0x300000000L
+
+.field public static intStaticField:I = 0x70000000
+.field public static intNegStaticField:I = -500
+
+.field public static shortStaticField:S = 500s
+.field public static shortNegStaticField:S = -500s
+
+.field public static byteStaticField:B = 123t
+.field public static byteNegStaticField:B = 0xAAt
+
+.field public static floatStaticField:F = 3.1415926f
+#                                         ^^^^^^^^^^ @number.float
+
+.field public static doubleStaticField:D = 3.141592653589793
+
+.field public static charStaticField:C = 'a'
+#                                        ^^^ @character
+.field public static charEscapedStaticField:C = '\n'
+#                                                ^^ @string.escape
+
+.field public static boolTrueStaticField:Z = true
+#                                            ^^^^ @boolean
+.field public static boolFalseStaticField:Z = false
+
+.field public static typeStaticField:Ljava/lang/Class; = Lbaksmali/test/class;
+
+.field public static stringStaticField:Ljava/lang/String; = "test"
+.field public static stringEscapedStaticField:Ljava/lang/String; = "test\ntest"
+
+
+.field public static fieldStaticField:Ljava/lang/reflect/Field; = Lbaksmali/test/class;->fieldStaticField:Ljava/lang/reflect/Field;
+
+.field public static methodStaticField:Ljava/lang/reflect/Method; = Lbaksmali/test/class;->testMethod(ILjava/lang/String;)Ljava/lang/String;
+#                                                                                        ^^ @punctuation.delimiter
+#                                                                                          ^^^^^^^^^^ @function.method.call
+
+.field public static arrayStaticField:[I = {1, 2, 3, {1, 2, 3, 4}}
+#                                     ^ @punctuation.special
+#                                          ^ @punctuation.bracket
+#                                            ^ @punctuation.delimiter
+
+.field public static enumStaticField:Lsome/enum; = .enum Lsome/enum;->someEnumValue:Lsome/enum;
+#                                                                     ^^^^^^^^^^^^^ @variable.member
+
+.field public static annotationStaticField:Lsome/annotation; = .subannotation Lsome/annotation;
+    value1 = "test"
+    value2 = .subannotation Lsome/annotation;
+        value1 = "test2"
+        value2 = Lsome/enum;
+    .end subannotation
+.end subannotation
+
+.field public static staticFieldWithAnnotation:I
+    .annotation runtime La/field/annotation;
+#               ^^^^^^^ @keyword.modifier
+        this = "is"
+        a = "test"
+    .end annotation
+    .annotation runtime Lorg/junit/Test;
+    .end annotation
+.end field
+
+.field public instanceField:Ljava/lang/String;
+
+
+
+.method public constructor <init>()V
+# <- @keyword.function
+#              ^^^^^^^^^^^ @constructor
+#                          ^^^^^^ @constructor
+    .registers 1
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+#   ^^^^^^^^^^^^^ @keyword.operator
+#                  ^^ @variable.parameter.builtin
+    return-void
+#   ^^^^^^^^^^^ @keyword.return
+.end method
+
+.method public testMethod(ILjava/lang/String;)Ljava/lang/String;
+#              ^^^^^^^^^^ @function.method
+    .registers 3
+    .annotation runtime Lorg/junit/Test;
+    .end annotation
+    .annotation system Lyet/another/annotation;
+        somevalue = 1234
+        anothervalue = 3.14159
+    .end annotation
+
+    const-string v0, "testing\n123"
+#                ^^ @variable.builtin
+
+    goto switch:
+#        ^^^^^^^ @label
+
+    sget v0, Lbaksmali/test/class;->staticField:I
+
+    switch:
+    packed-switch v0, pswitch:
+
+    try_start:
+    const/4 v0, 7
+    const v0, 10
+    nop
+    try_end:
+    .catch Ljava/lang/Exception; {try_start: .. try_end:} handler:
+#   ^^^^^^ @keyword.exception
+    .catchall {try_start: .. try_end:} handler2:
+#   ^^^^^^^^^ @keyword.exception
+#                         ^^ @operator
+
+    handler:
+
+    Label10:
+    Label11:
+    Label12:
+    Label13:
+    return-object v0
+
+
+
+    .array-data 4
+        1 2 3 4 5 6 200
+    .end array-data
+
+    pswitch:
+    .packed-switch 10
+        Label10:
+        Label11:
+        Label12:
+        Label13:
+    .end packed-switch
+
+    handler2:
+
+    return-void
+
+.end method
+
+.method public abstract testMethod2()V
+    .annotation runtime Lsome/annotation;
+        subannotation = .subannotation Lsome/other/annotation;
+            value = "value"
+        .end subannotation
+    .end annotation
+    .annotation runtime Lorg/junit/Test;
+    .end annotation
+.end method
+
+
+.method public tryTest()V
+    .registers 1
+
+    handler:
+    nop
+
+
+    try_start:
+    const/4 v0, 7
+    const v0, 10
+    nop
+    try_end:
+    .catch Ljava/lang/Exception; {try_start: .. try_end:} handler:
+.end method
+
+
+.method public debugTest(IIIII)V
+    .registers 10
+
+    .parameter "Blah"
+    .parameter
+    .parameter "BlahWithAnnotations"
+        .annotation runtime Lsome/annotation;
+            something = "some value"
+            somethingelse = 1234
+        .end annotation
+        .annotation runtime La/second/annotation;
+        .end annotation
+    .end parameter
+    .parameter
+        .annotation runtime Lsome/annotation;
+            something = "some value"
+            somethingelse = 1234
+        .end annotation
+    .end parameter
+    .parameter "LastParam"
+
+    .prologue
+#   ^^^^^^^^^ @keyword
+
+    nop
+    nop
+
+    .source "somefile.java"
+#   ^^^^^^^ @keyword.import
+    .line 101
+#         ^^^ @string.special
+
+    nop
+
+
+    .line 50
+
+    .local v0, aNumber:I
+#              ^^^^^^^ @variable
+    const v0, 1234
+    .end local v0
+
+    .source "someotherfile.java"
+    .line 900
+
+    const-string v0, "1234"
+
+    .restart local v0
+    const v0, 6789
+    .end local v0
+
+    .epilogue
+#   ^^^^^^^^^ @keyword
+
+.end method
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/solidity/test.sol b/pack/ant/start/nvim-treesitter/tests/query/highlights/solidity/test.sol
new file mode 100644
index 0000000..52334bd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/solidity/test.sol
@@ -0,0 +1,186 @@
+// Example contract from official documentation at https://github.com/ethereum/solidity/blob/v0.8.12/docs/examples/voting.rst
+
+// SPDX-License-Identifier: GPL-3.0
+// ^ @comment
+pragma solidity >=0.7.0 <0.9.0;
+// ^ @keyword.directive
+//     ^ @keyword.directive
+
+import * as something from "anotherFile";
+// ^     ^            ^ @keyword.import
+
+/// @title Voting with delegation.
+// <- @comment
+contract Ballot {
+// ^keyword.type
+//       ^ @type
+    // This declares a new complex type which will
+    // be used for variables later.
+    // It will represent a single voter.
+    struct Voter {
+//         ^ @type
+        uint weight; // weight is accumulated by delegation
+//      ^ @type.builtin
+//           ^ @variable.member
+        bool voted;  // if true, that person already voted
+        address delegate; // person delegated to
+        uint vote;   // index of the voted proposal
+    }
+
+    // This is a type for a single proposal.
+    struct Proposal {
+        bytes32 name;   // short name (up to 32 bytes)
+        uint voteCount; // number of accumulated votes
+    }
+
+    address public chairperson;
+//  ^ @type.builtin
+
+    // This declares a state variable that
+    // stores a `Voter` struct for each possible address.
+    mapping(address => Voter) public voters;
+//         ^                ^ @punctuation.bracket
+//                  ^ @punctuation.delimiter
+
+    // A dynamically-sized array of `Proposal` structs.
+    Proposal[] public proposals;
+
+    enum ActionChoices { GoLeft, GoRight, GoStraight, SitStill }
+//                       ^ @constant
+
+    /// Create a new ballot to choose one of `proposalNames`.
+    constructor(bytes32[] memory proposalNames) {
+//  ^ @constructor
+        chairperson = msg.sender;
+        voters[chairperson].weight = 1;
+
+        // For each of the provided proposal names,
+        // create a new proposal object and add it
+        // to the end of the array.
+        for (uint i = 0; i < proposalNames.length; i++) {
+            // `Proposal({...})` creates a temporary
+            // Proposal object and `proposals.push(...)`
+            // appends it to the end of `proposals`.
+            proposals.push(Proposal({
+                name: proposalNames[i],
+//              ^ @variable.member
+                voteCount: 0
+            }));
+        }
+    }
+
+    // Give `voter` the right to vote on this ballot.
+    // May only be called by `chairperson`.
+    function giveRightToVote(address voter) external {
+//  ^ @keyword.function
+//           ^ @function
+//                                   ^ @variable.parameter
+        // If the first argument of `require` evaluates
+        // to `false`, execution terminates and all
+        // changes to the state and to Ether balances
+        // are reverted.
+        // This used to consume all gas in old EVM versions, but
+        // not anymore.
+        // It is often a good idea to use `require` to check if
+        // functions are called correctly.
+        // As a second argument, you can also provide an
+        // explanation about what went wrong.
+        require(
+            msg.sender == chairperson,
+            "Only chairperson can give right to vote."
+        );
+        require(
+            !voters[voter].voted,
+            "The voter already voted."
+        );
+        require(voters[voter].weight == 0);
+        voters[voter].weight = 1;
+    }
+
+    /// Delegate your vote to the voter `to`.
+    function delegate(address to) external {
+        // assigns reference
+        Voter storage sender = voters[msg.sender];
+        require(!sender.voted, "You already voted.");
+
+        require(to != msg.sender, "Self-delegation is disallowed.");
+
+        // Forward the delegation as long as
+        // `to` also delegated.
+        // In general, such loops are very dangerous,
+        // because if they run too long, they might
+        // need more gas than is available in a block.
+        // In this case, the delegation will not be executed,
+        // but in other situations, such loops might
+        // cause a contract to get "stuck" completely.
+        while (voters[to].delegate != address(0)) {
+            to = voters[to].delegate;
+
+            // We found a loop in the delegation, not allowed.
+            require(to != msg.sender, "Found loop in delegation.");
+        }
+
+        // Since `sender` is a reference, this
+        // modifies `voters[msg.sender].voted`
+        Voter storage delegate_ = voters[to];
+
+        // Voters cannot delegate to wallets that cannot vote.
+        require(delegate_.weight >= 1);
+        sender.voted = true;
+        sender.delegate = to;
+        if (delegate_.voted) {
+            // If the delegate already voted,
+            // directly add to the number of votes
+            proposals[delegate_.vote].voteCount += sender.weight;
+        } else {
+            // If the delegate did not vote yet,
+            // add to her weight.
+            delegate_.weight += sender.weight;
+        }
+    }
+
+    /// Give your vote (including votes delegated to you)
+    /// to proposal `proposals[proposal].name`.
+    function vote(uint proposal) external {
+        Voter storage sender = voters[msg.sender];
+        require(sender.weight != 0, "Has no right to vote");
+        require(!sender.voted, "Already voted.");
+        sender.voted = true;
+        sender.vote = proposal;
+
+        // If `proposal` is out of the range of the array,
+        // this will throw automatically and revert all
+        // changes.
+        proposals[proposal].voteCount += sender.weight;
+    }
+
+    /// @dev Computes the winning proposal taking all
+    /// previous votes into account.
+    function winningProposal() public view
+            returns (uint winningProposal_)
+    {
+        uint winningVoteCount = 0;
+        for (uint p = 0; p < proposals.length; p++) {
+            if (proposals[p].voteCount > winningVoteCount) {
+                winningVoteCount = proposals[p].voteCount;
+                winningProposal_ = p;
+            }
+        }
+    }
+
+    // Calls winningProposal() function to get the index
+    // of the winner contained in the proposals array and then
+    // returns the name of the winner
+    function winnerName() external view
+            returns (bytes32 winnerName_)
+    {
+        winnerName_ = proposals[winningProposal()].name;
+    }
+}
+
+contract Another {
+  Ballot b = new Ballot(new bytes32[](1));
+//           ^ @keyword.operator
+}
+
+// vim:ft=solidity
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/t32/comments.cmm b/pack/ant/start/nvim-treesitter/tests/query/highlights/t32/comments.cmm
new file mode 100644
index 0000000..e36f7e6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/t32/comments.cmm
@@ -0,0 +1,10 @@
+// This is a comment
+; <- @comment
+
+; Another comment
+; <- @comment
+
+ECHO &a // This is a trailing comment
+;       ^ @comment
+
+// vim: set ft=t32:
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/t32/keywords.cmm b/pack/ant/start/nvim-treesitter/tests/query/highlights/t32/keywords.cmm
new file mode 100644
index 0000000..d1516eb
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/t32/keywords.cmm
@@ -0,0 +1,125 @@
+PRIVATE &password
+; <- @keyword
+;        ^ @variable.builtin
+ENTRY &password
+; <- @keyword
+;        ^ @variable.parameter
+
+ENTRY %LINE &salt
+; <- @keyword
+;      ^ @constant.builtin
+;            ^ @variable.parameter
+
+IF "&password"==""
+; <- @keyword.conditional
+;  ^ @string
+;    ^ @variable.builtin
+;             ^ @operator
+(
+    ECHO "Failed to provide password."
+    ENDDO
+;   ^ @keyword.return
+)
+ELSE
+; <- @keyword.conditional
+(
+    PRIVATE &pass
+
+    &pass=FALSE()
+;          ^ @function.builtin
+    WHILE !&pass
+;         ^ @operator
+    (
+        GOSUB verify_password "&password"
+;             ^ @function.call
+        RETURNVALUES &pass
+;                     ^ @variable.parameter
+        WAIT 10.ms
+;            ^ @number.float
+    )
+
+    IF !&pass
+        GOTO fail
+;            ^ @label
+    ELSE IF &debug
+;   ^ @keyword.conditional
+;        ^ @keyword.conditional
+    (
+        GOSUB start_debug
+;             ^ @function.call
+    )
+)
+
+LOCAL &num
+;      ^ @variable.builtin
+
+&num = 2.
+;      ^ @number
+
+RePeaT &num PRINT "Password: &password"
+;       ^ @variable.builtin
+;                             ^ @variable.builtin
+
+WinCLEAR
+FramePOS ,,,,Maximized
+;        ^ @punctuation.delimiter
+;            ^ @constant.builtin
+WinPOS 0% 50% 100% 35%
+;      ^ @number.float
+COVerage.ListFunc
+
+ENDDO
+
+
+fail:
+; <- @label
+    PRINT %ERROR "Password verification failed."
+    END
+;   ^ @keyword.return
+
+
+verify_password:
+; <- @function
+(
+    PARAMETERS &password
+;               ^ @variable.parameter
+
+    SYStem.Option.KEYCODE "&password"
+    SYStem.JtagClock  1kHz
+;                     ^ @number.float
+    SYStem.Mode.Attach
+
+    Data.Set N: EAXI:0x34000000 %Long 0x34000100 0x34000021 /verify
+;            ^ @constant.builtin
+;               ^ @constant.builtin
+;                    ^ @number
+;                                ^ @constant.builtin
+;                                     ^ @number
+;                                                            ^ @constant.builtin
+
+    RETURN TRUE()
+;   ^ @keyword.return
+)
+
+
+SUBROUTINE start_debug
+; <- @keyword.function
+;          ^ @function
+(
+    COVerage.ListModule %MULTI.OBC \sieve
+;    ^ @keyword
+;                        ^ @constant.builtin
+;                                  ^ @string.special.symbol
+
+    Var.DRAW flags[0..16] /Alternate 3
+;    ^ @keyword
+;             ^ @variable
+;                          ^ @constant.builtin
+;                                    ^ @number
+
+    Go main
+    RETURN
+;   ^ @keyword.return
+)
+
+// vim: set ft=t32:
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/t32/literals.cmm b/pack/ant/start/nvim-treesitter/tests/query/highlights/t32/literals.cmm
new file mode 100644
index 0000000..a9d72e4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/t32/literals.cmm
@@ -0,0 +1,39 @@
+WinPOS ,,1000.,,,,myWatchWindow
+;        ^ @number
+
+PRinTer.OPEN "~~~/varwatch.txt" ASCIIE
+;            ^ @string
+
+sYmbol.NEW _InitialSP   0x34000100
+;                       ^ @number
+
+DO ~~~~/test.cmm
+;  ^ @string.special.path
+
+WAIT 1.ns
+;    ^ @number.float
+
+SYStem.JtagClock  100.GHZ
+;                 ^ @number.float
+
+DATA.SET P:&HEAD+0x4 %LONG DATA.LONG(EA:&HEAD+0x4)&0xFFFFFF
+;                                    ^ @constant.builtin
+
+List `main`
+;    ^ @string.special.symbol
+
+&range = 'a'--'z'||'0'--'9'
+;        ^ @character
+;           ^ @operator
+;                       ^ @character
+
+Data.Set N: 0xffff800000 0y0011xx01xx&&a
+;        ^ @constant.builtin
+;           ^ @number
+;                        ^ @number
+;                                    ^ @operator
+
+WinPOS 0% 85% 100% 15%
+;             ^ @number.float
+
+// vim: set ft=t32:
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/t32/var.cmm b/pack/ant/start/nvim-treesitter/tests/query/highlights/t32/var.cmm
new file mode 100644
index 0000000..0deed99
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/t32/var.cmm
@@ -0,0 +1,75 @@
+Var.NEWGLOBAL char[4][32] \myarr
+; <- @keyword
+;             ^ @type.builtin
+;                          ^ @variable.builtin
+LOCAL &i &data
+
+&data="zero|one|two|three"
+
+&i=0.
+WHILE &i<4
+(
+    PRIVATE &val
+    &val=STRing.SPLIT("&data","|",&i)
+    Var.Assign \myarr[&i]="&val"
+;              ^ @variable.builtin
+;                        ^ @operator
+    &i=&i+1.
+)
+
+Var.NEWLOCAL \x
+; <- @keyword
+;             ^ @variable.builtin
+Var.set \x=func3(5,3)
+;       ^ @variable.builtin
+;          ^ @function.call
+;                ^ @number
+PRINT Var.VALUE(\x)
+;               ^ @variable.builtin
+PRINT Var.VALUE('a')
+;               ^ @character
+Var.Assign (*ap)[2..4] = &a
+;            ^ @variable
+;                         ^ @variable
+Var.Assign sp = &s.n+offset
+;          ^ @variable
+;                ^ @variable
+;                  ^ @variable.member
+;                    ^ @variable
+Var.Assign padd = (CAddition const * volatile)&d
+;          ^ @variable
+;                  ^ @type
+;                            ^ @keyword.modifier
+;                                    ^ @keyword.modifier
+;                                              ^ @variable
+Var.Assign e1 = (enum e2)&e
+;          ^ @variable
+;                ^ @keyword.type
+;                     ^ @type
+;                         ^ @variable
+Var.Assign *vector = (struct Vector3d*)&acceleration
+;           ^ @variable
+;                     ^ @keyword.type
+;                            ^ @type
+;                                       ^ @variable
+Var.Assign z = (union foo)x
+;          ^ @variable
+;               ^ @keyword.type
+;                     ^ @type
+;                         ^ @variable
+Var.Assign b = -a
+;          ^ @variable
+;               ^ @variable
+Var.Assign c = i++
+;          ^ @variable
+;              ^ @variable
+Var.Assign d = sizeof(int)
+;          ^ @variable
+;              ^ @keyword.operator
+;                     ^ @type.builtin
+Var.call strcmp(key,buffer)
+;        ^ @function.call
+;               ^ @variable
+;                   ^ @variable
+
+// vim: set ft=t32:
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/built-ins.tig b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/built-ins.tig
new file mode 100644
index 0000000..9aa6494
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/built-ins.tig
@@ -0,0 +1,44 @@
+let
+  var a := exit(0)
+  /*       ^ @function.builtin */
+
+  primitive exit(ret: int) /* Shadowing the prelude-included built-in */
+  /*                  ^ @type.builtin */
+
+  var b := exit(0)
+  /*       ^ @function.builtin */
+
+  type int = string /* Shadowing the built-in type */
+  /*         ^ @type.builtin */
+
+  var c : int := "This is an \"int\""
+  /*      ^ @type.builtin (not sure why it isn't 'type')*/
+
+  var d : Object := nil
+  /*      ^ @type.builtin */
+
+  type Object = int
+
+  var self := "self"
+in
+  let
+    var c : int := "This is an int"
+    /*      ^ @type.builtin (not sure why it isn't 'type')*/
+    var d : Object := "This is an object"
+    /*      ^ @type.builtin (not sure why it isn't 'type')*/
+  in
+  end;
+
+  exit(1);
+  /* <- @function.builtin */
+
+  print("shadowing is fun");
+  /* <- @function.builtin */
+
+  self;
+  /* <- @variable.builtin */
+
+  b := print
+  /*   ^ @variable */
+end
+/* vim: set ft=tiger: */
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/comment.tig b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/comment.tig
new file mode 100644
index 0000000..9323dba
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/comment.tig
@@ -0,0 +1,6 @@
+/* This is /* a nested */ comment */
+/* <- @comment
+            ^ @comment
+                                ^ @comment
+ */
+/* vim: set ft=tiger: */
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/functions.tig b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/functions.tig
new file mode 100644
index 0000000..706f199
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/functions.tig
@@ -0,0 +1,9 @@
+primitive print(s: string)
+/*        ^ @function */
+/*              ^ @variable.parameter */
+
+function func(a: int) : int = (print("Hello World!"); a)
+/*       ^ @function */
+/*            ^ @variable.parameter */
+/*                             ^ @function.builtin */
+/* vim: set ft=tiger: */
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/identifiers.tig b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/identifiers.tig
new file mode 100644
index 0000000..8d2207d
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/identifiers.tig
@@ -0,0 +1,30 @@
+type int = int
+/*   ^ @variable */
+/*         ^ @type.builtin */
+
+type int_array = array of int
+/*                        ^ @type.builtin */
+
+type record = {a: int, b: string}
+/*             ^ @variable.member */
+/*                ^ @type.builtin */
+/*                     ^ @variable.member */
+/*                        ^ @type.builtin */
+
+var record := record {a = 12, b = "27"}
+/*  ^ @variable */
+/*            ^ @type */
+/*                    ^ @variable.member */
+/*                            ^ @variable.member */
+
+var array := int_array[12] of 27;
+/*  ^ @variable */
+/*           ^ @type */
+
+primitive func(a: int, b: string) : array
+/*             ^ @variable.parameter */
+/*                ^ @type.builtin */
+/*                     ^ @variable.parameter */
+/*                        ^ @type.builtin */
+/*                                  ^ @type */
+/* vim: set ft=tiger: */
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/imports.tig b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/imports.tig
new file mode 100644
index 0000000..1c7ce30
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/imports.tig
@@ -0,0 +1,4 @@
+import "lib.tih"
+/* <- @keyword.import */
+/*      ^ @string.special.path */
+/* vim: set ft=tiger: */
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/keywords.tig b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/keywords.tig
new file mode 100644
index 0000000..c92cd92
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/keywords.tig
@@ -0,0 +1,42 @@
+let
+/* <- @keyword */
+
+  var a := 12
+  /* <- @keyword */
+
+  function f() : int = a
+  /* <- @keyword.function */
+  primitive g()
+  /* <- @keyword.function */
+
+  import "lib.tih"
+  /* <- @keyword.import */
+
+  type array_of_int = array of int
+  /* <- @keyword */
+  /*                  ^ @keyword */
+  /*                        ^ @keyword */
+
+in
+/* <- @keyword */
+
+  12;
+
+  if 12 then 27 else 42;
+  /* <- @keyword */
+  /*    ^ @keyword */
+  /*            ^ @keyword */
+
+  for i := 12 to 27 do 42;
+  /* <- @keyword.repeat */
+  /*          ^ @keyword.repeat */
+  /*                ^ @keyword.repeat */
+
+  while 12 do break
+  /* <- @keyword.repeat */
+  /*       ^ @keyword.repeat */
+  /*          ^ @keyword */
+
+end
+/* <- @keyword */
+/* vim: set ft=tiger: */
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/literals.tig b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/literals.tig
new file mode 100644
index 0000000..46f3c86
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/literals.tig
@@ -0,0 +1,9 @@
+nil
+/* <- @constant.builtin */
+42
+/* <- @number */
+"Hello World!\n"
+/* <- @string
+             ^ @string.escape
+*/
+/* vim: set ft=tiger: */
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/meta-variables.tig b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/meta-variables.tig
new file mode 100644
index 0000000..1b2c6c9
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/meta-variables.tig
@@ -0,0 +1,14 @@
+let
+  _chunks(42)
+  /* <- @keyword */
+
+in
+  _lvalue(12) : _namety(42) := _cast("I'm So Meta Even This Acronym", string);
+  /* <- @keyword */
+  /*            ^ @keyword */
+  /*                           ^ @keyword */
+
+  _exp(42)
+  /* <- @keyword */
+end
+/* vim: set ft=tiger: */
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/object-oriented.tig b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/object-oriented.tig
new file mode 100644
index 0000000..5c48c54
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/object-oriented.tig
@@ -0,0 +1,29 @@
+let
+  class A extends Object {}
+  /* <- @keyword.type */
+  /*      ^ @keyword */
+  /*              ^ @type.builtin */
+
+  type B = class extends A {
+  /*       ^ @keyword.type */
+  /*             ^ @keyword */
+  /*                     ^ @type */
+
+    var a := 12
+
+    method meth() : int = self.a
+    /* <- @keyword.function */
+    /*     ^ @function.method */
+    /*                    ^ @variable.builtin */
+  }
+
+  var object := new B
+  /*            ^ @keyword.operator */
+in
+  object.a := 27;
+  /*     ^ @variable.member */
+
+  object.meth()
+  /*     ^ @function.method */
+end
+/* vim: set ft=tiger: */
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/operators.tig b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/operators.tig
new file mode 100644
index 0000000..d803af7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/tiger/operators.tig
@@ -0,0 +1,49 @@
+let
+  var a : int := 42
+  /*    ^ @punctuation.delimiter */
+  /*          ^ @operator */
+in
+  (
+  /* <- @punctuation.bracket */
+
+    -1 | 2 & 3 + 4 * 5;
+    /* <- @operator */
+    /* ^ @operator */
+    /*     ^ @operator */
+    /*         ^ @operator */
+    /*             ^ @operator */
+    /*                ^ @punctuation.delimiter */
+
+    12 >= 27;
+    /* ^ @operator */
+    12 <= 27;
+    /* ^ @operator */
+    12 = 27;
+    /* ^ @operator */
+    12 <> 27;
+    /* ^ @operator */
+    12 < 27;
+    /* ^ @operator */
+    12 > 27;
+    /* ^ @operator */
+
+    record.field;
+    /*    ^ @punctuation.delimiter */
+
+    func(a, b);
+    /*  ^ @punctuation.bracket */
+    /*       ^ @punctuation.bracket */
+    /*    ^ @punctuation.delimiter */
+
+    record_type { };
+    /*          ^ @punctuation.bracket */
+    /*            ^ @punctuation.bracket */
+
+    array[42]
+    /*   ^ @punctuation.bracket */
+    /*      ^ @punctuation.bracket */
+
+  )
+  /* <- @punctuation.bracket */
+end
+/* vim: set ft=tiger: */
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/typescript/as.ts b/pack/ant/start/nvim-treesitter/tests/query/highlights/typescript/as.ts
new file mode 100644
index 0000000..30be1ff
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/typescript/as.ts
@@ -0,0 +1,8 @@
+import * as foo from 'foo';
+//       ^ @keyword.import
+
+export { foo as bar };
+//           ^ @keyword.import
+
+const n = 5 as number;
+//          ^ @keyword.operator
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/usd/prims.usda b/pack/ant/start/nvim-treesitter/tests/query/highlights/usd/prims.usda
new file mode 100644
index 0000000..da9a5d6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/usd/prims.usda
@@ -0,0 +1,118 @@
+def Xform "cube" (
+    assetInfo = {
+    # <- @keyword
+        asset[] payloadAssetDependencies = [@fizz.usd@, @buzz.usd@]
+        # <- @type
+        #       ^ @keyword
+        #                                   ^ @string.special.url
+        #                                               ^ @string.special.url
+    }
+)
+{
+}
+
+def "root" (
+    add references = @foo.usda@</Model> (offset = 1; scale = 2.0)
+                      # <- @string.special.url
+                      #        ^ @string.special
+                      #                  ^ @keyword
+                      #                           ^ @number
+                      #                            ^ @punctuation.delimiter
+                      #                              ^ @keyword
+                      #                                      ^ @number.float
+)
+{
+}
+
+def "World"
+{
+    over "points" (
+        clips = {
+        # <- @keyword
+            dictionary default = {
+            # <- @type
+            #          ^ @variable
+                double2[] times = [(101, 101), (102, 102)]
+                # <- @type
+                #         ^ @keyword
+                #                   ^ @number
+            }
+        }
+    )
+    {
+    }
+}
+
+def Xform "torch_2" (
+    payload = @./torch.usda@
+    kind = "model"
+)
+{
+    // Pre-published light list
+    # <- @comment
+    rel lightList = [ <light> ]  # inline comment
+    #                            ^ @comment
+    token lightList:cacheBehavior = "consumeAndContinue"
+
+    double3 xformOp:translate = (1, 0, 0.5)
+    uniform token[] xformOpOrder = ["xformOp:translate"]
+}
+
+def "foo" (
+  "some comment"
+  # <- @comment.documentation
+)
+{
+}
+
+def "foo" (
+  # inline comment
+  "actual in-description comment"
+  # <- @comment.documentation
+)
+{
+}
+
+def "foo" (
+    add references = @foo.usda@
+    # <- @function.call
+    append references = @foo.usda@
+    # <- @function.call
+    delete references = @foo.usda@
+    # <- @function.call
+    reorder references = [@foo.usda@]
+    # <- @function.call
+
+    references = [@foo.usda@]  # explicit
+)
+{
+}
+
+over "Parent" (
+    prepend references = [</InternalRef>, @./ref.usda@</RefParent>]
+    # <- @function.call
+    #       ^ @keyword
+    #                     ^ @string.special
+    #                                     ^ @string.special.url
+    #                                                 ^ @string.special
+)
+{
+}
+
+def "foo"
+{
+    float value.timeSamples = {
+    # <- @type
+    #     ^ @variable
+    #           ^ @property
+      -414: 14.4
+      # <- @number
+      #     ^ @number.float
+      10: 201.0,
+      # <- @number
+      #   ^ @number.float
+      10.123: 201.0123,
+      # <- @number.float
+      #       ^ @number.float
+    }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/usd/properties.usda b/pack/ant/start/nvim-treesitter/tests/query/highlights/usd/properties.usda
new file mode 100644
index 0000000..790ccfa
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/usd/properties.usda
@@ -0,0 +1,21 @@
+dictionary foo = {}
+# <- @type
+half[] foo = [2, 1, 2]
+# <- @type
+string foo = "something"
+# <- @type
+timecode time = 1.0
+# <- @type
+token[] purpose = ["default", "render"]
+# <- @type
+
+rel material:binding:collection:Erasers = None
+# <- @type
+#   ^ @module
+#           ^ @punctuation.delimiter
+#            ^ @module
+#                   ^ @punctuation.delimiter
+#                    ^ @module
+#                              ^ @punctuation.delimiter
+#                               ^ @variable
+#                                         ^ @constant.builtin
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/usd/subLayers.usda b/pack/ant/start/nvim-treesitter/tests/query/highlights/usd/subLayers.usda
new file mode 100644
index 0000000..ddd1dd7
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/usd/subLayers.usda
@@ -0,0 +1,9 @@
+#usda 1.0
+(
+    subLayers = [
+    # <- @keyword
+        @./model_sub.usda@ (offset = 1)
+        # <- @string.special.url
+        #                   ^ @keyword
+    ]
+)
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/wing/class.w b/pack/ant/start/nvim-treesitter/tests/query/highlights/wing/class.w
new file mode 100644
index 0000000..1507d75
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/wing/class.w
@@ -0,0 +1,21 @@
+bring cloud;
+// <- @keyword.import
+//    ^ @module
+
+class Foo {
+// <- @keyword.type
+//    ^   @type
+//        ^ @punctuation.bracket
+  name: str;
+//^    @property
+//      ^   @type.builtin
+//         ^ @punctuation.delimiter
+  new(name:  str) {
+//^    @keyword
+//    ^    @variable
+    this.name = name;
+//      ^ @punctuation.delimiter
+//       ^ @variable.member
+//            ^ @operator
+  }
+}
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/wing/nested_method.w b/pack/ant/start/nvim-treesitter/tests/query/highlights/wing/nested_method.w
new file mode 100644
index 0000000..080d297
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/wing/nested_method.w
@@ -0,0 +1,4 @@
+test1.test2.test3();
+// <- @variable
+//    ^ @variable.member
+//          ^ @function.method.call
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights/xhp-intro.hack b/pack/ant/start/nvim-treesitter/tests/query/highlights/xhp-intro.hack
new file mode 100644
index 0000000..0f8cffe
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights/xhp-intro.hack
@@ -0,0 +1,46 @@
+// From https://docs.hhvm.com/hack/XHP/introduction (MIT licensed)
+
+use namespace Facebook\XHP\Core as x;
+use type Facebook\XHP\HTML\{XHPHTMLHelpers, a, form};
+
+
+final xhp class a_post extends x\element {
+// ^ @keyword.modifier
+//     ^ @keyword.modifier
+//                        ^ @keyword
+  use XHPHTMLHelpers;
+
+  attribute string href @required;
+  //                      ^ @attribute
+  attribute string target;
+  // ^ @keyword
+
+  <<__Override>>
+  protected async function renderAsync(): Awaitable<x\node> {
+    $id = $this->getID();
+
+    $anchor = <a>{$this->getChildren()}</a>;
+                                    // ^ @tag.delimiter
+                                    // ^ @tag
+    $form = (
+      <form
+        id={$id}
+        method="post"
+        action={$this->:href}
+        target={$this->:target}
+        class="postLink">
+        {$anchor}
+      </form>
+    );
+
+    $anchor->setAttribute(
+      'onclick',
+      'document.getElementById("'.$id.'").submit(); return false;',
+    );
+    $anchor->setAttribute('href', '#');
+    //        ^ @function.method.call
+
+    return $form;
+  }
+}
+
diff --git a/pack/ant/start/nvim-treesitter/tests/query/highlights_spec.lua b/pack/ant/start/nvim-treesitter/tests/query/highlights_spec.lua
new file mode 100644
index 0000000..3bb03d4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/highlights_spec.lua
@@ -0,0 +1,125 @@
+local highlighter = require "vim.treesitter.highlighter"
+local parsers = require "nvim-treesitter.parsers"
+local ts = vim.treesitter
+
+local COMMENT_NODES = {
+  markdown = "html_block",
+  haskell = "haddock",
+}
+
+local function check_assertions(file)
+  local buf = vim.fn.bufadd(file)
+  vim.fn.bufload(file)
+  local lang = parsers.get_buf_lang(buf)
+  assert.same(
+    1,
+    vim.fn.executable "highlight-assertions",
+    '"highlight-assertions" not executable!'
+      .. ' Get it via "cargo install --git https://github.com/theHamsta/highlight-assertions"'
+  )
+  local comment_node = COMMENT_NODES[lang] or "comment"
+  local assertions = vim.fn.json_decode(
+    vim.fn.system(
+      "highlight-assertions -p '"
+        .. vim.api.nvim_get_runtime_file("parser/" .. lang .. ".so", false)[1]
+        .. "' -s '"
+        .. file
+        .. "' -c "
+        .. comment_node
+    )
+  )
+  local parser = parsers.get_parser(buf, lang)
+  parser:parse(true)
+
+  local self = highlighter.new(parser, {})
+
+  assert.True(#assertions > 0, "No assertions detected!")
+  for _, assertion in ipairs(assertions) do
+    local row = assertion.position.row
+    local col = assertion.position.column
+
+    local captures = {}
+    local highlights = {}
+    self:prepare_highlight_states(row, row + 1)
+    self:for_each_highlight_state(function(state)
+      if not state.tstree then
+        return
+      end
+
+      local root = state.tstree:root()
+      local root_start_row, _, root_end_row, _ = root:range()
+
+      -- Only worry about trees within the line range
+      if root_start_row > row or root_end_row < row then
+        return
+      end
+
+      local query = state.highlighter_query
+
+      -- Some injected languages may not have highlight queries.
+      if not query:query() then
+        return
+      end
+
+      local iter = query:query():iter_captures(root, self.bufnr, row, row + 1)
+
+      for capture, node, _ in iter do
+        local hl = query:get_hl_from_capture(capture)
+        assert.is.truthy(hl)
+
+        assert.Truthy(node)
+        assert.is.number(row)
+        assert.is.number(col)
+        if hl and ts.is_in_node_range(node, row, col) then
+          local c = query._query.captures[capture] -- name of the capture in the query
+          if c ~= nil and c ~= "spell" and c ~= "conceal" then
+            captures[c] = true
+            highlights[c] = true
+          end
+        end
+      end
+    end, true)
+    if assertion.expected_capture_name:match "^!" then
+      assert.Falsy(
+        captures[assertion.expected_capture_name:sub(2)] or highlights[assertion.expected_capture_name:sub(2)],
+        "Error in at "
+          .. file
+          .. ":"
+          .. (row + 1)
+          .. ":"
+          .. (col + 1)
+          .. ': expected "'
+          .. assertion.expected_capture_name
+          .. '", captures: '
+          .. vim.inspect(vim.tbl_keys(captures))
+          .. '", highlights: '
+          .. vim.inspect(vim.tbl_keys(highlights))
+      )
+    else
+      assert.True(
+        captures[assertion.expected_capture_name] or highlights[assertion.expected_capture_name],
+        "Error in at "
+          .. file
+          .. ":"
+          .. (row + 1)
+          .. ":"
+          .. (col + 1)
+          .. ': expected "'
+          .. assertion.expected_capture_name
+          .. '", captures: '
+          .. vim.inspect(vim.tbl_keys(captures))
+          .. '", highlights: '
+          .. vim.inspect(vim.tbl_keys(highlights))
+      )
+    end
+  end
+end
+
+describe("highlight queries", function()
+  local files = vim.fn.split(vim.fn.glob "tests/query/highlights/**/*.*")
+  for _, file in ipairs(files) do
+    it(file, function()
+      check_assertions(file)
+    end)
+  end
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/query/injection_spec.lua b/pack/ant/start/nvim-treesitter/tests/query/injection_spec.lua
new file mode 100644
index 0000000..95ad12e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/injection_spec.lua
@@ -0,0 +1,85 @@
+require "nvim-treesitter.highlight" -- yes, this is necessary to set the hlmap
+local configs = require "nvim-treesitter.configs"
+local parsers = require "nvim-treesitter.parsers"
+local ts = vim.treesitter
+
+local function check_assertions(file)
+  local buf = vim.fn.bufadd(file)
+  vim.fn.bufload(file)
+  local lang = parsers.get_buf_lang(buf)
+  assert.same(
+    1,
+    vim.fn.executable "highlight-assertions",
+    '"highlight-assertions" not executable!'
+      .. ' Get it via "cargo install --git https://github.com/theHamsta/highlight-assertions"'
+  )
+  local assertions = vim.fn.json_decode(
+    vim.fn.system(
+      "highlight-assertions -p '" .. configs.get_parser_install_dir() .. "/" .. lang .. ".so'" .. " -s '" .. file .. "'"
+    )
+  )
+  local parser = parsers.get_parser(buf, lang)
+
+  local self = parser
+  local top_level_root = parser:parse(true)[1]:root()
+
+  for _, assertion in ipairs(assertions) do
+    local row = assertion.position.row
+    local col = assertion.position.column
+
+    local neg_assert = assertion.expected_capture_name:match "^!"
+    assertion.expected_capture_name = neg_assert and assertion.expected_capture_name:sub(2)
+      or assertion.expected_capture_name
+    local found = false
+    self:for_each_tree(function(tstree, tree)
+      if not tstree then
+        return
+      end
+      local root = tstree:root()
+      --- If there are multiple tree with the smallest range possible
+      --- Check all of them to see if they fit or not
+      if not ts.is_in_node_range(root, row, col) or root == top_level_root then
+        return
+      end
+      if assertion.expected_capture_name == tree:lang() then
+        found = true
+      end
+    end, true)
+    if neg_assert then
+      assert.False(
+        found,
+        "Error in at "
+          .. file
+          .. ":"
+          .. (row + 1)
+          .. ":"
+          .. (col + 1)
+          .. ': expected "'
+          .. assertion.expected_capture_name
+          .. '" not to be injected here!'
+      )
+    else
+      assert.True(
+        found,
+        "Error in at "
+          .. file
+          .. ":"
+          .. (row + 1)
+          .. ":"
+          .. (col + 1)
+          .. ': expected "'
+          .. assertion.expected_capture_name
+          .. '" to be injected here!'
+      )
+    end
+  end
+end
+
+describe("injections", function()
+  local files = vim.fn.split(vim.fn.glob "tests/query/injections/**/*.*")
+  for _, file in ipairs(files) do
+    it(file, function()
+      check_assertions(file)
+    end)
+  end
+end)
diff --git a/pack/ant/start/nvim-treesitter/tests/query/injections/cuda/macro-self-injection.cu b/pack/ant/start/nvim-treesitter/tests/query/injections/cuda/macro-self-injection.cu
new file mode 100644
index 0000000..a911842
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/injections/cuda/macro-self-injection.cu
@@ -0,0 +1,2 @@
+#define FOO(X,Y) X + Y
+//                ^ @cuda
diff --git a/pack/ant/start/nvim-treesitter/tests/query/injections/dockerfile/bash-on-run-instructions.dockerfile b/pack/ant/start/nvim-treesitter/tests/query/injections/dockerfile/bash-on-run-instructions.dockerfile
new file mode 100644
index 0000000..00621f1
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/injections/dockerfile/bash-on-run-instructions.dockerfile
@@ -0,0 +1,6 @@
+FROM foo
+RUN bar
+#   ^ @bash
+RUN \
+  baz
+# ^ @bash
diff --git a/pack/ant/start/nvim-treesitter/tests/query/injections/ecma/ecma-test-injections.js b/pack/ant/start/nvim-treesitter/tests/query/injections/ecma/ecma-test-injections.js
new file mode 100644
index 0000000..16ddd3c
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/injections/ecma/ecma-test-injections.js
@@ -0,0 +1,9 @@
+html`<p></p>`;
+   // ^ @html
+html(`<p></p>`);
+   // ^ @html
+svg`<p></p>`;
+   // ^ @html
+svg(`<p></p>`);
+   // ^ @html
+
diff --git a/pack/ant/start/nvim-treesitter/tests/query/injections/html/test-html-injections.html b/pack/ant/start/nvim-treesitter/tests/query/injections/html/test-html-injections.html
new file mode 100644
index 0000000..0df3bd4
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/injections/html/test-html-injections.html
@@ -0,0 +1,55 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title></title>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link href="css/style.css" rel="stylesheet">
+    <style> footer{ } </style>
+    <!--       ^ @css  -->
+    <style title="Test Style without type attribute"> footer{ } </style>
+    <!--                                                 ^ @css  -->
+    <style type="text/css" title="test style with defined type attribute"> footer{ } </style>
+    <!--                                                                     ^ @css  -->
+  </head>
+  <body>
+    <script> const x = 1 </script>
+           <!--  ^ @javascript -->
+    <script defer> const x = 1 </script>
+                  <!--  ^ @javascript -->
+    <script async defer> const x = 1 </script>
+                     <!--  ^ @javascript -->
+    <script type="text/javascript"> const x = 1 </script>
+                                  <!--  ^ @javascript -->
+    <script type="text/ecmascript"> const x = 1 </script>
+                                  <!--  ^ @javascript -->
+    <script type="application/ecmascript"> const x = 1 </script>
+                                       <!--  ^ @javascript -->
+    <script type="application/javascript"> const x = 1 </script>
+                                       <!--  ^ @javascript -->
+    <script type="module"> import { foo } from "bar" </script>
+                                 <!--  ^ @javascript -->
+    <script defer type="text/javascript"> const x = 1 </script>
+                                        <!--  ^ @javascript -->
+    <script type="text/markdown">## Hello *World*!</script>
+                              <!--  ^ @markdown -->
+    <script type="application/graphql">query OK { dokey }</script>
+                                      <!--  ^ @graphql -->
+    <script type="application/typescript">type A = number;</script>
+                                      <!--  ^ @typescript -->
+    <script type="application/json">{ "true": false }</script>
+                                      <!--  ^ @json -->
+    <script type="importmap">{ "true": false }</script>
+                                  <!--  ^ @json -->
+    <div style="height: 100%">
+               <!--  ^ @css -->
+      Test div to test css injections for style attributes
+    </div>
+
+    <input pattern="[0-9]+">
+                  <!--  ^ @regex -->
+    <input pattern=[0-9]+ type="tel">
+                <!--  ^ @regex -->
+
+  </body>
+</html>
diff --git a/pack/ant/start/nvim-treesitter/tests/query/injections/query/test-query-injections.scm b/pack/ant/start/nvim-treesitter/tests/query/injections/query/test-query-injections.scm
new file mode 100644
index 0000000..f382edd
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/injections/query/test-query-injections.scm
@@ -0,0 +1,27 @@
+; vim: ft=query
+; format-ignore
+(((symbol) @constant
+  (#not-lua-match? @constant "^_*[A-Z][A-Z0-9_]*$"))
+;                             ^ @luap
+)
+
+; format-ignore
+(((tag
+  (attributes
+    (attribute
+      (attribute_name) @keyword)))
+  (#match? @keyword "^(:|v-bind|v-|\\@)"))
+;                    ^ @regex
+)
+
+((comment) @injection.language
+  .
+  [
+    (string_expression
+      (string_fragment) @injection.content)
+    (indented_string_expression
+      (string_fragment) @injection.content)
+  ]
+  (#gsub! @injection.language "#%s*([%w%p]+)%s*" "%1")
+  ;                            ^ @luap
+  (#set! injection.combined))
diff --git a/pack/ant/start/nvim-treesitter/tests/query/injections/svelte/test-svelte-injections.svelte b/pack/ant/start/nvim-treesitter/tests/query/injections/svelte/test-svelte-injections.svelte
new file mode 100644
index 0000000..ea88aa6
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/injections/svelte/test-svelte-injections.svelte
@@ -0,0 +1,22 @@
+<script> import Button from "./Button.svelte"; </script>
+<!--               ^ @javascript -->
+<script lang="ts"> const foo: number = 1 </script>
+<!--                            ^ @typescript -->
+<!--                            ^ @!javascript -->
+
+<style> main { font-family: sans-serif; text-align: center; } </style>
+<!--                        ^ @css  -->
+<style lang="scss"> main { &:hover { } } </style>
+<!--                        ^ @scss -->
+<!--                        ^ @!css -->
+
+<main>
+	<h1>Test file</h1>
+  {#each someItems as someItem}
+<!--          ^ @javascript -->
+    <div>{someItem}</div>
+<!--          ^ @javascript -->
+  {/each}
+	<Button />
+  <button on:click={() => foo++}></button>
+</main>
diff --git a/pack/ant/start/nvim-treesitter/tests/query/injections/vue/negative-assertions.vue b/pack/ant/start/nvim-treesitter/tests/query/injections/vue/negative-assertions.vue
new file mode 100644
index 0000000..000702a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/injections/vue/negative-assertions.vue
@@ -0,0 +1,4 @@
+<script lang="ts"> const foo: number = "1" </script>
+<!--                           ^ @!javascript   -->
+<style lang="scss"> .bar { &-baz { &.page{ } } } </style>
+<!--                           ^ @!css          -->
diff --git a/pack/ant/start/nvim-treesitter/tests/query/injections/vue/test-vue-injections.vue b/pack/ant/start/nvim-treesitter/tests/query/injections/vue/test-vue-injections.vue
new file mode 100644
index 0000000..4966e6a
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/injections/vue/test-vue-injections.vue
@@ -0,0 +1,39 @@
+<template>
+  <span>{{"Text inside interpolation"}}</span>
+  <!--       ^ @typescript -->
+
+  <template lang="pug"> a(:href="url") some link title in pug: </template>
+  <!--                                        ^ @pug -->
+
+  <template v-if="'text inside directives'"></template>
+<!--               ^ @typescript -->
+</template>
+<script> const foo = "1" </script>
+<!--       ^ @javascript -->
+<script defer> const foo = "1" </script>
+<!--               ^ @javascript -->
+<script lang="js">function x(){ return 1;}</script>
+<!--                               ^ @javascript -->
+<script lang="ts"> const foo: number = "1" </script>
+<!--                             ^ @typescript -->
+<!--                             ^ @!javascript -->
+<script lang="ts" defer>const foo: number = 1 </script>
+<!--                             ^ @typescript -->
+<!--                             ^ @!javascript -->
+<script lang="tsx" defer>const foo: number = 1</script>
+                              <!--   ^ @tsx -->
+                              <!--   ^ @!jsx -->
+                              <!--   ^ @!typescript -->
+<style> .bar { .foo{ } } </style>
+<!--                 ^ @css   -->
+<style scoped> .page.page--news { background: rebeccapurple; } </style>
+<!--                 ^ @css  -->
+<style lang="css"> .bar { justify-content: center; } </style>
+<!--                 ^ @css  -->
+<style lang="scss"> .bar { &-baz { } } </style>
+<!--                        ^ @scss -->
+<!--                        ^ @!css -->
+<style scoped lang="scss">body{} </style>
+<!--                        ^ @scss -->
+<!--                        ^ @!css -->
+  // const file = files[0];
diff --git a/pack/ant/start/nvim-treesitter/tests/query/injections/yaml/bash-on-github-actions.yml b/pack/ant/start/nvim-treesitter/tests/query/injections/yaml/bash-on-github-actions.yml
new file mode 100644
index 0000000..5c732b0
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/injections/yaml/bash-on-github-actions.yml
@@ -0,0 +1,32 @@
+name: CI
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: '16'
+      - name: Install dependencies
+        run: npm ci
+      #      ^ @bash
+      - name: Run tests
+        run: npm test
+      #      ^ @bash
+      - name: Parse Petalisp
+        run: |
+          git submodule init
+          git submodule update
+          if (( $(node_modules/tree-sitter-cli/tree-sitter parse test/Petalisp/**/*.lisp -q | wc -l) > 2 )); then # There are 2 known failures (strings that are not format strings but use ~X syntax)
+            exit 1 
+          else
+            echo "Successfully parsed Petalisp"
+          fi
+      #    ^ @bash
+      - name: Run tests
+        run: npm test
diff --git a/pack/ant/start/nvim-treesitter/tests/query/injections/yaml/promql-on-prometheus-rules.yaml b/pack/ant/start/nvim-treesitter/tests/query/injections/yaml/promql-on-prometheus-rules.yaml
new file mode 100644
index 0000000..f064da3
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/query/injections/yaml/promql-on-prometheus-rules.yaml
@@ -0,0 +1,19 @@
+groups:
+- name: Hardware alerts
+  rules:
+  - alert: Node down
+    expr: up{job="node_exporter"} == 0
+    #     ^ @promql
+    for: 3m
+    labels:
+      severity: warning
+    annotations:
+      title: Node {{ $labels.instance }} is down
+      description: Failed to scrape {{ $labels.job }} on {{ $labels.instance }} for more than 3 minutes. Node seems down.
+  - alert: Node down
+    expr: |
+      up{job="node_exporter"} == 0
+    # ^ @promql
+    for: 3m
+    labels:
+      severity: warning
diff --git a/pack/ant/start/nvim-treesitter/tests/unit/ts_utils_spec.lua b/pack/ant/start/nvim-treesitter/tests/unit/ts_utils_spec.lua
new file mode 100644
index 0000000..397fa7e
--- /dev/null
+++ b/pack/ant/start/nvim-treesitter/tests/unit/ts_utils_spec.lua
@@ -0,0 +1,114 @@
+local tsutils = require "nvim-treesitter.ts_utils"
+
+describe("update_selection", function()
+  local function get_updated_selection(case)
+    vim.api.nvim_buf_set_lines(0, 0, -1, false, case.lines)
+    tsutils.update_selection(0, case.node, case.selection_mode)
+    vim.cmd "normal! y"
+    return vim.fn.getreg '"'
+  end
+
+  it("charwise1", function()
+    assert.equal(
+      get_updated_selection {
+        lines = { "foo", "", "bar" },
+        node = { 0, 0, 2, 1 },
+        selection_mode = "v",
+      },
+      "foo\n\nb"
+    )
+    it("charwise2", function() end)
+    assert.equal(
+      get_updated_selection {
+        lines = { "foo", "", "bar" },
+        node = { 0, 1, 2, 1 },
+        selection_mode = "v",
+      },
+      "oo\n\nb"
+    )
+    it("charwise3", function() end)
+    assert.equal(
+      get_updated_selection {
+        lines = { "foo", "", "bar" },
+        node = { 0, 2, 2, 1 },
+        selection_mode = "v",
+      },
+      "o\n\nb"
+    )
+    it("charwise4", function() end)
+    assert.equal(
+      get_updated_selection {
+        lines = { "foo", "", "bar" },
+        node = { 0, 3, 2, 1 },
+        selection_mode = "v",
+      },
+      "\n\nb"
+    )
+  end)
+  it("linewise", function()
+    assert.equal(
+      get_updated_selection {
+        lines = { "foo", "", "bar" },
+        node = { 0, 3, 2, 1 },
+        selection_mode = "V",
+      },
+      "foo\n\nbar\n"
+    )
+  end)
+  it("blockwise", function()
+    assert.equal(
+      get_updated_selection {
+        lines = { "foo", "", "bar" },
+        node = { 0, 3, 2, 1 },
+        selection_mode = "<C-v>",
+      },
+      "foo\n\nbar"
+    )
+  end)
+end)
+
+describe("swap_nodes", function()
+  local function swap(case)
+    vim.api.nvim_buf_set_lines(0, 0, -1, false, case.lines)
+    vim.opt.filetype = case.filetype
+    local a = vim.treesitter.get_node {
+      bufnr = 0,
+      pos = { case.a[1], case.a[2] },
+    }
+    local b = vim.treesitter.get_node {
+      bufnr = 0,
+      pos = { case.b[1], case.b[2] },
+    }
+    tsutils.swap_nodes(a, b, 0, true)
+  end
+
+  it("works on adjacent nodes", function()
+    swap {
+      filetype = "python",
+      lines = { "print(1)" },
+      a = { 0, 0 },
+      b = { 0, 5 },
+    }
+
+    it("swaps text", function() end)
+    assert.same(vim.api.nvim_buf_get_lines(0, 0, -1, false), { "(1)print" })
+
+    it("moves the cursor", function() end)
+    assert.same(vim.api.nvim_win_get_cursor(0), { 1, 3 })
+  end)
+
+  it("works with multiline nodes", function()
+    swap {
+      filetype = "lua",
+      lines = { "x = { [[", "]], [[", ".....]]}" },
+      a = { 0, 6 },
+      b = { 1, 4 },
+    }
+
+    it("swaps text", function() end)
+    assert.same(vim.api.nvim_buf_get_lines(0, 0, -1, false), { "x = { [[", ".....]], [[", "]]}" })
+
+    it("moves the cursor", function() end)
+    assert.same(vim.api.nvim_win_get_cursor(0), { 2, 9 })
+  end)
+end)
diff --git a/plugins.md b/plugins.md
index 51b0469..2cef232 100644
--- a/plugins.md
+++ b/plugins.md
@@ -10,6 +10,7 @@ Git submodules are slow, so handle this manually.
 * [coc.nvim](https://github.com/neoclide/coc.nvim)
 * [limelight.vim](https://github.com/junegunn/limelight.vim)
 * [mom.vim](http://git.savannah.gnu.org/cgit/groff.git/plain/contrib/mom/examples/mom.vim)
+* [nvim-treesitter](https://github.com/nvim-treesitter/nvim-treesitter)
 * [tempus-themes-vim](https://gitlab.com/protesilaos/tempus-themes-vim)
 * [vim-actodo](https://github.com/acperkins/vim-actodo)
 * [vim-asciidoctor](https://github.com/habamax/vim-asciidoctor)