add tea (Gitea CLI) to home packages

- Remove deleted fonts.nix from directory layout
- Update 'Adding a New Program' section to reflect ponytail cleanup: simple packages go in common.nix, per-file only for programs needing real configuration
- Update Rules section to document common.nix and per-file program patterns

.gitignore

@@ -0,0 +1,10 @@
+.claude
+docs/
+
+# secret guardrails — keep credentials out of the repo
+secrets/
+*.age
+*.key
+*.pem
+.env
+.env.*

CLAUDE.md

@@ -0,0 +1,48 @@
+# NixOS Dotfiles
+
+## Directory Layout
+
+```
+flake.nix                        # entry point, defines hosts
+hosts/
+  hivebrain/                     # marvin's main machine
+  nikita-nixos/                  # nikita's machine
+home/
+  packages-base.nix              # universal packages every host gets (neovim, ripgrep, etc.)
+  programs/                      # installable programs (common.nix for simple packages, per-file for configured programs)
+  rofi.nix                       # rofi config + packages
+  symlinks.nix                   # home-manager symlinks
+  tmux.nix                       # tmux config
+  yazi.nix                       # yazi config
+  zsh.nix                        # zsh config
+system/                          # NixOS system-level modules
+```
+
+## Adding a New Program
+
+**For simple packages (no config):** Add the package to `home/programs/common.nix`'s `home.packages` list.
+
+**For programs that need configuration** (session variables, extra options, dependencies): Create `home/programs/<name>.nix`:
+
+```nix
+{ pkgs, ... }:
+{
+  # configuration + packages
+}
+```
+
+Then add the import to `hosts/<host>/home.nix`:
+
+```nix
+../../home/programs/<name>.nix
+```
+
+Example: `rustup.nix` needs config (session variables) so it gets its own file. Simple packages like `lazygit` go in `common.nix`.
+
+## Rules
+
+- `home/packages-base.nix` — shared baseline, imported by every host. Only add truly universal tools here (shell utilities, editors).
+- `home/programs/common.nix` — simple packages that just need to be installed (no extra config).
+- `home/programs/<name>.nix` — programs that need real configuration beyond just `home.packages`. Hosts opt in by importing.
+- `home/<tool>.nix` (tmux, zsh, rofi, etc.) — for programs that need configuration beyond just installing a package. Same opt-in pattern via host imports.
+- `system/` modules are NixOS system-level config (not home-manager). Add them to `hosts/<host>/default.nix`.

README.md

@@ -0,0 +1,12 @@
+What's verified:
+  - nix flake check passes for both hivebrain and nikita-nixos
+  - nixos-rebuild dry-build --flake .#hivebrain succeeds (your config is unchanged in behavior)
+  - nixos-rebuild dry-build --flake .#nikita-nixos succeeds (Plasma 6 + SDDM derivation resolves)
+  - main is untouched
+
+  What's still TODO before you can install nikita-nixos:
+  - Replace hosts/nikita-nixos/hardware-configuration.nix (placeholder with PLACEHOLDER-ROOT label) with
+  the real output of nixos-generate-config --root /mnt on his machine.
+  - Replace the placeholder git identity in hosts/nikita-nixos/home.nix (currently Nikita /
+  nikita@example.com).
+  - Set Nikita's password with passwd after first boot — nothing is baked in.

config/alacritty/alacritty.toml

@@ -0,0 +1,5 @@
+[window]
+opacity = 0.9
+
+[font]
+normal = { family = "JetBrainsMono Nerd Font", style = "Regular" }

config/nvim/.gitignore

@@ -1 +1,8 @@
-lazy-lock.json
+tt.*
+.tests
+doc/tags
+debug
+.repro
+foo.*
+*.log
+data

config/nvim/.neoconf.json

@@ -0,0 +1,15 @@
+{
+  "neodev": {
+    "library": {
+      "enabled": true,
+      "plugins": true
+    }
+  },
+  "neoconf": {
+    "plugins": {
+      "lua_ls": {
+        "enabled": true
+      }
+    }
+  }
+}

config/nvim/.stylua.toml

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

config/nvim/README.md

@@ -1,117 +0,0 @@
-# Neovim Keybinds Documentation
-
-This document provides a simple and organized overview of all the custom keybinds defined in my Neovim configuration.
-
-## General Keybinds
-
-| Mode | Key             | Action                                                                                      |
-|------|-----------------|---------------------------------------------------------------------------------------------|
-| `n`  | `<leader>cd`    | Open Ex mode (`:Ex`)                                                                        |
-| `n`  | `J`             | Join lines while keeping the cursor in place                                                |
-| `n`  | `<C-d>`         | Scroll half-page down and keep the cursor centered                                          |
-| `n`  | `<C-u>`         | Scroll half-page up and keep the cursor centered                                            |
-| `n`  | `n`             | Move to next search result and keep it centered                                             |
-| `n`  | `N`             | Move to previous search result and keep it centered                                         |
-| `n`  | `Q`             | Disable Ex mode                                                                             |
-| `n`  | `<C-k>`         | Jump to next quickfix entry and keep it centered                                            |
-| `n`  | `<C-j>`         | Jump to previous quickfix entry and keep it centered                                        |
-| `n`  | `<leader>k`     | Jump to next location entry and keep it centered                                            |
-| `n`  | `<leader>j`     | Jump to previous location entry and keep it centered                                        |
-| `i`  | `<C-c>`         | Exit insert mode (acts like `Esc`)                                                          |
-| `n`  | `<leader>x`     | Make current file executable (`chmod +x`)                                                   |
-| `n`  | `<leader>u`     | Toggle Undotree                                                                             |
-| `n`  | `<leader>rl`    | Reload the Neovim config (`~/.config/nvim/init.lua`)                                        |
-| `n`  | `<leader><leader>` | Source the current file (`:so`)                                                          |
-
----
-
-## Visual Mode Keybinds
-
-| Mode | Key             | Action                                                                                      |
-|------|-----------------|---------------------------------------------------------------------------------------------|
-| `v`  | `J`             | Move selected block down                                                                    |
-| `v`  | `K`             | Move selected block up                                                                      |
-| `x`  | `<leader>p`     | Paste without overwriting clipboard                                                         |
-| `v`  | `<leader>y`     | Yank into system clipboard (even on SSH)                                                    |
-
----
-
-## Linting and Formatting
-
-| Mode | Key             | Action                                                                                      |
-|------|-----------------|---------------------------------------------------------------------------------------------|
-| `n`  | `<leader>cc`    | Run `php-cs-fixer` to lint and format PHP files                                             |
-| `n`  | `<F3>`          | Format code (`LSP`)                                                                         |
-
----
-
-## Telescope Keybinds
-
-| Mode | Key             | Action                                                                                      |
-|------|-----------------|---------------------------------------------------------------------------------------------|
-| `n`  | `<leader>ff`    | Find files                                                                                  |
-| `n`  | `<leader>fg`    | Find git-tracked files                                                                      |
-| `n`  | `<leader>fo`    | Open recent files                                                                           |
-| `n`  | `<leader>fq`    | Open quickfix list                                                                          |
-| `n`  | `<leader>fh`    | Open help tags                                                                              |
-| `n`  | `<leader>fb`    | Open buffer list                                                                            |
-| `n`  | `<leader>fs`    | Grep current string                                                                         |
-| `n`  | `<leader>fc`    | Grep instances of the current file name without the extension                               |
-| `n`  | `<leader>fi`    | Find files in Neovim configuration directory (`~/.config/nvim/`)                            |
-
----
-
-## Harpoon Integration
-
-| Mode | Key             | Action                                                                                      |
-|------|-----------------|---------------------------------------------------------------------------------------------|
-| `n`  | `<leader>a`     | Add current file to Harpoon list                                                            |
-| `n`  | `<C-e>`         | Toggle Harpoon quick menu                                                                   |
-| `n`  | `<leader>fl`    | Open Harpoon window with Telescope                                                          |
-| `n`  | `<C-p>`         | Go to previous Harpoon mark                                                                 |
-| `n`  | `<C-n>`         | Go to next Harpoon mark                                                                     |
-
----
-
-## LSP Keybinds
-
-| Mode      | Key        | Action                                                                                      |
-|-----------|------------|---------------------------------------------------------------------------------------------|
-| `n`       | `K`        | Show hover information                                                                      |
-| `n`       | `gd`       | Go to definition                                                                            |
-| `n`       | `gD`       | Go to declaration                                                                           |
-| `n`       | `gi`       | Go to implementation                                                                        |
-| `n`       | `go`       | Go to type definition                                                                       |
-| `n`       | `gr`       | Show references                                                                             |
-| `n`       | `gs`       | Show signature help                                                                         |
-| `n`       | `gl`       | Show diagnostics in a floating window                                                       |
-| `n`       | `<F2>`     | Rename symbol                                                                               |
-| `n`, `x`  | `<F3>`     | Format code asynchronously                                                                 |
-| `n`       | `<F4>`     | Show code actions                                                                           |
-
----
-
-## Miscellaneous
-
-| Mode | Key             | Action                                                                                      |
-|------|-----------------|---------------------------------------------------------------------------------------------|
-| `n`  | `<leader>dg`    | Run `DogeGenerate` (comment documentation generation)                                       |
-| `n`  | `<leader>s`     | Replace all instances of the word under the cursor on the current line                      |
-
----
-
-# LSP servers:
-
-I am migrating my lsp config to /lua/plugins/lsp.lua because nvim v0.11 allows a very minimal debloated way to setup language server protocols. 
-
-Below is a running list of what and how to install the lsp's that are going to be configured in this build. I will avoid mason for now because I think its better to have full control over your system, and not outsource it to mason. Just uncommonet `return {` in /plugins/lsp.lua from the original lspconfig if you want to go that route.
-
-1. { lua-language-server } 
-  - refer to distro ( pacman -Ss lua-language-server )
-2. { css-language-server --studio, html-language-server }
-  - npm install -g vscode-langservers-extracted
-3. { intelephense }
-  - npm install -g intelephense
-4. { typescript-language-server }
-  - npm install -g typescript-language-server typescript
-

config/nvim/after/ftplugin/goon.lua

@@ -1,2 +0,0 @@
-vim.bo.commentstring = "// %s"
-vim.bo.comments = "s:/*,m: *,ex:*/,://"

config/nvim/after/ftplugin/hare.lua

@@ -1,12 +0,0 @@
-local set = vim.opt_local
-
-vim.bo.commentstring = "// %s"
-vim.bo.comments = "s:/*,m: *,ex:*/,://"
-
-set.shiftwidth = 4
-set.tabstop = 4
-set.softtabstop = 4
-set.expandtab = true
-
-set.number = true
-set.relativenumber = true

config/nvim/after/ftplugin/jsonc.lua

@@ -1,9 +0,0 @@
-local set = vim.opt_local
-
-set.shiftwidth = 2
-set.tabstop = 2
-set.softtabstop = 2
-set.expandtab = true
-
-set.number = true
-set.relativenumber = true

config/nvim/after/ftplugin/man.lua

@@ -1,8 +0,0 @@
-local set = vim.opt_local
-set.number = true
-set.relativenumber = true
-set.number = true
-set.relativenumber = false
-set.wrap = true
-set.linebreak = true
-set.conceallevel = 0

config/nvim/after/ftplugin/nix.lua

@@ -1,8 +0,0 @@
-local set = vim.opt_local
-
-set.shiftwidth = 2
-set.tabstop = 2
-set.softtabstop = 2
-set.expandtab = true
-set.number = true
-set.relativenumber = true

config/nvim/after/plugin/colors.lua

@@ -1,6 +0,0 @@
-vim.cmd.colorscheme("tokyonight")
-vim.cmd("hi Directory guibg=NONE")
-vim.cmd("hi SignColumn guibg=NONE")
-vim.api.nvim_set_hl(0, "Normal", { bg = "none" })
-vim.api.nvim_set_hl(0, "NormalFloat", { bg = "none" })
-vim.api.nvim_set_hl(0, "LineNr", { bg = "none" })

config/nvim/after/plugin/completion.lua

@@ -1,33 +0,0 @@
-local cmp = require("cmp")
-require("cmp_nvim_lsp").setup()
-cmp.register_source("path", require("cmp_path").new())
-cmp.register_source("buffer", require("cmp_buffer"))
-
-cmp.setup({
-    preselect = cmp.PreselectMode.Item,
-    completion = {
-        completeopt = "menu,menuone,noinsert",
-        autocomplete = { cmp.TriggerEvent.TextChanged },
-    },
-    window = { documentation = cmp.config.window.bordered() },
-    mapping = cmp.mapping.preset.insert({
-        ["<CR>"] = cmp.mapping.confirm({ select = false }),
-        ["<C-e>"] = cmp.mapping.abort(),
-        ["<C-Space>"] = cmp.mapping.complete(),
-        ["<C-n>"] = cmp.mapping.select_next_item({ behavior = cmp.SelectBehavior.Select }),
-        ["<C-p>"] = cmp.mapping.select_prev_item({ behavior = cmp.SelectBehavior.Select }),
-        ["<C-f>"] = cmp.mapping.scroll_docs(4),
-        ["<C-u>"] = cmp.mapping.scroll_docs(-4),
-        ["<Tab>"] = cmp.mapping(function(fallback)
-            if cmp.visible() then cmp.select_next_item() else fallback() end
-        end, { "i", "s" }),
-        ["<S-Tab>"] = cmp.mapping(function()
-            if cmp.visible() then cmp.select_prev_item() end
-        end, { "i", "s" }),
-    }),
-    sources = {
-        { name = "nvim_lsp" },
-        { name = "path" },
-        { name = "buffer", keyword_length = 3 },
-    },
-})

config/nvim/after/plugin/harpoon.lua

@@ -1,21 +0,0 @@
-local harpoon = require("harpoon")
-harpoon:setup()
-
-vim.keymap.set("n", "<leader>a", function() harpoon:list():add() end)
-vim.keymap.set("n", "<C-e>", function() harpoon.ui:toggle_quick_menu(harpoon:list()) end)
-vim.keymap.set("n", "<C-p>", function() harpoon:list():prev() end)
-vim.keymap.set("n", "<C-n>", function() harpoon:list():next() end)
-
-vim.keymap.set("n", "<leader>fl", function()
-    local conf = require("telescope.config").values
-    local themes = require("telescope.themes")
-    local file_paths = {}
-    for _, item in ipairs(harpoon:list().items) do
-        table.insert(file_paths, item.value)
-    end
-    require("telescope.pickers").new(themes.get_ivy({ prompt_title = "Working List" }), {
-        finder = require("telescope.finders").new_table({ results = file_paths }),
-        previewer = conf.file_previewer({}),
-        sorter = conf.generic_sorter({}),
-    }):find()
-end, { desc = "Open harpoon window" })

config/nvim/after/plugin/one-liners.lua

@@ -1,2 +0,0 @@
-require("lualine").setup({ options = { theme = "tokyonight" } })
-require("nvim-highlight-colors").setup({})

config/nvim/after/plugin/telescope.lua

@@ -1,34 +0,0 @@
-local actions = require("telescope.actions")
-require("telescope").setup({
-    defaults = {
-        mappings = {
-            i = {
-                ["<C-k>"] = actions.move_selection_previous,
-                ["<C-j>"] = actions.move_selection_next,
-                ["<C-q>"] = actions.smart_send_to_qflist + actions.open_qflist,
-            },
-        },
-    },
-})
-
-local builtin = require("telescope.builtin")
-vim.keymap.set("n", "<leader>ff", builtin.find_files)
-vim.keymap.set("n", "<leader>fo", builtin.oldfiles)
-vim.keymap.set("n", "<leader>fq", builtin.quickfix)
-vim.keymap.set("n", "<leader>fh", builtin.help_tags, { desc = "Telescope help tags" })
-vim.keymap.set("n", "<leader>fm", function()
-    builtin.man_pages({ sections = { "ALL" } })
-end, { desc = "Telescope man pages" })
-vim.keymap.set("n", "<leader>fb", builtin.buffers, { desc = "Telescope buffers" })
-vim.keymap.set("n", "<leader>fg", function()
-    builtin.grep_string({ search = vim.fn.input("Grep > ") })
-end)
-vim.keymap.set("n", "<leader>fc", function()
-    builtin.grep_string({ search = vim.fn.expand("%:t:r") })
-end, { desc = "Find current file" })
-vim.keymap.set("n", "<leader>fs", function()
-    builtin.grep_string({})
-end, { desc = "Find current string" })
-vim.keymap.set("n", "<leader>fi", function()
-    builtin.find_files({ cwd = "~/.config/nvim/" })
-end)

config/nvim/after/plugin/treesitter.lua

@@ -1,6 +0,0 @@
--- Treesitter config lives in plugin/tonysitter.lua.
--- The only thing left here is the goon filetype mapping;
--- goon's parser is at ~/.local/share/nvim/site/parser/goon.so
--- and queries are at ~/.config/nvim/queries/goon/, both auto-loaded.
-
-vim.filetype.add({ extension = { goon = "goon" } })

config/nvim/init.lua

@@ -1,3 +1,2 @@
-require("config.options")
+-- bootstrap lazy.nvim, LazyVim and your plugins
-require("config.keybinds")
+require("config.lazy")
-require("manage").setup()

config/nvim/lazy-lock.json

@@ -0,0 +1,43 @@
+{
+  "LazyVim": { "branch": "main", "commit": "459a4c3b1059671e766a46c7cc223827dc67e3d0" },
+  "blink.cmp": { "branch": "main", "commit": "78336bc89ee5365633bcf754d93df01678b5c08f" },
+  "bufferline.nvim": { "branch": "main", "commit": "655133c3b4c3e5e05ec549b9f8cc2894ac6f51b3" },
+  "catppuccin": { "branch": "main", "commit": "e068ab5f8261f23f6f71ffd8791ae40315b77b9c" },
+  "conform.nvim": { "branch": "master", "commit": "619363c30309d29ffa631e67c8183f2a72caa373" },
+  "crates.nvim": { "branch": "main", "commit": "694357861ec9ebf12475ddcdd04ea45a0923c32d" },
+  "flash.nvim": { "branch": "main", "commit": "fcea7ff883235d9024dc41e638f164a450c14ca2" },
+  "friendly-snippets": { "branch": "main", "commit": "6cd7280adead7f586db6fccbd15d2cac7e2188b9" },
+  "gitsigns.nvim": { "branch": "main", "commit": "2038c666bd9d8a0b7349a0b6ee00dc83104b9ecf" },
+  "grug-far.nvim": { "branch": "main", "commit": "c69859c1d5427ab5fc7ed12380ab521b4e336691" },
+  "lazy.nvim": { "branch": "main", "commit": "85c7ff3711b730b4030d03144f6db6375044ae82" },
+  "lazydev.nvim": { "branch": "main", "commit": "ff2cbcba459b637ec3fd165a2be59b7bbaeedf0d" },
+  "lualine.nvim": { "branch": "master", "commit": "221ce6b2d999187044529f49da6554a92f740a96" },
+  "mason-lspconfig.nvim": { "branch": "main", "commit": "47059d71b42d74b0a1e9f61c1d99d301039c3b5b" },
+  "mason-nvim-dap.nvim": { "branch": "main", "commit": "9a10e096703966335bd5c46c8c875d5b0690dade" },
+  "mason.nvim": { "branch": "main", "commit": "2a6940af80375532e5e9e7c1f2fc6319a1b7a69d" },
+  "mini.ai": { "branch": "main", "commit": "cb20f298ebf5ae91924cd0c6c310712de2ef4086" },
+  "mini.icons": { "branch": "main", "commit": "e56797f90192d81f1fda02e662fc3e8e3d775027" },
+  "mini.pairs": { "branch": "main", "commit": "db0fac0a25884183650352ccf92b362a41ed2e9c" },
+  "noice.nvim": { "branch": "main", "commit": "7bfd942445fb63089b59f97ca487d605e715f155" },
+  "nui.nvim": { "branch": "main", "commit": "de740991c12411b663994b2860f1a4fd0937c130" },
+  "nvim-dap": { "branch": "master", "commit": "9e848e09a697ee95302a3ef2dd43fd6eb709e570" },
+  "nvim-dap-ui": { "branch": "master", "commit": "1a66cabaa4a4da0be107d5eda6d57242f0fe7e49" },
+  "nvim-dap-virtual-text": { "branch": "master", "commit": "fbdb48c2ed45f4a8293d0d483f7730d24467ccb6" },
+  "nvim-lint": { "branch": "master", "commit": "a219b2c9e5b4765e5c845aba119dad55806fcaf1" },
+  "nvim-lspconfig": { "branch": "master", "commit": "3371bf298c1f56efc26771ee961f461176958fb5" },
+  "nvim-nio": { "branch": "master", "commit": "21f5324bfac14e22ba26553caf69ec76ae8a7662" },
+  "nvim-treesitter": { "branch": "main", "commit": "4916d6592ede8c07973490d9322f187e07dfefac" },
+  "nvim-treesitter-textobjects": { "branch": "main", "commit": "851e865342e5a4cb1ae23d31caf6e991e1c99f1e" },
+  "nvim-ts-autotag": { "branch": "main", "commit": "88c1453db4ba7dd24131086fe51fdf74e587d275" },
+  "persistence.nvim": { "branch": "main", "commit": "b20b2a7887bd39c1a356980b45e03250f3dce49c" },
+  "plenary.nvim": { "branch": "master", "commit": "74b06c6c75e4eeb3108ec01852001636d85a932b" },
+  "rose-pine": { "branch": "main", "commit": "ff483051a47e27d84bdef47703538df1ed9f4a47" },
+  "rustaceanvim": { "branch": "main", "commit": "5a3a4158857ee1f7ec839b6ddd87cc0083a19c5f" },
+  "snacks.nvim": { "branch": "main", "commit": "882c996cf28183f4d63640de0b4c02ec886d01f2" },
+  "todo-comments.nvim": { "branch": "main", "commit": "31e3c38ce9b29781e4422fc0322eb0a21f4e8668" },
+  "tokyonight.nvim": { "branch": "main", "commit": "cdc07ac78467a233fd62c493de29a17e0cf2b2b6" },
+  "trouble.nvim": { "branch": "main", "commit": "bd67efe408d4816e25e8491cc5ad4088e708a69a" },
+  "ts-comments.nvim": { "branch": "main", "commit": "a59d6092213447450191122c9346f309161504cb" },
+  "vim-tmux-navigator": { "branch": "master", "commit": "e41c431a0c7b7388ae7ba341f01a0d217eb3a432" },
+  "which-key.nvim": { "branch": "main", "commit": "3aab2147e74890957785941f0c1ad87d0a44c15a" }
+}

config/nvim/lazyvim.json

@@ -0,0 +1,10 @@
+{
+  "extras": [
+
+  ],
+  "install_version": 8,
+  "news": {
+    "NEWS.md": "11866"
+  },
+  "version": 8
+}

config/nvim/lua/config/keybinds.lua

@@ -1,64 +0,0 @@
--- KEYBINDS
-vim.g.mapleader = " "
-vim.keymap.set("n", "<leader>cd", vim.cmd.Ex)
-
-vim.keymap.set("v", "J", ":m '>+1<CR>gv=gv") -- Alt Up/Down in vscode
-vim.keymap.set("v", "K", ":m '<-2<CR>gv=gv")
-
-vim.keymap.set("n", "J", "mzJ`z")       -- Remap joining lines
-vim.keymap.set("n", "<C-d>", "<C-d>zz") -- Keep cursor in place while moving up/down page
-vim.keymap.set("n", "<C-u>", "<C-u>zz")
-vim.keymap.set("n", "n", "nzzzv")       -- center screen when looping search results
-vim.keymap.set("n", "N", "Nzzzv")
-
--- paste and don't replace clipboard over deleted text
-vim.keymap.set("x", "<leader>p", [["_dP]])
-vim.keymap.set({ "n", "v" }, "<leader>d", [["_d]])
-
-
--- sometimes in insert mode, control-c doesn't exactly work like escape
-vim.keymap.set("i", "<C-c>", "<Esc>")
-
--- add binds for Control J/K to scroll thru quickfix list
-vim.keymap.set("n", "<C-j>", "<cmd>cnext<CR>zz")
-vim.keymap.set("n", "<C-k>", "<cmd>cprev<CR>zz")
-
--- What the heck is Ex mode?
-vim.keymap.set("n", "Q", "<nop>")
-
-vim.keymap.set("n", "<leader>k", "<cmd>lnext<CR>zz")
-vim.keymap.set("n", "<leader>j", "<cmd>lprev<CR>zz")
-
-
--- lint / format php files for LC
-vim.keymap.set("n", "<leader>cc", "<cmd>!php-cs-fixer fix % --using-cache=no<cr>")
-
--- Replace all instances of whatever is under cursor (on line)
-vim.keymap.set("n", "<leader>s", [[:s/\<<C-r><C-w>\>//gI<Left><Left><Left>]])
-
--- make file executable
-vim.keymap.set("n", "<leader>x", "<cmd>!chmod +x %<CR>", { silent = true })
-
--- yank into clipboard even if on ssh
-vim.keymap.set('n', '<leader>y', '<Plug>OSCYankOperator')
-vim.keymap.set('v', '<leader>y', '<Plug>OSCYankVisual')
-
--- reload without exiting vim
-vim.keymap.set("n", "<leader>rl", "<cmd>source ~/.config/nvim/init.lua<cr>")
-
-vim.keymap.set("n", "<leader>u", vim.cmd.UndotreeToggle)
-
--- Quickfix list stuff
-vim.keymap.set("n", "<leader>cl", ":cclose<CR>", { silent = true })
-vim.keymap.set("n", "<leader>co", ":copen<CR>", { silent = true })
-vim.keymap.set("n", "<leader>cn", ":cnext<CR>zz")
-vim.keymap.set("n", "<leader>cp", ":cprev<CR>zz")
-vim.keymap.set("n", "<leader>li", ":checkhealth vim.lsp<CR>", { desc = "LSP Info" })
-
--- run make in current working directory
-vim.keymap.set("n", "<leader>mm", "<cmd>make<CR>")
-
--- source file
-vim.keymap.set("n", "<leader><leader>", function()
-    vim.cmd("so")
-end)

config/nvim/lua/config/keymaps.lua

@@ -0,0 +1,22 @@
+-- Keymaps are automatically loaded on the VeryLazy event
+-- Default keymaps: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/config/keymaps.lua
+
+local map = vim.keymap.set
+
+map("n", ";", ":", { desc = "CMD enter command mode" })
+map("i", "jk", "<ESC>")
+
+-- DAP (override LazyVim defaults with previous muscle-memory bindings)
+map("n", "<Leader>dl", function() require("dap").step_into() end, { desc = "Debugger step into" })
+map("n", "<Leader>dj", function() require("dap").step_over() end, { desc = "Debugger step over" })
+map("n", "<Leader>dk", function() require("dap").step_out() end, { desc = "Debugger step out" })
+map("n", "<Leader>dc", function() require("dap").continue() end, { desc = "Debugger continue" })
+map("n", "<Leader>db", function() require("dap").toggle_breakpoint() end, { desc = "Debugger toggle breakpoint" })
+map("n", "<Leader>dd", function()
+  require("dap").set_breakpoint(vim.fn.input("Breakpoint condition: "))
+end, { desc = "Debugger conditional breakpoint" })
+map("n", "<Leader>de", function() require("dap").terminate() end, { desc = "Debugger terminate" })
+map("n", "<Leader>dr", function() require("dap").run_last() end, { desc = "Debugger run last" })
+
+-- rustaceanvim
+map("n", "<Leader>dt", "<cmd>RustLsp testables<CR>", { desc = "Rust testables" })

config/nvim/lua/config/lazy.lua

@@ -0,0 +1,41 @@
+local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
+if not (vim.uv or vim.loop).fs_stat(lazypath) then
+  local lazyrepo = "https://github.com/folke/lazy.nvim.git"
+  local out = vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath })
+  if vim.v.shell_error ~= 0 then
+    vim.api.nvim_echo({
+      { "Failed to clone lazy.nvim:\n", "ErrorMsg" },
+      { out, "WarningMsg" },
+      { "\nPress any key to exit..." },
+    }, true, {})
+    vim.fn.getchar()
+    os.exit(1)
+  end
+end
+vim.opt.rtp:prepend(lazypath)
+
+require("lazy").setup({
+  spec = {
+    { "LazyVim/LazyVim", import = "lazyvim.plugins" },
+    { import = "lazyvim.plugins.extras.dap.core" },
+    { import = "lazyvim.plugins.extras.lang.rust" },
+    { import = "plugins" },
+  },
+  defaults = {
+    lazy = false,
+    version = false,
+  },
+  install = { colorscheme = { "rose-pine", "tokyonight", "habamax" } },
+  checker = { enabled = true, notify = false },
+  performance = {
+    rtp = {
+      disabled_plugins = {
+        "gzip",
+        "tarPlugin",
+        "tohtml",
+        "tutor",
+        "zipPlugin",
+      },
+    },
+  },
+})

config/nvim/lua/config/options.lua

@@ -1,55 +0,0 @@
--- OPTIONS
-local set = vim.opt
-
---line nums
-set.relativenumber = true
-set.number = true
-
--- indentation and tabs
-set.tabstop = 4
-set.shiftwidth = 4
-set.autoindent = true
-set.expandtab = true
-
--- search settings
-set.ignorecase = true
-set.smartcase = true
-
--- appearance
-set.termguicolors = true
-set.background = "dark"
-set.signcolumn = "yes"
-
--- cursor line
-set.cursorline = true
-
--- 80th column
-set.colorcolumn = "80"
-
--- clipboard
-set.clipboard:append("unnamedplus")
-
--- backspace
-set.backspace = "indent,eol,start"
-
--- split windows
-set.splitbelow = true
-set.splitright = true
-
--- dw/diw/ciw works on full-word
-set.iskeyword:append("-")
-
--- keep cursor at least 8 rows from top/bot
-set.scrolloff = 8
-
--- undo dir settings
-set.swapfile = false
-set.backup = false
-set.undodir = os.getenv("HOME") .. "/.vim/undodir"
-set.undofile = true
-
--- incremental search
-set.incsearch = true
-
--- faster cursor hold
-set.updatetime = 50

config/nvim/lua/manage.lua

@@ -1,36 +0,0 @@
-local M = {}
-local plug_dir = vim.fn.stdpath("data") .. "/plugins"
-
-local function ensure(spec)
-    local repo = type(spec) == "string" and spec or spec[1]
-    local name = repo:match(".+/(.+)$")
-    local path = plug_dir .. "/" .. name
-
-    if not vim.uv.fs_stat(path) then
-        vim.fn.mkdir(plug_dir, "p")
-        local cmd = { "git", "clone", "--depth=1" }
-        if spec.branch then
-            table.insert(cmd, "-b")
-            table.insert(cmd, spec.branch)
-        end
-        table.insert(cmd, "https://github.com/" .. repo)
-        table.insert(cmd, path)
-        print("Installing " .. name .. "...")
-        vim.fn.system(cmd)
-    end
-
-    vim.opt.rtp:prepend(path)
-    vim.opt.rtp:append(path .. "/after")
-    local lua_path = path .. "/lua"
-    if vim.uv.fs_stat(lua_path) then
-        package.path = package.path .. ";" .. lua_path .. "/?.lua;" .. lua_path .. "/?/init.lua"
-    end
-end
-
-function M.setup()
-    for _, spec in ipairs(require("plugin-list")) do
-        ensure(spec)
-    end
-end
-
-return M

config/nvim/lua/plugin-list.lua

@@ -1,17 +0,0 @@
-return {
-    "nvim-lua/plenary.nvim",
-    "nvim-tree/nvim-web-devicons",
-    "hrsh7th/nvim-cmp",
-    "hrsh7th/cmp-nvim-lsp",
-    "hrsh7th/cmp-path",
-    "hrsh7th/cmp-buffer",
-    "nvim-telescope/telescope.nvim",
-    { "ThePrimeagen/harpoon", branch = "harpoon2" },
-    "folke/tokyonight.nvim",
-    "nvim-lualine/lualine.nvim",
-    "brenoprata10/nvim-highlight-colors",
-    "tpope/vim-fugitive",
-    "mbbill/undotree",
-    "ojroques/vim-oscyank",
-    "captbaritone/better-indent-support-for-php-with-html",
-}

config/nvim/lua/plugins/colorscheme.lua

@@ -0,0 +1,8 @@
+return {
+  { "rose-pine/neovim", name = "rose-pine", lazy = false, priority = 1000 },
+
+  {
+    "LazyVim/LazyVim",
+    opts = { colorscheme = "rose-pine" },
+  },
+}

config/nvim/lua/plugins/tmux-navigator.lua

@@ -0,0 +1,6 @@
+return {
+  {
+    "christoomey/vim-tmux-navigator",
+    lazy = false,
+  },
+}

config/nvim/plugin/docgen.lua

@@ -1,224 +0,0 @@
-local M = {}
-
--- C/kernel-doc style: /** ... @param: ... Return: ... */
-local function generate_c_doc(bufnr, row, line)
-    -- strip static/inline/extern prefixes
-    local stripped = line:gsub("^%s*static%s+", ""):gsub("^%s*inline%s+", ""):gsub("^%s*extern%s+", "")
-
-    -- match: type *func_name(params) or type* func_name(params)
-    local ret, name, params = stripped:match("^%s*([%w_]+%s*%**)%s*([%w_]+)%s*%((.*)%)%s*{?%s*$")
-    if not name then
-        return nil, "No C function signature found on current line"
-    end
-
-    local doc = { "/**", " * " .. name .. "() - " }
-
-    -- parse parameters
-    if params and params:match("%S") and not params:match("^%s*void%s*$") then
-        for param in params:gmatch("([^,]+)") do
-            local pname = param:match("([%w_]+)%s*$")
-                or param:match("%*%s*([%w_]+)")
-                or param:match("([%w_]+)%s*%[")
-            if pname then
-                table.insert(doc, " * @" .. pname .. ": ")
-            end
-        end
-    end
-
-    table.insert(doc, " *")
-
-    -- add Return: if not void
-    ret = ret and ret:gsub("%s+", " "):gsub("^%s*", ""):gsub("%s*$", "") or ""
-    if ret ~= "void" and ret ~= "" then
-        table.insert(doc, " * Return: ")
-    end
-
-    table.insert(doc, " */")
-    return doc, nil
-end
-
--- Go style: // FunctionName does something.
-local function generate_go_doc(bufnr, row, line)
-    -- match: func (receiver) name(params) return or func name(params) return
-    local name, params, ret
-
-    -- method with receiver: func (r *Receiver) Name(params) return
-    name, params, ret = line:match("^%s*func%s+%([^)]+%)%s+([%w_]+)%s*%((.-)%)%s*(.-)%s*{?%s*$")
-
-    -- regular function: func Name(params) return
-    if not name then
-        name, params, ret = line:match("^%s*func%s+([%w_]+)%s*%((.-)%)%s*(.-)%s*{?%s*$")
-    end
-
-    if not name then
-        return nil, "No Go function signature found on current line"
-    end
-
-    local doc = { "// " .. name .. " " }
-
-    -- add parameter hints if present
-    if params and params:match("%S") then
-        local param_names = {}
-        for param in params:gmatch("([^,]+)") do
-            -- Go params: name type or name, name2 type
-            local pname = param:match("^%s*([%w_]+)")
-            if pname then
-                table.insert(param_names, pname)
-            end
-        end
-        if #param_names > 0 then
-            table.insert(doc, "//")
-            table.insert(doc, "// Parameters:")
-            for _, pname in ipairs(param_names) do
-                table.insert(doc, "//   - " .. pname .. ": ")
-            end
-        end
-    end
-
-    -- add return hint if present
-    ret = ret and ret:gsub("^%s*", ""):gsub("%s*$", "") or ""
-    if ret ~= "" and ret ~= "error" then
-        table.insert(doc, "//")
-        table.insert(doc, "// Returns: ")
-    end
-
-    return doc, nil
-end
-
--- Rust style: /// Description
-local function generate_rust_doc(bufnr, row, line)
-    -- match: fn name(params) -> return or pub fn name...
-    local name, params, ret = line:match("^%s*pub%s+fn%s+([%w_]+)%s*%((.-)%)%s*%->%s*(.-)%s*{?%s*$")
-    if not name then
-        name, params, ret = line:match("^%s*fn%s+([%w_]+)%s*%((.-)%)%s*%->%s*(.-)%s*{?%s*$")
-    end
-    if not name then
-        name, params = line:match("^%s*pub%s+fn%s+([%w_]+)%s*%((.-)%)%s*{?%s*$")
-    end
-    if not name then
-        name, params = line:match("^%s*fn%s+([%w_]+)%s*%((.-)%)%s*{?%s*$")
-    end
-
-    if not name then
-        return nil, "No Rust function signature found on current line"
-    end
-
-    local doc = { "/// " }
-
-    -- add parameter hints if present
-    if params and params:match("%S") then
-        local param_names = {}
-        for param in params:gmatch("([^,]+)") do
-            local pname = param:match("^%s*([%w_]+)%s*:")
-            if pname and pname ~= "self" and pname ~= "&self" and pname ~= "&mut" then
-                table.insert(param_names, pname)
-            end
-        end
-        if #param_names > 0 then
-            table.insert(doc, "///")
-            table.insert(doc, "/// # Arguments")
-            table.insert(doc, "///")
-            for _, pname in ipairs(param_names) do
-                table.insert(doc, "/// * `" .. pname .. "` - ")
-            end
-        end
-    end
-
-    -- add return hint if present
-    ret = ret and ret:gsub("^%s*", ""):gsub("%s*$", "") or ""
-    if ret ~= "" then
-        table.insert(doc, "///")
-        table.insert(doc, "/// # Returns")
-        table.insert(doc, "///")
-        table.insert(doc, "/// ")
-    end
-
-    return doc, nil
-end
-
--- Python style: """docstring"""
-local function generate_python_doc(bufnr, row, line)
-    local name, params = line:match("^%s*def%s+([%w_]+)%s*%((.-)%)%s*:?%s*$")
-    if not name then
-        name, params = line:match("^%s*async%s+def%s+([%w_]+)%s*%((.-)%)%s*:?%s*$")
-    end
-
-    if not name then
-        return nil, "No Python function signature found on current line"
-    end
-
-    local indent = line:match("^(%s*)") or ""
-    local doc = { indent .. '    """' }
-
-    -- parse parameters
-    if params and params:match("%S") then
-        local param_names = {}
-        for param in params:gmatch("([^,]+)") do
-            local pname = param:match("^%s*([%w_]+)")
-            if pname and pname ~= "self" and pname ~= "cls" then
-                table.insert(param_names, pname)
-            end
-        end
-        if #param_names > 0 then
-            table.insert(doc, indent .. "")
-            table.insert(doc, indent .. "    Args:")
-            for _, pname in ipairs(param_names) do
-                table.insert(doc, indent .. "        " .. pname .. ": ")
-            end
-        end
-    end
-
-    table.insert(doc, indent .. "")
-    table.insert(doc, indent .. "    Returns:")
-    table.insert(doc, indent .. "        ")
-    table.insert(doc, indent .. '    """')
-
-    return doc, nil
-end
-
--- filetype to generator mapping
-local generators = {
-    c = generate_c_doc,
-    cpp = generate_c_doc,
-    h = generate_c_doc,
-    go = generate_go_doc,
-    rust = generate_rust_doc,
-    python = generate_python_doc,
-}
-
-function M.generate_doc()
-    local bufnr = vim.api.nvim_get_current_buf()
-    local row = vim.api.nvim_win_get_cursor(0)[1]
-    local line = vim.api.nvim_buf_get_lines(bufnr, row - 1, row, false)[1]
-    local ft = vim.bo[bufnr].filetype
-
-    local generator = generators[ft]
-    if not generator then
-        vim.notify("No doc generator for filetype: " .. ft, vim.log.levels.WARN)
-        return
-    end
-
-    local doc, err = generator(bufnr, row, line)
-    if err then
-        vim.notify(err, vim.log.levels.ERROR)
-        return
-    end
-
-    vim.api.nvim_buf_set_lines(bufnr, row - 1, row - 1, false, doc)
-
-    -- position cursor at first empty description spot
-    local cursor_row = row
-    local cursor_col = #doc[1]
-    for i, docline in ipairs(doc) do
-        if docline:match("%s$") or docline:match(":%s*$") or docline:match("%-%s*$") then
-            cursor_row = row + i - 1
-            cursor_col = #docline
-            break
-        end
-    end
-
-    vim.api.nvim_win_set_cursor(0, { cursor_row, cursor_col })
-    vim.cmd("startinsert!")
-end
-
-vim.keymap.set("n", "<leader>dg", M.generate_doc)

config/nvim/plugin/flterm.lua

@@ -1,55 +0,0 @@
--- Remap leaving 'terminal mode' to double tap esc
-vim.keymap.set("t", "<esc><esc>", "<c-\\><c-n>")
-
-local state = {
-    floating = {
-        buf = -1,
-        win = -1,
-    }
-}
-
-local function open_floating_terminal(opts)
-    opts = opts or {}
-    local width = opts.width or math.floor(vim.o.columns * 0.8)
-    local height = opts.height or math.floor(vim.o.lines * 0.8)
-
-    local row = math.floor((vim.o.lines - height) / 2)
-    local col = math.floor((vim.o.columns - width) / 2)
-
-    local buf = nil
-    if vim.api.nvim_buf_is_valid(opts.buf) then
-        buf = opts.buf
-    else
-        buf = vim.api.nvim_create_buf(false, true)
-    end
-    if not buf then
-        error("Failed to create buffer")
-    end
-
-    local win = vim.api.nvim_open_win(buf, true, {
-        relative = 'editor',
-        width = width,
-        height = height,
-        row = row,
-        col = col,
-        style = 'minimal',
-        border = 'rounded',
-    })
-
-    return { buf = buf, win = win }
-end
-
-local toggle_terminal = function()
-    if not vim.api.nvim_win_is_valid(state.floating.win) then
-        state.floating = open_floating_terminal({ buf = state.floating.buf });
-        if vim.bo[state.floating.buf].buftype ~= "terminal" then
-            vim.cmd.terminal()
-            vim.cmd("startinsert!")
-        end
-    else
-        vim.api.nvim_win_hide(state.floating.win)
-    end
-end
-
-vim.api.nvim_create_user_command("Flterm", toggle_terminal, {})
-vim.api.nvim_set_keymap('n', '<leader>ft', [[:Flterm<CR>]], { noremap = true, silent = true })

config/nvim/plugin/lsp.lua

@@ -1,283 +0,0 @@
-vim.lsp.config('*', {
-    root_markers = { '.git' },
-})
-
-vim.diagnostic.config({
-    virtual_text  = true,
-    severity_sort = true,
-    float         = {
-        style  = 'minimal',
-        border = 'rounded',
-        source = 'if_many',
-        header = '',
-        prefix = '',
-    },
-    signs         = {
-        text = {
-            [vim.diagnostic.severity.ERROR] = '✘',
-            [vim.diagnostic.severity.WARN]  = '▲',
-            [vim.diagnostic.severity.HINT]  = '⚑',
-            [vim.diagnostic.severity.INFO]  = '»',
-        },
-    },
-})
-
-local orig = vim.lsp.util.open_floating_preview
----@diagnostic disable-next-line: duplicate-set-field
-function vim.lsp.util.open_floating_preview(contents, syntax, opts, ...)
-    opts            = opts or {}
-    opts.border     = opts.border or 'rounded'
-    opts.max_width  = opts.max_width or 80
-    opts.max_height = opts.max_height or 24
-    opts.wrap       = opts.wrap ~= false
-    return orig(contents, syntax, opts, ...)
-end
-
-vim.api.nvim_create_autocmd('LspAttach', {
-    group = vim.api.nvim_create_augroup('my.lsp', {}),
-    callback = function(args)
-        local client = assert(vim.lsp.get_client_by_id(args.data.client_id))
-        local buf    = args.buf
-        local map    = function(mode, lhs, rhs) vim.keymap.set(mode, lhs, rhs, { buffer = buf }) end
-
-        map('n', 'K', vim.lsp.buf.hover)
-        map('n', 'gd', vim.lsp.buf.definition)
-        map('n', 'gD', vim.lsp.buf.declaration)
-        map('n', 'gi', vim.lsp.buf.implementation)
-        map('n', 'go', vim.lsp.buf.type_definition)
-        map('n', 'gr', vim.lsp.buf.references)
-        map('n', 'gs', vim.lsp.buf.signature_help)
-        map('n', 'gl', vim.diagnostic.open_float)
-        map('n', '<F2>', vim.lsp.buf.rename)
-        map({ 'n', 'x' }, '<F3>', function() vim.lsp.buf.format({ async = true }) end)
-        map('n', '<F4>', vim.lsp.buf.code_action)
-
-        if client:supports_method('textDocument/documentHighlight') then
-            local highlight_augroup = vim.api.nvim_create_augroup('my.lsp.highlight', { clear = false })
-            vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {
-                buffer = buf,
-                group = highlight_augroup,
-                callback = vim.lsp.buf.document_highlight,
-            })
-            vim.api.nvim_create_autocmd({ 'CursorMoved', 'CursorMovedI' }, {
-                buffer = buf,
-                group = highlight_augroup,
-                callback = vim.lsp.buf.clear_references,
-            })
-        end
-
-        local excluded_filetypes = { php = true, c = true, cpp = true }
-        if not client:supports_method('textDocument/willSaveWaitUntil')
-            and client:supports_method('textDocument/formatting')
-            and not excluded_filetypes[vim.bo[buf].filetype]
-        then
-            vim.api.nvim_create_autocmd('BufWritePre', {
-                group = vim.api.nvim_create_augroup('my.lsp.format', { clear = false }),
-                buffer = buf,
-                callback = function()
-                    vim.lsp.buf.format({ bufnr = buf, id = client.id, timeout_ms = 1000 })
-                end,
-            })
-        end
-    end,
-})
-local caps = require("cmp_nvim_lsp").default_capabilities()
-vim.lsp.config['luals'] = {
-    cmd = { 'lua-language-server' },
-    filetypes = { 'lua' },
-    root_markers = { { '.luarc.json', '.luarc.jsonc' }, '.git' },
-    capabilities = caps,
-    settings = {
-        Lua = {
-            runtime = { version = 'LuaJIT' },
-            diagnostics = { globals = { 'vim' } },
-            workspace = {
-                checkThirdParty = false,
-                library = vim.list_extend(
-                    vim.api.nvim_get_runtime_file('', true),
-                    { '/home/tony/repos/oxwm/templates' }
-                ),
-            },
-            telemetry = { enable = false },
-        },
-    },
-}
-
-vim.lsp.config['cssls'] = {
-    cmd = { 'vscode-css-language-server', '--stdio' },
-    filetypes = { 'css', 'scss', 'less' },
-    root_markers = { 'package.json', '.git' },
-    capabilities = caps,
-    settings = {
-        css = { validate = true },
-        scss = { validate = true },
-        less = { validate = true },
-    },
-}
-
-vim.lsp.config['phpls'] = {
-    cmd = { 'intelephense', '--stdio' },
-    filetypes = { 'php' },
-    root_markers = { 'composer.json', '.git' },
-    capabilities = caps,
-    settings = {
-        intelephense = {
-            files = {
-                maxSize = 5000000, -- default 5MB
-            },
-        },
-    },
-}
-
-vim.lsp.config['ts_ls'] = {
-    cmd = { 'typescript-language-server', '--stdio' },
-    filetypes = {
-        'javascript', 'javascriptreact', 'javascript.jsx',
-        'typescript', 'typescriptreact', 'typescript.tsx',
-    },
-    root_markers = { 'package.json', 'tsconfig.json', 'jsconfig.json', '.git' },
-    capabilities = caps,
-    settings = {
-        completions = {
-            completeFunctionCalls = true,
-        },
-    },
-}
-
-vim.lsp.config['zls'] = {
-    cmd = { 'zls' },
-    filetypes = { 'zig', 'zir' },
-    root_markers = { 'zls.json', 'build.zig', '.git' },
-    capabilities = caps,
-    settings = {
-        zls = {
-            enable_build_on_save = true,
-            build_on_save_step = "install",
-            warn_style = false,
-            enable_snippets = true,
-        }
-    }
-}
-
-vim.lsp.config['nil_ls'] = {
-    cmd = { 'nil' },
-    filetypes = { 'nix' },
-    root_markers = { 'flake.nix', 'default.nix', '.git' },
-    capabilities = caps,
-    settings = {
-        ['nil'] = {
-            formatting = {
-                command = { "alejandra" }
-            }
-        }
-    }
-}
-
-vim.lsp.config['rust_analyzer'] = {
-    cmd = { 'rust-analyzer' },
-    filetypes = { 'rust' },
-    root_markers = { 'Cargo.toml', 'rust-project.json', '.git' },
-    capabilities = caps,
-    settings = {
-        ['rust-analyzer'] = {
-            cargo = { allFeatures = true },
-            formatting = {
-                command = { "rustfmt" }
-            },
-        },
-    },
-}
-
--- C / C++ via clangd
-vim.lsp.config['clangd'] = {
-    cmd = {
-        'clangd',
-        -- '--background-index',
-        -- '--clang-tidy',
-        -- '--header-insertion=never',
-        -- '--completion-style=detailed',
-        -- '--query-driver=/nix/store/*-gcc-*/bin/gcc*,/nix/store/*-clang-*/bin/clang*,/run/current-system/sw/bin/cc*',
-    },
-    filetypes = { 'c', 'cpp', 'objc', 'objcpp' },
-    root_markers = { 'compile_commands.json', '.clangd', 'configure.ac', 'Makefile', '.git' },
-    capabilities = caps,
-    -- init_options = {
-    --     fallbackFlags = { '-std=c23' }, -- Default to C23
-    -- },
-}
-
-vim.lsp.config['c3lsp'] = {
-    cmd = { 'c3-lsp' },
-    filetypes = { 'c3' },
-    root_markers = { 'project.json', '.git' },
-    capabilities = caps,
-}
-
-vim.lsp.config['serve_d'] = {
-    cmd = { 'serve-d' },
-    filetypes = { 'd' },
-    root_markers = { 'dub.sdl', 'dub.json', '.git' },
-    capabilities = caps,
-}
-
-vim.lsp.config['jsonls'] = {
-    cmd = { 'vscode-json-languageserver', '--stdio' },
-    filetypes = { 'json', 'jsonc' },
-    root_markers = { 'package.json', '.git', 'config.jsonc' },
-    capabilities = caps,
-}
-
-vim.lsp.config['hls'] = {
-    cmd = { 'haskell-language-server-wrapper', '--lsp' },
-    filetypes = { 'haskell', 'lhaskell' },
-    root_markers = { 'stack.yaml', 'cabal.project', 'package.yaml', '*.cabal', 'hie.yaml', '.git' },
-    capabilities = caps,
-    settings = {
-        haskell = {
-            formattingProvider = 'fourmolu',
-            plugin = {
-                semanticTokens = { globalOn = false }
-            },
-        },
-    },
-}
-
-vim.lsp.config['gopls'] = {
-    cmd = { 'gopls' },
-    filetypes = { 'go', 'gomod', 'gowork', 'gotmpl' },
-    root_markers = { 'go.mod', 'go.work', '.git' },
-    capabilities = caps,
-    settings = {
-        gopls = {
-            analyses = {
-                unusedparams = false,
-                ST1003 = false,
-                ST1000 = false,
-            },
-            staticcheck = true,
-        },
-    },
-}
-
-vim.lsp.config['templ'] = {
-    cmd = { 'templ', 'lsp' },
-    filetypes = { 'templ' },
-    root_markers = { 'go.mod', '.git' },
-    capabilities = caps,
-}
-
-vim.filetype.add({
-    extension = {
-        h = 'c',
-        c3 = 'c3',
-        d = 'd',
-        templ = 'templ',
-    },
-})
-
----@diagnostic disable-next-line: invisible
-for name, _ in pairs(vim.lsp.config._configs) do
-    if name ~= '*' then
-        vim.lsp.enable(name)
-    end
-end

config/nvim/plugin/quickformat.lua

@@ -1,40 +0,0 @@
-local function reformat_parenthesized_content()
-    local bufnr = vim.api.nvim_get_current_buf()
-    local row = vim.api.nvim_win_get_cursor(0)[1]
-    local line = vim.api.nvim_buf_get_lines(bufnr, row - 1, row, false)[1]
-
-    local inside = line:match("%((.-)%)")
-    if not inside then
-        vim.notify(
-            "No content found inside parentheses",
-            vim.log.levels.ERROR
-        )
-        return
-    end
-
-    local prefix = line:match("^(.-)%(") or ""
-    local suffix = line:match("%)(.*)$") or ""
-
-    local parts = vim.split(inside, ",%s*")
-    if #parts == 0 then
-        vim.notify("No comma-separated content found", vim.log.levels.ERROR)
-        return
-    end
-
-    local new_lines = {}
-    table.insert(new_lines, prefix .. "(")
-    for i, part in ipairs(parts) do
-        if i < #parts then
-            table.insert(new_lines, "        " .. part .. ",")
-        else
-            table.insert(new_lines, "        " .. part)
-        end
-    end
-    table.insert(new_lines, "    )" .. suffix)
-
-    vim.api.nvim_buf_set_lines(bufnr, row - 1, row, false, new_lines)
-end
-
-vim.keymap.set("n", "<leader>qq", function()
-    reformat_parenthesized_content()
-end)

config/nvim/plugin/tonycontext.lua

@@ -1,110 +0,0 @@
--- Minimal sticky context header. Replaces nvim-treesitter-context.
--- Shows the first line of the enclosing function/class pinned to the
--- top of the window when that line has scrolled offscreen above.
---
--- One level of context only (innermost enclosing). Extend CONTEXT_TYPES
--- to support more languages or richer node kinds.
---
--- Toggle:
---   <leader>th  hide
---   <leader>tu  unhide
-
-local M = { enabled = true }
-local ctx_buf, ctx_win
-
-local CONTEXT_TYPES = {
-    -- C / PHP
-    function_definition = true,
-    method_declaration = true,
-    class_declaration = true,
-    -- Lua
-    function_declaration = true,
-    -- Rust
-    function_item = true,
-    impl_item = true,
-    trait_item = true,
-    -- Go (function_declaration shared)
-    -- JS
-    method_definition = true,
-    arrow_function = true,
-    -- Zig
-    fn_proto = true,
-    -- Nix
-    function_expression = true,
-}
-
-local function close_ctx()
-    if ctx_win and vim.api.nvim_win_is_valid(ctx_win) then
-        vim.api.nvim_win_close(ctx_win, true)
-    end
-    ctx_win = nil
-end
-
-local function update_ctx()
-    if not M.enabled then close_ctx() return end
-
-    local bufnr = vim.api.nvim_get_current_buf()
-    local node = vim.treesitter.get_node()
-    if not node then close_ctx() return end
-
-    while node and not CONTEXT_TYPES[node:type()] do
-        node = node:parent()
-    end
-    if not node then close_ctx() return end
-
-    local sr = node:start()
-    local top_visible = vim.fn.line("w0") - 1
-    if sr >= top_visible then close_ctx() return end
-
-    local lines = vim.api.nvim_buf_get_lines(bufnr, sr, sr + 1, false)
-    if #lines == 0 then close_ctx() return end
-
-    if not ctx_buf or not vim.api.nvim_buf_is_valid(ctx_buf) then
-        ctx_buf = vim.api.nvim_create_buf(false, true)
-        vim.bo[ctx_buf].buftype = "nofile"
-    end
-    vim.api.nvim_buf_set_lines(ctx_buf, 0, -1, false, lines)
-    vim.bo[ctx_buf].filetype = vim.bo[bufnr].filetype
-
-    local config = {
-        relative = "win",
-        win = vim.api.nvim_get_current_win(),
-        row = 0,
-        col = 0,
-        width = vim.api.nvim_win_get_width(0),
-        height = 1,
-        focusable = false,
-        style = "minimal",
-        zindex = 20,
-    }
-    if ctx_win and vim.api.nvim_win_is_valid(ctx_win) then
-        vim.api.nvim_win_set_config(ctx_win, config)
-    else
-        ctx_win = vim.api.nvim_open_win(ctx_buf, false, config)
-        vim.wo[ctx_win].winhighlight = "Normal:TonyContext,NormalFloat:TonyContext"
-    end
-end
-
-vim.api.nvim_set_hl(0, "TonyContext", { link = "NormalFloat", default = true })
-
-local group = vim.api.nvim_create_augroup("TonyContext", { clear = true })
-vim.api.nvim_create_autocmd({ "CursorMoved", "CursorMovedI", "WinScrolled", "BufEnter" }, {
-    group = group,
-    callback = update_ctx,
-})
-vim.api.nvim_create_autocmd({ "BufLeave", "WinLeave" }, {
-    group = group,
-    callback = close_ctx,
-})
-
-vim.keymap.set("n", "<leader>th", function()
-    M.enabled = false
-    close_ctx()
-end, { desc = "Hide context header" })
-
-vim.keymap.set("n", "<leader>tu", function()
-    M.enabled = true
-    update_ctx()
-end, { desc = "Unhide context header" })
-
-return M

config/nvim/plugin/tonysitter.lua

@@ -1,86 +0,0 @@
-local function case_directive(transform)
-    return function(match, _, bufnr, pred, metadata)
-        local id = pred[2]
-        if type(id) ~= "number" then return end
-        local nodes = match[id]
-        if not nodes or #nodes == 0 then return end
-        local node = nodes[1]
-        local text = vim.treesitter.get_node_text(node, bufnr, { metadata = metadata[id] }) or ""
-        if not metadata[id] then metadata[id] = {} end
-        metadata[id].text = transform(text)
-    end
-end
-vim.treesitter.query.add_directive("downcase!", case_directive(string.lower), { force = true })
-vim.treesitter.query.add_directive("upcase!", case_directive(string.upper), { force = true })
-
-vim.api.nvim_create_autocmd("FileType", {
-    callback = function(args)
-        pcall(vim.treesitter.start, args.buf)
-    end,
-})
-
--- smallest @function.outer / @function.inner range containing the cursor.
-local function select_function(capture)
-    local bufnr = vim.api.nvim_get_current_buf()
-    local ok, parser = pcall(vim.treesitter.get_parser, bufnr)
-    if not ok or not parser then return end
-
-    local lang = parser:lang()
-    local query = vim.treesitter.query.get(lang, "textobjects")
-    if not query then return end
-
-    local tree = parser:parse()[1]
-    if not tree then return end
-    local root = tree:root()
-
-    local cur = vim.api.nvim_win_get_cursor(0)
-    local crow, ccol = cur[1] - 1, cur[2]
-
-    local best, best_size
-    for _, match in query:iter_matches(root, bufnr, 0, -1, { all = true }) do
-        local min_sr, min_sc, max_er, max_ec
-        for id, nodes in pairs(match) do
-            if query.captures[id] == capture then
-                if type(nodes) ~= "table" then nodes = { nodes } end
-                for _, node in ipairs(nodes) do
-                    local sr, sc, er, ec = node:range()
-                    if not min_sr or sr < min_sr or (sr == min_sr and sc < min_sc) then
-                        min_sr, min_sc = sr, sc
-                    end
-                    if not max_er or er > max_er or (er == max_er and ec > max_ec) then
-                        max_er, max_ec = er, ec
-                    end
-                end
-            end
-        end
-        if min_sr then
-            local contains = (min_sr < crow or (min_sr == crow and min_sc <= ccol))
-                and (max_er > crow or (max_er == crow and max_ec >= ccol))
-            if contains then
-                local size = (max_er - min_sr) * 1e6 + (max_ec - min_sc)
-                if not best_size or size < best_size then
-                    best_size = size
-                    best = { min_sr, min_sc, max_er, max_ec }
-                end
-            end
-        end
-    end
-
-    if not best then return end
-    local sr, sc, er, ec = best[1], best[2], best[3], best[4]
-
-    local mode = vim.fn.mode()
-    if mode == "v" or mode == "V" or mode == "\22" then
-        vim.api.nvim_feedkeys(
-            vim.api.nvim_replace_termcodes("<Esc>", true, false, true), "nx", false)
-    end
-
-    vim.api.nvim_win_set_cursor(0, { sr + 1, sc })
-    vim.cmd("normal! v")
-    vim.api.nvim_win_set_cursor(0, { er + 1, math.max(0, ec - 1) })
-end
-
-vim.keymap.set({ "x", "o" }, "af", function() select_function("function.outer") end,
-    { desc = "around function" })
-vim.keymap.set({ "x", "o" }, "if", function() select_function("function.inner") end,
-    { desc = "inside function" })

config/nvim/queries/c/folds.scm

@@ -1,23 +0,0 @@
-[
-  (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)

config/nvim/queries/c/highlights.scm

@@ -1,341 +0,0 @@
-; 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

config/nvim/queries/c/injections.scm

@@ -1,128 +0,0 @@
-((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"))

config/nvim/queries/c/locals.scm

@@ -1,67 +0,0 @@
-; 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

config/nvim/queries/c/textobjects.scm

@@ -1,151 +0,0 @@
-(declaration
-  declarator: (function_declarator)) @function.outer
-
-(function_definition
-  body: (compound_statement)) @function.outer
-
-(function_definition
-  body: (compound_statement
-    .
-    "{"
-    _+ @function.inner
-    "}"))
-
-(struct_specifier
-  body: (_) @class.inner) @class.outer
-
-(enum_specifier
-  body: (_) @class.inner) @class.outer
-
-; conditionals
-(if_statement
-  consequence: (compound_statement
-    .
-    "{"
-    _+ @conditional.inner
-    "}")) @conditional.outer
-
-(if_statement
-  alternative: (else_clause
-    (compound_statement
-      .
-      "{"
-      _+ @conditional.inner
-      "}"))) @conditional.outer
-
-(if_statement) @conditional.outer
-
-(if_statement
-  condition: (_) @conditional.inner
-  (#offset! @conditional.inner 0 1 0 -1))
-
-(while_statement
-  condition: (_) @conditional.inner
-  (#offset! @conditional.inner 0 1 0 -1))
-
-(do_statement
-  condition: (_) @conditional.inner
-  (#offset! @conditional.inner 0 1 0 -1))
-
-(for_statement
-  condition: (_) @conditional.inner)
-
-; loops
-(while_statement) @loop.outer
-
-(while_statement
-  body: (compound_statement
-    .
-    "{"
-    _+ @loop.inner
-    "}")) @loop.outer
-
-(for_statement) @loop.outer
-
-(for_statement
-  body: (compound_statement
-    .
-    "{"
-    _+ @loop.inner
-    "}")) @loop.outer
-
-(do_statement) @loop.outer
-
-(do_statement
-  body: (compound_statement
-    .
-    "{"
-    _+ @loop.inner
-    "}")) @loop.outer
-
-(compound_statement) @block.outer
-
-(comment) @comment.outer
-
-(call_expression) @call.outer
-
-(call_expression
-  arguments: (argument_list
-    .
-    "("
-    _+ @call.inner
-    ")"))
-
-(return_statement
-  (_)? @return.inner) @return.outer
-
-; Statements
-;(expression_statement ;; this is what we actually want to capture in most cases (";" is missing) probably
-;(_) @statement.inner) ;; the other statement like node type is declaration but declaration has a ";"
-(compound_statement
-  (_) @statement.outer)
-
-(field_declaration_list
-  (_) @statement.outer)
-
-(preproc_if
-  (_) @statement.outer)
-
-(preproc_elif
-  (_) @statement.outer)
-
-(preproc_else
-  (_) @statement.outer)
-
-(parameter_list
-  "," @parameter.outer
-  .
-  (parameter_declaration) @parameter.inner @parameter.outer)
-
-(parameter_list
-  .
-  (parameter_declaration) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-(argument_list
-  "," @parameter.outer
-  .
-  (_) @parameter.inner @parameter.outer)
-
-(argument_list
-  .
-  (_) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-(number_literal) @number.inner
-
-(declaration
-  declarator: (init_declarator
-    declarator: (_) @assignment.lhs
-    value: (_) @assignment.rhs) @assignment.inner) @assignment.outer
-
-(declaration
-  type: (primitive_type)
-  declarator: (_) @assignment.inner)
-
-(expression_statement
-  (assignment_expression
-    left: (_) @assignment.lhs
-    right: (_) @assignment.rhs) @assignment.inner) @assignment.outer

config/nvim/queries/ecma/folds.scm

@@ -1,24 +0,0 @@
-[
-  (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

config/nvim/queries/ecma/highlights.scm

@@ -1,392 +0,0 @@
-; 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))
-
-(call_expression
-  function: (await_expression
-    (identifier) @function.call))
-
-(call_expression
-  function: (await_expression
-    (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)

config/nvim/queries/ecma/injections.scm

@@ -1,203 +0,0 @@
-(((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")))))))

config/nvim/queries/ecma/locals.scm

@@ -1,42 +0,0 @@
-; 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

config/nvim/queries/ecma/textobjects.scm

@@ -1,372 +0,0 @@
-(function_declaration
-  body: (statement_block)) @function.outer
-
-(generator_function_declaration
-  body: (statement_block)) @function.outer
-
-(function_expression
-  body: (statement_block)) @function.outer
-
-(function_declaration
-  body: (statement_block
-    .
-    "{"
-    _+ @function.inner
-    "}"))
-
-(generator_function_declaration
-  body: (statement_block
-    .
-    "{"
-    _+ @function.inner
-    "}"))
-
-(function_expression
-  body: (statement_block
-    .
-    "{"
-    _+ @function.inner
-    "}"))
-
-(export_statement
-  (function_declaration)) @function.outer
-
-(arrow_function
-  body: (_) @function.inner) @function.outer
-
-(arrow_function
-  body: (statement_block
-    .
-    "{"
-    _+ @function.inner
-    "}"))
-
-(method_definition
-  body: (statement_block)) @function.outer
-
-(method_definition
-  body: (statement_block
-    .
-    "{"
-    _+ @function.inner
-    "}"))
-
-(class_declaration
-  body: (class_body)) @class.outer
-
-(class_declaration
-  body: (class_body
-    .
-    "{"
-    _+ @class.inner
-    "}"))
-
-(export_statement
-  (class_declaration)) @class.outer
-
-(for_in_statement
-  body: (statement_block
-    .
-    "{"
-    _+ @loop.inner
-    "}")) @loop.outer
-
-(for_statement
-  body: (statement_block
-    .
-    "{"
-    _+ @loop.inner
-    "}")) @loop.outer
-
-(while_statement
-  body: (statement_block
-    .
-    "{"
-    _+ @loop.inner
-    "}")) @loop.outer
-
-(do_statement
-  body: (statement_block
-    .
-    "{"
-    _+ @loop.inner
-    "}")) @loop.outer
-
-(if_statement
-  consequence: (statement_block
-    .
-    "{"
-    _+ @conditional.inner
-    "}")) @conditional.outer
-
-(if_statement
-  alternative: (else_clause
-    (statement_block
-      .
-      "{"
-      _+ @conditional.inner
-      "}"))) @conditional.outer
-
-(if_statement) @conditional.outer
-
-(switch_statement
-  body: (_)? @conditional.inner) @conditional.outer
-
-(call_expression) @call.outer
-
-(call_expression
-  arguments: (arguments
-    .
-    "("
-    _+ @call.inner
-    ")"))
-
-(new_expression
-  constructor: (identifier) @call.outer
-  arguments: (arguments
-    .
-    "("
-    _+ @call.inner
-    ")") @call.outer)
-
-; blocks
-(statement_block
-  (_)* @block.inner) @block.outer
-
-; parameters
-; function ({ x }) ...
-; function ([ x ]) ...
-; function (v = default_value)
-(formal_parameters
-  "," @parameter.outer
-  .
-  (_) @parameter.inner @parameter.outer)
-
-(formal_parameters
-  .
-  (_) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-; last element with trailing comma
-(formal_parameters
-  (_) @parameter.outer
-  .
-  "," @parameter.outer .)
-
-; If the array/object pattern is the first parameter, treat its elements as the argument list
-(formal_parameters
-  .
-  (_
-    [
-      (object_pattern
-        "," @parameter.outer
-        .
-        (_) @parameter.inner @parameter.outer)
-      (array_pattern
-        "," @parameter.outer
-        .
-        (_) @parameter.inner @parameter.outer)
-    ]))
-
-(formal_parameters
-  .
-  (_
-    [
-      (object_pattern
-        .
-        (_) @parameter.inner @parameter.outer
-        .
-        ","? @parameter.outer)
-      (array_pattern
-        .
-        (_) @parameter.inner @parameter.outer
-        .
-        ","? @parameter.outer)
-    ]))
-
-; last element with trailing comma
-(formal_parameters
-  .
-  (_
-    [
-      (object_pattern
-        (_) @parameter.outer
-        .
-        "," @parameter.outer .)
-      (array_pattern
-        (_) @parameter.outer
-        .
-        "," @parameter.outer .)
-    ]))
-
-; arguments
-(arguments
-  "," @parameter.outer
-  .
-  (_) @parameter.inner @parameter.outer)
-
-(arguments
-  .
-  (_) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-; last element with trailing comma
-(arguments
-  (_) @parameter.outer
-  .
-  "," @parameter.outer .)
-
-; comment
-(comment) @comment.outer
-
-; regex
-(regex
-  (regex_pattern) @regex.inner) @regex.outer
-
-; number
-(number) @number.inner
-
-(lexical_declaration
-  (variable_declarator
-    name: (_) @assignment.lhs
-    value: (_) @assignment.inner @assignment.rhs)) @assignment.outer
-
-(variable_declarator
-  name: (_) @assignment.inner)
-
-(object
-  (pair
-    key: (_) @assignment.lhs
-    value: (_) @assignment.inner @assignment.rhs) @assignment.outer)
-
-(return_statement
-  (_) @return.inner) @return.outer
-
-(return_statement) @statement.outer
-
-[
-  (if_statement)
-  (expression_statement)
-  (for_statement)
-  (while_statement)
-  (do_statement)
-  (for_in_statement)
-  (export_statement)
-  (lexical_declaration)
-] @statement.outer
-
-; 1.  default import
-(import_statement
-  (import_clause
-    (identifier) @parameter.inner @parameter.outer))
-
-; 2.  namespace import  e.g. `* as React`
-(import_statement
-  (import_clause
-    (namespace_import
-      (identifier) @parameter.inner) @parameter.outer))
-
-; 3.  named import  e.g. `import { Bar, Baz } from ...`
-(import_statement
-  (import_clause
-    (named_imports
-      (import_specifier) @parameter.inner)))
-
-; 3‑A.  named import followed by a comma
-(import_statement
-  (import_clause
-    (named_imports
-      (import_specifier) @parameter.outer
-      .
-      "," @parameter.outer)))
-
-; 3‑B.  comma followed by named import
-(import_statement
-  (import_clause
-    (named_imports
-      "," @parameter.outer
-      .
-      (import_specifier) @parameter.outer)))
-
-; 3-C.  only one named import without a comma
-(import_statement
-  (import_clause
-    (named_imports
-      .
-      (import_specifier) @parameter.outer .)))
-
-; Treat list or object elements as @parameter
-; 1. parameter.inner
-(object
-  (_) @parameter.inner)
-
-(array
-  (_) @parameter.inner)
-
-(object_pattern
-  (_) @parameter.inner)
-
-(array_pattern
-  (_) @parameter.inner)
-
-; 2. parameter.outer: Only one element, no comma
-(object
-  .
-  (_) @parameter.outer .)
-
-(array
-  .
-  (_) @parameter.outer .)
-
-(object_pattern
-  .
-  (_) @parameter.outer .)
-
-(array_pattern
-  .
-  (_) @parameter.outer .)
-
-; 3. parameter.outer: Comma before or after
-[
-  (object
-    "," @parameter.outer
-    .
-    (_) @parameter.outer)
-  (array
-    "," @parameter.outer
-    .
-    (_) @parameter.outer)
-  (object_pattern
-    "," @parameter.outer
-    .
-    (_) @parameter.outer)
-  (array_pattern
-    "," @parameter.outer
-    .
-    (_) @parameter.outer)
-]
-
-[
-  (object
-    .
-    (_) @parameter.outer
-    .
-    "," @parameter.outer)
-  (array
-    .
-    (_) @parameter.outer
-    .
-    "," @parameter.outer)
-  (object_pattern
-    .
-    (_) @parameter.outer
-    .
-    "," @parameter.outer)
-  (array_pattern
-    .
-    (_) @parameter.outer
-    .
-    "," @parameter.outer)
-]

config/nvim/queries/go/folds.scm

@@ -1,19 +0,0 @@
-[
-  (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

config/nvim/queries/go/highlights.scm

@@ -1,254 +0,0 @@
-; 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))
-
-; Regex
-(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
-        (raw_string_literal_content) @string.regexp)
-      (interpreted_string_literal
-        (interpreted_string_literal_content) @string.regexp)
-    ]))

config/nvim/queries/go/injections.scm

@@ -1,42 +0,0 @@
-((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
-        (raw_string_literal_content) @injection.content)
-      (interpreted_string_literal
-        (interpreted_string_literal_content) @injection.content)
-    ]
-    (#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
-      (interpreted_string_literal_content) @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
-      (interpreted_string_literal_content) @injection.content)))
-  (#any-of? @_method "Fprintf" "Fscanf" "Appendf" "Sscanf")
-  (#set! injection.language "printf"))

config/nvim/queries/go/locals.scm

@@ -1,88 +0,0 @@
-((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

config/nvim/queries/go/textobjects.scm

@@ -1,153 +0,0 @@
-; inner function textobject
-(function_declaration
-  body: (block
-    .
-    "{"
-    _+ @function.inner
-    "}"))
-
-; inner function literals
-(func_literal
-  body: (block
-    .
-    "{"
-    _+ @function.inner
-    "}"))
-
-; method as inner function textobject
-(method_declaration
-  body: (block
-    .
-    "{"
-    _+ @function.inner
-    "}"))
-
-; outer function textobject
-(function_declaration) @function.outer
-
-; outer function literals
-(func_literal
-  (_)?) @function.outer
-
-; method as outer function textobject
-(method_declaration
-  body: (block)?) @function.outer
-
-; struct and interface declaration as class textobject?
-(type_declaration
-  (type_spec
-    (type_identifier)
-    (struct_type
-      (field_declaration_list
-        (_)?) @class.inner))) @class.outer
-
-(type_declaration
-  (type_spec
-    (type_identifier)
-    (interface_type) @class.inner)) @class.outer
-
-; struct literals as class textobject
-(composite_literal
-  (type_identifier)?
-  (struct_type
-    (_))?
-  (literal_value
-    (_)) @class.inner) @class.outer
-
-; conditionals
-(if_statement
-  alternative: (_
-    (_) @conditional.inner)?) @conditional.outer
-
-(if_statement
-  consequence: (block)? @conditional.inner)
-
-(if_statement
-  condition: (_) @conditional.inner)
-
-; loops
-(for_statement
-  body: (block)? @loop.inner) @loop.outer
-
-; blocks
-(_
-  (block) @block.inner) @block.outer
-
-; statements
-(block
-  (_) @statement.outer)
-
-; comments
-(comment) @comment.outer
-
-; calls
-(call_expression) @call.outer
-
-(call_expression
-  arguments: (argument_list
-    .
-    "("
-    _+ @call.inner
-    ")"))
-
-; parameters
-(parameter_list
-  "," @parameter.outer
-  .
-  (parameter_declaration) @parameter.inner @parameter.outer)
-
-(parameter_list
-  .
-  (parameter_declaration) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-(parameter_declaration
-  name: (identifier)
-  type: (_)) @parameter.inner
-
-(parameter_declaration
-  name: (identifier)
-  type: (_)) @parameter.inner
-
-(parameter_list
-  "," @parameter.outer
-  .
-  (variadic_parameter_declaration) @parameter.inner @parameter.outer)
-
-; arguments
-(argument_list
-  "," @parameter.outer
-  .
-  (_) @parameter.inner @parameter.outer)
-
-(argument_list
-  .
-  (_) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-; assignments
-(short_var_declaration
-  left: (_) @assignment.lhs
-  right: (_) @assignment.rhs @assignment.inner) @assignment.outer
-
-(assignment_statement
-  left: (_) @assignment.lhs
-  right: (_) @assignment.rhs @assignment.inner) @assignment.outer
-
-(var_spec
-  name: (_) @assignment.lhs
-  value: (_) @assignment.rhs @assignment.inner) @assignment.outer
-
-(var_spec
-  name: (_) @assignment.inner
-  type: (_)) @assignment.outer
-
-(const_spec
-  name: (_) @assignment.lhs
-  value: (_) @assignment.rhs @assignment.inner) @assignment.outer
-
-(const_spec
-  name: (_) @assignment.inner
-  type: (_)) @assignment.outer

config/nvim/queries/goon/highlights.scm

@@ -1,55 +0,0 @@
-; Keywords
-"let" @keyword
-"if" @keyword.conditional
-"then" @keyword.conditional
-"else" @keyword.conditional
-"import" @keyword.import
-
-; Literals
-(string) @string
-(string_content) @string
-(escape_sequence) @string.escape
-(number) @number
-(boolean) @boolean
-
-; Identifiers
-(identifier) @variable
-
-; Types
-(type_annotation) @type
-
-; Fields
-(record_field
-  key: (identifier) @property)
-
-(field_access
-  (identifier) @property)
-
-; Functions
-(call_expression
-  function: (identifier) @function.call)
-
-; Operators
-"=" @operator
-":" @punctuation.delimiter
-"?" @operator
-"..." @operator
-"." @punctuation.delimiter
-
-; Punctuation
-"{" @punctuation.bracket
-"}" @punctuation.bracket
-"[" @punctuation.bracket
-"]" @punctuation.bracket
-"(" @punctuation.bracket
-")" @punctuation.bracket
-";" @punctuation.delimiter
-"," @punctuation.delimiter
-
-; Interpolation
-(interpolation
-  "${" @punctuation.special
-  "}" @punctuation.special)
-
-; Comments
-(comment) @comment

config/nvim/queries/javascript/folds.scm

@@ -1 +0,0 @@
-; inherits: ecma,jsx

config/nvim/queries/javascript/highlights.scm

@@ -1,56 +0,0 @@
-; 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

config/nvim/queries/javascript/injections.scm

@@ -1 +0,0 @@
-; inherits: ecma,jsx

config/nvim/queries/javascript/locals.scm

@@ -1,69 +0,0 @@
-; 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)

config/nvim/queries/javascript/textobjects.scm

@@ -1 +0,0 @@
-; inherits: ecma,jsx

config/nvim/queries/jsx/folds.scm

@@ -1 +0,0 @@
-(jsx_element) @fold

config/nvim/queries/jsx/highlights.scm

@@ -1,157 +0,0 @@
-(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"))
-
-((jsx_element) @_jsx_element
-  (#set! @_jsx_element bo.commentstring "{/* %s */}"))
-
-((jsx_attribute) @_jsx_attribute
-  (#set! @_jsx_attribute bo.commentstring "// %s"))

config/nvim/queries/jsx/injections.scm

@@ -1,11 +0,0 @@
-; 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)))

config/nvim/queries/jsx/textobjects.scm

@@ -1,8 +0,0 @@
-; inherits: ecma
-
-(jsx_attribute) @attribute.outer
-
-(jsx_attribute
-  (property_identifier)
-  (_
-    (_) @attribute.inner))

config/nvim/queries/lua/folds.scm

@@ -1,12 +0,0 @@
-[
-  (do_statement)
-  (while_statement)
-  (repeat_statement)
-  (if_statement)
-  (for_statement)
-  (function_declaration)
-  (function_definition)
-  (parameters)
-  (arguments)
-  (table_constructor)
-] @fold

config/nvim/queries/lua/highlights.scm

@@ -1,265 +0,0 @@
-; 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)))

config/nvim/queries/lua/injections.scm

@@ -1,202 +0,0 @@
-((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_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"))

config/nvim/queries/lua/locals.scm

@@ -1,54 +0,0 @@
-; 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

config/nvim/queries/lua/textobjects.scm

@@ -1,109 +0,0 @@
-; block
-(_
-  (block) @block.inner) @block.outer
-
-; call
-(function_call) @call.outer
-
-(function_call
-  (arguments) @call.inner
-  (#match? @call.inner "^[^\\(]"))
-
-(function_call
-  arguments: (arguments
-    .
-    "("
-    _+ @call.inner
-    ")"))
-
-; class
-; comment
-(comment
-  (comment_content) @comment.inner) @comment.outer
-
-; conditional
-(if_statement
-  alternative: (_
-    (_) @conditional.inner)?) @conditional.outer
-
-(if_statement
-  consequence: (block)? @conditional.inner)
-
-(if_statement
-  condition: (_) @conditional.inner)
-
-; frame
-; function
-[
-  (function_declaration)
-  (function_definition)
-] @function.outer
-
-(function_declaration
-  body: (_) @function.inner)
-
-(function_definition
-  body: (_) @function.inner)
-
-; return
-(return_statement
-  (_)? @return.inner) @return.outer
-
-; loop
-[
-  (while_statement)
-  (for_statement)
-  (repeat_statement)
-] @loop.outer
-
-(while_statement
-  body: (_) @loop.inner)
-
-(for_statement
-  body: (_) @loop.inner)
-
-(repeat_statement
-  body: (_) @loop.inner)
-
-; parameter
-(arguments
-  .
-  (_) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-(parameters
-  .
-  (_) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-(table_constructor
-  (field) @parameter.inner @parameter.outer
-  ","? @parameter.outer)
-
-(arguments
-  "," @parameter.outer
-  .
-  (_) @parameter.inner @parameter.outer)
-
-(parameters
-  "," @parameter.outer
-  .
-  (_) @parameter.inner @parameter.outer)
-
-; number
-(number) @number.inner
-
-(assignment_statement
-  (variable_list) @assignment.lhs
-  (expression_list) @assignment.inner @assignment.rhs) @assignment.outer
-
-(assignment_statement
-  (variable_list) @assignment.inner)
-
-; scopename
-; statement
-(statement) @statement.outer
-
-(return_statement) @statement.outer

config/nvim/queries/nix/folds.scm

@@ -1,11 +0,0 @@
-; 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

config/nvim/queries/nix/highlights.scm

@@ -1,210 +0,0 @@
-; 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"))
-
-; 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: (select_expression
-  attrpath: (attrpath
-    attr: (identifier) @function.call .))
-
-; 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"))
-
-; 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"))

config/nvim/queries/nix/injections.scm

@@ -1,190 +0,0 @@
-((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))

config/nvim/queries/nix/locals.scm

@@ -1,34 +0,0 @@
-; 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)

config/nvim/queries/nix/textobjects.scm

@@ -1,26 +0,0 @@
-; named function
-(binding
-  (function_expression)) @function.outer
-
-; anonymous function
-(function_expression
-  (_) ; argument
-  (_) @function.inner) @function.outer
-
-(function_expression
-  (formals
-    (formal) @parameter.inner))
-
-(function_expression
-  (_) @parameter.outer
-  (_))
-
-(comment) @comment.outer
-
-(if_expression
-  (_) @conditional.inner) @conditional.outer
-
-[
-  (integer_expression)
-  (float_expression)
-] @number.inner

config/nvim/queries/php/folds.scm

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

config/nvim/queries/php/highlights.scm

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

config/nvim/queries/php/injections.scm

@@ -1,5 +0,0 @@
-; inherits: php_only
-
-((text) @injection.content
-  (#set! injection.language "html")
-  (#set! injection.combined))

config/nvim/queries/php/locals.scm

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

config/nvim/queries/php/textobjects.scm

@@ -1,235 +0,0 @@
-; functions
-(function_definition
-  body: (compound_statement
-    .
-    "{"
-    _+ @function.inner
-    "}"))
-
-(function_definition) @function.outer
-
-(anonymous_function
-  body: (compound_statement
-    .
-    "{"
-    _+ @function.inner
-    "}"))
-
-(anonymous_function) @function.outer
-
-; methods
-(method_declaration
-  body: (compound_statement
-    .
-    "{"
-    _+ @function.inner
-    "}"))
-
-(method_declaration) @function.outer
-
-; traits
-(trait_declaration
-  body: (declaration_list
-    .
-    "{"
-    _+ @class.inner
-    "}"))
-
-(trait_declaration) @class.outer
-
-; interfaces
-(interface_declaration
-  body: (declaration_list
-    .
-    "{"
-    _+ @class.inner
-    "}"))
-
-(interface_declaration) @class.outer
-
-; enums
-(enum_declaration
-  body: (enum_declaration_list
-    .
-    "{"
-    _+ @class.inner
-    "}"))
-
-(enum_declaration) @class.outer
-
-; classes
-(class_declaration
-  body: (declaration_list
-    .
-    "{"
-    _+ @class.inner
-    "}"))
-
-(class_declaration) @class.outer
-
-; loops
-(for_statement
-  (compound_statement
-    .
-    "{"
-    _+ @loop.inner
-    "}"))
-
-(for_statement) @loop.outer
-
-(foreach_statement
-  body: (compound_statement
-    .
-    "{"
-    _+ @loop.inner
-    "}"))
-
-(foreach_statement) @loop.outer
-
-(while_statement
-  body: (compound_statement
-    .
-    "{"
-    _+ @loop.inner
-    "}"))
-
-(while_statement) @loop.outer
-
-(do_statement
-  body: (compound_statement
-    .
-    "{"
-    _+ @loop.inner
-    "}"))
-
-(do_statement) @loop.outer
-
-; conditionals
-(switch_statement
-  body: (switch_block
-    .
-    "{"
-    _+ @conditional.inner
-    "}"))
-
-(switch_statement) @conditional.outer
-
-(if_statement
-  body: (compound_statement
-    .
-    "{"
-    _+ @conditional.inner
-    "}"))
-
-(if_statement) @conditional.outer
-
-(else_clause
-  body: (compound_statement
-    .
-    "{"
-    _+ @conditional.inner
-    "}"))
-
-(else_if_clause
-  body: (compound_statement
-    .
-    "{"
-    _+ @conditional.inner
-    "}"))
-
-; blocks
-(_
-  (switch_block) @block.inner) @block.outer
-
-; parameters
-(arguments
-  "," @parameter.outer
-  .
-  (_) @parameter.inner @parameter.outer)
-
-(arguments
-  .
-  (_) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-(formal_parameters
-  "," @parameter.outer
-  .
-  (_) @parameter.inner @parameter.outer)
-
-(formal_parameters
-  .
-  (_) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-; comments
-(comment) @comment.outer
-
-; call
-(function_call_expression) @call.outer
-
-(member_call_expression) @call.outer
-
-(nullsafe_member_call_expression) @call.outer
-
-(scoped_call_expression) @call.outer
-
-(function_call_expression
-  arguments: (arguments
-    .
-    "("
-    _+ @call.inner
-    ")"))
-
-(member_call_expression
-  arguments: (arguments
-    .
-    "("
-    _+ @call.inner
-    ")"))
-
-(nullsafe_member_call_expression
-  arguments: (arguments
-    .
-    "("
-    _+ @call.inner
-    ")"))
-
-(scoped_call_expression
-  arguments: (arguments
-    .
-    "("
-    _+ @call.inner
-    ")"))
-
-; statement
-[
-  (expression_statement)
-  (declare_statement)
-  (return_statement)
-  (namespace_use_declaration)
-  (namespace_definition)
-  (if_statement)
-  (empty_statement)
-  (switch_statement)
-  (while_statement)
-  (do_statement)
-  (for_statement)
-  (foreach_statement)
-  (goto_statement)
-  (continue_statement)
-  (break_statement)
-  (try_statement)
-  (echo_statement)
-  (unset_statement)
-  (const_declaration)
-  (function_definition)
-  (class_declaration)
-  (interface_declaration)
-  (trait_declaration)
-  (enum_declaration)
-  (global_declaration)
-  (function_static_declaration)
-] @statement.outer

config/nvim/queries/php_only/folds.scm

@@ -1,17 +0,0 @@
-[
-  (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

config/nvim/queries/php_only/highlights.scm

@@ -1,479 +0,0 @@
-; 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)
-    (relative_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)
-    (relative_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_declaration
-  type: "function"
-  body: (namespace_use_group
-    (namespace_use_clause
-      [
-        (name) @function
-        (qualified_name
-          (name) @function)
-        alias: (name) @function
-      ])))
-
-(namespace_use_clause
-  type: "const"
-  [
-    (name) @constant
-    (qualified_name
-      (name) @constant)
-    alias: (name) @constant
-  ])
-
-(namespace_use_declaration
-  type: "const"
-  body: (namespace_use_group
-    (namespace_use_clause
-      [
-        (name) @constant
-        (qualified_name
-          (name) @constant)
-        alias: (name) @constant
-      ])))
-
-(class_interface_clause
-  [
-    (name) @type
-    (qualified_name
-      (name) @type)
-    (relative_name
-      (name) @type)
-  ])
-
-(scoped_call_expression
-  scope: [
-    (name) @type
-    (qualified_name
-      (name) @type)
-    (relative_name
-      (name) @type)
-  ])
-
-(class_constant_access_expression
-  .
-  [
-    (name) @type
-    (qualified_name
-      (name) @type)
-    (relative_name
-      (name) @type)
-  ]
-  (name) @constant)
-
-(scoped_property_access_expression
-  scope: [
-    (name) @type
-    (qualified_name
-      (name) @type)
-    (relative_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)
-    (relative_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: [
-    (name) @function.call
-    (qualified_name
-      (name) @function.call)
-    (relative_name
-      (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)
-    (relative_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)
-
-(relative_name
-  "namespace" @module.builtin)
-
-; 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

config/nvim/queries/php_only/injections.scm

@@ -1,43 +0,0 @@
-((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"))

config/nvim/queries/php_only/locals.scm

@@ -1,84 +0,0 @@
-; 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"))

config/nvim/queries/php_only/textobjects.scm

@@ -1 +0,0 @@
-; inherits php

config/nvim/queries/rust/folds.scm

@@ -1,25 +0,0 @@
-[
-  (mod_item)
-  (foreign_mod_item)
-  (function_item)
-  (struct_item)
-  (trait_item)
-  (enum_item)
-  (impl_item)
-  (type_item)
-  (union_item)
-  (const_item)
-  (let_declaration)
-  (loop_expression)
-  (for_expression)
-  (while_expression)
-  (if_expression)
-  (match_expression)
-  (call_expression)
-  (array_expression)
-  (macro_definition)
-  (macro_invocation)
-  (attribute_item)
-  (block)
-  (use_declaration)+
-] @fold

config/nvim/queries/rust/highlights.scm

@@ -1,531 +0,0 @@
-; 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)
-
-(parameter
-  (ref_pattern
-    [
-      (mut_pattern
-        (identifier) @variable.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"
-  "gen"
-] @keyword.coroutine
-
-"try" @keyword.exception
-
-[
-  "ref"
-  "pub"
-  "raw"
-  (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) @_identifier @keyword.exception
-  "!" @keyword.exception
-  (#eq? @_identifier "panic"))
-
-(macro_invocation
-  macro: (identifier) @_identifier @keyword.exception
-  "!" @keyword.exception
-  (#contains? @_identifier "assert"))
-
-(macro_invocation
-  macro: (identifier) @_identifier @keyword.debug
-  "!" @keyword.debug
-  (#eq? @_identifier "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
-
-(call_expression
-  function: (scoped_identifier
-    path: (identifier) @_regex
-    (#any-of? @_regex "Regex" "ByteRegexBuilder")
-    name: (identifier) @_new
-    (#eq? @_new "new"))
-  arguments: (arguments
-    (raw_string_literal
-      (string_content) @string.regexp)))
-
-(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
-      (string_content) @string.regexp)))
-
-(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
-        (string_content) @string.regexp))))
-
-(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
-        (string_content) @string.regexp))))

config/nvim/queries/rust/injections.scm

@@ -1,89 +0,0 @@
-(macro_invocation
-  macro: [
-    (scoped_identifier
-      name: (_) @_macro_name)
-    (identifier) @_macro_name
-  ]
-  (token_tree) @injection.content
-  (#not-any-of? @_macro_name "slint" "html" "json")
-  (#set! injection.language "rust")
-  (#set! injection.include-children))
-
-(macro_invocation
-  macro: [
-    (scoped_identifier
-      name: (_) @injection.language)
-    (identifier) @injection.language
-  ]
-  (token_tree) @injection.content
-  (#any-of? @injection.language "slint" "html" "json")
-  (#offset! @injection.content 0 1 0 -1)
-  (#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"))
-
-(call_expression
-  function: (scoped_identifier
-    path: (identifier) @_regex
-    (#any-of? @_regex "Regex" "RegexBuilder")
-    name: (identifier) @_new
-    (#eq? @_new "new"))
-  arguments: (arguments
-    (raw_string_literal
-      (string_content) @injection.content))
-  (#set! injection.language "regex"))
-
-(call_expression
-  function: (scoped_identifier
-    path: (scoped_identifier
-      (identifier) @_regex
-      (#any-of? @_regex "Regex" "RegexBuilder") .)
-    name: (identifier) @_new
-    (#eq? @_new "new"))
-  arguments: (arguments
-    (raw_string_literal
-      (string_content) @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
-        (string_content) @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
-        (string_content) @injection.content)))
-  (#set! injection.language "regex"))
-
-((block_comment) @injection.content
-  (#match? @injection.content "/\\*!([a-zA-Z]+:)?re2c")
-  (#set! injection.language "re2c"))

config/nvim/queries/rust/locals.scm

@@ -1,98 +0,0 @@
-; 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)
-
-(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

config/nvim/queries/rust/textobjects.scm

@@ -1,409 +0,0 @@
-; functions
-(function_signature_item) @function.outer
-
-(function_item) @function.outer
-
-(function_item
-  body: (block
-    .
-    "{"
-    _+ @function.inner
-    "}"))
-
-; quantifies as class(es)
-(struct_item) @class.outer
-
-(struct_item
-  body: (field_declaration_list
-    .
-    "{"
-    _+ @class.inner
-    "}"))
-
-(enum_item) @class.outer
-
-(enum_item
-  body: (enum_variant_list
-    .
-    "{"
-    _+ @class.inner
-    "}"))
-
-(union_item) @class.outer
-
-(union_item
-  body: (field_declaration_list
-    .
-    "{"
-    _+ @class.inner
-    "}"))
-
-(trait_item) @class.outer
-
-(trait_item
-  body: (declaration_list
-    .
-    "{"
-    _+ @class.inner
-    "}"))
-
-(impl_item) @class.outer
-
-(impl_item
-  body: (declaration_list
-    .
-    "{"
-    _+ @class.inner
-    "}"))
-
-(mod_item) @class.outer
-
-(mod_item
-  body: (declaration_list
-    .
-    "{"
-    _+ @class.inner
-    "}"))
-
-; conditionals
-(if_expression
-  alternative: (_
-    (_) @conditional.inner)?) @conditional.outer
-
-(if_expression
-  alternative: (else_clause
-    (block) @conditional.inner))
-
-(if_expression
-  condition: (_) @conditional.inner)
-
-(if_expression
-  consequence: (block) @conditional.inner)
-
-(match_arm
-  (_)) @conditional.inner
-
-(match_expression) @conditional.outer
-
-; loops
-(loop_expression
-  body: (block
-    .
-    "{"
-    _+ @loop.inner
-    "}")) @loop.outer
-
-(while_expression
-  body: (block
-    .
-    "{"
-    _+ @loop.inner
-    "}")) @loop.outer
-
-(for_expression
-  body: (block
-    .
-    "{"
-    _+ @loop.inner
-    "}")) @loop.outer
-
-; blocks
-(block
-  (_)* @block.inner) @block.outer
-
-(unsafe_block
-  (_)* @block.inner) @block.outer
-
-; calls
-(macro_invocation) @call.outer
-
-(macro_invocation
-  (token_tree
-    .
-    "("
-    _+ @call.inner
-    ")"))
-
-(call_expression) @call.outer
-
-(call_expression
-  arguments: (arguments
-    .
-    "("
-    _+ @call.inner
-    ")"))
-
-; returns
-(return_expression
-  (_)? @return.inner) @return.outer
-
-; statements
-(block
-  (_) @statement.outer)
-
-; comments
-(line_comment) @comment.outer
-
-(block_comment) @comment.outer
-
-; parameter
-(parameters
-  "," @parameter.outer
-  .
-  [
-    (self_parameter)
-    (parameter)
-    (type_identifier)
-  ] @parameter.inner @parameter.outer)
-
-(parameters
-  .
-  [
-    (self_parameter)
-    (parameter)
-    (type_identifier)
-  ] @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-; last element, with trailing comma
-(parameters
-  [
-    (self_parameter)
-    (parameter)
-    (type_identifier)
-  ] @parameter.outer
-  .
-  "," @parameter.outer .)
-
-(type_parameters
-  "," @parameter.outer
-  .
-  (_) @parameter.inner @parameter.outer)
-
-(type_parameters
-  .
-  (_) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-; last element, with trailing comma
-(type_parameters
-  (_) @parameter.outer
-  .
-  "," @parameter.outer .)
-
-(tuple_pattern
-  "," @parameter.outer
-  .
-  (identifier) @parameter.inner @parameter.outer)
-
-(tuple_pattern
-  .
-  (identifier) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-; last element, with trailing comma
-(tuple_pattern
-  (identifier) @parameter.outer
-  .
-  "," @parameter.outer .)
-
-(tuple_struct_pattern
-  "," @parameter.outer
-  .
-  (identifier) @parameter.inner @parameter.outer)
-
-(tuple_struct_pattern
-  .
-  (identifier) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-; last element, with trailing comma
-(tuple_struct_pattern
-  (identifier) @parameter.outer
-  .
-  "," @parameter.outer .)
-
-(tuple_expression
-  "," @parameter.outer
-  .
-  (_) @parameter.inner @parameter.outer)
-
-(tuple_expression
-  .
-  (_) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-; last element, with trailing comma
-(tuple_expression
-  (_) @parameter.outer
-  .
-  "," @parameter.outer .)
-
-(tuple_type
-  "," @parameter.outer
-  .
-  (_) @parameter.inner @parameter.outer)
-
-(tuple_type
-  .
-  (_) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-; last element, with trailing comma
-(tuple_type
-  (_) @parameter.outer
-  .
-  "," @parameter.outer .)
-
-(struct_item
-  body: (field_declaration_list
-    "," @parameter.outer
-    .
-    (_) @parameter.inner @parameter.outer))
-
-(struct_item
-  body: (field_declaration_list
-    .
-    (_) @parameter.inner @parameter.outer
-    .
-    ","? @parameter.outer))
-
-; last element, with trailing comma
-(struct_item
-  body: (field_declaration_list
-    (_) @parameter.outer
-    .
-    "," @parameter.outer .))
-
-(struct_expression
-  body: (field_initializer_list
-    "," @parameter.outer
-    .
-    (_) @parameter.inner @parameter.outer))
-
-(struct_expression
-  body: (field_initializer_list
-    .
-    (_) @parameter.inner @parameter.outer
-    .
-    ","? @parameter.outer))
-
-; last element, with trailing comma
-(struct_expression
-  body: (field_initializer_list
-    (_) @parameter.outer
-    .
-    "," @parameter.outer .))
-
-(closure_parameters
-  "," @parameter.outer
-  .
-  (_) @parameter.inner @parameter.outer)
-
-(closure_parameters
-  .
-  (_) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-; last element, with trailing comma
-(closure_parameters
-  (_) @parameter.outer
-  .
-  "," @parameter.outer .)
-
-(arguments
-  "," @parameter.outer
-  .
-  (_) @parameter.inner @parameter.outer)
-
-(arguments
-  .
-  (_) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-; last element, with trailing comma
-(arguments
-  (_) @parameter.outer
-  .
-  "," @parameter.outer .)
-
-(type_arguments
-  "," @parameter.outer
-  .
-  (_) @parameter.inner @parameter.outer)
-
-(type_arguments
-  .
-  (_) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-; last element, with trailing comma
-(type_arguments
-  (_) @parameter.outer
-  .
-  "," @parameter.outer .)
-
-(token_tree
-  "," @parameter.outer
-  .
-  (_) @parameter.inner @parameter.outer)
-
-(token_tree
-  .
-  (_) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-; last element, with trailing comma
-(token_tree
-  (_) @parameter.outer
-  .
-  "," @parameter.outer .)
-
-(scoped_use_list
-  list: (use_list
-    "," @parameter.outer
-    .
-    (_) @parameter.inner @parameter.outer))
-
-(scoped_use_list
-  list: (use_list
-    .
-    (_) @parameter.inner @parameter.outer
-    .
-    ","? @parameter.outer))
-
-; last element, with trailing comma
-(scoped_use_list
-  list: (use_list
-    (_) @parameter.outer
-    .
-    "," @parameter.outer .))
-
-[
-  (integer_literal)
-  (float_literal)
-] @number.inner
-
-(let_declaration
-  pattern: (_) @assignment.lhs
-  value: (_) @assignment.inner @assignment.rhs) @assignment.outer
-
-(let_declaration
-  pattern: (_) @assignment.inner)
-
-(assignment_expression
-  left: (_) @assignment.lhs
-  right: (_) @assignment.inner @assignment.rhs) @assignment.outer
-
-(assignment_expression
-  left: (_) @assignment.inner)

config/nvim/queries/zig/folds.scm

@@ -1,23 +0,0 @@
-[
-  (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

config/nvim/queries/zig/highlights.scm

@@ -1,283 +0,0 @@
-; 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 "^//!"))

config/nvim/queries/zig/injections.scm

@@ -1,10 +0,0 @@
-((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"))

config/nvim/queries/zig/locals.scm

@@ -1,96 +0,0 @@
-; Definitions
-(function_declaration
-  name: (identifier) @local.definition.function)
-
-(parameter
-  name: (identifier) @local.definition.parameter)
-
-(variable_declaration
-  (identifier) @local.definition.var)
-
-(variable_declaration
-  (identifier) @local.definition.type
-  (enum_declaration))
-
-(container_field
-  type: (identifier) @local.definition.field)
-
-(enum_declaration
-  (function_declaration
-    name: (identifier) @local.definition.method))
-
-(variable_declaration
-  (identifier) @local.definition.type
-  (struct_declaration))
-
-(struct_declaration
-  (function_declaration
-    name: (identifier) @local.definition.method))
-
-(container_field
-  name: (identifier) @local.definition.field)
-
-(variable_declaration
-  (identifier) @local.definition.type
-  (union_declaration))
-
-(union_declaration
-  (function_declaration
-    name: (identifier) @local.definition.method))
-
-(payload
-  (identifier) @local.definition.var)
-
-(block_label
-  (identifier) @local.definition)
-
-; References
-(identifier) @local.reference
-
-(parameter
-  type: (identifier) @local.reference
-  (#set! reference.kind "type"))
-
-(pointer_type
-  (identifier) @local.reference
-  (#set! reference.kind "type"))
-
-(nullable_type
-  (identifier) @local.reference
-  (#set! reference.kind "type"))
-
-(struct_initializer
-  (identifier) @local.reference
-  (#set! reference.kind "type"))
-
-(array_type
-  (_)
-  (identifier) @local.reference
-  (#set! reference.kind "type"))
-
-(slice_type
-  (identifier) @local.reference
-  (#set! reference.kind "type"))
-
-(field_expression
-  member: (identifier) @local.reference
-  (#set! reference.kind "field"))
-
-(call_expression
-  function: (field_expression
-    member: (identifier) @local.reference
-    (#set! reference.kind "function")))
-
-(break_label
-  (identifier) @local.reference)
-
-[
-  (for_statement)
-  (if_statement)
-  (while_statement)
-  (function_declaration)
-  (block)
-  (source_file)
-  (enum_declaration)
-  (struct_declaration)
-] @local.scope

config/nvim/queries/zig/textobjects.scm

@@ -1,110 +0,0 @@
-; "Classes"
-(variable_declaration
-  (struct_declaration)) @class.outer
-
-(variable_declaration
-  (struct_declaration
-    "struct"
-    "{"
-    _+ @class.inner
-    "}"))
-
-; functions
-(function_declaration) @function.outer
-
-(function_declaration
-  body: (block
-    .
-    "{"
-    _+ @function.inner
-    "}"))
-
-; loops
-(for_statement) @loop.outer
-
-(for_statement
-  body: (_) @loop.inner)
-
-(while_statement) @loop.outer
-
-(while_statement
-  body: (_) @loop.inner)
-
-; blocks
-(block) @block.outer
-
-(block
-  "{"
-  _+ @block.inner
-  "}")
-
-; statements
-(statement) @statement.outer
-
-; parameters
-(parameters
-  "," @parameter.outer
-  .
-  (parameter) @parameter.inner @parameter.outer)
-
-(parameters
-  .
-  (parameter) @parameter.inner @parameter.outer
-  .
-  ","? @parameter.outer)
-
-; arguments
-(call_expression
-  function: (_)
-  arguments: (arguments
-    "("
-    "," @parameter.outer
-    .
-    (_) @parameter.inner @parameter.outer
-    ")"))
-
-(call_expression
-  function: (_)
-  arguments: (arguments
-    "("
-    .
-    (_) @parameter.inner @parameter.outer
-    .
-    ","? @parameter.outer
-    ")"))
-
-; comments
-(comment) @comment.outer
-
-; conditionals
-(if_statement) @conditional.outer
-
-(if_statement
-  condition: (_) @conditional.inner)
-
-(if_statement
-  body: (_) @conditional.inner)
-
-(switch_expression) @conditional.outer
-
-(switch_expression
-  "("
-  (_) @conditional.inner
-  ")")
-
-(switch_expression
-  "{"
-  _+ @conditional.inner
-  "}")
-
-(while_statement
-  condition: (_) @conditional.inner)
-
-; calls
-(call_expression) @call.outer
-
-(call_expression
-  arguments: (arguments
-    "("
-    _+ @call.inner
-    ")"))