feat: create the base

Stolen from: https://github.com/0x61nas/nixfiles/tree/63b0a0c2e881c531eb3dc47b1c84ace3ca42236f/dev/nvim

init.lua

···
+-- Global Settings And Remaps
+require("settings")
+require("keybinds")
+require("autocommands")
+if vim.g.neovide then require("neovide") end
+
+vim.loader.enable()
+
+require("core.opts")
+
+local lazy_path = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
+
+require("core.utils").bootstrap(lazy_path)
+
+return require("lazy").setup("plugins")

lazy-lock.json

···
+{
+  "CamelCaseMotion": { "branch": "master", "commit": "de439d7c06cffd0839a29045a103fe4b44b15cdc" },
+  "Comment.nvim": { "branch": "master", "commit": "e30b7f2008e52442154b66f7c519bfd2f1e32acb" },
+  "CopilotChat.nvim": { "branch": "canary", "commit": "bddda2aaf66d34bf6dbae8af26166187a4343cca" },
+  "LuaSnip": { "branch": "master", "commit": "03c8e67eb7293c404845b3982db895d59c0d1538" },
+  "Vim-Jinja2-Syntax": { "branch": "master", "commit": "2c17843b074b06a835f88587e1023ceff7e2c7d1" },
+  "cmp-async-path": { "branch": "main", "commit": "03fac5dfd6f7880be2c059d58bebe007f0d6d8ee" },
+  "cmp-buffer": { "branch": "main", "commit": "3022dbc9166796b644a841a02de8dd1cc1d311fa" },
+  "cmp-cmdline": { "branch": "main", "commit": "d250c63aa13ead745e3a40f61fdd3470efde3923" },
+  "cmp-git": { "branch": "main", "commit": "50d526dff0f6bc441b51fc269d9fdc99a50c76af" },
+  "cmp-nvim-lsp": { "branch": "main", "commit": "39e2eda76828d88b773cc27a3f61d2ad782c922d" },
+  "cmp_luasnip": { "branch": "master", "commit": "05a9ab28b53f71d1aece421ef32fee2cb857a843" },
+  "conform.nvim": { "branch": "master", "commit": "0ebe875d9c306f5fc829db38492ffff2a70d8e9d" },
+  "crates.nvim": { "branch": "main", "commit": "1c924d5a9ea3496c4e1a02d0d51388ba809f8468" },
+  "edgy.nvim": { "branch": "main", "commit": "7e8dedc39abebe40c289b8012cc89b11c69aa7a0" },
+  "flit.nvim": { "branch": "main", "commit": "1ef72de6a02458d31b10039372c8a15ab8989e0d" },
+  "formatter.nvim": { "branch": "master", "commit": "ad246d34ce7a32f752071ed81b09b94e6b127fad" },
+  "friendly-snippets": { "branch": "main", "commit": "00ebcaa159e817150bd83bfe2d51fa3b3377d5c4" },
+  "gitsigns.nvim": { "branch": "main", "commit": "1ef74b546732f185d0f806860fa5404df7614f28" },
+  "glow.nvim": { "branch": "main", "commit": "238070a686c1da3bccccf1079700eb4b5e19aea4" },
+  "gruvbox.nvim": { "branch": "main", "commit": "7a1b23e4edf73a39642e77508ee6b9cbb8c60f9e" },
+  "harpoon": { "branch": "master", "commit": "1bc17e3e42ea3c46b33c0bbad6a880792692a1b3" },
+  "import-cost.nvim": { "branch": "main", "commit": "332b9870c7b22dcfb297a0be7d7a87c148181694" },
+  "indent-blankline.nvim": { "branch": "master", "commit": "18603eb949eba08300799f64027af11ef922283f" },
+  "kulala.nvim": { "branch": "main", "commit": "2cdc64d6c494af3bbee2be44218cc105ad43e8f9" },
+  "lazy.nvim": { "branch": "main", "commit": "48b52b5cfcf8f88ed0aff8fde573a5cc20b1306d" },
+  "leap.nvim": { "branch": "main", "commit": "c6bfb191f1161fbabace1f36f578a20ac6c7642c" },
+  "lspsaga.nvim": { "branch": "main", "commit": "4ce44df854f447cf0a8972e5387b3aeb5efc798b" },
+  "lua-async-await": { "branch": "main", "commit": "652d94df34e97abe2d4a689edbc4270e7ead1a98" },
+  "lualine.nvim": { "branch": "master", "commit": "b431d228b7bbcdaea818bdc3e25b8cdbe861f056" },
+  "mason.nvim": { "branch": "main", "commit": "e2f7f9044ec30067bc11800a9e266664b88cda22" },
+  "neo-tree.nvim": { "branch": "main", "commit": "0774fa2085c62a147fcc7b56f0ac37053cc80217" },
+  "neogen": { "branch": "main", "commit": "e932ba918b56723436b77aa3efb844a11b2851ab" },
+  "noice.nvim": { "branch": "main", "commit": "448bb9c524a7601035449210838e374a30153172" },
+  "nui.nvim": { "branch": "main", "commit": "61574ce6e60c815b0a0c4b5655b8486ba58089a1" },
+  "nvim-cmp": { "branch": "main", "commit": "ae644feb7b67bf1ce4260c231d1d4300b19c6f30" },
+  "nvim-colorizer.lua": { "branch": "master", "commit": "a065833f35a3a7cc3ef137ac88b5381da2ba302e" },
+  "nvim-dap": { "branch": "master", "commit": "20a4859ebde1c9bc8e96f8cc11a20667e7fdd516" },
+  "nvim-java": { "branch": "main", "commit": "b3174e41ab51867123d8663eced53b33f1548522" },
+  "nvim-java-core": { "branch": "main", "commit": "5b03dca22fee76524a89e1c2dc1d73a9f0b1a3bb" },
+  "nvim-java-dap": { "branch": "main", "commit": "55f239532f7a3789d21ea68d1e795abc77484974" },
+  "nvim-java-refactor": { "branch": "main", "commit": "ea1420fed5463c9cc976c2b4175f434b3646f0f7" },
+  "nvim-java-test": { "branch": "main", "commit": "7f0f40e9c5b7eab5096d8bec6ac04251c6e81468" },
+  "nvim-lint": { "branch": "master", "commit": "a7ce9c78a7c710c28bee56dfab10a5c0c80b7fb5" },
+  "nvim-lspconfig": { "branch": "master", "commit": "bdbc65aadc708ce528efb22bca5f82a7cca6b54d" },
+  "nvim-notify": { "branch": "master", "commit": "d333b6f167900f6d9d42a59005d82919830626bf" },
+  "nvim-tree.lua": { "branch": "master", "commit": "cb57691536702ea479afd294657f6a589d0faae1" },
+  "nvim-treesitter": { "branch": "master", "commit": "4770d9a1a77b0cc2b723c646c3dbe43a9133e5db" },
+  "nvim-treesitter-textobjects": { "branch": "master", "commit": "bf8d2ad35d1d1a687eae6c065c3d524f7ab61b23" },
+  "nvim-ts-context-commentstring": { "branch": "main", "commit": "375c2d86cee6674afd75b4f727ce3a80065552f7" },
+  "nvim-web-devicons": { "branch": "master", "commit": "9793801f974bba70e4ac5d7eae6c4f5659993d8e" },
+  "octo.nvim": { "branch": "master", "commit": "fd50872494abd1cb580c604f1f52aae2257f7220" },
+  "outline.nvim": { "branch": "main", "commit": "3725c652f276b486a20423829af389d84a0c15fe" },
+  "pears.nvim": { "branch": "master", "commit": "14e6c47c74768b74190a529e41911ae838c45254" },
+  "plenary.nvim": { "branch": "master", "commit": "ec289423a1693aeae6cd0d503bac2856af74edaa" },
+  "presence.nvim": { "branch": "main", "commit": "87c857a56b7703f976d3a5ef15967d80508df6e6" },
+  "rust.vim": { "branch": "master", "commit": "889b9a7515db477f4cb6808bef1769e53493c578" },
+  "spring-boot.nvim": { "branch": "main", "commit": "218c0c26c14d99feca778e4d13f5ec3e8b1b60f0" },
+  "tabular": { "branch": "master", "commit": "12437cd1b53488e24936ec4b091c9324cafee311" },
+  "tailwind-fold.nvim": { "branch": "main", "commit": "28a4190a97af3c5cc4885c228ec61e331d1296ea" },
+  "tailwindcss-colorizer-cmp.nvim": { "branch": "main", "commit": "3d3cd95e4a4135c250faf83dd5ed61b8e5502b86" },
+  "telescope-fzf-native.nvim": { "branch": "main", "commit": "cf48d4dfce44e0b9a2e19a008d6ec6ea6f01a83b" },
+  "telescope.nvim": { "branch": "master", "commit": "5972437de807c3bc101565175da66a1aa4f8707a" },
+  "todo-comments.nvim": { "branch": "main", "commit": "319c01b99b7a8c9ac2066bf0efd4d6ec68fef444" },
+  "trouble.nvim": { "branch": "main", "commit": "6efc446226679fda0547c0fd6a7892fd5f5b15d8" },
+  "undotree": { "branch": "master", "commit": "56c684a805fe948936cda0d1b19505b84ad7e065" },
+  "vim-fish-syntax": { "branch": "master", "commit": "e229becbf4bbee21cc78cd2cf24f57112e33c02a" },
+  "vim-fugitive": { "branch": "master", "commit": "d4877e54cef67f5af4f950935b1ade19ed6b7370" },
+  "vim-jsx-pretty": { "branch": "master", "commit": "6989f1663cc03d7da72b5ef1c03f87e6ddb70b41" },
+  "vim-just": { "branch": "main", "commit": "8ed1e472b72b739bd852d2b9a2d688b3da015cf5" },
+  "vim-markdown": { "branch": "master", "commit": "a657e697376909c41475a686eeef7fc7a4972d94" },
+  "vim-mustache-handlebars": { "branch": "master", "commit": "0153fe03a919add2d6cf2d41b2d5b6e1188bc0e0" },
+  "vim-repeat": { "branch": "master", "commit": "65846025c15494983dafe5e3b46c8f88ab2e9635" },
+  "vim-svelte": { "branch": "main", "commit": "0e93ec53c3667753237282926fec626785622c1c" },
+  "vim-terraform": { "branch": "master", "commit": "24de93afb05078bac6a2e966402cc1f672277708" },
+  "vim-toml": { "branch": "main", "commit": "d36caa6b1cf508a4df1c691f915572fc02143258" },
+  "vimtex": { "branch": "master", "commit": "ec3b648af5092372ddd72404fb5db46b2f78beb5" },
+  "which-key.nvim": { "branch": "main", "commit": "bfec3d6bc0a9b0b2cb11644642f78c2c3915eef0" },
+  "yaml.nvim": { "branch": "main", "commit": "615985c1886644a4b2c0eebf985c1d1ae8257dd1" }
+}

lua/autocommands.lua

···
+local augroup = vim.api.nvim_create_augroup
+local autocmd = vim.api.nvim_create_autocmd
+
+-- groff
+local groff = augroup("groff", {})
+autocmd("BufWritePost", {
+	pattern = { "*.ms" },
+	command = "silent !pdfroff -ms % -e -t -p > %:r.pdf",
+	group = groff,
+})
+
+-- -- leap
+-- autocmd("ColorScheme", {
+--   pattern = {"*"},
+--   callback = function()
+--     require('leap').init_highlight(true)
+--   end
+-- })
+--
+-- Intention
+local indention = augroup("indentaion", {})
+autocmd("FileType", {
+	pattern = {
+		"html",
+		"htmldjango",
+		"css",
+		"scss",
+		"javascript",
+		"javascriptreact",
+		"typescript",
+		"nix",
+		"typescriptreact",
+		"lua",
+		"markdown",
+		"jinja",
+		"html.mustache",
+		"html.handlebars",
+		"prisma",
+	},
+	command = "setlocal tabstop=2 softtabstop=2 shiftwidth=2",
+	group = indention,
+})
+
+-- Highlight yanked text
+local highlightYank = augroup("highlightYank", {})
+autocmd("TextYankPost", {
+	callback = function() vim.highlight.on_yank({ higroup = "Visual", timeout = 300 }) end,
+	group = highlightYank,
+})
+
+-- Center Screen On Insert
+local centerScreen = augroup("centerScreen", {})
+autocmd("InsertEnter", { pattern = "*", command = "norm zz", group = centerScreen })
+
+-- -- setting up the keyboard
+-- local keys = augroup("caps", {})
+-- autocmd("VimEnter", {pattern = "*", command = "silent !setxkbmap -option caps:escape", group=keys})
+-- autocmd("VimEnter", {pattern = "*", command = "silent !xset r rate 210 40", group=keys})
+
+-- Opens PDF/Media files in PDFVIWER/BROWSER which is defined in the environment variables
+-- instead of viewing the binary in Neovim
+-- TODO: Add support for other file types & commands
+local openMediaFiles = augroup("openMediaFiles", {})
+autocmd("BufReadPost", {
+	pattern = { "*.pdf" },
+	callback = function()
+		local command
+
+		---@diagnostic disable-next-line: param-type-mismatch
+		if pcall(os.getenv("PDFVIWER")) then
+			command = os.getenv("PDFVIWER")
+		else
+			command = os.getenv("BROWSER")
+		end
+
+		vim.fn.jobstart(string.format("%s '%s'", command, vim.fn.expand("%")), { detach = true })
+		vim.api.nvim_buf_delete(0, {})
+	end,
+	group = openMediaFiles,
+})
+
+autocmd("BufReadPost", {
+	pattern = { "*.png", "*.webp", "*.jpg", "*.jpeg", "*.mp4" },
+	callback = function()
+		local command = os.getenv("BROWSER")
+		vim.fn.jobstart(string.format("%s '%s'", command, vim.fn.expand("%")), { detach = true })
+		vim.api.nvim_buf_delete(0, {})
+	end,
+	group = openMediaFiles,
+})
+
+-- Save/restore code folds
+local saveFolds = augroup("saveFolds", {})
+autocmd("BufWritePost", { pattern = "?*", command = "silent mkview", group = saveFolds })
+autocmd("BufReadPost", { pattern = "?*", command = "silent! loadview", group = saveFolds })
+
+-- Clear Message Area (Not Working :/)
+-- vim.cmd([[
+-- function! s:empty_message(timer)
+--   if mode() ==# 'n'
+--     echon ''
+--   endif
+-- endfunction
+
+-- augroup cmd_msg_cls
+--     autocmd!
+--     autocmd CmdlineLeave :  call timer_start(5000, funcref('s:empty_message'))
+-- augroup END
+-- ]])

lua/config/snippets.lua

···
+local ls = require("luasnip")
+local fmt = require("luasnip.extras.fmt").fmt
+local rep = require("luasnip.extras").rep
+
+-- some shorthands...
+local snip = ls.snippet
+local node = ls.snippet_node
+local text = ls.text_node
+local insert = ls.insert_node
+local func = ls.function_node
+local choice = ls.choice_node
+local dynamicn = ls.dynamic_node
+
+ls.config.set_config({
+	history = true,
+	-- treesitter-hl has 100, use something higher (default is 200).
+	ext_base_prio = 200,
+	-- minimal increase in priority.
+	ext_prio_increase = 1,
+	enable_autosnippets = false,
+	store_selection_keys = "<TAB>",
+})
+
+local function get_line_iter(str)
+	if str:sub(-1) ~= "\n" then str = str .. "\n" end
+
+	return str:gmatch("(.-)\n")
+end
+local function box_trim_lines(str)
+	local new_str = ""
+
+	for line in get_line_iter(str) do
+		line = line:gsub("^%s+", "")
+		line = string.gsub(line, "%s+$", "")
+		new_str = new_str .. "\n" .. line
+	end
+
+	return new_str
+end
+
+local date = function() return { os.date("%Y-%m-%d") } end
+
+local filename = function() return { vim.fn.expand("%:p") } end
+
+-- Make sure to not pass an invalid command, as io.popen() may write over nvim-text.
+local function bash(_, _, command)
+	local file = io.popen(command, "r")
+	local res = {}
+	for line in file:lines() do
+		table.insert(res, line)
+	end
+	return res
+end
+
+local function get_port_snip(args)
+	if #args < 1 and not args[1][1] then return node(nil, text("hello world")) end
+
+	local type = args[1][1]
+	local indent = "      "
+
+	if type == "NodePort" or type == "LoadBalancer" then
+		return node(
+			nil,
+			fmt(
+				box_trim_lines([[
+        - port: {}
+          {}targetPort: {}
+          {}nodePort: {}
+        ]]),
+				{
+					insert(1, "30000"),
+					indent,
+					insert(2, "80"),
+					indent,
+					insert(3, "30000"),
+				}
+			)
+		)
+	end
+
+	if type == "ClusterIP" then
+		return node(
+			nil,
+			fmt(
+				[[
+        - port: {}
+        {}targetPort: {}
+        ]],
+				{
+					insert(1, "30000"),
+					indent,
+					insert(2, "80"),
+				}
+			)
+		)
+	end
+end
+
+ls.add_snippets(nil, {
+	all = {
+		snip({
+			trig = "date",
+			namr = "Date",
+			dscr = "Date in the form of YYYY-MM-DD",
+		}, {
+			func(date, {}),
+		}),
+		snip({
+			trig = "pwd",
+			namr = "PWD",
+			dscr = "Path to current working directory",
+		}, {
+			func(bash, {}, { user_args = { "pwd" } }),
+		}),
+		snip({
+			trig = "filename",
+			namr = "Filename",
+			dscr = "Absolute path to file",
+		}, {
+			func(filename, {}),
+		}),
+		snip({
+			trig = "signature",
+			namr = "Signature",
+			dscr = "Name and Surname",
+		}, {
+			text("Anas Elgarhy"),
+			insert(0),
+		}),
+	},
+	sh = {
+		snip("shebang", {
+			text({ "#!/bin/sh", "" }),
+			insert(0),
+		}),
+	},
+	python = {
+		snip("shebang", {
+			text({ "#!/usr/bin/env python", "" }),
+			insert(0),
+		}),
+	},
+	lua = {
+		snip("shebang", {
+			text({ "#!/usr/bin/lua", "", "" }),
+			insert(0),
+		}),
+		snip("req", {
+			text("require('"),
+			insert(1, "Module-name"),
+			text("')"),
+			insert(0),
+		}),
+		snip("func", {
+			text("function("),
+			insert(1, "Arguments"),
+			text({ ")", "\t" }),
+			insert(2),
+			text({ "", "end", "" }),
+			insert(0),
+		}),
+		snip("forp", {
+			text("for "),
+			insert(1, "k"),
+			text(", "),
+			insert(2, "v"),
+			text(" in pairs("),
+			insert(3, "table"),
+			text({ ") do", "\t" }),
+			insert(4),
+			text({ "", "end", "" }),
+			insert(0),
+		}),
+		snip("fori", {
+			text("for "),
+			insert(1, "k"),
+			text(", "),
+			insert(2, "v"),
+			text(" in ipairs("),
+			insert(3, "table"),
+			text({ ") do", "\t" }),
+			insert(4),
+			text({ "", "end", "" }),
+			insert(0),
+		}),
+		snip("if", {
+			text("if "),
+			insert(1),
+			text({ " then", "\t" }),
+			insert(2),
+			text({ "", "end", "" }),
+			insert(0),
+		}),
+		snip("M", {
+			text({ "local M = {}", "", "" }),
+			insert(0),
+			text({ "", "", "return M" }),
+		}),
+	},
+	markdown = {
+		-- Select link, press C-s, enter link to receive snippet
+		snip({
+			trig = "link",
+			namr = "markdown_link",
+			dscr = "Create markdown link [txt](url)",
+		}, {
+			text("["),
+			insert(1),
+			text("]("),
+			func(function(_, snip) return snip.env.TM_SELECTED_TEXT[1] or {} end, {}),
+			text(")"),
+			insert(0),
+		}),
+		snip({
+			trig = "codewrap",
+			namr = "markdown_code_wrap",
+			dscr = "Create markdown code block from existing text",
+		}, {
+			text("``` "),
+			insert(1, "Language"),
+			text({ "", "" }),
+			func(function(_, snip)
+				local tmp = {}
+				tmp = snip.env.TM_SELECTED_TEXT
+				tmp[0] = nil
+				return tmp or {}
+			end, {}),
+			text({ "", "```", "" }),
+			insert(0),
+		}),
+		snip({
+			trig = "codeempty",
+			namr = "markdown_code_empty",
+			dscr = "Create empty markdown code block",
+		}, {
+			text("``` "),
+			insert(1, "Language"),
+			text({ "", "" }),
+			insert(2, "Content"),
+			text({ "", "```", "" }),
+			insert(0),
+		}),
+		snip({
+			trig = "meta",
+			namr = "Metadata",
+			dscr = "Yaml metadata format for markdown",
+		}, {
+			text({ "---", "title: " }),
+			insert(1, "note_title"),
+			text({ "", "author: " }),
+			insert(2, "author"),
+			text({ "", "date: " }),
+			func(date, {}),
+			text({ "", "cathegories: [" }),
+			insert(3, ""),
+			text({ "]", "lastmod: " }),
+			func(date, {}),
+			text({ "", "tags: [" }),
+			insert(4),
+			text({ "]", "comments: true", "---", "" }),
+			insert(0),
+		}),
+	},
+	go = {
+		snip("test", {
+			text("func "),
+			insert(1, "Name"),
+			text("(t *testing.T)"),
+			text({ " {", "" }),
+			text("\t"),
+			insert(0),
+			text({ "", "}" }),
+		}),
+		snip("typei", {
+			text("type "),
+			insert(1, "Name"),
+			text({ " interface {", "" }),
+			text("\t"),
+			insert(0),
+			text({ "", "}" }),
+		}),
+		snip("types", {
+			text("type "),
+			insert(1, "Name"),
+			text({ " struct {", "" }),
+			text("\t"),
+			insert(0),
+			text({ "", "}" }),
+		}),
+		snip("func", {
+			text("func "),
+			insert(1, "Name"),
+			text("("),
+			insert(2),
+			text(")"),
+			insert(3),
+			text({ " {", "" }),
+			text("\t"),
+			insert(0),
+			text({ "", "}" }),
+		}),
+		snip("if", {
+			text("if "),
+			insert(1, "true"),
+			text({ " {", "" }),
+			text("\t"),
+			insert(0),
+			text({ "", "}" }),
+		}),
+
+		snip("fori", {
+			text("for "),
+			insert(1, "i := 0"),
+			text(";"),
+			insert(2, "i < 10"),
+			text(";"),
+			insert(3, "i++"),
+			text({ " {", "" }),
+			text("\t"),
+			insert(0),
+			text({ "", "}" }),
+		}),
+		snip("forr", {
+			text("for "),
+			insert(1, "k, v"),
+			text(" := range "),
+			insert(2, "expr"),
+			text({ " {", "" }),
+			text("\t"),
+			insert(0),
+			text({ "", "}" }),
+		}),
+	},
+	yaml = {
+		snip(
+			{
+				trig = "pod",
+				namr = "k8s Pod",
+				dscr = "Kubernetes Pod definition",
+			},
+			fmt(
+				[[
+                  apiVersion: v1
+                  kind: Pod
+                  metadata:
+                    name: {}
+                    labels:
+                      {}: {}
+                  spec:
+                    containers:
+                    - name: {}
+                      image: {}:{}
+                      ports:
+                      - containerPort: {}
+                ]],
+				{
+					insert(1, "nginx"),
+					insert(2, "run"),
+					insert(3, "nginx"),
+					insert(4, "nginx"),
+					insert(5, "nginx"),
+					insert(6, "latest"),
+					insert(7, "80"),
+				}
+			)
+		),
+		snip(
+			{
+				trig = "deploy",
+				namr = "k8s Deployment",
+				dscr = "Kubernetes Deployment definition",
+			},
+			fmt(
+				[[
+                  apiVersion: apps/v1
+                  kind: Deployment
+                  metadata:
+                    name: {}
+                    labels:
+                      {}
+                  spec:
+                    replicas: {}
+                    selector:
+                      matchLabels:
+                        {}
+                    template:
+                      metadata:
+                        labels:
+                          {}
+                      spec:
+                        containers:
+                        - name: {}
+                          image: {}:{}
+                          ports:
+                          - containerPort: {}
+                ]],
+				{
+					insert(1, "name"),
+					insert(2, "label"),
+					insert(3, "1"),
+					insert(4, "label"),
+					rep(4),
+					insert(5, "container_name"),
+					insert(6, "image"),
+					insert(7, "1.0"),
+					insert(8, "80"),
+				}
+			)
+		),
+		snip(
+			{
+				trig = "service",
+				namr = "k8s Service",
+				dscr = "Kubernetes Service definition",
+			},
+			fmt(
+				[[
+                    apiVersion: v1
+                    kind: Service
+                    metadata:
+                      name: {}
+                      labels:
+                        {}
+                    spec:
+                      selector:
+                        {}
+                      type: {}
+                      ports:
+                        {}
+                ]],
+				{
+					insert(1, "name"),
+					insert(2),
+					insert(3),
+					choice(4, {
+						text("ClusterIP"),
+						text("NodePort"),
+						text("LoadBalancer"),
+					}),
+					dynamicn(5, get_port_snip, { 4 }),
+				}
+			)
+		),
+	},
+})

lua/core/opts.lua

···
+-- I'm lazy
+local opt = vim.opt
+
+-- Nice Number Line
+opt.relativenumber = true
+opt.number = true
+
+-- Tabs & Spaces
+opt.expandtab = false
+opt.tabstop = 2
+opt.softtabstop = 2
+opt.shiftwidth = 2
+opt.smartindent = true
+opt.autoindent = true
+
+-- Searching
+opt.ignorecase = true
+opt.smartcase = true
+opt.hlsearch = true
+opt.incsearch = true
+
+-- Column Settings
+opt.signcolumn = "yes"
+opt.colorcolumn = "120"
+opt.wrap = false
+
+-- Cursor Settings
+opt.cursorline = true
+-- opt.guicursor = "n-v-c-sm:block,ci-ve:ver25,r-cr-o:hor20,i:underline" ..
+--                     ",a:blinkwait700-blinkoff400-blinkon250-Cursor/lCursor" ..
+--                     ",sm:block-blinkwait175-blinkoff150-blinkon175"
+
+-- Window Settings
+opt.splitbelow = true
+opt.splitright = true
+opt.lazyredraw = true
+opt.showtabline = 2
+
+-- Spelling
+opt.spell = true
+opt.spelloptions = "camel"
+
+-- Other
+opt.mouse = "a"
+opt.showmode = false
+opt.termguicolors = true
+opt.hidden = true
+-- opt.clipboard = "unnamedplus"
+opt.formatoptions = "cjql"
+opt.laststatus = 3
+opt.completeopt = { "menu", "menuone", "preview" }
+opt.conceallevel = 2
+opt.concealcursor = ""
+-- opt.updatetime = 100
+
+-- Backup -- I have power issues :/
+opt.backup = true
+opt.swapfile = true
+opt.undodir = os.getenv("HOME") .. "/.cache/undodir"
+opt.undofile = true
+
+-- arabic support
+opt.encoding = "utf-8"
+opt.termbidi = true

lua/core/utils.lua

···
+local M = {}
+
+M.bootstrap = function(lazy_path)
+	if not vim.loop.fs_stat(lazy_path) then
+		vim.fn.system({
+			"git",
+			"clone",
+			"--filter=blob:none",
+			"https://github.com/folke/lazy.nvim.git",
+			"--branch=stable", -- latest stable release
+			lazy_path,
+		})
+	end
+	vim.opt.rtp:prepend(lazy_path)
+end
+
+local cmds = { "nu!", "rnu!", "nonu!" }
+local current_index = 1
+
+function M.toggle_numbering()
+	current_index = current_index % #cmds + 1
+	vim.cmd("set " .. cmds[current_index])
+	local signcolumn_setting = "auto"
+	if cmds[current_index] == "nonu!" then signcolumn_setting = "yes:4" end
+	vim.opt.signcolumn = signcolumn_setting
+end
+
+--- Toggle inlay hints
+function M.toggle_inlay_hint()
+	local is_enabled = vim.lsp.inlay_hint.is_enabled()
+	vim.lsp.inlay_hint.enable(not is_enabled)
+end
+
+-- Custom formatting function for Lua
+function M.custom_lua_format()
+	local buf = vim.api.nvim_get_current_buf()
+	local filepath = vim.api.nvim_buf_get_name(buf)
+
+	-- Save the buffer before formatting
+	vim.api.nvim_command("write")
+
+	-- Execute lua-format command
+	local cmd = string.format(
+		"lua-format -i --indent-width=2 --no-use-tab --keep-simple-function-one-line --keep-simple-control-block-one-line --single-quote-to-double-quote --spaces-inside-table-braces --spaces-around-equals-in-field %s",
+		filepath
+	)
+	os.execute(cmd)
+
+	-- Reload the buffer to reflect the changes
+	vim.api.nvim_command("edit")
+end
+
+return M

lua/keybinds.lua

···
+local map = vim.keymap.set
+local cmd = vim.cmd
+
+-- Easy wq
+cmd(":command! WQ wq")
+cmd(":command! WQ wq")
+cmd(":command! Wq wq")
+cmd(":command! Wqa xall")
+cmd(":command! Waq xall")
+cmd(":command! WA wa")
+cmd(":command! Wa wa")
+cmd(":command! W w")
+cmd(":command! Q q")
+
+-- Set up <Space> to be the leader key
+map("n", "<Space>", "<NOP>", { noremap = true, silent = true })
+vim.g.mapleader = " "
+
+-- Easy :
+map("n", ";", ":", { noremap = true })
+
+-- Easy Resize
+map("n", "<M-c>", ":vertical resize -2<CR>", { noremap = true })
+map("n", "<M-k>", ":resize +2<CR>", { noremap = true })
+-- map("n", "<M-k>", ":resize -2<CR>", {noremap = true})
+map("n", "<M-d>", ":vertical resize +2<CR>", { noremap = true })
+
+-- Easy Capitalization
+map("n", "<F7>", "<Esc>V:s/\\v<(.)(\\w*)/\\u\\1\\L\\2/g<CR>:noh<CR>", {})
+map("v", "<F7>", "<Esc>V:s/\\v<(.)(\\w*)/\\u\\1\\L\\2/g<CR>:noh<CR>", {})
+map("i", "<F7>", "<Esc>V:s/\\v<(.)(\\w*)/\\u\\1\\L\\2/g<CR>:noh<CR>i", {})
+
+-- The Best Thing In vscode But Better
+map("v", "U", ":m '<-2<CR>gv=gv")
+map("v", "Y", ":m '>+1<CR>gv=gv")
+
+-- Replace The Current Word
+-- map.set("n", "<leader>s", [[:%s/\<<C-r><C-w>\>/<C-r><C-w>/gI<Left><Left><Left>]])
+
+-- The BEST MAP
+map("x", "<Leader>p", '"_dP')
+
+-- STOP USING THE ARROW KEYS !!
+-- map('n', '<Up>', [[:echoerr "Do not do that!!"<cr>]], {noremap = true})
+-- map('n', '<Down>', [[:echoerr "Do not do that!!"<cr>]], {noremap = true})
+-- map('n', '<Left>', [[:echoerr "Do not do that!!"<cr>]], {noremap = true})
+-- map('n', '<Right>', [[:echoerr "Do not do that!!"<cr>]], {noremap = true})
+
+-- I use Dvorak layout, so.. no hjkl :|
+-- Instead, I will use  -kcd
+local modes = { "n", "v", "s", "o" } -- Normal, visual, select, operator-pending
+local keys = { { "h", "-" }, { "j", "c" }, { "l", "d" } }
+for _, mode in ipairs(modes) do
+	for _, key in ipairs(keys) do
+		map(mode, key[1], key[2], { noremap = true })
+		map(mode, key[2], key[1], { noremap = true })
+	end
+end
+
+-- Keybinds Reloading Init Files
+map("n", "<Leader>vr", "<Cmd>luafile $MYVIMRC<CR>", { noremap = true })
+
+-- Deleting Words With <C-Bs>
+map("i", "", "<C-w>", { noremap = true, silent = true })
+map("c", "", "<C-w>", { noremap = true, silent = true })
+map("i", "<C-BS>", "<C-w>", { noremap = true, silent = true })
+map("c", "<C-BS>", "<C-w>", { noremap = true })
+
+-- Better Indent/Unintend Lines And Blocks Of Text
+map("n", ">", ">>", { noremap = true, silent = true })
+map("n", "<", "<<", { noremap = true, silent = true })
+map("v", ">", ">gv", { noremap = true, silent = true })
+map("v", "<", "<gv", { noremap = true, silent = true })
+
+-- Make Y Actually Make Sense
+map("n", "Y", "yg$", { noremap = true, silent = true })
+
+-- Buffer Navigation
+map("n", "<Leader><Tab>", ":bn<CR>", { noremap = true, silent = true })
+map("n", "<Leader><S-Tab>", ":bp<CR>", { noremap = true, silent = true })
+
+-- Buffer Deletion
+map("n", "<Leader>bd", ":bd<CR>", { noremap = true, silent = true })
+
+-- Window Navigation
+map("n", "<C-h>", "<C-w>h", { noremap = true, silent = true })
+map("n", "<C-j>", "<C-w>j", { noremap = true, silent = true })
+map("n", "<C-k>", "<C-w>k", { noremap = true, silent = true })
+map("n", "<C-l>", "<C-w>l", { noremap = true, silent = true })
+
+-- Ctrl + W Close The Window
+-- map('n', '<C-w>', ':bd!<CR>', { noremap = true, silent = true })
+-- map('i', '<C-w>', ':bd!<CR>', { noremap = true, silent = true })
+
+-- split
+map("n", "<leader>wv", ":vsplit<CR>", { noremap = true })
+map("n", "<leader>ws", ":split<CR>", { noremap = true })
+
+-- Other
+map("n", "<Leader>l", ":noh<CR>", { noremap = true }) -- Clear highlights
+map("n", "<leader>o", ":pu =''<CR>", { noremap = true }) -- Insert a newline and back to normal mode
+map("n", "<leader>O", ":pu! =''<CR>", { noremap = true }) -- Insert a newline and back to normal mode

lua/neovide.lua

···
+vim.o.guifont = "JetBrains_Mono,Noto_Color_Emoji,Noto_Kufi_Arabic:h10"

lua/plugins/camelcase-motion.lua

···
+return {
+	"bkad/CamelCaseMotion",
+	lazy = false,
+	keys = {
+		{ "w", "<Plug>CamelCaseMotion_w", { silent = true }, desc = "", mode = "n" },
+		{ "b", "<Plug>CamelCaseMotion_b", { silent = true }, desc = "", mode = "n" },
+		{ "e", "<Plug>CamelCaseMotion_e", { silent = true }, desc = "", mode = "n" },
+		{ "ge", "<Plug>CamelCaseMotion_ge", { silent = true }, desc = "", mode = "n" },
+
+		{ "w", "<Plug>CamelCaseMotion_w", { silent = true }, desc = "", mode = "v" },
+		{ "b", "<Plug>CamelCaseMotion_b", { silent = true }, desc = "", mode = "v" },
+		{ "ge", "<Plug>CamelCaseMotion_ge", { silent = true }, desc = "", mode = "v" },
+		{ "e", "<Plug>CamelCaseMotion_e", { silent = true }, desc = "", mode = "v" },
+	},
+}

lua/plugins/cmp-git.lua

···
+return {
+	"petertriho/cmp-git",
+	dependencies = {
+		"nvim-lua/plenary.nvim",
+	},
+	init = function() table.insert(require("cmp").get_config().sources, { name = "git" }) end,
+	config = function()
+		local format = require("cmp_git.format")
+		local sort = require("cmp_git.sort")
+
+		require("cmp_git").setup({
+			-- defaults
+			filetypes = { "gitcommit", "octo" },
+			remotes = { "upstream", "origin" }, -- in order of most to least prioritized
+			enableRemoteUrlRewrites = false, -- enable git url rewrites, see https://git-scm.com/docs/git-config#Documentation/git-config.txt-urlltbasegtinsteadOf
+			git = {
+				commits = {
+					limit = 100,
+					sort_by = sort.git.commits,
+					format = format.git.commits,
+				},
+			},
+			github = {
+				hosts = {}, -- list of private instances of github
+				issues = {
+					fields = { "title", "number", "body", "updatedAt", "state" },
+					filter = "all", -- assigned, created, mentioned, subscribed, all, repos
+					limit = 100,
+					state = "open", -- open, closed, all
+					sort_by = sort.github.issues,
+					format = format.github.issues,
+				},
+				mentions = {
+					limit = 100,
+					sort_by = sort.github.mentions,
+					format = format.github.mentions,
+				},
+				pull_requests = {
+					fields = { "title", "number", "body", "updatedAt", "state" },
+					limit = 100,
+					state = "open", -- open, closed, merged, all
+					sort_by = sort.github.pull_requests,
+					format = format.github.pull_requests,
+				},
+			},
+			gitlab = {
+				hosts = {}, -- list of private instances of gitlab
+				issues = {
+					limit = 100,
+					state = "opened", -- opened, closed, all
+					sort_by = sort.gitlab.issues,
+					format = format.gitlab.issues,
+				},
+				mentions = {
+					limit = 100,
+					sort_by = sort.gitlab.mentions,
+					format = format.gitlab.mentions,
+				},
+				merge_requests = {
+					limit = 100,
+					state = "opened", -- opened, closed, locked, merged
+					sort_by = sort.gitlab.merge_requests,
+					format = format.gitlab.merge_requests,
+				},
+			},
+			trigger_actions = {
+				{
+					debug_name = "git_commits",
+					trigger_character = ":",
+					action = function(sources, trigger_char, callback, params, git_info)
+						return sources.git:get_commits(callback, params, trigger_char)
+					end,
+				},
+				{
+					debug_name = "gitlab_issues",
+					trigger_character = "#",
+					action = function(sources, trigger_char, callback, params, git_info)
+						return sources.gitlab:get_issues(callback, git_info, trigger_char)
+					end,
+				},
+				{
+					debug_name = "gitlab_mentions",
+					trigger_character = "@",
+					action = function(sources, trigger_char, callback, params, git_info)
+						return sources.gitlab:get_mentions(callback, git_info, trigger_char)
+					end,
+				},
+				{
+					debug_name = "gitlab_mrs",
+					trigger_character = "!",
+					action = function(sources, trigger_char, callback, params, git_info)
+						return sources.gitlab:get_merge_requests(callback, git_info, trigger_char)
+					end,
+				},
+				{
+					debug_name = "github_issues_and_pr",
+					trigger_character = "#",
+					action = function(sources, trigger_char, callback, params, git_info)
+						return sources.github:get_issues_and_prs(callback, git_info, trigger_char)
+					end,
+				},
+				{
+					debug_name = "github_mentions",
+					trigger_character = "@",
+					action = function(sources, trigger_char, callback, params, git_info)
+						return sources.github:get_mentions(callback, git_info, trigger_char)
+					end,
+				},
+			},
+		})
+	end,
+}

lua/plugins/cmp.lua

···
+return {
+	"hrsh7th/nvim-cmp",
+	dependencies = {
+		"hrsh7th/cmp-nvim-lsp",
+		"hrsh7th/cmp-buffer",
+		-- 'hrsh7th/cmp-path',
+		"https://codeberg.org/FelipeLema/cmp-async-path",
+		"hrsh7th/cmp-cmdline",
+		"L3MON4D3/LuaSnip",
+		"saadparwaiz1/cmp_luasnip",
+	},
+	event = { "LspAttach", "InsertCharPre" },
+	config = function()
+		local cmp = require("cmp")
+		cmp.setup({
+			snippet = {
+				expand = function(args) require("luasnip").lsp_expand(args.body) end,
+			},
+			mapping = cmp.mapping.preset.insert({
+				["<Tab>"] = cmp.mapping(function(fallback)
+					if cmp.visible() then
+						cmp.select_next_item()
+					else
+						fallback()
+					end
+				end, { "i", "s" }),
+				["<S-Tab>"] = cmp.mapping(function(fallback)
+					if cmp.visible() then
+						cmp.select_prev_item()
+					else
+						fallback()
+					end
+				end, { "i", "s" }),
+				["<C-;>"] = cmp.mapping.abort(),
+				["<C-k>"] = cmp.mapping.confirm({ select = true }), -- Accept currently selected item. Set `select` to `false` to only confirm explicitly selected items.
+
+				["<C-g>"] = cmp.mapping(function()
+					if not cmp.visible() then cmp.complete() end
+					cmp.abort()
+				end, { "i", "s" }),
+				["<c-y>"] = cmp.mapping(function(fallback)
+					if not cmp.visible() then fallback() end
+					cmp.scroll_docs(-1)
+				end, { "i", "s" }),
+				["<c-e>"] = cmp.mapping(function(fallback)
+					if not cmp.visible() then fallback() end
+					cmp.scroll_docs(1)
+				end, { "i", "s" }),
+				["<c-p>"] = cmp.mapping(function(fallback)
+					if not cmp.visible() then fallback() end
+					cmp.select_prev_item()
+				end, { "i", "s" }),
+				["<c-n>"] = cmp.mapping(function(fallback)
+					if not cmp.visible() then fallback() end
+					cmp.select_next_item()
+				end, { "i", "s" }),
+				["<cr>"] = cmp.mapping(function(fallback)
+					if cmp.get_selected_entry() == nil then fallback() end
+					cmp.confirm()
+				end, { "i", "s" }),
+			}),
+
+			sources = cmp.config.sources({
+				{ name = "async_path", max_item_count = 20 },
+				{
+					name = "nvim_lsp",
+					max_item_count = 80,
+				},
+				{
+					name = "buffer",
+					max_item_count = 20,
+					option = {
+						get_bufnrs = function()
+							return vim.tbl_map(function(win) return vim.api.nvim_win_get_buf(win) end, vim.api.nvim_list_wins())
+						end,
+					},
+				},
+				{ name = "luasnip" }, -- For luasnip users.
+				-- { name = 'ultisnips' }, -- For ultisnips users.
+				-- { name = 'snippy' }, -- For snippy users.
+				-- { name = 'crates' },
+			}),
+			-- eof
+		})
+
+		-- Set configuration for specific filetype.
+		cmp.setup.filetype("gitcommit", {
+			sources = cmp.config.sources({
+				{ name = "git" }, -- You can specify the `git` source if [you were installed it](https://github.com/petertriho/cmp-git).
+			}, {
+				{ name = "buffer" },
+			}),
+		})
+
+		-- Use buffer source for `/` and `?` (if you enabled `native_menu`, this won't work anymore).
+		cmp.setup.cmdline({ "/", "?" }, {
+			mapping = cmp.mapping.preset.cmdline(),
+			sources = {
+				{ name = "buffer" },
+			},
+		})
+
+		-- Use cmdline & path source for ':' (if you enabled `native_menu`, this won't work anymore).
+		cmp.setup.cmdline(":", {
+			mapping = cmp.mapping.preset.cmdline(),
+			sources = cmp.config.sources({
+				{ name = "path" },
+			}, {
+				{ name = "cmdline" },
+			}),
+			matching = { disallow_symbol_nonprefix_matching = false },
+		})
+	end,
+}

lua/plugins/comment.lua

···
+return {
+	"numToStr/Comment.nvim",
+	init = function() require("ts_context_commentstring").setup({}) end,
+	config = function()
+		require("Comment").setup({
+			pre_hook = require("ts_context_commentstring.integrations.comment_nvim").create_pre_hook(),
+		})
+	end,
+	lazy = true,
+	event = "VeryLazy",
+	keys = {
+		{
+			"<C-_>",
+			":lua require('Comment.api').toggle.linewise.current()<CR>",
+			{ noremap = true, silent = true },
+			desc = "",
+			mode = "n",
+		},
+		{
+			"<C-_>",
+			'<ESC><CMD>lua require("Comment.api").toggle.linewise(vim.fn.visualmode())<CR>',
+			{ noremap = true, silent = true },
+			desc = "",
+			mode = "x",
+		},
+		{
+			"<C-_>",
+			":lua require('Comment.api').toggle.linewise.current() <CR>",
+			{ noremap = true, silent = true },
+			desc = "",
+			mode = "i",
+		}, -- same as above but fixes some weird issues
+		{
+			"<C-/>",
+			":lua require('Comment.api').toggle.linewise.current()<CR>",
+			{ noremap = true, silent = true },
+			desc = "",
+			mode = "n",
+		},
+		{
+			"<C-/>",
+			'<ESC><CMD>lua require("Comment.api").toggle.linewise(vim.fn.visualmode())<CR>',
+			{ noremap = true, silent = true },
+			desc = "",
+			mode = "x",
+		},
+		{
+			"<C-/>",
+			":lua require('Comment.api').toggle.linewise.current() <CR>",
+			{ noremap = true, silent = true },
+			desc = "",
+			mode = "i",
+		},
+	},
+	dependencies = { "JoosepAlviste/nvim-ts-context-commentstring" },
+}

lua/plugins/conform.lua

···
+return {
+	"stevearc/conform.nvim",
+	event = { "BufWritePre" },
+	cmd = { "ConformInfo" },
+	keys = {
+		{
+			"<leader>cf",
+			function() require("conform").format({ async = true }) end,
+			mode = "",
+			desc = "Format buffer",
+		},
+	},
+	opts = {
+		-- Map of filetype to formatters
+		formatters_by_ft = {
+			lua = { "stylua" },
+			-- Conform will run multiple formatters sequentially
+			go = { "goimports", "gofmt" },
+			-- You can also customize some of the format options for the filetype
+			rust = { "rustfmt", lsp_format = "fallback" },
+			-- You can use a function here to determine the formatters dynamically
+			python = function(bufnr)
+				if require("conform").get_formatter_info("ruff_format", bufnr).available then
+					return { "ruff_format" }
+				else
+					return { "isort", "black" }
+				end
+			end,
+			nix = { "nixfmt" },
+			["markdown"] = { "prettier", "markdownlint-cli2", "markdown-toc" },
+			["markdown.mdx"] = { "prettier", "markdownlint-cli2", "markdown-toc" },
+			-- Use the "*" filetype to run formatters on all filetypes.
+			-- ["*"] = { "codespell" },
+			-- Use the "_" filetype to run formatters on filetypes that don't
+			-- have other format
+			["_"] = { "trim_whitespace" },
+		},
+		-- Set this to change the default values when calling conform.format()
+		-- This will also affect the default values for format_on_save/format_after_save
+		default_format_opts = { lsp_format = "fallback" },
+		-- If this is set, Conform will run the formatter asynchronously after save.
+		-- It will pass the table to conform.format().
+		-- This can also be a function that returns the table.
+		format_after_save = { lsp_format = "fallback" },
+		-- Set the log level. Use `:ConformInfo` to see the location of the log file.
+		log_level = vim.log.levels.ERROR,
+		-- Conform will notify you when a formatter errors
+		notify_on_error = true,
+		-- Conform will notify you when no formatters are available for the buffer
+		notify_no_formatters = true,
+		-- Custom formatters and overrides for built-in formatters
+		formatters = {
+			stylua = {
+				prepend_args = {
+					"--call-parentheses",
+					"Always",
+					"--collapse-simple-statement",
+					"Always",
+					"--indent-type",
+					"Tabs",
+					"--indent-width",
+					"2",
+					"--sort-requires",
+				},
+			},
+			["markdown-toc"] = {
+				condition = function(_, ctx)
+					for _, line in ipairs(vim.api.nvim_buf_get_lines(ctx.buf, 0, -1, false)) do
+						if line:find("<!%-%- toc %-%->") then return true end
+					end
+				end,
+			},
+			["markdownlint-cli2"] = {
+				condition = function(_, ctx)
+					local diag = vim.tbl_filter(function(d) return d.source == "markdownlint" end, vim.diagnostic.get(ctx.buf))
+					return #diag > 0
+				end,
+			},
+		},
+	},
+}

lua/plugins/copilot-chat.lua

···
+local prompts = {
+	-- Code related prompts
+	Explain = "Please explain how the following code works.",
+	Review = "Please review the following code and provide suggestions for improvement.",
+	Tests = "Please explain how the selected code works, then generate unit tests for it.",
+	Refactor = "Please refactor the following code to improve its clarity and readability.",
+	FixCode = "Please fix the following code to make it work as intended.",
+	FixError = "Please explain the error in the following text and provide a solution.",
+	BetterNamings = "Please provide better names for the following variables and functions.",
+	Documentation = "Please provide documentation for the following code.",
+	SwaggerApiDocs = "Please provide documentation for the following API using Swagger.",
+	SwaggerJsDocs = "Please write JSDoc for the following API using Swagger.",
+	-- Text related prompts
+	Summarize = "Please summarize the following text.",
+	Spelling = "Please correct any grammar and spelling errors in the following text.",
+	Wording = "Please improve the grammar and wording of the following text.",
+	Concise = "Please rewrite the following text to make it more concise.",
+}
+
+return {
+	{
+		"CopilotC-Nvim/CopilotChat.nvim",
+		version = "v2.13.0",
+		-- branch = "canary", -- Use the canary branch if you want to test the latest features but it might be unstable
+		-- Do not use branch and version together, either use branch or version
+		dependencies = {
+			{ "nvim-telescope/telescope.nvim" }, -- Use telescope for help actions
+			{ "nvim-lua/plenary.nvim" },
+		},
+		opts = {
+			question_header = "## User ",
+			answer_header = "## Copilot ",
+			error_header = "## Error ",
+			prompts = prompts,
+			auto_follow_cursor = false, -- Don't follow the cursor after getting response
+			show_help = false, -- Show help in virtual text, set to true if that's 1st time using Copilot Chat
+			mappings = {
+				-- Use tab for completion
+				complete = {
+					detail = "Use @<Tab> or /<Tab> for options.",
+					insert = "<Tab>",
+				},
+				-- Close the chat
+				close = {
+					normal = "q",
+					insert = "<C-c>",
+				},
+				-- Reset the chat buffer
+				reset = {
+					normal = "<C-x>",
+					insert = "<C-x>",
+				},
+				-- Submit the prompt to Copilot
+				submit_prompt = {
+					normal = "<CR>",
+					insert = "<C-CR>",
+				},
+				-- Accept the diff
+				accept_diff = {
+					normal = "<C-y>",
+					insert = "<C-y>",
+				},
+				-- Yank the diff in the response to register
+				yank_diff = {
+					normal = "gmy",
+				},
+				-- Show the diff
+				show_diff = {
+					normal = "gmd",
+				},
+				-- Show the prompt
+				show_system_prompt = {
+					normal = "gmp",
+				},
+				-- Show the user selection
+				show_user_selection = {
+					normal = "gms",
+				},
+			},
+		},
+		config = function(_, opts)
+			local chat = require("CopilotChat")
+			local select = require("CopilotChat.select")
+			-- Use unnamed register for the selection
+			opts.selection = select.unnamed
+
+			-- Override the git prompts message
+			opts.prompts.Commit = {
+				prompt = "Write commit message for the change with commitizen convention",
+				selection = select.gitdiff,
+			}
+			opts.prompts.CommitStaged = {
+				prompt = "Write commit message for the change with commitizen convention",
+				selection = function(source) return select.gitdiff(source, true) end,
+			}
+
+			chat.setup(opts)
+			-- Setup the CMP integration
+			require("CopilotChat.integrations.cmp").setup()
+
+			vim.api.nvim_create_user_command(
+				"CopilotChatVisual",
+				function(args) chat.ask(args.args, { selection = select.visual }) end,
+				{ nargs = "*", range = true }
+			)
+
+			-- Inline chat with Copilot
+			vim.api.nvim_create_user_command(
+				"CopilotChatInline",
+				function(args)
+					chat.ask(args.args, {
+						selection = select.visual,
+						window = {
+							layout = "float",
+							relative = "cursor",
+							width = 1,
+							height = 0.4,
+							row = 1,
+						},
+					})
+				end,
+				{ nargs = "*", range = true }
+			)
+
+			-- Restore CopilotChatBuffer
+			vim.api.nvim_create_user_command(
+				"CopilotChatBuffer",
+				function(args) chat.ask(args.args, { selection = select.buffer }) end,
+				{ nargs = "*", range = true }
+			)
+
+			-- Custom buffer for CopilotChat
+			vim.api.nvim_create_autocmd("BufEnter", {
+				pattern = "copilot-*",
+				callback = function()
+					vim.opt_local.relativenumber = true
+					vim.opt_local.number = true
+
+					-- Get current filetype and set it to markdown if the current filetype is copilot-chat
+					local ft = vim.bo.filetype
+					if ft == "copilot-chat" then vim.bo.filetype = "markdown" end
+				end,
+			})
+
+			-- Add which-key mappings
+			local wk = require("which-key")
+			wk.add({
+				{ "<leader>gm", group = "+Copilot Chat" }, -- group
+				{ "<leader>gmd", desc = "Show diff" },
+				{ "<leader>gmp", desc = "System prompt" },
+				{ "<leader>gms", desc = "Show selection" },
+				{ "<leader>gmy", desc = "Yank diff" },
+			})
+		end,
+		event = "VeryLazy",
+		keys = {
+			-- Show help actions with telescope
+			{
+				"<leader>ah",
+				function()
+					local actions = require("CopilotChat.actions")
+					require("CopilotChat.integrations.telescope").pick(actions.help_actions())
+				end,
+				desc = "CopilotChat - Help actions",
+			},
+			-- Show prompts actions with telescope
+			{
+				"<leader>ap",
+				function()
+					local actions = require("CopilotChat.actions")
+					require("CopilotChat.integrations.telescope").pick(actions.prompt_actions())
+				end,
+				desc = "CopilotChat - Prompt actions",
+			},
+			{
+				"<leader>ap",
+				":lua require('CopilotChat.integrations.telescope').pick(require('CopilotChat.actions').prompt_actions({selection = require('CopilotChat.select').visual}))<CR>",
+				mode = "x",
+				desc = "CopilotChat - Prompt actions",
+			},
+			-- Code related commands
+			{ "<leader>ae", "<cmd>CopilotChatExplain<cr>", desc = "CopilotChat - Explain code" },
+			{ "<leader>at", "<cmd>CopilotChatTests<cr>", desc = "CopilotChat - Generate tests" },
+			{ "<leader>ar", "<cmd>CopilotChatReview<cr>", desc = "CopilotChat - Review code" },
+			{ "<leader>aR", "<cmd>CopilotChatRefactor<cr>", desc = "CopilotChat - Refactor code" },
+			{ "<leader>an", "<cmd>CopilotChatBetterNamings<cr>", desc = "CopilotChat - Better Naming" },
+			-- Chat with Copilot in visual mode
+			{
+				"<leader>av",
+				":CopilotChatVisual",
+				mode = "x",
+				desc = "CopilotChat - Open in vertical split",
+			},
+			{
+				"<leader>ax",
+				":CopilotChatInline<cr>",
+				mode = "x",
+				desc = "CopilotChat - Inline chat",
+			},
+			-- Custom input for CopilotChat
+			{
+				"<leader>ai",
+				function()
+					local input = vim.fn.input("Ask Copilot: ")
+					if input ~= "" then vim.cmd("CopilotChat " .. input) end
+				end,
+				desc = "CopilotChat - Ask input",
+			},
+			-- Generate commit message based on the git diff
+			{
+				"<leader>am",
+				"<cmd>CopilotChatCommit<cr>",
+				desc = "CopilotChat - Generate commit message for all changes",
+			},
+			{
+				"<leader>aM",
+				"<cmd>CopilotChatCommitStaged<cr>",
+				desc = "CopilotChat - Generate commit message for staged changes",
+			},
+			-- Quick chat with Copilot
+			{
+				"<leader>aq",
+				function()
+					local input = vim.fn.input("Quick Chat: ")
+					if input ~= "" then vim.cmd("CopilotChatBuffer " .. input) end
+				end,
+				desc = "CopilotChat - Quick chat",
+			},
+			-- Debug
+			{ "<leader>ad", "<cmd>CopilotChatDebugInfo<cr>", desc = "CopilotChat - Debug Info" },
+			-- Fix the issue with diagnostic
+			{ "<leader>af", "<cmd>CopilotChatFixDiagnostic<cr>", desc = "CopilotChat - Fix Diagnostic" },
+			-- Clear buffer and chat history
+			{ "<leader>al", "<cmd>CopilotChatReset<cr>", desc = "CopilotChat - Clear buffer and chat history" },
+			-- Toggle Copilot Chat Vsplit
+			{ "<leader>av", "<cmd>CopilotChatToggle<cr>", desc = "CopilotChat - Toggle" },
+			-- Copilot Chat Models
+			{ "<leader>a?", "<cmd>CopilotChatModels<cr>", desc = "CopilotChat - Select Models" },
+		},
+	},
+}

lua/plugins/crates.lua

···
+return {
+	"saecki/crates.nvim",
+	tag = "stable",
+	event = { "BufRead Cargo.toml" },
+	config = function()
+		require("crates").setup()
+		vim.api.nvim_create_autocmd("BufRead", {
+			group = vim.api.nvim_create_augroup("CmpSourceCargo", { clear = true }),
+			pattern = "Cargo.toml",
+			callback = function() cmp.setup.buffer({ sources = { { name = "crates" } } }) end,
+		})
+	end,
+}

lua/plugins/edgy.lua

···
+return {
+	"folke/edgy.nvim",
+	event = "VeryLazy",
+	init = function()
+		vim.opt.laststatus = 3
+		vim.opt.splitkeep = "screen"
+	end,
+	opts = {
+		bottom = {
+			-- toggleterm / lazyterm at the bottom with a height of 40% of the screen
+			"Trouble",
+			{ ft = "qf", title = "QuickFix" },
+			{
+				ft = "help",
+				size = { height = 20 },
+				-- only show help buffers
+				filter = function(buf) return vim.bo[buf].buftype == "help" end,
+			},
+			{ ft = "spectre_panel", size = { height = 0.4 } },
+		},
+		left = {
+			-- Neo-tree filesystem always takes half the screen height
+			{
+				title = "Neo-Tree",
+				ft = "neo-tree",
+				filter = function(buf) return vim.b[buf].neo_tree_source == "filesystem" end,
+				size = { height = 0.5 },
+			},
+			{
+				title = "Neo-Tree Git",
+				ft = "neo-tree",
+				filter = function(buf) return vim.b[buf].neo_tree_source == "git_status" end,
+				pinned = true,
+				collapsed = true, -- show window as closed/collapsed on start
+				open = "Neotree position=right git_status",
+			},
+			{
+				title = "Neo-Tree Buffers",
+				ft = "neo-tree",
+				filter = function(buf) return vim.b[buf].neo_tree_source == "buffers" end,
+				pinned = true,
+				collapsed = true, -- show window as closed/collapsed on start
+				open = "Neotree position=top buffers",
+			},
+			{
+				title = function()
+					local buf_name = vim.api.nvim_buf_get_name(0) or "[No Name]"
+					return vim.fn.fnamemodify(buf_name, ":t")
+				end,
+				ft = "Outline",
+				pinned = true,
+				open = "SymbolsOutlineOpen",
+			}, -- any other neo-tree windows
+			"neo-tree",
+		},
+		right = {
+			{
+				title = "copilot-chat",
+				ft = "markdown",
+				direction = "vertical",
+				size = { width = 0.36 },
+				filter = function(buf, win) return vim.api.nvim_win_get_config(win).relative == "" end,
+			},
+		},
+	},
+}

lua/plugins/flit.lua

···
+return {
+	"ggandor/flit.nvim",
+	keys = function()
+		local ret = {}
+		for _, key in ipairs({ "f", "F", "t", "T" }) do
+			ret[#ret + 1] = { key, mode = { "n", "x", "o" }, desc = key }
+		end
+		return ret
+	end,
+	opts = { labeled_modes = "nx" },
+	dependencies = { "ggandor/leap.nvim" },
+}

lua/plugins/formatter.lua

···
+-- Format On Save
+local formatCode = vim.api.nvim_create_augroup("formatCode ", {})
+vim.api.nvim_create_autocmd("BufWritePre", {
+	pattern = { "*" },
+	command = "silent FormatWrite",
+	group = formatCode,
+})
+
+-- local function prettier_tailwindcss()
+--   local util = require 'formatter.util'
+--   return {
+--     exe = "prettier",
+--     args = {
+--       "--stdin-filepath", util.escape_path(util.get_current_buffer_file_path()),
+--       "--plugin",
+--       '~/.local/share/npm/lib/node_modules/prettier-plugin-tailwindcss/dist/index.mjs'
+--     },
+--     stdin = true,
+--     try_node_modules = true
+--   }
+-- end
+
+-- local function jinja2_formatter()
+--   -- prettier-plugin-jinja-template
+--   local util = require 'formatter.util'
+--   return {
+--     exe = "prettier",
+--     args = {
+--       "--stdin-filepath", util.escape_path(util.get_current_buffer_file_path()),
+--       "--plugin",
+--       '~/.local/share/npm/lib/node_modules/prettier-plugin-jinja-template/lib/index.js',
+--       "--plugin",
+--       '~/.local/share/npm/lib/node_modules/prettier-plugin-tailwindcss/dist/index.mjs'
+--
+--     },
+--     stdin = true,
+--     try_node_modules = true
+--   }
+-- end
+
+-- Provides the Format and FormatWrite commands
+return {
+	"mhartington/formatter.nvim",
+	lazy = true,
+	keys = {
+		{
+			"<Leader>F",
+			":FormatWrite<CR>",
+			{ noremap = true },
+			desc = "Format And Save",
+		},
+	},
+	cmd = { "Format", "FormatWrite" },
+	config = function()
+		require("formatter").setup({
+			logging = true,
+			log_level = vim.log.levels.WARN,
+			filetype = {
+				["*"] = {
+					require("formatter.filetypes.any").remove_trailing_whitespace,
+					function()
+						-- Ignore already configured types.
+						local defined_types = require("formatter.config").values.filetype
+						if defined_types[vim.bo.filetype] ~= nil then return nil end
+						vim.lsp.buf.format()
+					end,
+				},
+				c = { require("formatter.filetypes.c").clangformat },
+				cpp = { require("formatter.filetypes.cpp").clangformat },
+				cs = { require("formatter.filetypes.cs").clangformat },
+				css = { require("formatter.filetypes.css").prettierd },
+				html = { require("formatter.filetypes.html").prettierd },
+				-- jinja = { jinja2_formatter },
+				javascript = { require("formatter.filetypes.javascript").prettierd },
+				javascriptreact = {
+					require("formatter.filetypes.javascriptreact").prettier,
+				},
+				json = { require("formatter.filetypes.json").prettierd },
+				lua = { require("formatter.filetypes.lua").luaformat },
+				markdown = { require("formatter.filetypes.css").prettierd },
+				nix = { require("formatter.filetypes.nix").nixpkgs_fmt },
+				kotlin = { require("formatter.filetypes.kotlin").ktlint },
+				python = {
+					function()
+						return {
+							exe = "black",
+							args = { "--line-length 120", "-q", "-" },
+							stdin = true,
+						}
+					end,
+				},
+				rust = { require("formatter.filetypes.rust").rustfmt },
+				toml = { require("formatter.filetypes.toml").taplo },
+				typescript = { require("formatter.filetypes.typescript").prettierd },
+				typescriptreact = {
+					require("formatter.filetypes.typescriptreact").prettierd,
+				},
+				xml = { require("formatter.filetypes.css").prettierd },
+				yaml = { require("formatter.filetypes.yaml").prettierd },
+			},
+		})
+	end,
+}

lua/plugins/gitsigns.lua

···
+return {
+	"lewis6991/gitsigns.nvim",
+	lazy = false,
+	init = function()
+		require("gitsigns").setup({
+			attach_to_untracked = false,
+			current_line_blame = true, -- Toggle with `:Gitsigns toggle_current_line_blame`
+			current_line_blame_opts = {
+				virt_text = true,
+				virt_text_pos = "eol", -- 'eol' | 'overlay' | 'right_align'
+				delay = 200,
+				ignore_whitespace = false,
+				virt_text_priority = 100,
+			},
+			current_line_blame_formatter = "<author>, <author_time:%Y-%m-%d> - <summary>",
+			-- current_line_blame_formatter_opts = {
+			--   relative_time = false,
+			-- },
+		})
+	end,
+}

lua/plugins/gruvbox.lua

···
+return {
+	"ellisonleao/gruvbox.nvim",
+	priority = 1000,
+	lazy = false,
+	enabled = true,
+	config = function()
+		require("gruvbox").setup({
+			transparent_mode = false,
+			-- overrides = {
+			--     NvimTreeNormal = {bg = '#32302f'},
+			--     NvimTreeEndOfBuffer = {fg = '#32302f'},
+			--     EndOfBuffer = {fg = "#32302f"},
+			--     NonText = {fg = "#5a524c"}
+			-- }
+		})
+		vim.cmd([[colorscheme gruvbox]])
+		vim.o.background = "dark" -- or "light" for light mode
+	end,
+}

lua/plugins/harpoon.lua

···
+-- -- harpoon
+-- local harpoon = vim.api.nvim_create_augroup("harpoon", {})
+-- vim.api.nvim_create_autocmd("BufEnter",
+--         {pattern="*", callback=function() require("harpoon.mark").add_file() end, group=harpoon
+-- })
+
+return {
+	"ThePrimeagen/harpoon",
+	lazy = true,
+	keys = {
+		{ "<Leader>ha", ':lua require("harpoon.mark").add_file()<CR>', desc = "Add File" },
+		{ "<Leader>hh", ':lua require("harpoon.ui").toggle_quick_menu()<CR>', desc = "Toggle Quick Menu" },
+		{
+			"<M-Tab>",
+			':lua require("harpoon.ui").nav_next() <CR>',
+			{ noremap = true, silent = true },
+			desc = "Next Harpooned File",
+		},
+		{
+			"<M-S-Tab>",
+			':lua require("harpoon.ui").nav_prev() <CR>',
+			{ noremap = true, silent = true },
+			desc = "Previous Harpooned File",
+		},
+	},
+	opts = {
+		excluded_filetypes = { "harpoon" },
+	},
+}

lua/plugins/import-cost.lua

···
+return {
+	"barrett-ruth/import-cost.nvim",
+	build = [[
+    #! /usr/bin/env nix-shell
+    #! nix-shell -i bash -p nodePackages_latest.pnpm
+
+    sh install.sh pnpm
+  ]],
+	config = true,
+}

lua/plugins/indent-blankline.lua

···
+-- vim.opt.list = true
+-- vim.opt.listchars:append("space:⋅")
+-- vim.opt.listchars:append("eol:↴")
+
+-- vim.cmd [[highlight IndentBlanklineIndent1 guifg=#E06C75 gui=nocombine]]
+-- vim.cmd [[highlight IndentBlanklineIndent2 guifg=#E5C07B gui=nocombine]]
+-- vim.cmd [[highlight IndentBlanklineIndent3 guifg=#98C379 gui=nocombine]]
+-- vim.cmd [[highlight IndentBlanklineIndent4 guifg=#56B6C2 gui=nocombine]]
+-- vim.cmd [[highlight IndentBlanklineIndent5 guifg=#61AFEF gui=nocombine]]
+-- vim.cmd [[highlight IndentBlanklineIndent6 guifg=#C678DD gui=nocombine]]
+
+return {
+	"lukas-reineke/indent-blankline.nvim",
+	lazy = false,
+	main = "ibl",
+	opts = {
+		-- space_char_blankline = " ",
+		-- show_current_context = true,
+		-- show_current_context_start = true,
+		-- char_highlight_list = {
+		--   "IndentBlanklineIndent1",
+		--   "IndentBlanklineIndent2",
+		--   "IndentBlanklineIndent3",
+		--   "IndentBlanklineIndent4",
+		--   "IndentBlanklineIndent5",
+		--   "IndentBlanklineIndent6",
+		-- },
+	},
+}

lua/plugins/init.lua

···
+return {
+	-- Cosmetics
+	{
+		"folke/todo-comments.nvim",
+		config = true,
+	},
+
+	-- Git
+	"tpope/vim-fugitive",
+
+	-- Utilities
+
+	"ellisonleao/glow.nvim",
+}

lua/plugins/java.lua

···
+return { "nvim-java/nvim-java" }

lua/plugins/jinja2.lua

···
+return {
+	"Glench/Vim-Jinja2-Syntax",
+}

lua/plugins/jsut.lua

···
+return {
+	"NoahTheDuke/vim-just",
+	ft = { "just" },
+}

lua/plugins/jsx-pretty.lua

···
+return {
+	"MaxMEllon/vim-jsx-pretty",
+}

lua/plugins/kotlin.lua

···
+return { "udalov/kotlin-vim", ft = { "kotlin" }, enabled = false }

lua/plugins/kulala.lua

···
+return {
+	"mistweaverco/kulala.nvim",
+	ft = "http",
+	keys = {
+		{ "<leader>R", "", desc = "+Rest" },
+		{
+			"<leader>Rs",
+			"<cmd>lua require('kulala').run()<cr>",
+			desc = "Send the request",
+		},
+		{
+			"<leader>Rt",
+			"<cmd>lua require('kulala').toggle_view()<cr>",
+			desc = "Toggle headers/body",
+		},
+		{
+			"<leader>Rp",
+			"<cmd>lua require('kulala').jump_prev()<cr>",
+			desc = "Jump to previous request",
+		},
+		{
+			"<leader>Rn",
+			"<cmd>lua require('kulala').jump_next()<cr>",
+			desc = "Jump to next request",
+		},
+	},
+	opts = {},
+}

lua/plugins/leap.lua

···
+return {
+	"ggandor/leap.nvim",
+	keys = {
+		{ "s", mode = { "n", "x", "o" }, desc = "Leap forward to" },
+		{ "S", mode = { "n", "x", "o" }, desc = "Leap backward to" },
+		{ "gs", mode = { "n", "x", "o" }, desc = "Leap from windows" },
+	},
+	config = function(_, opts)
+		local leap = require("leap")
+		for k, v in pairs(opts) do
+			leap.opts[k] = v
+		end
+		leap.add_default_mappings(true)
+		vim.keymap.del({ "x", "o" }, "x")
+		vim.keymap.del({ "x", "o" }, "X")
+	end,
+	dependencies = { "tpope/vim-repeat" },
+}

lua/plugins/lint.lua

···
+return {
+	"mfussenegger/nvim-lint",
+	-- Event to trigger linters
+	events = { "BufWritePost", "BufReadPost", "InsertLeave" },
+	opts = {
+		linters_by_ft = {
+			-- Use the "*" filetype to run linters on all filetypes.
+			-- Use the "_" filetype to run linters on filetypes that don't have other linters configured.
+			-- ['_'] = { 'fallback linter' },
+			["*"] = { "typos", "codespell" },
+		},
+		linters = {
+			-- -- Example of using selene only when a selene.toml file is present
+			-- selene = {
+			--   -- `condition` is another LazyVim extension that allows you to
+			--   -- dynamically enable/disable linters based on the context.
+			--   condition = function(ctx)
+			--     return vim.fs.find({ "selene.toml" }, { path = ctx.filename, upward = true })[1]
+			--   end,
+			-- },
+		},
+	},
+	config = function(_, opts)
+		local M = {}
+
+		local lint = require("lint")
+		for name, linter in pairs(opts.linters) do
+			if type(linter) == "table" and type(lint.linters[name]) == "table" then
+				lint.linters[name] = vim.tbl_deep_extend("force", lint.linters[name], linter)
+			else
+				lint.linters[name] = linter
+			end
+		end
+		lint.linters_by_ft = opts.linters_by_ft
+
+		function M.debounce(ms, fn)
+			local timer = vim.uv.new_timer()
+			return function(...)
+				local argv = { ... }
+				timer:start(ms, 0, function()
+					timer:stop()
+					vim.schedule_wrap(fn)(unpack(argv))
+				end)
+			end
+		end
+
+		function M.lint()
+			-- Use nvim-lint's logic first:
+			-- * checks if linters exist for the full filetype first
+			-- * otherwise will split filetype by "." and add all those linters
+			-- * this differs from conform.nvim which only uses the first filetype that has a formatter
+			local names = lint._resolve_linter_by_ft(vim.bo.filetype)
+
+			-- Create a copy of the names table to avoid modifying the original.
+			names = vim.list_extend({}, names)
+
+			-- Add fallback linters.
+			if #names == 0 then vim.list_extend(names, lint.linters_by_ft["_"] or {}) end
+
+			-- Add global linters.
+			vim.list_extend(names, lint.linters_by_ft["*"] or {})
+
+			-- Filter out linters that don't exist or don't match the condition.
+			local ctx = { filename = vim.api.nvim_buf_get_name(0) }
+			ctx.dirname = vim.fn.fnamemodify(ctx.filename, ":h")
+			names = vim.tbl_filter(function(name)
+				local linter = lint.linters[name]
+				if not linter then LazyVim.warn("Linter not found: " .. name, { title = "nvim-lint" }) end
+				return linter and not (type(linter) == "table" and linter.condition and not linter.condition(ctx))
+			end, names)
+
+			-- Run linters.
+			if #names > 0 then lint.try_lint(names) end
+		end
+	end,
+}

lua/plugins/lsp.lua

···
+return {
+	"neovim/nvim-lspconfig",
+	opts = { inlay_hints = { enable = true } },
+	lazy = false,
+	keys = {
+		{
+			"gD",
+			vim.lsp.buf.declaration,
+			{ noremap = true, silent = true },
+			desc = "Go To Declaration",
+			mode = "n",
+		},
+		{
+			"gd",
+			vim.lsp.buf.definition,
+			{ noremap = true, silent = true },
+			desc = "Go To Definition",
+			mode = "n",
+		},
+		{
+			"gi",
+			vim.lsp.buf.implementation,
+			{ noremap = true, silent = true },
+			desc = "Go To Implementation",
+			mode = "n",
+		},
+		{ "K", vim.lsp.buf.hover, { silent = true }, desc = "Show Info", mode = "n" },
+		{
+			"<leader>ck",
+			vim.lsp.buf.signature_help,
+			{ silent = true, noremap = true },
+			desc = "Show Signature",
+			mode = "n",
+		},
+		{
+			"<leader>r",
+			vim.lsp.buf.rename,
+			{ silent = true, noremap = true },
+			desc = "Rename symbol",
+			mode = "n",
+		}, -- {
+		--         "<leader>cf",
+		--         vim.lsp.buf.format,
+		--         {silent = true, noremap = true},
+		--         desc = "Format",
+		--         mode = "n"
+		--     },
+		{
+			"<Leader>gr",
+			vim.lsp.buf.references,
+			{ noremap = true, silent = true },
+			desc = "Go To References",
+			mode = "n",
+		},
+		{
+			"<Leader>D",
+			vim.lsp.buf.type_definition,
+			{ noremap = true, silent = true },
+			desc = "Show Type Definition",
+			mode = "n",
+		},
+		{
+			"<Leader>ca",
+			vim.lsp.buf.code_action,
+			{ noremap = true, silent = true },
+			desc = "Code actions",
+		},
+	},
+	config = function()
+		-- Setup language servers.
+		local lspconfig = require("lspconfig")
+		local capabilities = vim.lsp.protocol.make_client_capabilities()
+		capabilities = require("cmp_nvim_lsp").default_capabilities(capabilities)
+
+		-- Rust
+		lspconfig.rust_analyzer.setup({
+			capabilities = capabilities,
+			autostart = true,
+			settings = {
+				["rust-analyzer"] = {
+					cargo = {
+						allFeatures = true,
+						loadOutDirsFromCheck = true,
+						buildScripts = { enable = true },
+					},
+					assist = {
+						-- Whether to insert #[must_use] when generating as_ methods for enum variants.
+						emitMustUse = true,
+					},
+					imports = { group = { enable = false } },
+					completion = { postfix = { enable = false } },
+					-- Add clippy lints for Rust.
+					checkOnSave = {
+						allFeatures = true,
+						command = "clippy",
+						extraArgs = { "--no-deps" },
+					},
+					procMacro = {
+						enable = true,
+						ignored = {
+							["async-trait"] = { "async_trait" },
+							["napi-derive"] = { "napi" },
+							["async-recursion"] = { "async_recursion" },
+						},
+					},
+					hint = { enable = true },
+				},
+			},
+		})
+
+		-- assembly
+		lspconfig.asm_lsp.setup({
+			capabilities = capabilities,
+			filetypes = { "asm", "vmasm", "nasm" },
+			autostart = true,
+			single_file_support = true,
+			-- formatting
+		})
+
+		-- nix
+		lspconfig.nil_ls.setup({
+			capabilities = capabilities,
+			autostart = true,
+			settings = { ["nil"] = { formatting = { command = { "nixpkgs-fmt" } } } },
+		})
+
+		-- lua
+		lspconfig.lua_ls.setup({
+			capabilities = capabilities,
+			autostart = true,
+			settings = {
+				Lua = {
+					runtime = { version = "LuaJIT" },
+					completion = { callSnippet = "Replace" },
+					diagnostics = { globals = { "vim" } },
+					format = { enable = false },
+					hint = { enable = true },
+				},
+			},
+		})
+
+		lspconfig.gopls.setup({
+			capabilities = capabilities,
+			autostart = true,
+			cmd = { "gopls" },
+			filetypes = { "go", "gomod", "gowork", "gotmpl" },
+			single_file_support = true,
+		})
+
+		-- python
+		lspconfig.ruff.setup({
+			capabilities = capabilities,
+			autostart = true,
+			init_options = {
+				settings = {
+					lineLength = 120,
+					lint = {
+						enable = true,
+						preview = true,
+					},
+					format = {
+						preview = true,
+					},
+				},
+			},
+			single_file_support = true,
+		})
+
+		lspconfig.tsserver.setup({
+			capabilities = capabilities,
+			autostart = true,
+			cmd = { "typescript-language-server", "--stdio" },
+			filetypes = {
+				"javascript",
+				"javascriptreact",
+				"javascript.jsx",
+				"typescript",
+				"typescriptreact",
+				"typescript.tsx",
+			},
+			init_options = { hostInfo = "neovim" },
+			single_file_support = true,
+		})
+
+		lspconfig.gleam.setup({
+			capabilities = capabilities,
+			autostart = true,
+			cmd = { "gleam", "lsp" },
+			filetypes = { "gleam" },
+			root_dir = lspconfig.util.root_pattern("gleam.toml", ".git"),
+		})
+
+		lspconfig.nil_ls.setup({
+			capabilities = capabilities,
+			autostart = true,
+			cmd = { "nil" },
+			filetypes = { "nix" },
+			root_pattern = { "flake.nix", ".git" },
+			single_file_support = true,
+		})
+
+		-- Zig
+		lspconfig.zls.setup({
+			capabilities = capabilities,
+			autostart = true,
+			cmd = { "zls" },
+			filetypes = { "zig", "zir" },
+			single_file_support = true,
+		})
+
+		-- Java
+		-- lspconfig.java_language_server.setup {
+		--   capabilities = capabilities,
+		--
+		--   autostart = true,
+		--   single_file_support = true
+		-- }
+		lspconfig.jdtls.setup({
+			capabilities = capabilities,
+			autostart = true,
+			single_file_support = true,
+		})
+
+		-- C/C++
+		lspconfig.clangd.setup({
+			capabilities = capabilities,
+			autostart = true,
+			single_file_support = true,
+		})
+
+		-- Kotlin
+		lspconfig.kotlin_language_server.setup({
+			capabilities = capabilities,
+			autostart = true,
+			single_file_support = true,
+		})
+
+		-- Bash LSP
+		local configs = require("lspconfig.configs")
+		if not configs.bash_lsp and vim.fn.executable("bash-language-server") == 1 then
+			configs.bash_lsp = {
+				capabilities = capabilities,
+				autostart = true,
+				default_config = {
+					cmd = { "bash-language-server", "start" },
+					filetypes = { "sh" },
+					root_dir = require("lspconfig").util.find_git_ancestor,
+					init_options = { settings = { args = {} } },
+				},
+			}
+		end
+		if configs.bash_lsp then lspconfig.bash_lsp.setup({}) end
+
+		-- Grammar
+		lspconfig.ltex.setup({
+			capabilities = capabilities,
+			autostart = true,
+			filetypes = {
+				"bib",
+				"gitcommit",
+				"markdown",
+				"org",
+				"plaintex",
+				"rst",
+				"rnoweb",
+				"tex",
+				"pandoc",
+				"quarto",
+				"rmd",
+				"context",
+				"html",
+				"xhtml",
+				"mail",
+				"text",
+			},
+			single_file_support = true,
+		})
+
+		-- Dockerfile
+		lspconfig.dockerls.setup({
+			capabilities = capabilities,
+			settings = {
+				docker = {
+					languageserver = { formatter = { ignoreMultilineInstructions = true } },
+				},
+			},
+		})
+
+		-- Docker compose
+		lspconfig.docker_compose_language_service.setup({
+			capabilities = capabilities,
+			autostart = true,
+			single_file_support = true,
+			filetypes = { "yaml", "yaml.docker-compose" },
+		})
+
+		-- enable inlay hints
+		vim.lsp.inlay_hint.enable()
+	end,
+}

lua/plugins/lspsaga.lua

···
+return {
+	"nvimdev/lspsaga.nvim",
+	lazy = true,
+	event = "LspAttach",
+	keys = {
+		{
+			"<leader>ca",
+			"<cmd>Lspsaga code_action<CR>",
+			{ silent = true, noremap = true },
+			desc = "Range Code Action",
+			mode = "v",
+		},
+		{ "<leader>ca", "<cmd>Lspsaga code_action<CR>", { silent = true, noremap = true }, desc = "Code Action", mode = "n" },
+
+		{
+			"<leader>e",
+			"<cmd>Lspsaga show_line_diagnostics<CR>",
+			{ silent = true, noremap = true },
+			desc = "Show Line Diagnostics",
+			mode = "n",
+		},
+		{
+			"<Leader>[",
+			"<cmd>Lspsaga diagnostic_jump_prev<CR>",
+			{ noremap = true, silent = true },
+			desc = "Jump To The Next Diagnostics",
+			mode = "n",
+		},
+		{
+			"<Leader>]",
+			"<cmd>Lspsaga diagnostic_jump_next<CR>",
+			{ noremap = true, silent = true },
+			desc = "Jump To The Previous Diagnostics",
+			mode = "n",
+		},
+
+		{ "<Leader>T", "<cmd>Lspsaga open_floaterm<CR>", { silent = true }, desc = "Open Float Term", mode = "n" },
+		{ "<Leader>T", [[<C-\><C-n><cmd>Lspsaga close_floaterm<CR>]], { silent = true }, desc = "Close Float Term", mode = "t" },
+
+		{ "gr", "<cmd>Lspsaga rename<CR>", { silent = true, noremap = true }, desc = "Rename", mode = "n" },
+		{ "gh", "<cmd>Lspsaga lsp_finder<CR>", { silent = true, noremap = true }, desc = "LSP Finder", mode = "n" },
+		{ "<Leader>gd", "<cmd>Lspsaga peek_definition<CR>", { silent = true }, desc = "Peek Definition", mode = "n" },
+	},
+	-- opts = {border_style = "rounded"},
+	config = function() require("lspsaga").setup({ border_style = "rounded" }) end,
+	dependencies = {
+		"nvim-treesitter/nvim-treesitter",
+		"nvim-tree/nvim-web-devicons",
+		"neovim/nvim-lspconfig",
+	},
+}

lua/plugins/lualine.lua

···
+return {
+	"nvim-lualine/lualine.nvim",
+	opts = {
+		options = {
+			icons_enabled = true,
+			theme = "gruvbox-material",
+			component_separators = { left = "|", right = "|" },
+			section_separators = { left = "", right = "" },
+			disabled_filetypes = { "NvimTree", "packer" },
+			always_divide_middle = true,
+			globalstatuses = true,
+		},
+		sections = {
+			lualine_a = { "mode" },
+			lualine_b = {
+				"branch",
+				"diff",
+				{
+					"diagnostics",
+					sources = { "nvim_lsp", "coc" },
+					update_in_insert = true,
+					always_visible = true,
+				},
+			},
+			lualine_c = { { "filename", file_status = true, path = 1 } },
+			lualine_x = { "filetype" },
+			lualine_y = { "%p%%", "location" },
+			lualine_z = {},
+		},
+		inactive_sections = {
+			lualine_a = {},
+			lualine_b = {},
+			lualine_c = { { "filename", file_status = true, path = 1 } },
+			lualine_x = { "filetype" },
+			lualine_y = { "%p%%", "location" },
+			lualine_z = {},
+		},
+		tabline = {},
+		extensions = { "fugitive", "fzf", "nvim-tree" },
+	},
+}

lua/plugins/luasnip.lua

···
+return {
+	"L3MON4D3/LuaSnip",
+	-- follow latest release.
+	version = "v2.*", -- Replace <CurrentMajor> by the latest released major (first number of latest release)
+	-- install jsregexp (optional!).
+	build = "make install_jsregexp",
+	dependencies = { "rafamadriz/friendly-snippets" },
+	config = function()
+		require("luasnip.loaders.from_vscode").lazy_load()
+		require("config.snippets")
+	end,
+}

lua/plugins/multi-cursor.lua

···
+return {
+	-- "mg979/vim-visual-multi",
+	-- init = function()
+	--   vim.g.VM_maps = {
+	--     ['Find Under'] = '<C-m>',
+	--     ['Find Subword Under'] = '<C-m>'
+	--   }
+	-- end,
+}

lua/plugins/mustache-handlebars.lua

···
+return {
+	"mustache/vim-mustache-handlebars",
+	ft = {
+		"html.mustache",
+		"html.handlebars",
+	},
+}

lua/plugins/neo-tree.lua

···
+return {
+	"nvim-neo-tree/neo-tree.nvim",
+	cmd = "Neotree",
+	keys = {
+		{
+			"<leader>fe",
+			function() require("neo-tree.command").execute({ toggle = true }) end,
+			desc = "Explorer NeoTree (Root Dir)",
+		},
+		{
+			"<leader>fE",
+			function()
+				require("neo-tree.command").execute({
+					toggle = true,
+					dir = vim.uv.cwd(),
+				})
+			end,
+			desc = "Explorer NeoTree (cwd)",
+		},
+		{
+			"<leader>e",
+			"<leader>fe",
+			desc = "Explorer NeoTree (Root Dir)",
+			remap = true,
+		},
+		{
+			"<leader>E",
+			"<leader>fE",
+			desc = "Explorer NeoTree (cwd)",
+			remap = true,
+		},
+		{
+			"<leader>ge",
+			function()
+				require("neo-tree.command").execute({
+					source = "git_status",
+					toggle = true,
+				})
+			end,
+			desc = "Git Explorer",
+		},
+		{
+			"<leader>be",
+			function()
+				require("neo-tree.command").execute({
+					source = "buffers",
+					toggle = true,
+				})
+			end,
+			desc = "Buffer Explorer",
+		},
+	},
+	deactivate = function() vim.cmd([[Neotree close]]) end,
+	init = function()
+		-- FIX: use `autocmd` for lazy-loading neo-tree instead of directly requiring it,
+		-- because `cwd` is not set up properly.
+		vim.api.nvim_create_autocmd("BufEnter", {
+			group = vim.api.nvim_create_augroup("Neotree_start_directory", { clear = true }),
+			desc = "Start Neo-tree with directory",
+			once = true,
+			callback = function()
+				if package.loaded["neo-tree"] then
+					return
+				else
+					local stats = vim.uv.fs_stat(vim.fn.argv(0))
+					if stats and stats.type == "directory" then require("neo-tree") end
+				end
+			end,
+		})
+	end,
+	opts = {
+		sources = { "filesystem", "buffers", "git_status" },
+		open_files_do_not_replace_types = {
+			"terminal",
+			"Trouble",
+			"trouble",
+			"qf",
+			"Outline",
+		},
+		filesystem = {
+			filtered_items = {
+				visible = false, -- when true, they will just be displayed differently than normal items
+				hide_dotfiles = false,
+				hide_gitignored = true,
+				hide_hidden = true, -- only works on Windows for hidden files/directories
+				hide_by_name = {
+					"node_modules",
+				},
+				hide_by_pattern = { -- uses glob style patterns
+					-- "*.meta",
+					-- "*/src/*/tsconfig.json",
+				},
+				always_show = { -- remains visible even if other settings would normally hide it
+					".gitignored",
+					".justfile",
+				},
+				-- uses glob style patterns
+				always_show_by_pattern = { ".env*" },
+				-- remains hidden even if visible is toggled to true, this overrides always_show
+				never_show = {
+					".DS_Store",
+				},
+			},
+			follow_current_file = {
+				enabled = false, -- This will find and focus the file in the active buffer every time
+				--               -- the current file is changed while the tree is open.
+				leave_dirs_open = false, -- `false` closes auto expanded dirs, such as with `:Neotree reveal`
+			},
+			group_empty_dirs = true, -- when true, empty folders will be grouped together
+			hijack_netrw_behavior = "open_default", -- netrw disabled, opening a directory opens neo-tree
+			-- in whatever position is specified in window.position
+			-- "open_current",  -- netrw disabled, opening a directory opens within the
+			-- window like netrw would, regardless of window.position
+			-- "disabled",    -- netrw left alone, neo-tree does not handle opening dirs
+			use_libuv_file_watcher = true, -- This will use the OS level file watchers to detect changes
+		},
+		enable_git_status = true,
+		enable_diagnostics = true,
+		window = {
+			mappings = {
+				["l"] = "open",
+				["h"] = "close_node",
+				["<space>"] = "none",
+				["Y"] = {
+					function(state)
+						local node = state.tree:get_node()
+						local path = node:get_id()
+						vim.fn.setreg("+", path, "c")
+						vim.notify("Path copyie to the system's clipboard")
+					end,
+					desc = "Copy Path to Clipboard",
+				},
+				["O"] = {
+					function(state) require("lazy.util").open(state.tree:get_node().path, { system = true }) end,
+					desc = "Open with System Application",
+				},
+				["P"] = { "toggle_preview", config = { use_float = false } },
+			},
+		},
+		default_component_configs = {
+			indent = {
+				with_expanders = true, -- if nil and file nesting is enabled, will enable expanders
+				expander_collapsed = "",
+				expander_expanded = "",
+				expander_highlight = "NeoTreeExpander",
+			},
+			git_status = { symbols = { unstaged = "󰄱", staged = "󰱒" } },
+		},
+	},
+	config = function(_, opts)
+		local function on_move(data) vim.lsp.on_rename(data.source, data.destination) end
+
+		local events = require("neo-tree.events")
+		opts.event_handlers = opts.event_handlers or {}
+		vim.list_extend(opts.event_handlers, {
+			{ event = events.FILE_MOVED, handler = on_move },
+			{ event = events.FILE_RENAMED, handler = on_move },
+		})
+		require("neo-tree").setup(opts)
+		vim.api.nvim_create_autocmd("TermClose", {
+			pattern = "*lazygit",
+			callback = function()
+				if package.loaded["neo-tree.sources.git_status"] then require("neo-tree.sources.git_status").refresh() end
+			end,
+		})
+	end,
+}

lua/plugins/neogen.lua

···
+return {
+	"danymat/neogen",
+	cmd = "Neogen",
+	keys = {
+		{
+			"<leader>cn",
+			function() require("neogen").generate() end,
+			desc = "Generate Annotations (Neogen)",
+		},
+	},
+	opts = function(_, opts)
+		if opts.snippet_engine ~= nil then return end
+		opts.snippet_engine = "luasnip"
+	end,
+}

lua/plugins/noice.lua

···
+return {
+	"folke/noice.nvim",
+	dependencies = { "rcarriga/nvim-notify" },
+	event = "VeryLazy",
+	opts = {
+		cmdline = {
+			view = "cmdline",
+			format = {
+				search_down = {
+					view = "cmdline",
+				},
+				search_up = {
+					view = "cmdline",
+				},
+			},
+		},
+		lsp = {
+			override = {
+				["vim.lsp.util.convert_input_to_markdown_lines"] = true,
+				["vim.lsp.util.stylize_markdown"] = true,
+				["cmp.entry.get_documentation"] = true,
+			},
+		},
+		routes = {
+			{
+				filter = {
+					event = "msg_show",
+					any = {
+						{ find = "%d+L, %d+B" },
+						{ find = "; after #%d+" },
+						{ find = "; before #%d+" },
+					},
+				},
+				view = "mini",
+			},
+		},
+		presets = {
+			bottom_search = true,
+			command_palette = true,
+			long_message_to_split = true,
+		},
+	},
+	keys = {
+		{ "<leader>sn", "", desc = "+noice" },
+		{
+			"<S-Enter>",
+			function() require("noice").redirect(vim.fn.getcmdline()) end,
+			mode = "c",
+			desc = "Redirect Cmdline",
+		},
+		{
+			"<leader>snl",
+			function() require("noice").cmd("last") end,
+			desc = "Noice Last Message",
+		},
+		{
+			"<leader>snh",
+			function() require("noice").cmd("history") end,
+			desc = "Noice History",
+		},
+		{
+			"<leader>sna",
+			function() require("noice").cmd("all") end,
+			desc = "Noice All",
+		},
+		{
+			"<leader>snd",
+			function() require("noice").cmd("dismiss") end,
+			desc = "Dismiss All",
+		},
+		{
+			"<leader>snt",
+			function() require("noice").cmd("pick") end,
+			desc = "Noice Picker (Telescope/FzfLua)",
+		},
+		{
+			"<c-f>",
+			function()
+				if not require("noice.lsp").scroll(4) then return "<c-f>" end
+			end,
+			silent = true,
+			expr = true,
+			desc = "Scroll Forward",
+			mode = { "i", "n", "s" },
+		},
+		{
+			"<c-b>",
+			function()
+				if not require("noice.lsp").scroll(-4) then return "<c-b>" end
+			end,
+			silent = true,
+			expr = true,
+			desc = "Scroll Backward",
+			mode = { "i", "n", "s" },
+		},
+	},
+	config = function(_, opts)
+		-- HACK: noice shows messages from before it was enabled,
+		-- but this is not ideal when Lazy is installing plugins,
+		-- so clear the messages in this case.
+		if vim.o.filetype == "lazy" then vim.cmd([[messages clear]]) end
+		require("noice").setup(opts)
+	end,
+}

lua/plugins/nvim-colorizer.lua

···
+return {
+	"norcalli/nvim-colorizer.lua",
+	lazy = false,
+	enable = true,
+	ft = {
+		"css",
+		"html",
+		"jinja",
+		"javascript",
+		"javascriptreact",
+		"typescript",
+		"typescriptreact",
+	},
+	config = function() require("colorizer").setup() end,
+	--opts = {
+	--    {'*'}, {
+	--        RGB = true, -- #RGB hex codes
+	--        RRGGBB = true, -- #RRGGBB hex codes
+	--        names = true, -- "Name" codes like Blue
+	--        RRGGBBAA = true, -- #RRGGBB hex codes
+	--        rgb_fn = true, -- CSS rgb() and rgba() functions
+	--        hsl_fn = true, -- CSS hsl() and hsla() functions
+	--        css = true, -- Enable all CSS features: rgb_fn, hsl_fn, names, RGB, RRGGBB
+	--        css_fn = true -- Enable all CSS *functions*: rgb_fn, hsl_fn
+	--    }
+	--}
+}

lua/plugins/nvim-tree.lua

···
+local function on_attach(bufnr)
+	local api = require("nvim-tree.api")
+
+	local function opts(desc)
+		return { desc = "nvim-tree: " .. desc, buffer = bufnr, noremap = true, silent = true, nowait = true }
+	end
+
+	-- Default mappings. Feel free to modify or remove as you wish.
+	--
+	-- BEGIN_DEFAULT_ON_ATTACH
+	vim.keymap.set("n", "<C-]>", api.tree.change_root_to_node, opts("CD"))
+	vim.keymap.set("n", "<C-e>", api.node.open.replace_tree_buffer, opts("Open: In Place"))
+	vim.keymap.set("n", "<C-k>", api.node.show_info_popup, opts("Info"))
+	vim.keymap.set("n", "<C-r>", api.fs.rename_sub, opts("Rename: Omit Filename"))
+	vim.keymap.set("n", "<C-t>", api.node.open.tab, opts("Open: New Tab"))
+	vim.keymap.set("n", "<C-v>", api.node.open.vertical, opts("Open: Vertical Split"))
+	vim.keymap.set("n", "<C-x>", api.node.open.horizontal, opts("Open: Horizontal Split"))
+	vim.keymap.set("n", "<BS>", api.node.navigate.parent_close, opts("Close Directory"))
+	vim.keymap.set("n", "<CR>", api.node.open.edit, opts("Open"))
+	vim.keymap.set("n", "<Tab>", api.node.open.preview, opts("Open Preview"))
+	vim.keymap.set("n", ">", api.node.navigate.sibling.next, opts("Next Sibling"))
+	vim.keymap.set("n", "<", api.node.navigate.sibling.prev, opts("Previous Sibling"))
+	vim.keymap.set("n", ".", api.node.run.cmd, opts("Run Command"))
+	vim.keymap.set("n", "-", api.tree.change_root_to_parent, opts("Up"))
+	vim.keymap.set("n", "a", api.fs.create, opts("Create"))
+	vim.keymap.set("n", "bmv", api.marks.bulk.move, opts("Move Bookmarked"))
+	vim.keymap.set("n", "B", api.tree.toggle_no_buffer_filter, opts("Toggle No Buffer"))
+	vim.keymap.set("n", "c", api.fs.copy.node, opts("Copy"))
+	vim.keymap.set("n", "C", api.tree.toggle_git_clean_filter, opts("Toggle Git Clean"))
+	vim.keymap.set("n", "[c", api.node.navigate.git.prev, opts("Prev Git"))
+	vim.keymap.set("n", "]c", api.node.navigate.git.next, opts("Next Git"))
+	vim.keymap.set("n", "d", api.fs.remove, opts("Delete"))
+	vim.keymap.set("n", "D", api.fs.trash, opts("Trash"))
+	vim.keymap.set("n", "E", api.tree.expand_all, opts("Expand All"))
+	vim.keymap.set("n", "e", api.fs.rename_basename, opts("Rename: Basename"))
+	vim.keymap.set("n", "]e", api.node.navigate.diagnostics.next, opts("Next Diagnostic"))
+	vim.keymap.set("n", "[e", api.node.navigate.diagnostics.prev, opts("Prev Diagnostic"))
+	vim.keymap.set("n", "F", api.live_filter.clear, opts("Clean Filter"))
+	vim.keymap.set("n", "f", api.live_filter.start, opts("Filter"))
+	vim.keymap.set("n", "g?", api.tree.toggle_help, opts("Help"))
+	vim.keymap.set("n", "gy", api.fs.copy.absolute_path, opts("Copy Absolute Path"))
+	vim.keymap.set("n", "H", api.tree.toggle_hidden_filter, opts("Toggle Dotfiles"))
+	vim.keymap.set("n", "I", api.tree.toggle_gitignore_filter, opts("Toggle Git Ignore"))
+	vim.keymap.set("n", "J", api.node.navigate.sibling.last, opts("Last Sibling"))
+	vim.keymap.set("n", "K", api.node.navigate.sibling.first, opts("First Sibling"))
+	vim.keymap.set("n", "m", api.marks.toggle, opts("Toggle Bookmark"))
+	vim.keymap.set("n", "o", api.node.open.edit, opts("Open"))
+	vim.keymap.set("n", "O", api.node.open.no_window_picker, opts("Open: No Window Picker"))
+	vim.keymap.set("n", "p", api.fs.paste, opts("Paste"))
+	vim.keymap.set("n", "P", api.node.navigate.parent, opts("Parent Directory"))
+	vim.keymap.set("n", "q", api.tree.close, opts("Close"))
+	vim.keymap.set("n", "r", api.fs.rename, opts("Rename"))
+	vim.keymap.set("n", "R", api.tree.reload, opts("Refresh"))
+	vim.keymap.set("n", "s", api.node.run.system, opts("Run System"))
+	vim.keymap.set("n", "S", api.tree.search_node, opts("Search"))
+	vim.keymap.set("n", "U", api.tree.toggle_custom_filter, opts("Toggle Hidden"))
+	vim.keymap.set("n", "W", api.tree.collapse_all, opts("Collapse"))
+	vim.keymap.set("n", "x", api.fs.cut, opts("Cut"))
+	vim.keymap.set("n", "y", api.fs.copy.filename, opts("Copy Name"))
+	vim.keymap.set("n", "Y", api.fs.copy.relative_path, opts("Copy Relative Path"))
+	vim.keymap.set("n", "<2-LeftMouse>", api.node.open.edit, opts("Open"))
+	vim.keymap.set("n", "<2-RightMouse>", api.tree.change_root_to_node, opts("CD"))
+	-- END_DEFAULT_ON_ATTACH
+
+	-- Mappings migrated from view.mappings.list
+	--
+	-- You will need to insert "your code goes here" for any mappings with a custom action_cb
+	vim.keymap.set("n", "u", api.tree.change_root_to_parent, opts("Up"))
+end
+
+vim.g.loaded_netrw = 1
+vim.g.loaded_netrwPlugin = 1
+
+vim.api.nvim_create_autocmd({ "UIEnter" }, {
+	callback = function(data)
+		-- buffer is a directory
+		local directory = vim.fn.isdirectory(data.file) == 1
+
+		if not directory then return end
+
+		-- change to the directory
+		vim.cmd.cd(data.file)
+
+		-- open the tree
+		require("nvim-tree.api").tree.open()
+	end,
+})
+
+return {
+	"kyazdani42/nvim-tree.lua",
+	dependencies = "nvim-tree/nvim-web-devicons",
+	lazy = false,
+	keys = {
+		{ "<C-\\>", ":NvimTreeToggle<CR>", { noremap = true, silent = true }, desc = "Toggle NvimTree" },
+	},
+	opts = {
+		sync_root_with_cwd = true,
+		reload_on_bufenter = true,
+		respect_buf_cwd = true,
+		on_attach = on_attach,
+		view = {
+			adaptive_size = true,
+			side = "left",
+		},
+		renderer = {
+			group_empty = true,
+			indent_markers = {
+				enable = true,
+				icons = { corner = "└ ", edge = "│ ", item = "│ ", none = "  " },
+			},
+		},
+		diagnostics = {
+			enable = true,
+			show_on_dirs = true,
+			-- icons = {hint = "", info = "", warning = "", error = ""}
+		},
+		filters = { dotfiles = true, custom = {
+			".*\\~",
+			"build$",
+			"gradle$",
+			"gradlew",
+			"node_modules",
+		} },
+		filesystem_watchers = { enable = true, debounce_delay = 50 },
+	},
+}

lua/plugins/octo.lua

···
+return {
+	"pwntester/octo.nvim",
+	cmd = "Octo",
+	event = { { event = "BufReadCmd", pattern = "octo://*" } },
+	opts = {
+		enable_builtin = true,
+		default_to_projects_v2 = true,
+		default_merge_method = "squash",
+		picker = "telescope",
+	},
+	keys = {
+		{ "<leader>gi", "<cmd>Octo issue list<CR>", desc = "List Issues (Octo)" },
+		{ "<leader>gI", "<cmd>Octo issue search<CR>", desc = "Search Issues (Octo)" },
+		{ "<leader>gp", "<cmd>Octo pr list<CR>", desc = "List PRs (Octo)" },
+		{ "<leader>gP", "<cmd>Octo pr search<CR>", desc = "Search PRs (Octo)" },
+		{ "<leader>gr", "<cmd>Octo repo list<CR>", desc = "List Repos (Octo)" },
+		{ "<leader>gS", "<cmd>Octo search<CR>", desc = "Search (Octo)" },
+
+		{ "<leader>a", "", desc = "+assignee (Octo)", ft = "octo" },
+		{ "<leader>c", "", desc = "+comment/code (Octo)", ft = "octo" },
+		{ "<leader>l", "", desc = "+label (Octo)", ft = "octo" },
+		{ "<leader>i", "", desc = "+issue (Octo)", ft = "octo" },
+		{ "<leader>r", "", desc = "+react (Octo)", ft = "octo" },
+		{ "<leader>p", "", desc = "+pr (Octo)", ft = "octo" },
+		{ "<leader>v", "", desc = "+review (Octo)", ft = "octo" },
+		{ "@", "@<C-x><C-o>", mode = "i", ft = "octo", silent = true },
+		{ "#", "#<C-x><C-o>", mode = "i", ft = "octo", silent = true },
+	},
+}

lua/plugins/outher.lua

···
+return {
+	-- language support
+	-- terraform
+	{
+		"hashivim/vim-terraform",
+		ft = { "terraform" },
+	},
+	-- svelte
+	{
+		"evanleck/vim-svelte",
+		ft = { "svelte" },
+	},
+	-- toml
+	"cespare/vim-toml",
+	-- yaml
+	{
+		"cuducos/yaml.nvim",
+		ft = { "yaml" },
+		dependencies = {
+			"nvim-treesitter/nvim-treesitter",
+		},
+	},
+	-- rust
+	{
+		"rust-lang/rust.vim",
+		ft = { "rust" },
+		config = function()
+			vim.g.rustfmt_autosave = 1
+			vim.g.rustfmt_emit_files = 1
+			vim.g.rustfmt_fail_silently = 0
+			vim.g.rust_clip_command = "xcopy"
+		end,
+	},
+	-- fish
+	"khaveesh/vim-fish-syntax",
+	-- markdown
+	{
+		"plasticboy/vim-markdown",
+		ft = { "markdown" },
+		dependencies = {
+			"godlygeek/tabular",
+		},
+		config = function()
+			-- never ever fold!
+			vim.g.vim_markdown_folding_disabled = 1
+			-- support front-matter in .md files
+			vim.g.vim_markdown_frontmatter = 1
+			-- 'o' on a list item should insert at same level
+			vim.g.vim_markdown_new_list_item_indent = 0
+			-- don't add bullets when wrapping:
+			-- https://github.com/preservim/vim-markdown/issues/232
+			vim.g.vim_markdown_auto_insert_bullets = 0
+		end,
+	},
+}

lua/plugins/outline.lua

···
+return {
+	"hedyhli/outline.nvim",
+	lazy = true,
+	cmd = { "Outline", "OutlineOpen" },
+	keys = { -- Example mapping to toggle outline
+		{ "<leader>o", "<cmd>Outline<CR>", desc = "Toggle outline" },
+	},
+	opts = {
+		outline_window = {
+			-- Auto close the outline window if goto_location is triggered and not for
+			-- peek_location
+			auto_close = false,
+			-- Automatically scroll to the location in code when navigating outline window.
+			auto_jump = true,
+			-- boolean or integer for milliseconds duration to apply a temporary highlight
+			-- when jumping. false to disable.
+			jump_highlight_duration = 300,
+			-- Whether to center the cursor line vertically in the screen when
+			-- jumping/focusing. Executes zz.
+			center_on_jump = true,
+
+			-- Vim options for the outline window
+			show_numbers = false,
+			show_relative_numbers = false,
+			wrap = false,
+		},
+
+		outline_items = {
+			-- Show extra details with the symbols (lsp dependent) as virtual next
+			show_symbol_details = true,
+			-- Show corresponding line numbers of each symbol on the left column as
+			-- virtual text, for quick navigation when not focused on outline.
+			-- Why? See this comment:
+			-- https://github.com/simrat39/symbols-outline.nvim/issues/212#issuecomment-1793503563
+			show_symbol_lineno = true,
+			-- Whether to highlight the currently hovered symbol and all direct parents
+			highlight_hovered_item = true,
+			-- Whether to automatically set cursor location in outline to match
+			-- location in code when focus is in code. If disabled you can use
+			-- `:OutlineFollow[!]` from any window or `<C-g>` from outline window to
+			-- trigger this manually.
+			auto_set_cursor = true,
+			-- Autocmd events to automatically trigger these operations.
+			auto_update_events = {
+				-- Includes both setting of cursor and highlighting of hovered item.
+				-- The above two options are respected.
+				-- This can be triggered manually through `follow_cursor` lua API,
+				-- :OutlineFollow command, or <C-g>.
+				follow = { "CursorMoved" },
+				-- Re-request symbols from the provider.
+				-- This can be triggered manually through `refresh_outline` lua API, or
+				-- :OutlineRefresh command.
+				items = { "InsertLeave", "WinEnter", "BufEnter", "BufWinEnter", "TabEnter", "BufWritePost" },
+			},
+		},
+
+		-- Options for outline guides which help show tree hierarchy of symbols
+		guides = {
+			enabled = true,
+			markers = {
+				-- It is recommended for bottom and middle markers to use the same number
+				-- of characters to align all child nodes vertically.
+				bottom = "└",
+				middle = "├",
+				vertical = "│",
+			},
+		},
+
+		symbol_folding = {
+			-- Depth past which nodes will be folded by default. Set to false to unfold all on open.
+			autofold_depth = 1,
+			-- When to auto unfold nodes
+			auto_unfold = {
+				-- Auto unfold currently hovered symbol
+				hovered = true,
+				-- Auto fold when the root level only has this many nodes.
+				-- Set true for 1 node, false for 0.
+				only = true,
+			},
+			markers = { "", "" },
+		},
+
+		-- These keymaps can be a string or a table for multiple keys.
+		-- Set to `{}` to disable. (Using 'nil' will fallback to default keys)
+		keymaps = {
+			show_help = "?",
+			close = { "<Esc>", "q" },
+			-- Jump to symbol under cursor.
+			-- It can auto close the outline window when triggered, see
+			-- 'auto_close' option above.
+			goto_location = "<Cr>",
+			-- Jump to symbol under cursor but keep focus on outline window.
+			peek_location = "o",
+			-- Visit location in code and close outline immediately
+			goto_and_close = "<S-Cr>",
+			-- Change cursor position of outline window to match current location in code.
+			-- 'Opposite' of goto/peek_location.
+			restore_location = "<C-g>",
+			-- Open LSP/provider-dependent symbol hover information
+			hover_symbol = "<C-space>",
+			-- Preview location code of the symbol under cursor
+			toggle_preview = "K",
+			rename_symbol = "r",
+			code_actions = "a",
+			-- These fold actions are collapsing tree nodes, not code folding
+			fold = "h",
+			unfold = "l",
+			fold_toggle = "<Tab>",
+			-- Toggle folds for all nodes.
+			-- If at least one node is folded, this action will fold all nodes.
+			-- If all nodes are folded, this action will unfold all nodes.
+			fold_toggle_all = "<S-Tab>",
+			fold_all = "W",
+			unfold_all = "E",
+			fold_reset = "R",
+			-- Move down/up by one line and peek_location immediately.
+			-- You can also use outline_window.auto_jump=true to do this for any
+			-- j/k/<down>/<up>.
+			down_and_jump = "<C-j>",
+			up_and_jump = "<C-k>",
+		},
+
+		providers = {
+			priority = { "lsp", "coc", "markdown", "norg" },
+			-- Configuration for each provider (3rd party providers are supported)
+			lsp = {
+				-- Lsp client names to ignore
+				blacklist_clients = {},
+			},
+			markdown = {
+				-- List of supported ft's to use the markdown provider
+				filetypes = { "markdown" },
+			},
+		},
+
+		symbols = {
+			-- Filter by kinds (string) for symbols in the outline.
+			-- Possible kinds are the Keys in the icons table below.
+			-- A filter list is a string[] with an optional exclude (boolean) field.
+			-- The symbols.filter option takes either a filter list or ft:filterList
+			-- key-value pairs.
+			-- Put  exclude=true  in the string list to filter by excluding the list of
+			-- kinds instead.
+			-- Include all except String and Constant:
+			--   filter = { 'String', 'Constant', exclude = true }
+			-- Only include Package, Module, and Function:
+			--   filter = { 'Package', 'Module', 'Function' }
+			-- See more examples below.
+			filter = nil,
+
+			icons = {
+				File = { icon = "󰈔", hl = "Identifier" },
+				Module = { icon = "󰆧", hl = "Include" },
+				Namespace = { icon = "󰅪", hl = "Include" },
+				Package = { icon = "󰏗", hl = "Include" },
+				Class = { icon = "𝓒", hl = "Type" },
+				Method = { icon = "ƒ", hl = "Function" },
+				Property = { icon = "", hl = "Identifier" },
+				Field = { icon = "󰆨", hl = "Identifier" },
+				Constructor = { icon = "", hl = "Special" },
+				Enum = { icon = "ℰ", hl = "Type" },
+				Interface = { icon = "󰜰", hl = "Type" },
+				Function = { icon = "", hl = "Function" },
+				Variable = { icon = "", hl = "Constant" },
+				Constant = { icon = "", hl = "Constant" },
+				String = { icon = "𝓐", hl = "String" },
+				Number = { icon = "#", hl = "Number" },
+				Boolean = { icon = "⊨", hl = "Boolean" },
+				Array = { icon = "󰅪", hl = "Constant" },
+				Object = { icon = "⦿", hl = "Type" },
+				Key = { icon = "🔐", hl = "Type" },
+				Null = { icon = "NULL", hl = "Type" },
+				EnumMember = { icon = "", hl = "Identifier" },
+				Struct = { icon = "𝓢", hl = "Structure" },
+				Event = { icon = "🗲", hl = "Type" },
+				Operator = { icon = "+", hl = "Identifier" },
+				TypeParameter = { icon = "𝙏", hl = "Identifier" },
+				Component = { icon = "󰅴", hl = "Function" },
+				Fragment = { icon = "󰅴", hl = "Constant" },
+				TypeAlias = { icon = " ", hl = "Type" },
+				Parameter = { icon = " ", hl = "Identifier" },
+				StaticMethod = { icon = " ", hl = "Function" },
+				Macro = { icon = " ", hl = "Function" },
+			},
+		},
+	},
+}

lua/plugins/pairs.lua

···
+return {
+	"steelsojka/pears.nvim",
+	lazy = false,
+	config = function()
+		require("pears").setup(function(conf)
+			conf.preset("tag_matching")
+			conf.expand_on_enter(true)
+			conf.on_enter(function(pears_handle)
+				if vim.fn.pumvisible() == 1 and vim.fn.complete_info().selected ~= -1 then
+					vim.cmd([[:startinsert | call feedkeys("\<c-y>")]])
+				else
+					pears_handle()
+				end
+			end)
+		end)
+	end,
+}

lua/plugins/presence.lua

···
+-- Discord Rich Presence
+return {
+	"andweeb/presence.nvim",
+	opts = {
+		-- General options
+		neovim_image_text = "The One True Text Editor", -- Text displayed when hovered over the Neovim image
+		main_image = "neovim", -- Main image display (either "neovim" or "file")
+		enable_line_number = false, -- Displays the current line number instead of the current project
+
+		-- Rich Presence text options
+		editing_text = "Coding :p",
+		file_explorer_text = "Coding :p",
+		git_commit_text = "Coding :p",
+		plugin_manager_text = "Coding :p",
+		reading_text = "Coding :p",
+		workspace_text = "NEOVIM BABYY",
+	},
+}

lua/plugins/tailwindcss.lua

···
+return {
+	{
+		"roobert/tailwindcss-colorizer-cmp.nvim",
+		-- optionally, override the default options:
+		config = function() require("tailwindcss-colorizer-cmp").setup({ color_square_width = 2 }) end,
+	},
+	{
+		"razak17/tailwind-fold.nvim",
+		opts = {},
+		dependencies = { "nvim-treesitter/nvim-treesitter" },
+		ft = { "html", "typescriptreact", "tsx" },
+	},
+}

lua/plugins/telescope.lua

···
+return {
+	"nvim-telescope/telescope.nvim",
+	lazy = false,
+	keys = {
+		{
+			"<Leader>ff",
+			":lua require('telescope.builtin').find_files()<CR>",
+			{ noremap = true, silent = true },
+			desc = "Find Files",
+		},
+		{
+			"<Leader>bb",
+			":lua require('telescope.builtin').buffers()<CR>",
+			{ noremap = true, silent = true },
+			desc = "Buffers",
+		},
+		{
+			"<Leader>g",
+			":lua require('telescope.builtin').live_grep()<CR>",
+			{ noremap = true, silent = true },
+			desc = "Live Grep",
+		},
+		{
+			"<Leader>h",
+			":lua require('telescope.builtin').help_tags()<CR>",
+			{ noremap = true, silent = true },
+			desc = "Help Tags",
+		},
+		{
+			"<Leader>ss",
+			":lua require('telescope.builtin').spell_suggest()<CR>",
+			{ noremap = true, silent = true },
+			desc = "Spell Suggest",
+		},
+		{
+			"<Leader>k",
+			":lua require('telescope.builtin').keymaps()<CR>",
+			{ noremap = true, silent = true },
+			desc = "Show Key Maps",
+		},
+		{
+			"<Leader>vo",
+			":lua require('telescope.builtin').vim_options()<CR>",
+			{ noremap = true, silent = true },
+			desc = "Neovim Options",
+		},
+		{
+			"<Leader>D",
+			":lua require('telescope.builtin').diagnostics()<CR>",
+			{ noremap = true, silent = true },
+			desc = "Diagnostics",
+		},
+		{
+			"<Leader>cs",
+			":lua require('telescope.builtin').git_status()<CR>",
+			{ noremap = true, silent = true },
+			desc = "Git Status",
+		},
+	},
+	dependencies = {
+		{ "nvim-lua/plenary.nvim" },
+		{ "nvim-telescope/telescope-fzf-native.nvim" },
+		-- ripgrep needs to be installed on the system 'pacman -S ripgrep'
+	},
+	config = function()
+		local actions = require("telescope.actions")
+		require("telescope").setup({
+			defaults = { mappings = { i = { ["<esc>"] = actions.close } } },
+			extensions = {
+				fzf = {
+					fuzzy = true,
+					override_generic_sorter = true,
+					override_file_sorter = true,
+					case_mode = "smart_case",
+				},
+			},
+		})
+	end,
+}

lua/plugins/todo-comment.lua

···
+return {
+	"folke/todo-comments.nvim",
+	cmd = { "TodoTrouble", "TodoTelescope" },
+	opts = {},
+	keys = {
+		{ "]t", function() require("todo-comments").jump_next() end, desc = "Next Todo Comment" },
+		{ "[t", function() require("todo-comments").jump_prev() end, desc = "Previous Todo Comment" },
+		{ "<leader>xt", "<cmd>Trouble todo toggle<cr>", desc = "Todo (Trouble)" },
+		{
+			"<leader>xT",
+			"<cmd>Trouble todo toggle filter = {tag = {TODO,FIX,FIXME}}<cr>",
+			desc = "Todo/Fix/Fixme (Trouble)",
+		},
+		{ "<leader>st", "<cmd>TodoTelescope<cr>", desc = "Todo" },
+		{ "<leader>sT", "<cmd>TodoTelescope keywords=TODO,FIX,FIXME<cr>", desc = "Todo/Fix/Fixme" },
+	},
+}

lua/plugins/treesitter.lua

···
+return {
+	"nvim-treesitter/nvim-treesitter",
+	version = false, -- last release is way too old and doesn't work on Windows
+	build = ":TSUpdate",
+	event = { "VeryLazy" },
+	init = function(plugin)
+		-- PERF: add nvim-treesitter queries to the rtp and it's custom query predicates early
+		-- This is needed because a bunch of plugins no longer `require("nvim-treesitter")`, which
+		-- no longer trigger the **nvim-treesitter** module to be loaded in time.
+		-- Luckily, the only things that those plugins need are the custom queries, which we make available
+		-- during startup.
+		require("lazy.core.loader").add_to_rtp(plugin)
+		require("nvim-treesitter.query_predicates")
+	end,
+	dependencies = {
+		{
+			"nvim-treesitter/nvim-treesitter-textobjects",
+			config = function()
+				-- When in diff mode, we want to use the default
+				-- vim text objects c & C instead of the treesitter ones.
+				local move = require("nvim-treesitter.textobjects.move") ---@type table<string,fun(...)>
+				local configs = require("nvim-treesitter.configs")
+				for name, fn in pairs(move) do
+					if name:find("goto") == 1 then
+						move[name] = function(q, ...)
+							if vim.wo.diff then
+								local config = configs.get_module("textobjects.move")[name] ---@type table<string,string>
+								for key, query in pairs(config or {}) do
+									if q == query and key:find("[%]%[][cC]") then
+										vim.cmd("normal! " .. key)
+										return
+									end
+								end
+							end
+							return fn(q, ...)
+						end
+					end
+				end
+			end,
+		},
+	},
+	cmd = { "TSUpdateSync", "TSUpdate", "TSInstall" },
+	keys = {
+		{ "<c-space>", desc = "Increment Selection" },
+		{ "<bs>", desc = "Decrement Selection", mode = "x" },
+	},
+	opts = {
+		highlight = { enable = true },
+		indent = { enable = true },
+		ensure_installed = {
+			"rust",
+			"bash",
+			"c",
+			"diff",
+			"html",
+			"javascript",
+			"jsdoc",
+			"json",
+			"jsonc",
+			"lua",
+			"luadoc",
+			"luap",
+			"markdown",
+			"markdown_inline",
+			"nim",
+			"python",
+			"query",
+			"regex",
+			"toml",
+			"tsx",
+			"typescript",
+			"vim",
+			"nasm",
+			"vimdoc",
+			"xml",
+			"yaml",
+			"hurl",
+			"nix",
+			"zig",
+			"asm",
+			"jq",
+			"just",
+			"latex",
+			"go",
+			"gleam",
+			"gitcommit",
+			"gitignore",
+			"dockerfile",
+			"go",
+			"kdl",
+			"kotlin",
+			"java",
+			"make",
+			"pony",
+			"po",
+			"printf",
+			"sql",
+			"typst",
+			"http",
+			"graphql",
+			"earthfile",
+			"editorconfig",
+			"ssh_config",
+			"tmux",
+		},
+		incremental_selection = {
+			enable = true,
+			keymaps = {
+				init_selection = "<C-space>",
+				node_incremental = "<C-space>",
+				scope_incremental = false,
+				node_decremental = "<bs>",
+			},
+		},
+		textobjects = {
+			move = {
+				enable = true,
+				goto_next_start = { ["]f"] = "@function.outer", ["]c"] = "@class.outer" },
+				goto_next_end = { ["]F"] = "@function.outer", ["]C"] = "@class.outer" },
+				goto_previous_start = {
+					["[f"] = "@function.outer",
+					["[c"] = "@class.outer",
+				},
+				goto_previous_end = {
+					["[F"] = "@function.outer",
+					["[C"] = "@class.outer",
+				},
+			},
+		},
+	},
+	config = function(_, opts)
+		if type(opts.ensure_installed) == "table" then
+			---@type table<string, boolean>
+			local added = {}
+			opts.ensure_installed = vim.tbl_filter(function(lang)
+				if added[lang] then return false end
+				added[lang] = true
+				return true
+			end, opts.ensure_installed)
+		end
+		require("nvim-treesitter.configs").setup(opts)
+	end,
+}

lua/plugins/trouble.lua

···
+return {
+	"folke/trouble.nvim",
+	cmd = { "Trouble" },
+	opts = { modes = { lsp = { win = { position = "right" } } } },
+	keys = {
+		{
+			"<leader>xx",
+			"<cmd>Trouble diagnostics toggle<cr>",
+			desc = "Diagnostics (Trouble)",
+		},
+		{
+			"<leader>xX",
+			"<cmd>Trouble diagnostics toggle filter.buf=0<cr>",
+			desc = "Buffer Diagnostics (Trouble)",
+		},
+		{
+			"<leader>cs",
+			"<cmd>Trouble symbols toggle<cr>",
+			desc = "Symbols (Trouble)",
+		},
+		{
+			"<leader>cS",
+			"<cmd>Trouble lsp toggle<cr>",
+			desc = "LSP references/definitions/... (Trouble)",
+		},
+		{
+			"<leader>xL",
+			"<cmd>Trouble loclist toggle<cr>",
+			desc = "Location List (Trouble)",
+		},
+		{
+			"<leader>xQ",
+			"<cmd>Trouble qflist toggle<cr>",
+			desc = "Quickfix List (Trouble)",
+		},
+		{
+			"[q",
+			function()
+				if require("trouble").is_open() then
+					require("trouble").prev({ skip_groups = true, jump = true })
+				else
+					local ok, err = pcall(vim.cmd.cprev)
+					if not ok then vim.notify(err, vim.log.levels.ERROR) end
+				end
+			end,
+			desc = "Previous Trouble/Quickfix Item",
+		},
+		{
+			"]q",
+			function()
+				if require("trouble").is_open() then
+					require("trouble").next({ skip_groups = true, jump = true })
+				else
+					local ok, err = pcall(vim.cmd.cnext)
+					if not ok then vim.notify(err, vim.log.levels.ERROR) end
+				end
+			end,
+			desc = "Next Trouble/Quickfix Item",
+		},
+	},
+}

lua/plugins/undotree.lua

···
+return {
+	"mbbill/undotree",
+	lazy = true,
+	keys = {
+		{ "<Leader>u", ":UndotreeToggle<CR>", { noremap = true }, desc = "", mode = "n" },
+	},
+}

lua/plugins/vimtex.lua

···
+return {
+	"lervag/vimtex",
+	lazy = false, -- lazy-loading will disable inverse search
+	init = function() vim.g.vimtex_view_method = "zathura" end,
+	config = function()
+		vim.g.vimtex_mappings_disable = { ["n"] = { "K" } } -- disable `K` as it conflicts with LSP hover
+		vim.g.vimtex_quickfix_method = vim.fn.executable("pplatex") == 1 and "pplatex" or "latexlog"
+	end,
+	keys = { { "<localLeader>l", "", desc = "+vimtext" } },
+}

lua/plugins/which-key.lua

···
+return {
+	"folke/which-key.nvim",
+	event = "VeryLazy",
+	opts_extend = { "spec" },
+	opts = {
+		defaults = {},
+		spec = {
+			{
+				mode = { "n", "v" },
+				{ "<leader><tab>", group = "tabs" },
+				{ "<leader>c", group = "code" },
+				{ "<leader>f", group = "file/find" },
+				{ "<leader>g", group = "git" },
+				{ "<leader>gh", group = "hunks" },
+				{ "<leader>q", group = "quit/session" },
+				{ "<leader>s", group = "search" },
+				{ "<leader>u", group = "ui", icon = { icon = "󰙵 ", color = "cyan" } },
+				{
+					"<leader>x",
+					group = "diagnostics/quickfix",
+					icon = { icon = "󱖫 ", color = "green" },
+				},
+				{ "[", group = "prev" },
+				{ "]", group = "next" },
+				{ "g", group = "goto" },
+				{ "gs", group = "surround" },
+				{ "z", group = "fold" },
+				{
+					"<leader>b",
+					group = "buffer",
+					expand = function() return require("which-key.extras").expand.buf() end,
+				},
+				{
+					"<leader>w",
+					group = "windows",
+					proxy = "<c-w>",
+					expand = function() return require("which-key.extras").expand.win() end,
+				},
+				-- better descriptions
+				{ "gx", desc = "Open with system app" },
+			},
+		},
+	},
+	keys = {
+		{
+			"<leader>?",
+			function() require("which-key").show({ global = false }) end,
+			desc = "Buffer Keymaps (which-key)",
+		},
+		{
+			"<c-w><space>",
+			function() require("which-key").show({ keys = "<c-w>", loop = true }) end,
+			desc = "Window Hydra Mode (which-key)",
+		},
+	},
+	config = function(_, opts)
+		local wk = require("which-key")
+		wk.setup(opts)
+		if not vim.tbl_isempty(opts.defaults) then
+			vim.notify("which-key: opts.defaults is deprecated. Please use opts.spec instead.", "error")
+			wk.register(opts.defaults)
+		end
+	end,
+}

lua/settings.lua

···
+-- I'm lazy
+local opt = vim.opt
+
+-- Nice Number Line
+opt.relativenumber = true
+opt.number = true
+
+-- Tabs & Spaces
+opt.expandtab = true
+opt.tabstop = 4
+opt.softtabstop = 4
+opt.shiftwidth = 4
+opt.smartindent = true
+opt.autoindent = true
+
+-- Searching
+opt.ignorecase = true
+opt.smartcase = true
+opt.hlsearch = true
+opt.incsearch = true
+
+-- Column Settings
+opt.signcolumn = "yes"
+opt.colorcolumn = "120"
+opt.wrap = false
+
+-- Cursor Settings
+opt.cursorline = true
+-- opt.guicursor =
+-- "n-v-c-sm:block,ci-ve:ver25,r-cr-o:hor20,i:block-blinkoff1-blinkon1"
+
+-- Window Settings
+opt.splitbelow = true
+opt.splitright = true
+opt.lazyredraw = true
+opt.showtabline = 0
+
+-- Spelling
+opt.spell = true
+opt.spelloptions = "camel"
+
+-- Other
+opt.mouse = "a"
+opt.showmode = false
+opt.termguicolors = true
+opt.hidden = true
+opt.clipboard = "unnamedplus"
+opt.formatoptions = "cjql"
+opt.laststatus = 3
+opt.completeopt = { "menu", "menuone", "preview" }
+opt.conceallevel = 2
+opt.concealcursor = ""
+-- opt.updatetime = 100
+
+-- Backup -- I have power issues :/
+opt.backup = true
+opt.swapfile = true
+opt.undodir = os.getenv("HOME") .. "/.cache/undodir"
+opt.undofile = true
+
+-- arabic support
+opt.encoding = "utf-8"
+opt.termbidi = true

spell/en.utf-8.add

···
+HTTPException
+ormar
+async
+fastapi
+OAuth2
+async
+HTTPAuthorization
+OAuth2
+str
+bool
+pydantic
+import
+class
+init
+=======
+Nvidia
+AUR
+multilib
+aur
+utils
+config
+linux
+config
+arcolinux
+Qtile
+vscode
+spotify
+adblock
+refrenced
+date
+date
+redis
+Todo
+Lua
+LSP
+fontsize
+qtile
+libqtile
+pathlib
+os
+rofi
+pyright
+pwd
+sa
+kwargs
+SQLModel
+UUID4
+sqlmodel
+uuid
+passlib
+uuid4
+from
+pwd
+bcrypt
+timedelta
+datetime
+aioredis
+jwt
+ExpiredSignatureError
+APIRouter
+OAuth2
+OAuth2
+from
+param
+signup
+OAuth2
+oauth
+access
+user
+whatsapp
+idx
+msg
+numbers
+url
+grid
+floating
+JSX
+HTMLAttributes
+HTMLButton
+api
+mx
+rtl
+ltr
+px
+py
+بحث
+fi
+ai
+headlessui
+md
+bg
+xl
+overscroll
+firefox
+preact
+WhatsappURLStage
+Configs
+Enum
+preact
+eslint
+sm
+const
+enums
+Browser
+usr
+exe
+win32
+src
+env
+tsx
+baseUrl
+jsxFragmentFactory
+jsxFactory
+jsxImportSource
+jsx
+skipLibCheck
+noImplicitReturns
+noUnusedParameters
+compilerOptions
+dom
+compat
+tsconfig
+json
+js
+tailwindcss
+vite
+Abdallah
+Gamal
+TypeScript
+cjs
+mjs
+cts
+mts
+noEmit
+tsc
+typecheck
+postinstall
+deps
+npm
+devDependencies
+autoprefixer
+postcss
+utf8
+Stage
+mb
+www
+css
+javascriptreact
+typescriptreact
+htmldjango
+javascript
+nvim
+lsp
+coq
+cmp
+sourcery
+filetypes
+cssls
+github
+neovim
+lspconfig
+lspconfig's
+urls
+localhost
+ws
+deserialized
+backend
+win64
+userdata
+img
+png
+jpeg
+txt
+AMedia
+AMedia
+useDefineForClassFields
+ESNext
+Iterable
+allowJs
+esModuleInterop
+allowSyntheticDefaultImports
+forceConsistentCasingInFileNames
+moduleResolution
+resolveJsonModule
+isolatedModules
+vitejs
+frontend
+UndoTree
+undodir
+gv
+dP
+Badr
+whitespace
+exists
+starlite
+wouter
+classnames
+btn
+pdfroff
+LOC
+longpress
+libphonenumber
+WriteFormat
+FormatWrite
+testid
+AsyncGenerator
+dir
+auth
+uri
+X11
+asyncio
+funcion
+OAuth
+endblock
+noqa
+F401
+CORSMiddleware
+HTTPSRedirect
+HTTPSRedirect
+jinja
+xset
+flatpak
+hashmap
+filesystem
+Mutex
+icon
+dbus
+freedesktop
+GC
+F403
+ar
+clsx
+BookDetails
+BookStore
+ستور
+بوك
+ico
+Navbar
+QuickActions
+nextjs
+نت
+python3
+Gamemode
+xs
+DetailsButton
+DetailsText
+useUrlFilter
+UrlFilterProvider
+FilterComponent
+UrlFilterContext
+HomeCards
+d99
+e8a
+e7
+bbe000bac05
+PiNumber
+numbersToName
+lang
+w3
+svg
+currentColor
+HeroScrollDownArrow
+fetchData
+AiOutlinePound
+Unkown
+HTMX
+Delist
+extralight
+vercel
+csrfToken
+signin
+nextauth
+nextauthjs
+discussioncomment
+FiSearch
+FaShoppingCart
+FaUser
+useOnScreen
+facebook
+outContactNumber
+ourContactInfo
+scrollend
+scrollAmount
+MdKeyboardArrowLeft
+MdKeyboardArrowRight
+useState
+useEffect
+useMemo
+AiOutlineEye
+postgres
+services
+postgresql
+pgdata
+pgadmin4
+dpage
+MdOutlineError
+enum
+navbar
+image
+services
+Ok
+vw
+minmax
+useFilteredData
+serverless
+adidas
+href
+ui
+PasswordField
+onChange
+credentialsError
+UrlProvider
+useFilter