initial commit

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

config/fuzzel/fuzzel.ini

@@ -1,8 +1,12 @@
 [main]
 terminal=foot
-width=30
+font=JetBrains Mono:size=16
+width=45
 lines=10
 anchor=center
+icons-enabled=yes
+icon-theme=hicolor
+fuzzy=yes
 
 [colors]
 background=0a0a0aff

config/nvim/.gitignore

@@ -1 +0,0 @@
-lazy-lock.json

config/nvim/.luacheckrc

@@ -0,0 +1 @@
+globals = { "vim" }

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,461 @@
-require("config.options")
+--
-require("config.keybinds")
+-- CONFIGS
-require("manage").setup()
+--
+vim.opt.termguicolors = true -- enable 24-bit RGB colors in the terminal
+
+-- Line numbers
+vim.opt.number = true -- show absolute line number on current line
+vim.opt.relativenumber = true -- show relative line numbers for all other lines
+vim.opt.cursorline = true -- highlight the row the cursor is on
+vim.opt.wrap = false -- do not wrap long lines
+vim.opt.scrolloff = 10 -- keep at least 10 lines above/below the cursor
+vim.opt.sidescrolloff = 10 -- keep at least 10 columns left/right of the cursor
+
+-- Indentation: 2-space soft tabs
+vim.opt.tabstop = 2 -- a <Tab> counts as 2 columns
+vim.opt.shiftwidth = 2 -- >> / << shift by 2 columns
+vim.opt.softtabstop = 2 -- <Tab> in insert mode inserts 2 spaces
+vim.opt.expandtab = true -- insert spaces instead of tab characters
+vim.opt.smartindent = true
+vim.opt.autoindent = true
+
+-- Search
+vim.opt.ignorecase = true -- case-insensitive search by default
+vim.opt.smartcase = true -- switch to case-sensitive when query contains an uppercase letter
+vim.opt.hlsearch = true -- highlight all matches
+vim.opt.incsearch = true -- show matches while typing the query
+
+-- UI
+vim.opt.showmatch = true -- briefly jump to matching bracket when one is inserted
+vim.opt.cmdheight = 1 -- always show the command line (1 row)
+vim.opt.showmode = false -- hide "-- INSERT --" etc.; the statusline shows the mode instead
+vim.opt.pumheight = 10 -- limit the completion popup to 10 items
+vim.opt.pumblend = 10 -- make the completion popup slightly transparent
+vim.opt.winblend = 0 -- floating windows are fully opaque
+vim.opt.conceallevel = 0 -- never hide markup characters (e.g. Markdown asterisks)
+vim.opt.concealcursor = "" -- never hide markup on the cursor line either
+vim.opt.synmaxcol = 300 -- stop syntax highlighting for columns beyond 300 (perf guard)
+vim.opt.fillchars = { eob = " " } -- replace the "~" placeholder on empty lines with a space
+
+-- Persistent undo: survive across sessions even after the buffer is closed
+local undodir = vim.fn.expand("~/.vim/undodir")
+if
+	vim.fn.isdirectory(undodir) == 0 -- create undodir if nonexistent
+then
+	vim.fn.mkdir(undodir, "p")
+end
+
+vim.opt.backup = false -- do not create a backup file
+vim.opt.writebackup = false -- do not keep a backup while overwriting a file
+vim.opt.swapfile = false -- do not create a swapfile
+vim.opt.undofile = true -- persist undo history to disk
+vim.opt.undodir = undodir -- where to store undo files
+vim.opt.updatetime = 300 -- write swap file (and trigger CursorHold) after 300 ms of inactivity
+vim.opt.timeoutlen = 500 -- wait 500 ms for a mapped key sequence to complete
+vim.opt.ttimeoutlen = 50 -- wait 50 ms for a terminal key code to complete
+vim.opt.autoread = true -- reload a file changed outside Neovim without prompting
+vim.opt.autowrite = false -- do not silently save on :make / buffer switch
+
+-- Buffer and editing behaviour
+vim.opt.hidden = true -- allow switching away from an unsaved buffer without closing it
+vim.opt.errorbells = false -- disable the error bell
+vim.opt.backspace = "indent,eol,start" -- allow backspace over auto-indent, line breaks, and insert start
+vim.opt.autochdir = false -- keep the working directory fixed (don't follow the open file)
+vim.opt.iskeyword:append("-") -- treat "foo-bar" as a single word for motions like w/b
+vim.opt.path:append("**") -- make :find search recursively into subdirectories
+vim.opt.selection = "inclusive" -- visual selection includes the character under the cursor
+vim.opt.mouse = "a" -- enable mouse support in all modes
+vim.opt.clipboard:append("unnamedplus") -- share the system clipboard (+ register)
+
+-- Over SSH, wl-clipboard is unavailable; use OSC 52 to write yanks to the local terminal clipboard.
+if os.getenv("SSH_TTY") then
+	vim.g.clipboard = {
+		name = "OSC 52",
+		copy = {
+			["+"] = require("vim.ui.clipboard.osc52").copy("+"),
+			["*"] = require("vim.ui.clipboard.osc52").copy("*"),
+		},
+		paste = {
+			["+"] = require("vim.ui.clipboard.osc52").paste("+"),
+			["*"] = require("vim.ui.clipboard.osc52").paste("*"),
+		},
+	}
+end
+vim.opt.modifiable = true -- allow buffer modifications (safety default)
+vim.opt.encoding = "utf-8" -- internal character encoding
+
+-- Folding: driven by Tree-sitter when available; foldlevel = 99 means all folds start open
+vim.opt.foldmethod = "expr"
+vim.opt.foldexpr = "v:lua.vim.treesitter.foldexpr()"
+vim.opt.foldlevel = 99 -- a high value ensures every fold is open on buffer load
+
+-- Window splits
+vim.opt.splitbelow = true -- :split opens the new window below
+vim.opt.splitright = true -- :vsplit opens the new window to the right
+
+-- Miscellaneous
+vim.opt.wildmenu = true -- enable enhanced command-line completion
+vim.opt.wildmode = "longest:full,full" -- first Tab completes the longest common prefix and lists all; subsequent Tabs cycle
+vim.opt.diffopt:append("linematch:60") -- use the improved diff algorithm for blocks up to 60 lines
+vim.opt.redrawtime = 10000 -- allow up to 10 s for a full screen redraw (useful for large files)
+vim.opt.maxmempattern = 20000 -- raise the memory cap for pattern matching (avoids "pattern too complex" errors)
+
+--
+-- KEYMAPS
+--
+vim.g.mapleader = " " -- <Space> as the leader key
+vim.g.maplocalleader = " " -- <Space> as the local leader key
+
+-- j/k navigate display lines when there is no count prefix, so wrapped lines
+-- feel natural. With a count (e.g. 5j) they use real lines so relative jumps work.
+vim.keymap.set("n", "j", function()
+	return vim.v.count == 0 and "gj" or "j"
+end, { expr = true, silent = true, desc = "Down (wrap-aware)" })
+vim.keymap.set("n", "k", function()
+	return vim.v.count == 0 and "gk" or "k"
+end, { expr = true, silent = true, desc = "Up (wrap-aware)" })
+
+-- Keep search results and half-page jumps vertically centred
+vim.keymap.set("n", "n", "nzzzv", { desc = "Next search result (centered)" })
+vim.keymap.set("n", "N", "Nzzzv", { desc = "Previous search result (centered)" })
+vim.keymap.set("n", "<C-d>", "<C-d>zz", { desc = "Half page down (centered)" })
+vim.keymap.set("n", "<C-u>", "<C-u>zz", { desc = "Half page up (centered)" })
+
+-- Window navigation without the <C-w> prefix
+vim.keymap.set("n", "<C-h>", "<C-w>h", { desc = "Move to left window" })
+vim.keymap.set("n", "<C-j>", "<C-w>j", { desc = "Move to bottom window" })
+vim.keymap.set("n", "<C-k>", "<C-w>k", { desc = "Move to top window" })
+vim.keymap.set("n", "<C-l>", "<C-w>l", { desc = "Move to right window" })
+
+-- Re-select visual block after indent so you can keep indenting with < or >
+vim.keymap.set("v", "<", "<gv", { desc = "Indent left and reselect" })
+vim.keymap.set("v", ">", ">gv", { desc = "Indent right and reselect" })
+
+-- J joins lines but restores the cursor position (mz saves, `z restores)
+vim.keymap.set("n", "J", "mzJ`z", { desc = "Join lines and keep cursor position" })
+
+vim.keymap.set("n", "H", "<cmd>bprev<cr>", { desc = "Previous buffer" })
+vim.keymap.set("n", "L", "<cmd>bnext<cr>", { desc = "Next buffer" })
+
+-- Toggle LSP diagnostics on/off for the current session
+vim.keymap.set("n", "<leader>td", function()
+	vim.diagnostic.enable(not vim.diagnostic.is_enabled())
+end, { desc = "Toggle diagnostics" })
+
+-- Toggle inline virtual text only (keeps underlines and signs)
+vim.keymap.set("n", "<leader>tv", function()
+	local current = vim.diagnostic.config().virtual_text
+	vim.diagnostic.config({ virtual_text = not current })
+end, { desc = "Toggle virtual text" })
+
+--
+-- AUTOCOMMANDS
+--
+local augroup = vim.api.nvim_create_augroup("UserConfig", { clear = true })
+
+-- Format on save via the EFM language server.
+-- Only runs when: the buffer is a real file, it is modifiable, it has a name,
+-- and efm is attached. This avoids spurious save prompts on scratch buffers.
+vim.api.nvim_create_autocmd("BufWritePre", {
+	group = augroup,
+	pattern = {
+		"*.cs",
+		"*.lua",
+		"*.py",
+		"*.go",
+		"*.js",
+		"*.jsx",
+		"*.ts",
+		"*.tsx",
+		"*.json",
+		"*.css",
+		"*.scss",
+		"*.html",
+		"*.sh",
+		"*.bash",
+	},
+	callback = function(args)
+		-- avoid formatting non-file buffers (helps prevent weird write prompts)
+		if vim.bo[args.buf].buftype ~= "" then
+			return
+		end
+		if not vim.bo[args.buf].modifiable then
+			return
+		end
+		if vim.api.nvim_buf_get_name(args.buf) == "" then
+			return
+		end
+
+		local has_efm = false
+		for _, c in ipairs(vim.lsp.get_clients({ bufnr = args.buf })) do
+			if c.name == "efm" then
+				has_efm = true
+				break
+			end
+		end
+		if not has_efm then
+			return
+		end
+
+		pcall(vim.lsp.buf.format, {
+			bufnr = args.buf,
+			timeout_ms = 2000,
+			filter = function(c)
+				return c.name == "efm"
+			end,
+		})
+	end,
+})
+
+-- Flash the yanked region briefly so it is clear what was copied
+vim.api.nvim_create_autocmd("TextYankPost", {
+	group = augroup,
+	callback = function()
+		vim.hl.on_yank()
+	end,
+})
+
+-- Restore the cursor to where it was when the file was last closed
+vim.api.nvim_create_autocmd("BufReadPost", {
+	group = augroup,
+	desc = "Restore last cursor position",
+	callback = function()
+		if vim.o.diff then -- except in diff mode
+			return
+		end
+
+		local last_pos = vim.api.nvim_buf_get_mark(0, '"') -- {line, col}
+		local last_line = vim.api.nvim_buf_line_count(0)
+
+		local row = last_pos[1]
+		if row < 1 or row > last_line then
+			return
+		end
+
+		pcall(vim.api.nvim_win_set_cursor, 0, last_pos)
+	end,
+})
+
+-- Prose-friendly settings for Markdown, plain text, and commit messages
+vim.api.nvim_create_autocmd("FileType", {
+	group = augroup,
+	pattern = { "markdown", "text", "gitcommit" },
+	callback = function()
+		vim.opt_local.wrap = true -- soft-wrap at window edge
+		vim.opt_local.linebreak = true -- break at word boundaries, not mid-word
+		vim.opt_local.spell = true -- enable spell-checking
+	end,
+})
+
+--
+-- PLUGINS
+--
+vim.pack.add({
+	"https://github.com/folke/which-key.nvim", -- shows pending keymap hints
+	"https://github.com/folke/tokyonight.nvim", -- colorscheme
+	"https://github.com/nvim-lualine/lualine.nvim", -- statusline
+	"https://www.github.com/lewis6991/gitsigns.nvim", -- git hunk signs in the gutter
+	"https://www.github.com/echasnovski/mini.nvim", -- collection of small plugins
+	"https://www.github.com/ibhagwan/fzf-lua", -- fuzzy finder (files, grep, LSP, …)
+	"https://www.github.com/neovim/nvim-lspconfig", -- provides cmd/root_dir/filetypes for each LSP server
+	"https://github.com/mason-org/mason.nvim", -- LSP / tool installer UI
+	"https://github.com/creativenull/efmls-configs-nvim", -- pre-built efm-langserver tool configs
+	"https://github.com/WhoIsSethDaniel/mason-tool-installer.nvim", -- auto-install Mason tools on startup
+	"https://github.com/folke/flash.nvim", -- enhanced f/t/s jumps with labels
+	"https://github.com/L3MON4D3/LuaSnip", -- snippet engine (used by blink.cmp)
+	{
+		src = "https://github.com/saghen/blink.cmp", -- completion engine
+		version = vim.version.range("1.*"), -- pin to any 1.x release
+	},
+	{
+		src = "https://github.com/nvim-treesitter/nvim-treesitter",
+		branch = "main",
+		build = ":TSUpdate", -- keep parser binaries up to date after install/update
+	},
+	"https://github.com/nvim-treesitter/nvim-treesitter-textobjects",
+	"https://github.com/HakonHarnes/img-clip.nvim", -- paste images from clipboard (no Python required)
+})
+
+--
+-- PLUGIN CONFIGS
+--
+require("lualine").setup()
+
+vim.cmd.colorscheme("tokyonight")
+
+-- which-key: shows a popup of available keymaps after a delay.
+-- Groups give the prefixes human-readable titles in the popup.
+require("which-key").setup({})
+require("which-key").add({
+	{ "<leader>f", group = "Find" }, -- fzf-lua pickers (files, grep, LSP symbols, …)
+	{ "<leader>g", group = "Go to" }, -- LSP navigation (definition, split, …)
+	{ "<leader>c", group = "Code" }, -- code actions
+	{ "<leader>r", group = "Refactor" }, -- rename, extract, …
+	{ "<leader>t", group = "Toggle" }, -- toggle settings (diagnostics, …)
+	{ "<leader>o", group = "Organize" }, -- organize imports, sort, …
+	{ "<leader>d", group = "Diagnostics" }, -- diagnostic float / list
+	{ "<leader>n", group = "Next" }, -- jump to next item
+	{ "<leader>p", group = "Prev" }, -- jump to previous item
+	{ "]m", hidden = true },
+	{ "[m", hidden = true },
+	{ "]M", hidden = true },
+	{ "[M", hidden = true },
+})
+
+-- Tree-sitter: start the parser for a filetype only when its grammar is
+-- already installed. Missing grammars are installed asynchronously on first
+-- launch so the editor never blocks at startup.
+local setup_treesitter = function()
+	local treesitter = require("nvim-treesitter")
+	treesitter.setup({})
+	local ensure_installed = {
+		"vim",
+		"vimdoc",
+		"go",
+		"html",
+		"css",
+		"javascript",
+		"json",
+		"lua",
+		"markdown",
+		"python",
+		"typescript",
+		"bash",
+		"c_sharp",
+	}
+
+	local config = require("nvim-treesitter.config")
+
+	-- Only install parsers that are not already present
+	local already_installed = config.get_installed()
+	local parsers_to_install = {}
+
+	for _, parser in ipairs(ensure_installed) do
+		if not vim.tbl_contains(already_installed, parser) then
+			table.insert(parsers_to_install, parser)
+		end
+	end
+
+	if #parsers_to_install > 0 then
+		treesitter.install(parsers_to_install)
+	end
+
+	-- Start the Tree-sitter parser whenever a supported filetype is opened.
+	-- Using an autocmd instead of the built-in auto_install avoids the
+	-- blocking install prompt on first open.
+	local group = vim.api.nvim_create_augroup("TreeSitterConfig", { clear = true })
+	vim.api.nvim_create_autocmd("FileType", {
+		group = group,
+		callback = function(args)
+			if vim.list_contains(treesitter.get_installed(), vim.treesitter.language.get_lang(args.match)) then
+				vim.treesitter.start(args.buf)
+			end
+		end,
+	})
+end
+
+setup_treesitter()
+
+require("nvim-treesitter-textobjects").setup({ move = { set_jumps = true } })
+
+local move = require("nvim-treesitter-textobjects.move")
+vim.keymap.set({ "n", "x", "o" }, "]f", function()
+	move.goto_next_start("@function.outer", "textobjects")
+end, { desc = "Next function" })
+vim.keymap.set({ "n", "x", "o" }, "[f", function()
+	move.goto_previous_start("@function.outer", "textobjects")
+end, { desc = "Prev function" })
+vim.keymap.set({ "n", "x", "o" }, "]c", function()
+	move.goto_next_start("@class.outer", "textobjects")
+end, { desc = "Next class" })
+vim.keymap.set({ "n", "x", "o" }, "[c", function()
+	move.goto_previous_start("@class.outer", "textobjects")
+end, { desc = "Prev class" })
+
+-- fzf-lua: fuzzy finder keymaps
+require("fzf-lua").setup({
+	files = {
+		actions = {
+			["ctrl-h"] = { require("fzf-lua").actions.toggle_hidden },
+		},
+	},
+})
+vim.keymap.set("n", "<leader><leader>", function()
+	require("fzf-lua").files()
+end, { desc = "Find files" })
+vim.keymap.set("n", "<leader>fg", function()
+	require("fzf-lua").live_grep()
+end, { desc = "FZF Live Grep" })
+vim.keymap.set("n", "<leader>fb", function()
+	require("fzf-lua").buffers()
+end, { desc = "FZF Buffers" })
+vim.keymap.set("n", "<leader>fh", function()
+	require("fzf-lua").help_tags()
+end, { desc = "FZF Help Tags" })
+vim.keymap.set("n", "<leader>fx", function()
+	require("fzf-lua").diagnostics_document()
+end, { desc = "FZF Diagnostics Document" })
+vim.keymap.set("n", "<leader>fX", function()
+	require("fzf-lua").diagnostics_workspace()
+end, { desc = "FZF Diagnostics Workspace" })
+
+-- mini.nvim: a suite of small, focused plugins. Each module is opted in explicitly.
+require("mini.ai").setup({}) -- extended text objects (e.g. cia = inside any argument)
+require("mini.comment").setup({}) -- gcc / gc<motion> to toggle comments
+require("mini.move").setup({}) -- move lines/selections with Option+hjkl (macOS Option = Alt)
+require("mini.surround").setup({}) -- sa/sd/sr to add/delete/replace surrounding chars
+require("mini.cursorword").setup({}) -- highlight all occurrences of the word under the cursor
+require("mini.indentscope").setup({}) -- animated indent-scope indicator line
+require("mini.pairs").setup({}) -- auto-close brackets, quotes, etc.
+require("mini.trailspace").setup({}) -- highlight and trim trailing whitespace
+require("mini.notify").setup({}) -- non-blocking notification popups
+require("mini.icons").setup({}) -- icon provider (replaces nvim-web-devicons calls)
+
+-- flash.nvim: label-based jumps for f/t and anywhere on screen
+require("flash").setup({})
+vim.keymap.set({ "n", "x", "o" }, "s", function()
+	require("flash").jump()
+end, { desc = "Flash jump" })
+vim.keymap.set({ "n", "x", "o" }, "S", function()
+	require("flash").treesitter()
+end, { desc = "Flash treesitter" })
+vim.keymap.set("o", "r", function()
+	require("flash").remote()
+end, { desc = "Flash remote" })
+vim.keymap.set({ "o", "x" }, "R", function()
+	require("flash").treesitter_search()
+end, { desc = "Flash treesitter search" })
+
+-- img-clip: paste images from clipboard into markdown files (no Python required)
+require("img-clip").setup({
+	default = {
+		use_absolute_path = false,
+		relative_to_current_file = true,
+		file_name = function()
+			return os.date("%Y-%m-%d_%H-%M-%S")
+		end,
+	},
+	filetypes = {
+		markdown = { template = "![]($FILE_PATH)" },
+	},
+})
+vim.keymap.set({ "n", "x" }, "<leader>pi", "<cmd>PasteImage<CR>", { desc = "Paste image" })
+
+-- gitsigns: decorates the sign column with added/changed/removed hunk markers
+require("gitsigns").setup({
+	signs = {
+		add = { text = "\u{2590}" }, -- ▏
+		change = { text = "\u{2590}" }, -- ▐
+		delete = { text = "\u{2590}" }, -- ◦
+		topdelete = { text = "\u{25e6}" }, -- ◦
+		changedelete = { text = "\u{25cf}" }, -- ●
+		untracked = { text = "\u{25cb}" }, -- ○
+	},
+	signcolumn = true,
+	current_line_blame = false, -- set to true to show inline git blame on the cursor line
+})
+
+--
+-- LSP - Too anoying to have in this file
+--
+require("lsp-nix")

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/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/lsp-nix.lua

@@ -0,0 +1,211 @@
+local augroup = vim.api.nvim_create_augroup("UserConfig", { clear = false })
+
+-- Diagnostic icons shown in the sign column and virtual text
+local diagnostic_signs = {
+	Error = " ",
+	Warn = " ",
+	Hint = "",
+	Info = "",
+}
+
+-- Global diagnostic display options
+vim.diagnostic.config({
+	virtual_text = { prefix = "●", spacing = 4 }, -- inline diagnostic text to the right
+	signs = {
+		text = {
+			[vim.diagnostic.severity.ERROR] = diagnostic_signs.Error,
+			[vim.diagnostic.severity.WARN] = diagnostic_signs.Warn,
+			[vim.diagnostic.severity.INFO] = diagnostic_signs.Info,
+			[vim.diagnostic.severity.HINT] = diagnostic_signs.Hint,
+		},
+	},
+	underline = true,
+	update_in_insert = false, -- do not update diagnostics while typing (reduces noise)
+	severity_sort = true,     -- show errors before warnings in lists
+	float = {
+		border = "rounded",
+		source = "always", -- always show which LSP server produced the diagnostic
+		header = "",
+		prefix = "",
+		focusable = false,
+		style = "minimal",
+	},
+})
+
+-- Patch vim.lsp.util.open_floating_preview so every LSP floating window
+-- (hover, signature help, etc.) gets a rounded border without having to
+-- configure it per-server.
+do
+	local orig = vim.lsp.util.open_floating_preview
+	function vim.lsp.util.open_floating_preview(contents, syntax, opts, ...)
+		opts = opts or {}
+		opts.border = opts.border or "rounded"
+		return orig(contents, syntax, opts, ...)
+	end
+end
+
+-- lsp_on_attach is called whenever an LSP server attaches to a buffer.
+-- It sets up buffer-local keymaps that are only active when an LSP is present.
+local function lsp_on_attach(ev)
+	local client = vim.lsp.get_client_by_id(ev.data.client_id)
+	if not client then
+		return
+	end
+
+	local bufnr = ev.buf
+	local function map(key, fn, desc)
+		vim.keymap.set("n", key, fn, { noremap = true, silent = true, buffer = bufnr, desc = desc })
+	end
+
+	-- Navigation
+	map("<leader>gd", vim.lsp.buf.definition,                                                              "Go to definition")
+	map("<leader>gS", function() vim.cmd("vsplit") vim.lsp.buf.definition() end,                           "Go to definition (vsplit)")
+
+	-- Code actions and refactoring
+	map("<leader>ca", vim.lsp.buf.code_action, "Code action")
+	map("<leader>rn", vim.lsp.buf.rename,      "Rename symbol")
+
+	-- Diagnostics
+	map("<leader>D",  function() vim.diagnostic.open_float({ scope = "line" })   end, "Line diagnostics")
+	map("<leader>d",  function() vim.diagnostic.open_float({ scope = "cursor" }) end, "Cursor diagnostic")
+	map("<leader>nd", function() vim.diagnostic.jump({ count = 1 })              end, "Next diagnostic")
+	map("<leader>pd", function() vim.diagnostic.jump({ count = -1 })             end, "Prev diagnostic")
+
+	-- Hover documentation
+	map("K", vim.lsp.buf.hover, "Hover docs")
+
+	-- fzf-lua LSP pickers
+	map("<leader>fd", function() require("fzf-lua").lsp_definitions({ jump_to_single_result = true }) end, "Definitions")
+	map("<leader>fr", function() require("fzf-lua").lsp_references()         end, "References")
+	map("<leader>ft", function() require("fzf-lua").lsp_typedefs()           end, "Type definitions")
+	map("<leader>fs", function() require("fzf-lua").lsp_document_symbols()   end, "Document symbols")
+	map("<leader>fw", function() require("fzf-lua").lsp_workspace_symbols()  end, "Workspace symbols")
+	map("<leader>fi", function() require("fzf-lua").lsp_implementations()    end, "Implementations")
+
+	-- Organise imports then format (only registered when the server supports codeAction)
+	if client:supports_method("textDocument/codeAction", bufnr) then
+		map("<leader>oi", function()
+			vim.lsp.buf.code_action({
+				context = { only = { "source.organizeImports" }, diagnostics = {} },
+				apply = true,
+				bufnr = bufnr,
+			})
+			-- Small delay lets the import action settle before formatting
+			vim.defer_fn(function()
+				vim.lsp.buf.format({ bufnr = bufnr })
+			end, 50)
+		end, "Organize imports")
+	end
+end
+
+vim.api.nvim_create_autocmd("LspAttach", { group = augroup, callback = lsp_on_attach })
+
+-- Global diagnostic keymaps (available without an LSP attached)
+vim.keymap.set("n", "<leader>q", function() vim.diagnostic.setloclist({ open = true }) end, { desc = "Open diagnostic list" })
+
+-- blink.cmp: completion engine wired to LuaSnip for snippet expansion
+require("blink.cmp").setup({
+	enabled = function()
+		return not vim.tbl_contains({ "markdown", "text" }, vim.bo.filetype)
+	end,
+	keymap = {
+		preset = "none", -- start from a blank slate; all bindings are explicit
+		["<C-Space>"] = { "show", "hide" },      -- toggle the completion menu
+		["<CR>"] = { "accept", "fallback" },     -- confirm selection
+		["<C-j>"] = { "select_next", "fallback" },
+		["<C-k>"] = { "select_prev", "fallback" },
+		["<Tab>"] = { "snippet_forward", "fallback" },   -- jump to next snippet placeholder
+		["<S-Tab>"] = { "snippet_backward", "fallback" }, -- jump to previous placeholder
+	},
+	appearance = { nerd_font_variant = "mono" },
+	completion = { menu = { auto_show = true } }, -- show the menu automatically (no manual trigger needed)
+	sources = { default = { "lsp", "path", "buffer", "snippets" } },
+	snippets = {
+		-- Delegate snippet expansion to LuaSnip
+		expand = function(snippet)
+			require("luasnip").lsp_expand(snippet)
+		end,
+	},
+	fuzzy = {
+		implementation = "prefer_rust", -- use the faster Rust fuzzy-matching backend when available
+		prebuilt_binaries = { download = true }, -- automatically download the pre-built binary
+	},
+})
+
+-- Inject blink.cmp capabilities into every LSP server so they can offer
+-- completions that respect snippet and LSP-specific completion item fields
+vim.lsp.config["*"] = {
+	capabilities = require("blink.cmp").get_lsp_capabilities(),
+}
+
+-- Server configurations
+vim.lsp.config("lua_ls", {
+	settings = {
+		Lua = {
+			diagnostics = { globals = { "vim" } }, -- teach lua_ls that `vim` is a known global
+			telemetry = { enable = false },
+		},
+	},
+})
+vim.lsp.config("pyright", {})  -- Python type checker and language server
+vim.lsp.config("bashls", {})   -- Bash language server
+vim.lsp.config("vtsls", {})    -- TypeScript / JavaScript language server (VS Code's TS server)
+vim.lsp.config("gopls", {})    -- Go language server
+vim.lsp.config("omnisharp", {}) -- C# language server
+
+-- EFM (efm-langserver): a generic LSP adapter that runs command-line linters
+-- and formatters and exposes them as LSP capabilities.
+do
+	local luacheck  = require("efmls-configs.linters.luacheck")
+	local stylua    = require("efmls-configs.formatters.stylua")
+	local flake8    = require("efmls-configs.linters.flake8")
+	local black     = require("efmls-configs.formatters.black")
+	local prettier_d = require("efmls-configs.formatters.prettier_d")
+	local eslint_d  = require("efmls-configs.linters.eslint_d")
+	local fixjson   = require("efmls-configs.formatters.fixjson")
+	local shellcheck = require("efmls-configs.linters.shellcheck")
+	local shfmt     = require("efmls-configs.formatters.shfmt")
+	local go_revive = require("efmls-configs.linters.go_revive")
+	local gofumpt   = require("efmls-configs.formatters.gofumpt")
+	local csharpier = { formatCommand = "dotnet csharpier --write-stdout", formatStdin = true }
+
+	vim.lsp.config("efm", {
+		filetypes = {
+			"cs", "css", "go", "html",
+			"javascript", "javascriptreact",
+			"json", "jsonc",
+			"lua", "markdown", "python", "sh",
+			"typescript", "typescriptreact",
+		},
+		init_options = { documentFormatting = true },
+		settings = {
+			languages = {
+				cs             = { csharpier },
+				go             = { gofumpt, go_revive },
+				css            = { prettier_d },
+				html           = { prettier_d },
+				javascript     = { eslint_d, prettier_d },
+				javascriptreact = { eslint_d, prettier_d },
+				json           = { eslint_d, fixjson },
+				jsonc          = { eslint_d, fixjson },
+				lua            = { luacheck, stylua },
+				markdown       = { prettier_d },
+				python         = { flake8, black },
+				sh             = { shellcheck, shfmt },
+				typescript     = { eslint_d, prettier_d },
+				typescriptreact = { eslint_d, prettier_d },
+			},
+		},
+	})
+end
+
+-- Start all configured LSP servers
+vim.lsp.enable({
+	"lua_ls",
+	"pyright",
+	"bashls",
+	"vtsls",
+	"gopls",
+	"omnisharp",
+	"efm",
+})

config/nvim/lua/lsp.lua

@@ -0,0 +1,242 @@
+-- mason: GUI for installing LSP servers, DAPs, linters and formatters
+require("mason").setup({})
+
+-- mason-tool-installer: automatically install all required tools on startup
+require("mason-tool-installer").setup({
+	ensure_installed = {
+		-- LSP servers
+		"lua-language-server",
+		"pyright",
+		"bash-language-server",
+		"vtsls",
+		"gopls",
+		"omnisharp",
+		"efm",
+		-- Formatters
+		"stylua",
+		"black",
+		"prettierd",
+		"shfmt",
+		"gofumpt",
+		"fixjson",
+		-- Linters
+		"flake8",
+		"eslint_d",
+		"shellcheck",
+		"revive",
+	},
+	auto_update = false,
+	run_on_start = true,
+})
+
+local augroup = vim.api.nvim_create_augroup("UserConfig", { clear = false })
+
+-- Diagnostic icons shown in the sign column and virtual text
+local diagnostic_signs = {
+	Error = " ",
+	Warn = " ",
+	Hint = "",
+	Info = "",
+}
+
+-- Global diagnostic display options
+vim.diagnostic.config({
+	virtual_text = { prefix = "●", spacing = 4 }, -- inline diagnostic text to the right
+	signs = {
+		text = {
+			[vim.diagnostic.severity.ERROR] = diagnostic_signs.Error,
+			[vim.diagnostic.severity.WARN] = diagnostic_signs.Warn,
+			[vim.diagnostic.severity.INFO] = diagnostic_signs.Info,
+			[vim.diagnostic.severity.HINT] = diagnostic_signs.Hint,
+		},
+	},
+	underline = true,
+	update_in_insert = false, -- do not update diagnostics while typing (reduces noise)
+	severity_sort = true,     -- show errors before warnings in lists
+	float = {
+		border = "rounded",
+		source = "always", -- always show which LSP server produced the diagnostic
+		header = "",
+		prefix = "",
+		focusable = false,
+		style = "minimal",
+	},
+})
+
+-- Patch vim.lsp.util.open_floating_preview so every LSP floating window
+-- (hover, signature help, etc.) gets a rounded border without having to
+-- configure it per-server.
+do
+	local orig = vim.lsp.util.open_floating_preview
+	function vim.lsp.util.open_floating_preview(contents, syntax, opts, ...)
+		opts = opts or {}
+		opts.border = opts.border or "rounded"
+		return orig(contents, syntax, opts, ...)
+	end
+end
+
+-- lsp_on_attach is called whenever an LSP server attaches to a buffer.
+-- It sets up buffer-local keymaps that are only active when an LSP is present.
+local function lsp_on_attach(ev)
+	local client = vim.lsp.get_client_by_id(ev.data.client_id)
+	if not client then
+		return
+	end
+
+	local bufnr = ev.buf
+	local function map(key, fn, desc)
+		vim.keymap.set("n", key, fn, { noremap = true, silent = true, buffer = bufnr, desc = desc })
+	end
+
+	-- Navigation
+	map("<leader>gd", vim.lsp.buf.definition,                                                              "Go to definition")
+	map("<leader>gS", function() vim.cmd("vsplit") vim.lsp.buf.definition() end,                           "Go to definition (vsplit)")
+
+	-- Code actions and refactoring
+	map("<leader>ca", vim.lsp.buf.code_action, "Code action")
+	map("<leader>rn", vim.lsp.buf.rename,      "Rename symbol")
+
+	-- Diagnostics
+	map("<leader>D",  function() vim.diagnostic.open_float({ scope = "line" })   end, "Line diagnostics")
+	map("<leader>d",  function() vim.diagnostic.open_float({ scope = "cursor" }) end, "Cursor diagnostic")
+	map("<leader>nd", function() vim.diagnostic.jump({ count = 1 })              end, "Next diagnostic")
+	map("<leader>pd", function() vim.diagnostic.jump({ count = -1 })             end, "Prev diagnostic")
+
+	-- Hover documentation
+	map("K", vim.lsp.buf.hover, "Hover docs")
+
+	-- fzf-lua LSP pickers
+	map("<leader>fd", function() require("fzf-lua").lsp_definitions({ jump_to_single_result = true }) end, "Definitions")
+	map("<leader>fr", function() require("fzf-lua").lsp_references()         end, "References")
+	map("<leader>ft", function() require("fzf-lua").lsp_typedefs()           end, "Type definitions")
+	map("<leader>fs", function() require("fzf-lua").lsp_document_symbols()   end, "Document symbols")
+	map("<leader>fw", function() require("fzf-lua").lsp_workspace_symbols()  end, "Workspace symbols")
+	map("<leader>fi", function() require("fzf-lua").lsp_implementations()    end, "Implementations")
+
+	-- Organise imports then format (only registered when the server supports codeAction)
+	if client:supports_method("textDocument/codeAction", bufnr) then
+		map("<leader>oi", function()
+			vim.lsp.buf.code_action({
+				context = { only = { "source.organizeImports" }, diagnostics = {} },
+				apply = true,
+				bufnr = bufnr,
+			})
+			-- Small delay lets the import action settle before formatting
+			vim.defer_fn(function()
+				vim.lsp.buf.format({ bufnr = bufnr })
+			end, 50)
+		end, "Organize imports")
+	end
+end
+
+vim.api.nvim_create_autocmd("LspAttach", { group = augroup, callback = lsp_on_attach })
+
+-- Global diagnostic keymaps (available without an LSP attached)
+vim.keymap.set("n", "<leader>q", function() vim.diagnostic.setloclist({ open = true }) end, { desc = "Open diagnostic list" })
+
+-- blink.cmp: completion engine wired to LuaSnip for snippet expansion
+require("blink.cmp").setup({
+	enabled = function()
+		return not vim.tbl_contains({ "markdown", "text" }, vim.bo.filetype)
+	end,
+	keymap = {
+		preset = "none", -- start from a blank slate; all bindings are explicit
+		["<C-Space>"] = { "show", "hide" },      -- toggle the completion menu
+		["<CR>"] = { "accept", "fallback" },     -- confirm selection
+		["<C-j>"] = { "select_next", "fallback" },
+		["<C-k>"] = { "select_prev", "fallback" },
+		["<Tab>"] = { "snippet_forward", "fallback" },   -- jump to next snippet placeholder
+		["<S-Tab>"] = { "snippet_backward", "fallback" }, -- jump to previous placeholder
+	},
+	appearance = { nerd_font_variant = "mono" },
+	completion = { menu = { auto_show = true } }, -- show the menu automatically (no manual trigger needed)
+	sources = { default = { "lsp", "path", "buffer", "snippets" } },
+	snippets = {
+		-- Delegate snippet expansion to LuaSnip
+		expand = function(snippet)
+			require("luasnip").lsp_expand(snippet)
+		end,
+	},
+	fuzzy = {
+		implementation = "prefer_rust", -- use the faster Rust fuzzy-matching backend when available
+		prebuilt_binaries = { download = true }, -- automatically download the pre-built binary
+	},
+})
+
+-- Inject blink.cmp capabilities into every LSP server so they can offer
+-- completions that respect snippet and LSP-specific completion item fields
+vim.lsp.config["*"] = {
+	capabilities = require("blink.cmp").get_lsp_capabilities(),
+}
+
+-- Server configurations
+vim.lsp.config("lua_ls", {
+	settings = {
+		Lua = {
+			diagnostics = { globals = { "vim" } }, -- teach lua_ls that `vim` is a known global
+			telemetry = { enable = false },
+		},
+	},
+})
+vim.lsp.config("pyright", {})  -- Python type checker and language server
+vim.lsp.config("bashls", {})   -- Bash language server
+vim.lsp.config("vtsls", {})    -- TypeScript / JavaScript language server (VS Code's TS server)
+vim.lsp.config("gopls", {})    -- Go language server
+vim.lsp.config("omnisharp", {}) -- C# language server
+
+-- EFM (efm-langserver): a generic LSP adapter that runs command-line linters
+-- and formatters and exposes them as LSP capabilities.
+do
+	local luacheck  = require("efmls-configs.linters.luacheck")
+	local stylua    = require("efmls-configs.formatters.stylua")
+	local flake8    = require("efmls-configs.linters.flake8")
+	local black     = require("efmls-configs.formatters.black")
+	local prettier_d = require("efmls-configs.formatters.prettier_d")
+	local eslint_d  = require("efmls-configs.linters.eslint_d")
+	local fixjson   = require("efmls-configs.formatters.fixjson")
+	local shellcheck = require("efmls-configs.linters.shellcheck")
+	local shfmt     = require("efmls-configs.formatters.shfmt")
+	local go_revive = require("efmls-configs.linters.go_revive")
+	local gofumpt   = require("efmls-configs.formatters.gofumpt")
+	local csharpier = { formatCommand = "dotnet csharpier --write-stdout", formatStdin = true }
+
+	vim.lsp.config("efm", {
+		filetypes = {
+			"cs", "css", "go", "html",
+			"javascript", "javascriptreact",
+			"json", "jsonc",
+			"lua", "markdown", "python", "sh",
+			"typescript", "typescriptreact",
+		},
+		init_options = { documentFormatting = true },
+		settings = {
+			languages = {
+				cs             = { csharpier },
+				go             = { gofumpt, go_revive },
+				css            = { prettier_d },
+				html           = { prettier_d },
+				javascript     = { eslint_d, prettier_d },
+				javascriptreact = { eslint_d, prettier_d },
+				json           = { eslint_d, fixjson },
+				jsonc          = { eslint_d, fixjson },
+				lua            = { luacheck, stylua },
+				markdown       = { prettier_d },
+				python         = { flake8, black },
+				sh             = { shellcheck, shfmt },
+				typescript     = { eslint_d, prettier_d },
+				typescriptreact = { eslint_d, prettier_d },
+			},
+		},
+	})
+end
+
+-- Start all configured LSP servers
+vim.lsp.enable({
+	"lua_ls",
+	"pyright",
+	"bashls",
+	"vtsls",
+	"gopls",
+	"omnisharp",
+	"efm",
+})

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/nvim-pack-lock.json

@@ -0,0 +1,69 @@
+{
+  "plugins": {
+    "LuaSnip": {
+      "rev": "a62e1083a3cfe8b6b206e7d3d33a51091df25357",
+      "src": "https://github.com/L3MON4D3/LuaSnip"
+    },
+    "blink.cmp": {
+      "rev": "78336bc89ee5365633bcf754d93df01678b5c08f",
+      "src": "https://github.com/saghen/blink.cmp",
+      "version": "1.0.0 - 2.0.0"
+    },
+    "efmls-configs-nvim": {
+      "rev": "5dc52088c231f2721f545570fcb541b04802ce6b",
+      "src": "https://github.com/creativenull/efmls-configs-nvim"
+    },
+    "flash.nvim": {
+      "rev": "fcea7ff883235d9024dc41e638f164a450c14ca2",
+      "src": "https://github.com/folke/flash.nvim"
+    },
+    "fzf-lua": {
+      "rev": "657c1bbb7357c61e26a20d868b53a460b05c18c0",
+      "src": "https://www.github.com/ibhagwan/fzf-lua"
+    },
+    "gitsigns.nvim": {
+      "rev": "8d82c240f190fc33723d48c308ccc1ed8baad69d",
+      "src": "https://www.github.com/lewis6991/gitsigns.nvim"
+    },
+    "img-clip.nvim": {
+      "rev": "b6ddfb97b5600d99afe3452d707444afda658aca",
+      "src": "https://github.com/HakonHarnes/img-clip.nvim"
+    },
+    "lualine.nvim": {
+      "rev": "a905eeebc4e63fdc48b5135d3bf8aea5618fb21c",
+      "src": "https://github.com/nvim-lualine/lualine.nvim"
+    },
+    "mason-tool-installer.nvim": {
+      "rev": "443f1ef8b5e6bf47045cb2217b6f748a223cf7dc",
+      "src": "https://github.com/WhoIsSethDaniel/mason-tool-installer.nvim"
+    },
+    "mason.nvim": {
+      "rev": "b03fb0f20bc1d43daf558cda981a2be22e73ac42",
+      "src": "https://github.com/mason-org/mason.nvim"
+    },
+    "mini.nvim": {
+      "rev": "4182d64727fb4876407af65c181b85428a4a70d1",
+      "src": "https://www.github.com/echasnovski/mini.nvim"
+    },
+    "nvim-lspconfig": {
+      "rev": "cb5bc0b2b35a6d513e3298d285db81453e791f4f",
+      "src": "https://www.github.com/neovim/nvim-lspconfig"
+    },
+    "nvim-treesitter": {
+      "rev": "4916d6592ede8c07973490d9322f187e07dfefac",
+      "src": "https://github.com/nvim-treesitter/nvim-treesitter"
+    },
+    "nvim-treesitter-textobjects": {
+      "rev": "851e865342e5a4cb1ae23d31caf6e991e1c99f1e",
+      "src": "https://github.com/nvim-treesitter/nvim-treesitter-textobjects"
+    },
+    "tokyonight.nvim": {
+      "rev": "cdc07ac78467a233fd62c493de29a17e0cf2b2b6",
+      "src": "https://github.com/folke/tokyonight.nvim"
+    },
+    "which-key.nvim": {
+      "rev": "3aab2147e74890957785941f0c1ad87d0a44c15a",
+      "src": "https://github.com/folke/which-key.nvim"
+    }
+  }
+}

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,85 +0,0 @@
--- Local treesitter setup. Replaces nvim-treesitter + nvim-treesitter-textobjects.
--- Parsers: ~/.config/nvim/parser/<lang>.so
--- Queries: ~/.config/nvim/queries/<lang>/
-
--- Start treesitter highlighting on FileType when a parser is available.
-vim.api.nvim_create_autocmd("FileType", {
-    callback = function(args)
-        pcall(vim.treesitter.start, args.buf)
-    end,
-})
-
--- Function text objects: af / if
--- Walks the textobjects query for the buffer's language and selects the
--- 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]
-
-    -- A single textobject (e.g. @function.inner) is often split across
-    -- multiple captures within the same match (e.g. one per statement in
-    -- the body). Use iter_matches and union the ranges of all captures
-    -- with our target name within each match.
-    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]
-
-    -- If we were invoked from visual mode (`vif`, `vaf`, etc.), exit it
-    -- first — otherwise `normal! v` below would toggle visual off instead
-    -- of re-entering it, and we'd end up only moving the cursor.
-    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
-    ")"))

configuration.nix

@@ -26,6 +26,7 @@
   networking.hostName = "nixos"; # Define your hostname.
 
   networking.networkmanager.enable = true;
+  networking.networkmanager.wifi.powersave = false;
 
   time.timeZone = "Europe/Stockholm";
 
@@ -78,9 +79,11 @@
     extraGroups = [ "networkmanager" "wheel" ];
   };
 
+  programs.steam.enable = true;
   programs.zsh.enable = true;
 
   security.pam.services.swaylock = {};
+  security.polkit.enable = true;
 
   programs.firefox.enable = true;
   programs.sway = {
@@ -88,6 +91,12 @@
     wrapperFeatures.gtk = true;
   };
 
+  xdg.portal = {
+    enable = true;
+    wlr.enable = true;
+    extraPortals = [ pkgs.xdg-desktop-portal-gtk ];
+  };
+
   nixpkgs.config.allowUnfree = true;
 
   environment.systemPackages = with pkgs; [

flake.lock

@@ -7,11 +7,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1779726825,
+        "lastModified": 1780361225,
-        "narHash": "sha256-RUkMrREjKDQrA+dA9+xZviGAxM5W1aVdyOr/bSYpHrE=",
+        "narHash": "sha256-wnV9ttf4fPWNonBIQmvlrSlNpQYgx5HgWWd007mwIFA=",
         "owner": "nix-community",
         "repo": "home-manager",
-        "rev": "b179bde238977f7d4454fc770b1a727eaf55111c",
+        "rev": "e28654b71096e08c019d4861ca26acb646f583d8",
         "type": "github"
       },
       "original": {
@@ -23,11 +23,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1780203844,
+        "lastModified": 1780453794,
-        "narHash": "sha256-K5sT4jTpGs15ADhviMKNBH38REpPf5Q6mM1+N6cArVE=",
+        "narHash": "sha256-bXMRa9VTsHSPXL4Cw8R6JJLQeY3Y/IP4+YJCYVmQ7FY=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "b51242d7d43689db2f3be91bd05d5b24fbb469c4",
+        "rev": "6b316287bae2ee04c9b93c8c858d930fd07d7338",
         "type": "github"
       },
       "original": {

home.nix

@@ -47,6 +47,26 @@
       bindkey "^[OA" up-line-or-beginning-search
       bindkey "^[OB" down-line-or-beginning-search
 
+      function mkenv() {
+        local template="$HOME/nixos-dotfiles/templates/shell-''${1}.nix"
+        if [[ -z "$1" ]]; then
+          echo "Usage: mkenv <python|go|ts|csharp>"
+          return 1
+        fi
+        if [[ ! -f "$template" ]]; then
+          echo "No template for '$1'. Available: python, go, ts, csharp"
+          return 1
+        fi
+        if [[ -f shell.nix ]]; then
+          echo "shell.nix already exists"
+          return 1
+        fi
+        cp "$template" shell.nix
+        echo "use nix" > .envrc
+        direnv allow
+        echo "Created shell.nix and .envrc for $1"
+      }
+
       function y() {
         local tmp="$(mktemp -t "yazi-cwd.XXXXXX")" cwd
         command yazi "$@" --cwd-file="$tmp"
@@ -61,9 +81,15 @@
     enable = true;
     enableZshIntegration = true;
     settings = {
-      format = "$directory$git_branch$git_status$line_break$character";
+      format = "$hostname$directory$git_branch$git_status$direnv$line_break$character";
       right_format = "$time";
 
+      hostname = {
+        ssh_only = true;
+        format = "[$hostname]($style) ";
+        style = "bold green";
+      };
+
       directory = {
         truncation_length = 3;
         truncate_to_repo = false;
@@ -94,6 +120,18 @@
         time_format = "%H:%M:%S";
       };
 
+      direnv = {
+        disabled = false;
+        format = "[$symbol$loaded/$allowed]($style) ";
+        symbol = "direnv ";
+        style = "bold yellow";
+        allowed_msg = "on";
+        not_allowed_msg = "off";
+        denied_msg = "denied";
+        loaded_msg = "loaded";
+        unloaded_msg = "not loaded";
+      };
+
       character = {
         success_symbol = "[❯](bold green)";
         error_symbol = "[❯](bold red)";
@@ -124,6 +162,12 @@
     enable = true;
   };
 
+  programs.direnv = {
+    enable = true;
+    enableZshIntegration = true;
+    nix-direnv.enable = true;
+  };
+
   home.sessionVariables = {
     _ZO_FZF_OPTS = "--preview 'eza --tree --level=2 --color=always {2..}' --preview-window=right:40%";
   };
@@ -186,7 +230,7 @@
   xdg.configFile."fuzzel/fuzzel.ini".source = ./config/fuzzel/fuzzel.ini;
   xdg.configFile."qtile".source = ./config/qtile;
   xdg.configFile."nvim" = {
-    source = config.lib.file.mkOutOfStoreSymlink "/home/ulve/nixos-dotfiles/config/dottily";
+    source = config.lib.file.mkOutOfStoreSymlink "/home/ulve/nixos-dotfiles/config/nvim";
   };
   xdg.configFile."sway".source = ./config/sway;
   xdg.configFile."waybar".source = ./config/waybar;
@@ -252,34 +296,20 @@
     neovim                       # editor
 
     # compilers / runtimes
-    gcc                          # c compiler (also needed by treesitter)
+    gcc                          # c compiler (needed by treesitter)
-    nodejs                       # javascript runtime
-    go                           # go toolchain (needed by gopls + revive)
-    dotnet-sdk                   # .net sdk (c#)
 
     # nvim: lsp servers
     tree-sitter                  # parser generator (nvim)
     nil                          # language server for nix
     lua-language-server          # lsp: lua
-    pyright                      # lsp: python
     bash-language-server         # lsp: bash
-    vtsls                        # lsp: typescript/javascript
-    gopls                        # lsp: go
-    omnisharp-roslyn             # lsp: c#
     efm-langserver               # lsp: general purpose (runs linters/formatters)
 
     # nvim: formatters and linters
     nixpkgs-fmt                  # formatter: nix
     stylua                       # formatter: lua
-    black                        # formatter: python
-    prettierd                    # formatter: js/ts/html/css/json (daemon)
-    fixjson                      # formatter: json
-    gofumpt                      # formatter: go (stricter gofmt)
     shfmt                        # formatter: bash/sh
     lua54Packages.luacheck       # linter: lua
-    python3Packages.flake8       # linter: python
-    eslint_d                     # linter: js/ts (daemon)
     shellcheck                   # linter: bash/sh
-    revive                       # linter: go
   ];
 }

templates/shell-csharp.nix

@@ -0,0 +1,8 @@
+{ pkgs ? import <nixpkgs> {} }:
+pkgs.mkShell {
+  packages = with pkgs; [
+    dotnet-sdk
+    omnisharp-roslyn
+    # add project-specific packages below
+  ];
+}

templates/shell-go.nix

@@ -0,0 +1,10 @@
+{ pkgs ? import <nixpkgs> {} }:
+pkgs.mkShell {
+  packages = with pkgs; [
+    go
+    gopls
+    gofumpt
+    revive
+    # add project-specific packages below
+  ];
+}

templates/shell-python.nix

@@ -0,0 +1,9 @@
+{ pkgs ? import <nixpkgs> {} }:
+pkgs.mkShell {
+  packages = with pkgs; [
+    pyright
+    black
+    python3Packages.flake8
+    # add project-specific packages below
+  ];
+}

templates/shell-ts.nix

@@ -0,0 +1,11 @@
+{ pkgs ? import <nixpkgs> {} }:
+pkgs.mkShell {
+  packages = with pkgs; [
+    nodejs
+    vtsls
+    prettierd
+    eslint_d
+    fixjson
+    # add project-specific packages below
+  ];
+}