neovim

private_dot_config/nvim/Session.vim

···
+let SessionLoad = 1
+let s:so_save = &g:so | let s:siso_save = &g:siso | setg so=0 siso=0 | setl so=-1 siso=-1
+let v:this_session=expand("<sfile>:p")
+silent only
+silent tabonly
+cd ~/.config/nvim
+if expand('%') == '' && !&modified && line('$') <= 1 && getline(1) == ''
+  let s:wipebuf = bufnr('%')
+endif
+let s:shortmess_save = &shortmess
+if &shortmess =~ 'A'
+  set shortmess=aoOA
+else
+  set shortmess=aoO
+endif
+badd +198 lua/thomasgen/lazy/mini.lua
+badd +1 lua/thomasgen/lazy/telescope.lua
+badd +3 lua/thomasgen/lazy/colors.lua
+badd +1 ~/.config/nvim/lua/thomasgen/lazy/alpha.lua
+argglobal
+%argdel
+edit ~/.config/nvim/lua/thomasgen/lazy/alpha.lua
+argglobal
+balt lua/thomasgen/lazy/mini.lua
+setlocal fdm=manual
+setlocal fde=0
+setlocal fmr={{{,}}}
+setlocal fdi=#
+setlocal fdl=0
+setlocal fml=1
+setlocal fdn=20
+setlocal fen
+silent! normal! zE
+let &fdl = &fdl
+let s:l = 10 - ((9 * winheight(0) + 29) / 59)
+if s:l < 1 | let s:l = 1 | endif
+keepjumps exe s:l
+normal! zt
+keepjumps 10
+normal! 0
+tabnext 1
+if exists('s:wipebuf') && len(win_findbuf(s:wipebuf)) == 0 && getbufvar(s:wipebuf, '&buftype') isnot# 'terminal'
+  silent exe 'bwipe ' . s:wipebuf
+endif
+unlet! s:wipebuf
+set winheight=1 winwidth=20
+let &shortmess = s:shortmess_save
+let s:sx = expand("<sfile>:p:r")."x.vim"
+if filereadable(s:sx)
+  exe "source " . fnameescape(s:sx)
+endif
+let &g:so = s:so_save | let &g:siso = s:siso_save
+nohlsearch
+doautoall SessionLoadPost
+unlet SessionLoad
+" vim: set ft=vim :

private_dot_config/nvim/init.lua

···
+require("thomasgen")

private_dot_config/nvim/lazy-lock.json

···
+{
+  "LuaSnip": { "branch": "master", "commit": "ce0a05ab4e2839e1c48d072c5236cce846a387bc" },
+  "alpha-nvim": { "branch": "main", "commit": "de72250e054e5e691b9736ee30db72c65d560771" },
+  "chezmoi.nvim": { "branch": "main", "commit": "f5614261b77cb17df72ba2c4fdbc31f7ee42bc6c" },
+  "cmp-nvim-lsp": { "branch": "main", "commit": "39e2eda76828d88b773cc27a3f61d2ad782c922d" },
+  "cmp-path": { "branch": "main", "commit": "91ff86cd9c29299a64f968ebb45846c485725f23" },
+  "cmp_luasnip": { "branch": "master", "commit": "05a9ab28b53f71d1aece421ef32fee2cb857a843" },
+  "codecompanion.nvim": { "branch": "main", "commit": "f20ebfbaf64a1c6d2a3268a80431df697a4d2bbe" },
+  "codeium.vim": { "branch": "main", "commit": "fc5a68d6273715f13a1257f02a63d668604d9f27" },
+  "conform.nvim": { "branch": "master", "commit": "cd75be867f2331b22905f47d28c0c270a69466aa" },
+  "fidget.nvim": { "branch": "main", "commit": "ef99df04a1c53a453602421bc0f756997edc8289" },
+  "gitsigns.nvim": { "branch": "main", "commit": "39b5b6f48bde0595ce68007ffce408c5d7ac1f79" },
+  "harpoon": { "branch": "harpoon2", "commit": "0378a6c428a0bed6a2781d459d7943843f374bce" },
+  "lazy.nvim": { "branch": "main", "commit": "7e6c863bc7563efbdd757a310d17ebc95166cef3" },
+  "lualine.nvim": { "branch": "master", "commit": "0a5a66803c7407767b799067986b4dc3036e1983" },
+  "marks.nvim": { "branch": "master", "commit": "bb25ae3f65f504379e3d08c8a02560b76eaf91e8" },
+  "mason-lspconfig.nvim": { "branch": "main", "commit": "37a336b653f8594df75c827ed589f1c91d91ff6c" },
+  "mason-tool-installer.nvim": { "branch": "main", "commit": "c5e07b8ff54187716334d585db34282e46fa2932" },
+  "mason.nvim": { "branch": "main", "commit": "0950b15060067f752fde13a779a994f59516ce3d" },
+  "mini.icons": { "branch": "main", "commit": "54686be7d58807906cb2c8c2216e0bf9c044f19a" },
+  "mini.nvim": { "branch": "main", "commit": "73af55e44865f2ede67a772b0972a5d34dcedd0e" },
+  "multicursor.nvim": { "branch": "1.0", "commit": "88e4e27b021dce741945856ab6f6640b198ea425" },
+  "nvim-cmp": { "branch": "main", "commit": "a110e12d0b58eefcf5b771f533fc2cf3050680ac" },
+  "nvim-lspconfig": { "branch": "master", "commit": "cf97d2485fc3f6d4df1b79a3ea183e24c272215e" },
+  "nvim-treesitter": { "branch": "master", "commit": "caf275382f91ec8a2498d455c4d7d3fd0265ebd3" },
+  "nvim-treesitter-context": { "branch": "master", "commit": "a45e576526f92766a05726ea3da809e9998c9694" },
+  "nvim-web-devicons": { "branch": "master", "commit": "c0cfc1738361b5da1cd0a962dd6f774cc444f856" },
+  "oil.nvim": { "branch": "master", "commit": "8ea40b5506115b6d355e304dd9ee5089f7d78601" },
+  "plenary.nvim": { "branch": "master", "commit": "a3e3bc82a3f95c5ed0d7201546d5d2c19b20d683" },
+  "rose-pine": { "branch": "main", "commit": "91548dca53b36dbb9d36c10f114385f759731be1" },
+  "snacks.nvim": { "branch": "main", "commit": "974bccb126b6b5d7170c519c380207069d23f557" },
+  "telescope.nvim": { "branch": "master", "commit": "6312868392331c9c0f22725041f1ec2bef57c751" },
+  "undotree": { "branch": "master", "commit": "56c684a805fe948936cda0d1b19505b84ad7e065" },
+  "vim-abolish": { "branch": "master", "commit": "dcbfe065297d31823561ba787f51056c147aa682" },
+  "vim-be-good": { "branch": "master", "commit": "4fa57b7957715c91326fcead58c1fa898b9b3625" },
+  "vim-matchup": { "branch": "master", "commit": "1535a769d5dca851fe7d41b0be95f7c7203a4bef" },
+  "vim-suda": { "branch": "master", "commit": "9adda7d195222d4e2854efb2a88005a120296c47" }
+}

private_dot_config/nvim/lua/thomasgen/init.lua

···
+require("thomasgen.set")
+require("thomasgen.remap")
+require("thomasgen.lazy_init")
+
+local augroup = vim.api.nvim_create_augroup
+local ThomasgenGroup = augroup('Thomasgen', {})
+
+local autocmd = vim.api.nvim_create_autocmd
+local yank_group = augroup('HighlightYank', {})
+
+function R(name)
+	require("plenary.reload").reload_module(name)
+end
+
+vim.filetype.add({
+	extension = {
+		templ = 'templ',
+	}
+})
+
+autocmd('TextYankPost', {
+	group = yank_group,
+	pattern = '*',
+	callback = function()
+		vim.highlight.on_yank({
+			higroup = 'IncSearch',
+			timeout = 100,
+		})
+	end,
+})
+
+autocmd({ "BufWritePre" }, {
+	group = ThomasgenGroup,
+	pattern = "*",
+	command = [[%s/\s\+$//e]],
+})
+
+-- vim.g.netrw_browse_split = 0
+-- vim.g.netrw_banner = 0
+vim.g.netrw_winsize = 25
+vim.g.netrw_bufsettings = 'noma nomod nu rnu nobl nowrap ro'

private_dot_config/nvim/lua/thomasgen/lazy/abolish.lua

···
+return {
+	"tpope/vim-abolish",
+	enabled = true,
+}

private_dot_config/nvim/lua/thomasgen/lazy/alpha.lua

···
+return {
+	"goolord/alpha-nvim",
+	dependencies = {
+		"echasnovski/mini.icons",
+		"nvim-lua/plenary.nvim",
+	},
+	config = function()
+		local function getLen(str, start_pos)
+			local byte = string.byte(str, start_pos)
+			if not byte then
+				return nil
+			end
+
+			return (byte < 0x80 and 1) or (byte < 0xE0 and 2) or (byte < 0xF0 and 3) or (byte < 0xF8 and 4) or 1
+		end
+
+		local function colorize(header, header_color_map, colors)
+			for letter, color in pairs(colors) do
+				local color_name = "AlphaJemuelKwelKwelWalangTatay" .. letter
+				vim.api.nvim_set_hl(0, color_name, color)
+				colors[letter] = color_name
+			end
+
+			local colorized = {}
+
+			for i, line in ipairs(header_color_map) do
+				local colorized_line = {}
+				local pos = 0
+
+				for j = 1, #line do
+					local start = pos
+					pos = pos + getLen(header[i], start + 1)
+
+					local color_name = colors[line:sub(j, j)]
+					if color_name then
+						table.insert(colorized_line, { color_name, start, pos })
+					end
+				end
+
+				table.insert(colorized, colorized_line)
+			end
+
+			return colorized
+		end
+
+		local alpha_c = function()
+			local alpha = require("alpha")
+
+			local dashboard = require("alpha.themes.dashboard")
+
+			local header = {
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████                                   ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+				[[ ██████████████████████████████████████████████████████████████████████████████████████████████████████ ]],
+			}
+
+			local color_map = {
+				[[ WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBWWWWWWWWWWWWWW ]],
+				[[ RRRRWWWWWWWWWWWWWWWWRRRRRRRRRRRRRRRRWWWWWWWWWWWWWWWWBBPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPBBWWWWWWWWWWWW ]],
+				[[ RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRBBPPPPPPHHHHHHHHHHHHHHHHHHHHHHHHHHPPPPPPBBWWWWWWWWWW ]],
+				[[ RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRBBPPPPHHHHHHHHHHHHFFHHHHFFHHHHHHHHHHPPPPBBWWWWWWWWWW ]],
+				[[ OOOORRRRRRRRRRRRRRRROOOOOOOOOOOOOOOORRRRRRRRRRRRRRBBPPHHHHFFHHHHHHHHHHHHHHHHHHHHHHHHHHHHPPBBWWWWWWWWWW ]],
+				[[ OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOBBPPHHHHHHHHHHHHHHHHHHHHBBBBHHHHFFHHHHPPBBWWBBBBWWWW ]],
+				[[ OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOBBPPHHHHHHHHHHHHHHHHHHBBMMMMBBHHHHHHHHPPBBBBMMMMBBWW ]],
+				[[ YYYYOOOOOOOOOOOOOOOOYYYYYYYYYYYYYYYYOOBBBBBBBBOOOOBBPPHHHHHHHHHHHHFFHHHHBBMMMMMMBBHHHHHHPPBBMMMMMMBBWW ]],
+				[[ YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYBBMMMMBBBBOOBBPPHHHHHHHHHHHHHHHHHHBBMMMMMMMMBBBBBBBBMMMMMMMMBBWW ]],
+				[[ YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYBBBBMMMMBBBBBBPPHHHHHHFFHHHHHHHHHHBBMMMMMMMMMMMMMMMMMMMMMMMMBBWW ]],
+				[[ GGGGYYYYYYYYYYYYYYYYGGGGGGGGGGGGGGGGYYYYBBBBMMMMBBBBPPHHHHHHHHHHHHHHFFBBMMMMMMMMMMMMMMMMMMMMMMMMMMMMBB ]],
+				[[ GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGBBBBMMMMBBPPHHFFHHHHHHHHHHHHBBMMMMMMCCBBMMMMMMMMMMCCBBMMMMBB ]],
+				[[ GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGBBBBBBBBPPHHHHHHHHHHHHHHHHBBMMMMMMBBBBMMMMMMBBMMBBBBMMMMBB ]],
+				[[ UUUUGGGGGGGGGGGGGGGGUUUUUUUUUUUUUUUUGGGGGGGGGGGGBBBBPPHHHHHHHHHHFFHHHHBBMMRRRRMMMMMMMMMMMMMMMMMMRRRRBB ]],
+				[[ UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUBBPPPPHHFFHHHHHHHHHHBBMMRRRRMMBBMMMMBBMMMMBBMMRRRRBB ]],
+				[[ UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUBBPPPPPPHHHHHHHHHHHHHHBBMMMMMMBBBBBBBBBBBBBBMMMMBBWW ]],
+				[[ VVVVUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVUUUUUUUUUUUUBBBBBBPPPPPPPPPPPPPPPPPPPPBBMMMMMMMMMMMMMMMMMMMMBBWWWW ]],
+				[[ VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVBBMMMMMMBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBWWWWWW ]],
+				[[ VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVBBMMMMBBBBWWBBMMMMBBWWWWWWWWWWBBMMMMBBWWBBMMMMBBWWWWWWWW ]],
+				[[ WWWWVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWVVVVVVVVVVBBBBBBBBWWWWBBBBBBWWWWWWWWWWWWWWBBBBBBWWWWBBBBWWWWWWWWWW ]],
+			}
+
+			local palette = require("rose-pine.palette")
+
+			local colors = {
+				["W"] = { fg = palette.base },
+				["C"] = { fg = palette.text },
+				["B"] = { fg = palette.surface },
+				["R"] = { fg = palette.love },
+				["O"] = { fg = palette.rose },
+				["Y"] = { fg = palette.gold },
+				["G"] = { fg = palette.foam },
+				["U"] = { fg = palette.pine },
+				["P"] = { fg = "#d7c08d" }, -- Using Yellow color (as specified in original)
+				["H"] = { fg = palette.iris },
+				["F"] = { fg = palette.love },
+				["M"] = { fg = palette.subtle },
+				["V"] = { fg = palette.iris },
+			}
+			dashboard.section.header.val = header
+			dashboard.section.header.opts = {
+				hl = colorize(header, color_map, colors),
+				position = "center",
+			}
+
+			dashboard.section.buttons.val = {
+				dashboard.button("n", "  New file", "<Cmd>ene <CR>"),
+				dashboard.button("SPC p f", "  Find file"),
+				dashboard.button("SPC w q", "  Quit"),
+			}
+			for _, a in ipairs(dashboard.section.buttons.val) do
+				a.opts.width = 49
+				a.opts.cursor = -2
+			end
+
+			alpha.setup(dashboard.config)
+		end
+
+		alpha_c()
+	end,
+}

private_dot_config/nvim/lua/thomasgen/lazy/animate.lua

···
+return {
+	'echasnovski/mini.animate',
+	version = false,
+	enabled = false,
+	config = function()
+		require('mini.animate').setup({
+			cursor = {
+				enable = false
+			}
+		})
+	end
+}

private_dot_config/nvim/lua/thomasgen/lazy/cmp.lua

···
+return { -- Autocompletion
+	"hrsh7th/nvim-cmp",
+	event = "InsertEnter",
+	dependencies = {
+		-- Snippet Engine & its associated nvim-cmp source
+		{
+			"L3MON4D3/LuaSnip",
+			build = (function()
+				-- Build Step is needed for regex support in snippets.
+				-- This step is not supported in many windows environments.
+				-- Remove the below condition to re-enable on windows.
+				if vim.fn.has("win32") == 1 or vim.fn.executable("make") == 0 then
+					return
+				end
+				return "make install_jsregexp"
+			end)(),
+			dependencies = {
+				-- `friendly-snippets` contains a variety of premade snippets.
+				--    See the README about individual language/framework/plugin snippets:
+				--    https://github.com/rafamadriz/friendly-snippets
+				-- {
+				--   'rafamadriz/friendly-snippets',
+				--   config = function()
+				--     require('luasnip.loaders.from_vscode').lazy_load()
+				--   end,
+				-- },
+			},
+		},
+		"saadparwaiz1/cmp_luasnip",
+
+		-- Adds other completion capabilities.
+		--  nvim-cmp does not ship with all sources by default. They are split
+		--  into multiple repos for maintenance purposes.
+		"hrsh7th/cmp-nvim-lsp",
+		"hrsh7th/cmp-path",
+	},
+	config = function()
+		-- See `:help cmp`
+		local cmp = require("cmp")
+		local luasnip = require("luasnip")
+		luasnip.config.setup({})
+
+		cmp.setup({
+			snippet = {
+				expand = function(args)
+					luasnip.lsp_expand(args.body)
+				end,
+			},
+			completion = { completeopt = "menu,menuone,noinsert" },
+
+			-- For an understanding of why these mappings were
+			-- chosen, you will need to read `:help ins-completion`
+			--
+			-- No, but seriously. Please read `:help ins-completion`, it is really good!
+			mapping = cmp.mapping.preset.insert({
+				-- Select the [n]ext item
+				["<C-n>"] = cmp.mapping.select_next_item(),
+				-- Select the [p]revious item
+				["<C-p>"] = cmp.mapping.select_prev_item(),
+
+				-- Scroll the documentation window [b]ack / [f]orward
+				["<C-b>"] = cmp.mapping.scroll_docs(-4),
+				["<C-f>"] = cmp.mapping.scroll_docs(4),
+
+				-- Accept ([y]es) the completion.
+				--  This will auto-import if your LSP supports it.
+				--  This will expand snippets if the LSP sent a snippet.
+				["<C-y>"] = cmp.mapping.confirm({ select = true }),
+
+				-- If you prefer more traditional completion keymaps,
+				-- you can uncomment the following lines
+				--['<CR>'] = cmp.mapping.confirm { select = true },
+				--['<Tab>'] = cmp.mapping.select_next_item(),
+				--['<S-Tab>'] = cmp.mapping.select_prev_item(),
+
+				-- Manually trigger a completion from nvim-cmp.
+				--  Generally you don't need this, because nvim-cmp will display
+				--  completions whenever it has completion options available.
+				["<C-Space>"] = cmp.mapping.complete({}),
+
+				-- Think of <c-l> as moving to the right of your snippet expansion.
+				--  So if you have a snippet that's like:
+				--  function $name($args)
+				--    $body
+				--  end
+				--
+				-- <c-l> will move you to the right of each of the expansion locations.
+				-- <c-h> is similar, except moving you backwards.
+				["<C-l>"] = cmp.mapping(function()
+					if luasnip.expand_or_locally_jumpable() then
+						luasnip.expand_or_jump()
+					end
+				end, { "i", "s" }),
+				["<C-h>"] = cmp.mapping(function()
+					if luasnip.locally_jumpable(-1) then
+						luasnip.jump(-1)
+					end
+				end, { "i", "s" }),
+
+				-- For more advanced Luasnip keymaps (e.g. selecting choice nodes, expansion) see:
+				--    https://github.com/L3MON4D3/LuaSnip?tab=readme-ov-file#keymaps
+			}),
+			sources = {
+				{name = "cody" },
+				{
+					name = "lazydev",
+					-- set group index to 0 to skip loading LuaLS completions as lazydev recommends it
+					group_index = 0,
+				},
+				{ name = "nvim_lsp" },
+				{ name = "luasnip" },
+				{ name = "path" },
+			},
+		})
+	end,
+}

private_dot_config/nvim/lua/thomasgen/lazy/codecompanion.lua

···
+return {
+	"olimorris/codecompanion.nvim",
+	dependencies = {
+		"nvim-lua/plenary.nvim",
+		"nvim-treesitter/nvim-treesitter",
+	},
+	config = function()
+		require("codecompanion").setup({
+			strategies = {
+				chat = {
+					adapter = "anthropic",
+				},
+				inline = {
+					adapter = "anthropic",
+				},
+			},
+		})
+	end,
+}

private_dot_config/nvim/lua/thomasgen/lazy/codeium.lua

···
+return {
+	"Exafunction/codeium.vim",
+	-- enabled = false,
+	config = function()
+		local map = function(keys, func, desc, mode)
+			mode = mode or "n"
+			vim.keymap.set(mode, keys, func, { desc = desc })
+		end
+
+		map("<leader>cd", function()
+			vim.cmd("CodeiumDisable")
+			vim.notify("Codeium disabled", vim.log.levels.INFO, { title = "Codeium" })
+		end, "Disable Codeium")
+
+		map("<leader>ce", function()
+			vim.cmd("CodeiumEnable")
+			vim.notify("Codeium enabled", vim.log.levels.INFO, { title = "Codeium" })
+		end, "Enable Codeium")
+
+		map("<leader>ct", function()
+			vim.cmd("CodeiumToggle")
+			vim.notify("Codeium toggled", vim.log.levels.INFO, { title = "Codeium" })
+		end, "Toggle Codeium")
+	end,
+}

private_dot_config/nvim/lua/thomasgen/lazy/colors.lua

···
+return {
+	{
+		"rose-pine/neovim",
+		name = "rose-pine",
+		config = function()
+			vim.opt.laststatus = 2 -- Or 3 for global statusline
+			vim.opt.statusline = " %f %m %= %l:%c ♥ "
+
+			require("rose-pine").setup({
+				variant = "moon", -- auto, main, moon, or dawn
+				dark_variant = "moon", -- main, moon, or dawn
+				dim_inactive_windows = false,
+				extend_background_behind_borders = true,
+
+				enable = {
+					terminal = true,
+					legacy_highlights = true, -- Improve compatibility for previous versions of Neovim
+					migrations = true, -- Handle deprecated options automatically
+				},
+
+				styles = {
+					bold = true,
+					italic = true,
+					transparency = false,
+				},
+
+				groups = {
+					border = "muted",
+					link = "iris",
+					panel = "surface",
+
+					error = "love",
+					hint = "iris",
+					info = "foam",
+					note = "pine",
+					todo = "rose",
+					warn = "gold",
+
+					git_add = "foam",
+					git_change = "rose",
+					git_delete = "love",
+					git_dirty = "rose",
+					git_ignore = "muted",
+					git_merge = "iris",
+					git_rename = "pine",
+					git_stage = "iris",
+					git_text = "rose",
+					git_untracked = "subtle",
+
+					h1 = "iris",
+					h2 = "foam",
+					h3 = "rose",
+					h4 = "gold",
+					h5 = "pine",
+					h6 = "foam",
+				},
+
+				highlight_groups = {
+					-- Comment = { fg = "foam" },
+					-- VertSplit = { fg = "muted", bg = "muted" },
+					StatusLine = { fg = "love", bg = "love", blend = 10 },
+					StatusLineNC = { fg = "subtle", bg = "surface" },
+
+					-- Transparent Telescope
+					TelescopeBorder = { fg = "highlight_high", bg = "none" },
+					TelescopeNormal = { bg = "none" },
+					TelescopePromptNormal = { bg = "base" },
+					TelescopeResultsNormal = { fg = "subtle", bg = "none" },
+					TelescopeSelection = { fg = "text", bg = "base" },
+					TelescopeSelectionCaret = { fg = "rose", bg = "rose" },
+				},
+
+				before_highlight = function(group, highlight, palette)
+					-- Disable all undercurls
+					-- if highlight.undercurl then
+					--     highlight.undercurl = false
+					-- end
+					--
+					-- Change palette colour
+					-- if highlight.fg == palette.pine then
+					--     highlight.fg = palette.foam
+					-- end
+				end,
+			})
+
+			vim.cmd("colorscheme rose-pine")
+		end,
+	},
+}

private_dot_config/nvim/lua/thomasgen/lazy/comment.lua

···
+return {
+	"numToStr/Comment.nvim",
+	enabled = false,
+	opts = {
+		-- add any options here
+	},
+}

private_dot_config/nvim/lua/thomasgen/lazy/conform.lua

···
+return {
+	"stevearc/conform.nvim",
+	event = { "BufReadPre", "BufNewFile" },
+	config = function()
+		local conform = require("conform")
+
+		conform.setup({
+			formatters_by_ft = {
+				javascript = { "prettier" },
+				typescript = { "prettier" },
+				javascriptreact = { "prettier" },
+				typescriptreact = { "prettier" },
+				svelte = { "prettier" },
+				vue = { "prettier" },
+				css = { "prettier" },
+				html = { "prettier" },
+				json = { "prettier" },
+				yaml = { "prettier" },
+				markdown = { "prettier" },
+				graphql = { "prettier" },
+				lua = { "stylua" },
+				python = { "isort", "black" },
+				astro = { "prettier" },
+				nix = { "alejandra" }
+			},
+			format_on_save = function(bufnr)
+				-- Disable with a global or buffer-local variable
+				if vim.g.disable_autoformat or vim.b[bufnr].disable_autoformat then
+					return
+				end
+				return { timeout_ms = 1000, lsp_format = "fallback" }
+			end,
+		})
+
+		vim.api.nvim_create_user_command("Format", function(args)
+			local range = nil
+			if args.count ~= -1 then
+				local end_line = vim.api.nvim_buf_get_lines(0, args.line2 - 1, args.line2, true)[1]
+				range = {
+					start = { args.line1, 0 },
+					["end"] = { args.line2, end_line:len() },
+				}
+			end
+			require("conform").format({ async = true, lsp_fallback = true, range = range })
+		end, { range = true })
+
+		vim.api.nvim_create_user_command("FormatDisable", function(args)
+			if args.bang then
+				-- FormatDisable! will disable formatting just for this buffer
+				vim.b.disable_autoformat = true
+			else
+				vim.g.disable_autoformat = true
+			end
+		end, {
+			desc = "Disable autoformat-on-save",
+			bang = true,
+		})
+
+		vim.api.nvim_create_user_command("FormatEnable", function()
+			vim.b.disable_autoformat = false
+			vim.g.disable_autoformat = false
+		end, {
+			desc = "Re-enable autoformat-on-save",
+		})
+	end,
+}

private_dot_config/nvim/lua/thomasgen/lazy/gitblame.lua

···
+return {
+	"f-person/git-blame.nvim",
+	enabled = false,
+	config = function()
+		require("gitblame").setup({ enabled = false })
+		vim.keymap.set("n", "<leader>gb", ":GitBlameToggle<CR>", {
+			desc = "Toggle git blame",
+		})
+	end,
+}

private_dot_config/nvim/lua/thomasgen/lazy/gitsigns.lua

···
+return {
+	"lewis6991/gitsigns.nvim",
+	config = function(bufnr)
+		require("gitsigns").setup({
+			on_attach = function(bufnr)
+				local gitsigns = require("gitsigns")
+
+				local function map(mode, l, r, opts)
+					opts = opts or {}
+					opts.buffer = bufnr
+					vim.keymap.set(mode, l, r, opts)
+				end
+
+				-- Navigation
+				-- map('n', ']c', function()
+				-- 	if vim.wo.diff then
+				-- 		vim.cmd.normal({ ']c', bang = true })
+				-- 	else
+				-- 		gitsigns.nav_hunk('next')
+				-- 	end
+				-- end)
+
+				-- map('n', '[c', function()
+				-- 	if vim.wo.diff then
+				-- 		vim.cmd.normal({ '[c', bang = true })
+				-- 	else
+				-- 		gitsigns.nav_hunk('prev')
+				-- 	end
+				-- end)
+
+				-- -- Actions
+				-- map('n', '<leader>hs', gitsigns.stage_hunk)
+				-- map('n', '<leader>hr', gitsigns.reset_hunk)
+				-- map('v', '<leader>hs', function() gitsigns.stage_hunk { vim.fn.line('.'), vim.fn.line('v') } end)
+				-- map('v', '<leader>hr', function() gitsigns.reset_hunk { vim.fn.line('.'), vim.fn.line('v') } end)
+				-- map('n', '<leader>hS', gitsigns.stage_buffer)
+				-- map('n', '<leader>hu', gitsigns.undo_stage_hunk)
+				-- map('n', '<leader>hR', gitsigns.reset_buffer)
+				map("n", "<leader>gp", gitsigns.preview_hunk, { desc = "Preview hunk" })
+				-- map('n', '<leader>hb', function() gitsigns.blame_line { full = true } end)
+				-- map('n', '<leader>tb', gitsigns.toggle_current_line_blame)
+				map("n", "<leader>gd", gitsigns.diffthis, { desc = "Diff this" })
+				-- map('n', '<leader>hD', function() gitsigns.diffthis('~') end)
+				-- map('n', '<leader>td', gitsigns.toggle_deleted)
+
+				-- -- Text object
+				-- map({ 'o', 'x' }, 'ih', ':<C-U>Gitsigns select_hunk<CR>')
+			end,
+		})
+	end,
+}

private_dot_config/nvim/lua/thomasgen/lazy/harpoon.lua

···
+return {
+	"theprimeagen/harpoon",
+	branch = "harpoon2",
+	dependencies = { "nvim-lua/plenary.nvim", "nvim-telescope/telescope.nvim" },
+
+	config = function()
+		local harpoon = require("harpoon")
+		harpoon:setup({
+			settings = { save_on_toggle = true },
+		})
+
+		vim.keymap.set("n", "<leader>a", function()
+			harpoon:list():add()
+		end)
+		vim.keymap.set("n", "<leader>h", function()
+			harpoon.ui:toggle_quick_menu(harpoon:list())
+		end)
+
+		vim.keymap.set("n", "<leader>1", function()
+			harpoon:list():select(1)
+		end)
+		vim.keymap.set("n", "<leader>2", function()
+			harpoon:list():select(2)
+		end)
+		vim.keymap.set("n", "<leader>3", function()
+			harpoon:list():select(3)
+		end)
+		vim.keymap.set("n", "<leader>4", function()
+			harpoon:list():select(4)
+		end)
+		vim.keymap.set("n", "<leader>5", function()
+			harpoon:list():select(5)
+		end)
+		vim.keymap.set("n", "<leader>6", function()
+			harpoon:list():select(6)
+		end)
+		vim.keymap.set("n", "<leader>7", function()
+			harpoon:list():select(7)
+		end)
+		vim.keymap.set("n", "<leader>8", function()
+			harpoon:list():select(8)
+		end)
+		vim.keymap.set("n", "<leader>9", function()
+			harpoon:list():select(9)
+		end)
+
+		-- Toggle previous & next buffers stored within Harpoon list
+		vim.keymap.set("n", "<C-S-P>", function()
+			harpoon:list():prev()
+		end)
+		vim.keymap.set("n", "<C-S-N>", function()
+			harpoon:list():next()
+		end)
+
+		-- basic telescope configuration
+		local conf = require("telescope.config").values
+		local function toggle_telescope(harpoon_files)
+			local file_paths = {}
+			for _, item in ipairs(harpoon_files.items) do
+				table.insert(file_paths, item.value)
+			end
+
+			require("telescope.pickers")
+				.new({}, {
+					prompt_title = "Harpoon",
+					finder = require("telescope.finders").new_table({
+						results = file_paths,
+					}),
+					previewer = conf.file_previewer({}),
+					sorter = conf.generic_sorter({}),
+				})
+				:find()
+		end
+
+		vim.keymap.set("n", "<C-e>", function()
+			toggle_telescope(harpoon:list())
+		end, { desc = "Open harpoon window" })
+	end,
+}

private_dot_config/nvim/lua/thomasgen/lazy/indent_line.lua

···
+return {
+	"lukas-reineke/indent-blankline.nvim",
+	enabled = false,
+	config = function()
+		require("ibl").setup()
+	end
+}

private_dot_config/nvim/lua/thomasgen/lazy/init.lua

···
+return {
+	"theprimeagen/vim-be-good",
+	"nvim-treesitter/nvim-treesitter-context",
+}

private_dot_config/nvim/lua/thomasgen/lazy/linting.lua

···
+return {
+	"mfussenegger/nvim-lint",
+	enabled = false,
+	event = {
+		"BufReadPre",
+		"BufNewFile",
+	},
+	config = function()
+		local lint = require("lint")
+
+		lint.linters_by_ft = {
+			javascript = { "eslint" },
+			typescript = { "eslint" },
+			javascriptreact = { "eslint" },
+			typescriptreact = { "eslint" },
+			svelte = { "eslint" },
+			vue = { "eslint" },
+			python = { "pylint" },
+			astro = { "eslint" },
+		}
+
+		local lint_augroup = vim.api.nvim_create_augroup("lint", { clear = true })
+
+		vim.api.nvim_create_autocmd({ "BufEnter", "BufWritePost", "InsertLeave", "TextChanged" }, {
+			group = lint_augroup,
+			callback = function()
+				lint.try_lint(nil, { ignore_errors = true })
+			end,
+		})
+	end,
+}

private_dot_config/nvim/lua/thomasgen/lazy/lsp.lua

···
+return {
+	-- Main LSP Configuration
+	"neovim/nvim-lspconfig",
+	dependencies = {
+		-- Automatically install LSPs and related tools to stdpath for Neovim
+		{ "williamboman/mason.nvim", config = true }, -- NOTE: Must be loaded before dependants
+		"williamboman/mason-lspconfig.nvim",
+		"WhoIsSethDaniel/mason-tool-installer.nvim",
+
+		-- Useful status updates for LSP.
+		-- NOTE: `opts = {}` is the same as calling `require('fidget').setup({})`
+		{ "j-hui/fidget.nvim", opts = {} },
+
+		-- Allows extra capabilities provided by nvim-cmp
+		"hrsh7th/cmp-nvim-lsp",
+	},
+	config = function()
+		vim.api.nvim_create_autocmd("LspAttach", {
+			group = vim.api.nvim_create_augroup("kickstart-lsp-attach", { clear = true }),
+			callback = function(event)
+				-- NOTE: Remember that Lua is a real programming language, and as such it is possible
+				-- to define small helper and utility functions so you don't have to repeat yourself.
+				--
+				-- In this case, we create a function that lets us more easily define mappings specific
+				-- for LSP related items. It sets the mode, buffer and description for us each time.
+				local map = function(keys, func, desc, mode)
+					mode = mode or "n"
+					vim.keymap.set(mode, keys, func, { buffer = event.buf, desc = "LSP: " .. desc })
+				end
+
+				-- Jump to the definition of the word under your cursor.
+				--  This is where a variable was first declared, or where a function is defined, etc.
+				--  To jump back, press <C-t>.
+				map("gd", require("telescope.builtin").lsp_definitions, "[G]oto [D]efinition")
+
+				map("<leader>lr", ":LspRestart<CR>", "Restart LSP")
+
+				map("K", function()
+					vim.lsp.buf.hover()
+				end, "Show documentation for symbol under cursor")
+
+				map("<leader>rr", function()
+					vim.lsp.buf.references()
+				end, "[R]eferences")
+
+				-- Find references for the word under your cursor.
+				map("gr", require("telescope.builtin").lsp_references, "[G]oto [R]eferences")
+
+				-- Jump to the implementation of the word under your cursor.
+				--  Useful when your language has ways of declaring types without an actual implementation.
+				map("gI", require("telescope.builtin").lsp_implementations, "[G]oto [I]mplementation")
+
+				-- Jump to the type of the word under your cursor.
+				--  Useful when you're not sure what type a variable is and you want to see
+				--  the definition of its *type*, not where it was *defined*.
+				map("<leader>D", require("telescope.builtin").lsp_type_definitions, "Type [D]efinition")
+
+				-- Fuzzy find all the symbols in your current document.
+				--  Symbols are things like variables, functions, types, etc.
+				map("<leader>ds", require("telescope.builtin").lsp_document_symbols, "[D]ocument [S]ymbols")
+
+				-- Fuzzy find all the symbols in your current workspace.
+				--  Similar to document symbols, except searches over your entire project.
+				--map("<leader>ws", require("telescope.builtin").lsp_dynamic_workspace_symbols, "[W]orkspace [S]ymbols")
+
+				-- Rename the variable under your cursor.
+				--  Most Language Servers support renaming across files, etc.
+				map("<leader>rn", function()
+					vim.api.nvim_create_autocmd({ "CmdlineEnter" }, {
+						callback = function()
+							local key = vim.api.nvim_replace_termcodes("<C-f>", true, false, true)
+							vim.api.nvim_feedkeys(key, "c", false)
+							vim.api.nvim_feedkeys("0", "n", false)
+							return true
+						end,
+					})
+					vim.lsp.buf.rename()
+				end, "[R]e[n]ame")
+
+				-- Execute a code action, usually your cursor needs to be on top of an error
+				-- or a suggestion from your LSP for this to activate.
+				map("<leader>ca", vim.lsp.buf.code_action, "[C]ode [A]ction", { "n", "x" })
+
+				-- WARN: This is not Goto Definition, this is Goto Declaration.
+				--  For example, in C this would take you to the header.
+				map("gD", vim.lsp.buf.declaration, "[G]oto [D]eclaration")
+
+				map("<leader>vd", function()
+					vim.diagnostic.open_float()
+				end, "[V]iew [D]iagnostics")
+
+				map("[d", function()
+					vim.diagnostic.goto_prev()
+				end, "Prev Diagnostic")
+				map("]d", function()
+					vim.diagnostic.goto_next()
+				end, "Next Diagnostic")
+
+				-- The following two autocommands are used to highlight references of the
+				-- word under your cursor when your cursor rests there for a little while.
+				--    See `:help CursorHold` for information about when this is executed
+				--
+				-- When you move your cursor, the highlights will be cleared (the second autocommand).
+				local client = vim.lsp.get_client_by_id(event.data.client_id)
+				if client and client.supports_method(vim.lsp.protocol.Methods.textDocument_documentHighlight) then
+					local highlight_augroup = vim.api.nvim_create_augroup("kickstart-lsp-highlight", { clear = false })
+					vim.api.nvim_create_autocmd({ "CursorHold", "CursorHoldI" }, {
+						buffer = event.buf,
+						group = highlight_augroup,
+						callback = vim.lsp.buf.document_highlight,
+					})
+
+					vim.api.nvim_create_autocmd({ "CursorMoved", "CursorMovedI" }, {
+						buffer = event.buf,
+						group = highlight_augroup,
+						callback = vim.lsp.buf.clear_references,
+					})
+
+					vim.api.nvim_create_autocmd("LspDetach", {
+						group = vim.api.nvim_create_augroup("kickstart-lsp-detach", { clear = true }),
+						callback = function(event2)
+							vim.lsp.buf.clear_references()
+							vim.api.nvim_clear_autocmds({ group = "kickstart-lsp-highlight", buffer = event2.buf })
+						end,
+					})
+				end
+
+				-- The following code creates a keymap to toggle inlay hints in your
+				-- code, if the language server you are using supports them
+				--
+				-- This may be unwanted, since they displace some of your code
+				if client and client.supports_method(vim.lsp.protocol.Methods.textDocument_inlayHint) then
+					map("<leader>th", function()
+						vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled({ bufnr = event.buf }))
+					end, "[T]oggle Inlay [H]ints")
+				end
+			end,
+		})
+
+		-- LSP servers and clients are able to communicate to each other what features they support.
+		--  By default, Neovim doesn't support everything that is in the LSP specification.
+		--  When you add nvim-cmp, luasnip, etc. Neovim now has *more* capabilities.
+		--  So, we create new capabilities with nvim cmp, and then broadcast that to the servers.
+		local capabilities = vim.lsp.protocol.make_client_capabilities()
+		capabilities = vim.tbl_deep_extend("force", capabilities, require("cmp_nvim_lsp").default_capabilities())
+
+		local mason_registry = require("mason-registry")
+		local vue_language_server_path = mason_registry.get_package("vue-language-server"):get_install_path()
+			.. "/node_modules/@vue/language-server"
+
+		-- Enable the following language servers
+		--  Feel free to add/remove any LSPs that you want here. They will automatically be installed.
+		--
+		--  Add any additional override configuration in the following tables. Available keys are:
+		--  - cmd (table): Override the default command used to start the server
+		--  - filetypes (table): Override the default list of associated filetypes for the server
+		--  - capabilities (table): Override fields in capabilities. Can be used to disable certain LSP features.
+		--  - settings (table): Override the default settings passed when initializing the server.
+		--        For example, to see the options for `lua_ls`, you could go to: https://luals.github.io/wiki/settings/
+		local servers = {
+			-- clangd = {},
+			-- gopls = {},
+			-- pyright = {},
+			-- rust_analyzer = {},
+			-- ... etc. See `:help lspconfig-all` for a list of all the pre-configured LSPs
+			--
+			-- Some languages (like typescript) have entire language plugins that can be useful:
+			--    https://github.com/pmizio/typescript-tools.nvim
+			--
+			-- But for many setups, the LSP (`tsserver`) will work just fine
+			-- tsserver = {},
+			--
+			--
+			tsserver = {
+				init_options = {
+					plugins = {
+						{
+							-- this happneed to be installed, maybe it does not need to be added manually but if it does not work then try to install it
+							name = "@vue/typescript-plugin",
+							location = vue_language_server_path,
+							languages = { "vue" },
+						},
+					},
+				},
+				filetypes = { "typescript", "javascript", "javascriptreact", "typescriptreact", "vue" },
+				commands = {
+					OrganizeImports = {
+						function()
+							local params = {
+								command = "_typescript.organizeImports",
+								arguments = { vim.api.nvim_buf_get_name(0) },
+								title = "",
+							}
+							vim.lsp.buf.execute_command(params)
+						end,
+						description = "Organize Imports",
+					},
+				},
+			},
+
+			volar = {},
+
+			lua_ls = {
+				-- cmd = {...},
+				-- filetypes = { ...},
+				-- capabilities = {},
+				settings = {
+					Lua = {
+						completion = {
+							callSnippet = "Replace",
+						},
+						diagnostics = {
+							globals = { "vim" },
+						},
+						-- You can toggle below to ignore Lua_LS's noisy `missing-fields` warnings
+						-- diagnostics = { disable = { 'missing-fields' } },
+					},
+				},
+			},
+		}
+
+		-- Ensure the servers and tools above are installed
+		--  To check the current status of installed tools and/or manually install
+		--  other tools, you can run
+		--    :Mason
+		--
+		--  You can press `g?` for help in this menu.
+		require("mason").setup()
+
+		-- You can add other tools here that you want Mason to install
+		-- for you, so that they are available from within Neovim.
+		local ensure_installed = vim.tbl_keys(servers or {})
+		vim.list_extend(ensure_installed, {
+			"stylua", -- Used to format Lua code
+		})
+		require("mason-tool-installer").setup({ ensure_installed = ensure_installed })
+
+		require("mason-lspconfig").setup({
+			handlers = {
+				function(server_name)
+					local server = servers[server_name] or {}
+					-- This handles overriding only values explicitly passed
+					-- by the server configuration above. Useful when disabling
+					-- certain features of an LSP (for example, turning off formatting for tsserver)
+					server.capabilities = vim.tbl_deep_extend("force", {}, capabilities, server.capabilities or {})
+					require("lspconfig")[server_name].setup(server)
+				end,
+			},
+		})
+
+		-- Setup specific LSPs
+
+		-- Styling
+		vim.lsp.handlers["textDocument/hover"] = vim.lsp.with(vim.lsp.handlers.hover, { border = "rounded" })
+
+		vim.lsp.handlers["textDocument/signatureHelp"] =
+			vim.lsp.with(vim.lsp.handlers.signature_help, { border = "rounded" })
+
+		vim.diagnostic.config({
+			-- update_in_insert = true,
+			float = {
+				focusable = false,
+				style = "minimal",
+				border = "rounded",
+				source = "always",
+				header = "",
+				prefix = "",
+			},
+		})
+	end,
+}

private_dot_config/nvim/lua/thomasgen/lazy/lualine.lua

···
+local function setup_macro_refresh(lualine)
+	vim.api.nvim_create_autocmd("RecordingEnter", {
+		callback = function()
+			lualine.refresh({
+				place = { "statusline" },
+			})
+		end,
+	})
+	vim.api.nvim_create_autocmd("RecordingLeave", {
+		callback = function()
+			local timer = vim.loop.new_timer()
+			timer:start(
+				50,
+				0,
+				vim.schedule_wrap(function()
+					lualine.refresh({
+						place = { "statusline" },
+					})
+				end)
+			)
+		end,
+	})
+end
+
+local function macro_recording_status()
+	local function current_status()
+		local register = vim.fn.reg_recording()
+		return register == "" and "" or "RECORDING @" .. register
+	end
+	return { "macro-recording", fmt = current_status }
+end
+
+return {
+	"nvim-lualine/lualine.nvim",
+	event = "VeryLazy",
+	dependencies = {
+		"nvim-tree/nvim-web-devicons",
+	},
+	init = function()
+		vim.opt.laststatus = 0
+	end,
+	config = function()
+		vim.opt.laststatus = 3
+
+		local lualine = require("lualine")
+		setup_macro_refresh(lualine)
+
+		local function heart()
+			return [[♥ ]]
+			--return [[󰋑]]
+		end
+
+		-- custom theme
+		-- local custom_rose_pine = require 'lualine.themes.rose-pine'
+		local p = require("rose-pine.palette")
+		local config = require("rose-pine.config")
+
+		local bg_base = p.base
+		if config.options.styles.transparency then
+			bg_base = "NONE"
+		end
+
+		local custom_rose_pine = {
+			normal = {
+				a = { bg = p.rose, fg = p.base, gui = "bold" },
+				b = { bg = p.overlay, fg = p.rose },
+				c = { bg = p.surface, fg = p.text },
+			},
+			insert = {
+				a = { bg = p.foam, fg = p.base, gui = "bold" },
+				b = { bg = p.overlay, fg = p.foam },
+				--c = { bg = "#252834", fg = p.text },
+			},
+			visual = {
+				a = { bg = p.iris, fg = p.base, gui = "bold" },
+				b = { bg = p.overlay, fg = p.iris },
+				--c = { bg = "#292436", fg = p.text },
+			},
+			replace = {
+				a = { bg = p.pine, fg = p.base, gui = "bold" },
+				b = { bg = p.overlay, fg = p.pine },
+				-- c = { bg = "#1C2231", fg = p.text },
+			},
+			command = {
+				a = { bg = p.love, fg = p.base, gui = "bold" },
+				b = { bg = p.overlay, fg = p.love },
+				-- c = { bg = "#2C1F2E", fg = p.text },
+			},
+			inactive = {
+				a = { bg = bg_base, fg = p.muted, gui = "bold" },
+				b = { bg = bg_base, fg = p.muted },
+				-- c = { bg = bg_base, fg = p.muted },
+			},
+		}
+
+		--- @param trunc_width number trunctates component when screen width is less then trunc_width
+		--- @param trunc_len number truncates component to trunc_len number of chars
+		--- @param hide_width number hides component when window width is smaller then hide_width
+		--- @param no_ellipsis boolean whether to disable adding '...' at end after truncation
+		--- return function that can format the component accordingly
+		local function trunc(trunc_width, trunc_len, hide_width, no_ellipsis)
+			return function(str)
+				local win_width = vim.fn.winwidth(0)
+				if hide_width and win_width < hide_width then
+					return ""
+				elseif trunc_width and trunc_len and win_width < trunc_width and #str > trunc_len then
+					return str:sub(1, trunc_len) .. (no_ellipsis and "" or "...")
+				end
+				return str
+			end
+		end
+
+		lualine.setup({
+			options = {
+				theme = custom_rose_pine,
+				component_separators = "",
+				section_separators = { left = "", right = "" },
+				disabled_filetypes = { "alpha" },
+			},
+			sections = {
+				lualine_a = {
+					{ "mode", separator = { left = "", right = "" }, right_padding = 2 },
+					macro_recording_status(),
+				},
+				lualine_b = {
+					{ "branch", fmt = trunc(1200, 20, nil, false) },
+					"diff",
+					"diagnostics",
+				},
+				lualine_c = { { "filename", path = 1 } },
+				lualine_x = { "filetype" },
+				lualine_y = { "progress" },
+				lualine_z = {
+					{
+						"location",
+						separator = { left = "" },
+						left_padding = 2,
+					},
+					{
+						heart,
+						separator = { right = "" },
+					},
+				},
+			},
+			extensions = { "nvim-tree", "fzf" },
+		})
+	end,
+}

private_dot_config/nvim/lua/thomasgen/lazy/marks.lua

···
+return {
+	"chentoast/marks.nvim",
+	event = "VeryLazy",
+	opts = {},
+}

private_dot_config/nvim/lua/thomasgen/lazy/matchup.lua

···
+return {
+	'andymass/vim-matchup',
+}

private_dot_config/nvim/lua/thomasgen/lazy/mini.lua

···
+return {
+	"echasnovski/mini.nvim",
+	version = false,
+	config = function()
+		require("mini.ai").setup({
+			-- Table with textobject id as fields, textobject specification as values.
+			-- Also use this to disable builtin textobjects. See |MiniAi.config|.
+			custom_textobjects = nil,
+
+			-- Module mappings. Use `''` (empty string) to disable one.
+			mappings = {
+				-- Main textobject prefixes
+				around = "a",
+				inside = "i",
+
+				-- Next/last variants
+				around_next = "an",
+				inside_next = "in",
+				around_last = "al",
+				inside_last = "il",
+
+				-- Move cursor to corresponding edge of `a` textobject
+				goto_left = "g[",
+				goto_right = "g]",
+			},
+
+			-- Number of lines within which textobject is searched
+			n_lines = 1000,
+
+			-- How to search for object (first inside current line, then inside
+			-- neighborhood). One of 'cover', 'cover_or_next', 'cover_or_prev',
+			-- 'cover_or_nearest', 'next', 'previous', 'nearest'.
+			search_method = "cover_or_next",
+
+			-- Whether to disable showing non-error feedback
+			-- This also affects (purely informational) helper messages shown after
+			-- idle time if user input is required.
+			silent = false,
+		})
+
+		require("mini.surround").setup(
+			-- No need to copy this inside `setup()`. Will be used automatically.
+			{
+				-- Add custom surroundings to be used on top of builtin ones. For more
+				-- information with examples, see `:h MiniSurround.config`.
+				custom_surroundings = nil,
+
+				-- Duration (in ms) of highlight when calling `MiniSurround.highlight()`
+				highlight_duration = 500,
+
+				-- Module mappings. Use `''` (empty string) to disable one.
+				mappings = {
+					add = "sa", -- Add surrounding in Normal and Visual modes
+					delete = "sd", -- Delete surrounding
+					find = "sf", -- Find surrounding (to the right)
+					find_left = "sF", -- Find surrounding (to the left)
+					highlight = "sh", -- Highlight surrounding
+					replace = "sr", -- Replace surrounding
+					update_n_lines = "sn", -- Update `n_lines`
+
+					suffix_last = "l", -- Suffix to search with "prev" method
+					suffix_next = "n", -- Suffix to search with "next" method
+				},
+
+				-- Number of lines within which surrounding is searched
+				n_lines = 1000,
+
+				-- Whether to respect selection type:
+				-- - Place surroundings on separate lines in linewise mode.
+				-- - Place surroundings on each line in blockwise mode.
+				respect_selection_type = false,
+
+				-- How to search for surrounding (first inside current line, then inside
+				-- neighborhood). One of 'cover', 'cover_or_next', 'cover_or_prev',
+				-- 'cover_or_nearest', 'next', 'prev', 'nearest'. For more details,
+				-- see `:h MiniSurround.config`.
+				search_method = "cover",
+
+				-- Whether to disable showing non-error feedback
+				-- This also affects (purely informational) helper messages shown after
+				-- idle time if user input is required.
+				silent = false,
+			}
+		)
+
+		require("mini.pairs").setup({
+			-- In which modes mappings from this `config` should be created
+			modes = { insert = true, command = false, terminal = false },
+
+			-- Global mappings. Each right hand side should be a pair information, a
+			-- table with at least these fields (see more in |MiniPairs.map|):
+			-- - <action> - one of 'open', 'close', 'closeopen'.
+			-- - <pair> - two character string for pair to be used.
+			-- By default pair is not inserted after `\`, quotes are not recognized by
+			-- `<CR>`, `'` does not insert pair after a letter.
+			-- Only parts of tables can be tweaked (others will use these defaults).
+			mappings = {
+				["("] = { action = "open", pair = "()", neigh_pattern = "[^\\]." },
+				["["] = { action = "open", pair = "[]", neigh_pattern = "[^\\]." },
+				["{"] = { action = "open", pair = "{}", neigh_pattern = "[^\\]." },
+				["<"] = { action = "open", pair = "<>", neigh_pattern = "[^\\]." },
+
+				[")"] = { action = "close", pair = "()", neigh_pattern = "[^\\]." },
+				["]"] = { action = "close", pair = "[]", neigh_pattern = "[^\\]." },
+				["}"] = { action = "close", pair = "{}", neigh_pattern = "[^\\]." },
+				[">"] = { action = "close", pair = "<>", neigh_pattern = "[^\\]." },
+
+				['"'] = { action = "closeopen", pair = '""', neigh_pattern = "[^\\].", register = { cr = false } },
+				["'"] = { action = "closeopen", pair = "''", neigh_pattern = "[^%a\\].", register = { cr = false } },
+				["`"] = { action = "closeopen", pair = "``", neigh_pattern = "[^\\].", register = { cr = false } },
+			},
+		})
+
+		require("mini.comment").setup({
+			-- Options which control module behavior
+			options = {
+				-- Function to compute custom 'commentstring' (optional)
+				custom_commentstring = nil,
+
+				-- Whether to ignore blank lines when commenting
+				ignore_blank_line = false,
+
+				-- Whether to recognize as comment only lines without indent
+				start_of_line = false,
+
+				-- Whether to force single space inner padding for comment parts
+				pad_comment_parts = true,
+			},
+
+			-- Module mappings. Use `''` (empty string) to disable one.
+			mappings = {
+				-- Toggle comment (like `gcip` - comment inner paragraph) for both
+				-- Normal and Visual modes
+				comment = "gc",
+
+				-- Toggle comment on current line
+				comment_line = "gcc",
+
+				-- Toggle comment on visual selection
+				comment_visual = "gc",
+
+				-- Define 'comment' textobject (like `dgc` - delete whole comment block)
+				-- Works also in Visual mode if mapping differs from `comment_visual`
+				textobject = "gc",
+			},
+
+			-- Hook functions to be executed at certain stage of commenting
+			hooks = {
+				-- Before successful commenting. Does nothing by default.
+				pre = function() end,
+				-- After successful commenting. Does nothing by default.
+				post = function() end,
+			},
+		})
+
+		local miniclue = require("mini.clue")
+		miniclue.setup({
+			triggers = {
+				-- Leader triggers
+				{ mode = "n", keys = "<Leader>" },
+				{ mode = "x", keys = "<Leader>" },
+
+				-- Built-in completion
+				{ mode = "i", keys = "<C-x>" },
+
+				-- `g` key
+				{ mode = "n", keys = "g" },
+				{ mode = "x", keys = "g" },
+
+				-- Marks
+				{ mode = "n", keys = "'" },
+				{ mode = "n", keys = "`" },
+				{ mode = "x", keys = "'" },
+				{ mode = "x", keys = "`" },
+
+				-- Registers
+				{ mode = "n", keys = '"' },
+				{ mode = "x", keys = '"' },
+				{ mode = "i", keys = "<C-r>" },
+				{ mode = "c", keys = "<C-r>" },
+
+				-- Window commands
+				{ mode = "n", keys = "<C-w>" },
+
+				-- `z` key
+				{ mode = "n", keys = "z" },
+				{ mode = "x", keys = "z" },
+			},
+
+			clues = {
+				-- Enhance this by adding descriptions for <Leader> mapping groups
+				miniclue.gen_clues.builtin_completion(),
+				miniclue.gen_clues.g(),
+				miniclue.gen_clues.marks(),
+				miniclue.gen_clues.registers(),
+				miniclue.gen_clues.windows(),
+				miniclue.gen_clues.z(),
+			},
+		})
+
+		-- local starter = require("mini.starter")
+		-- starter.setup({
+		-- 	evaluate_single = true,
+		-- 	header = "hi",
+		-- 	items = {
+		-- 		starter.sections.builtin_actions(),
+		-- 		starter.sections.telescope(),
+		-- 		starter.sections.sessions(5, true),
+		-- 	},
+		-- })
+
+		-- local sessions = require("mini.sessions")
+		-- sessions.setup({
+		-- 	autoread = true,
+		-- })
+
+		require("mini.move").setup({
+			-- Module mappings. Use `''` (empty string) to disable one.
+			mappings = {
+				-- Move visual selection in Visual mode. Defaults are Alt (Meta) + hjkl.
+				left = "<M-left>",
+				right = "<M-right>",
+				down = "<M-down>",
+				up = "<M-up>",
+
+				-- Move current line in Normal mode
+				line_left = "<M-left>",
+				line_right = "<M-right>",
+				line_down = "<M-down>",
+				line_up = "<M-up>",
+			},
+
+			-- Options which control moving behavior
+			options = {
+				-- Automatically reindent selection during linewise vertical move
+				reindent_linewise = true,
+			},
+		})
+	end,
+}

private_dot_config/nvim/lua/thomasgen/lazy/multicursor.lua

···
+return {
+	"jake-stewart/multicursor.nvim",
+	branch = "1.0",
+	enabled = true,
+	config = function()
+		local mc = require("multicursor-nvim")
+
+		mc.setup()
+
+		-- Add cursors above/below the main cursor.
+		vim.keymap.set({ "n", "v" }, "<C-up>", function()
+			mc.addCursor("k")
+		end)
+		vim.keymap.set({ "n", "v" }, "<C-down>", function()
+			mc.addCursor("j")
+		end)
+
+		-- Add a cursor and jump to the next word under cursor.
+		vim.keymap.set({ "n", "v" }, "<c-n>", function()
+			mc.addCursor("*")
+		end)
+
+		-- Jump to the next word under cursor but do not add a cursor.
+		vim.keymap.set({ "n", "v" }, "<c-s>", function()
+			mc.skipCursor("*")
+		end)
+
+		-- Rotate the main cursor.
+		vim.keymap.set({ "n", "v" }, "<C-left>", mc.nextCursor)
+		vim.keymap.set({ "n", "v" }, "<C-right>", mc.prevCursor)
+
+		-- Delete the main cursor.
+		vim.keymap.set({ "n", "v" }, "<leader>x", mc.deleteCursor)
+
+		-- Add and remove cursors with control + left click.
+		vim.keymap.set("n", "<c-leftmouse>", mc.handleMouse)
+
+		vim.keymap.set({ "n", "v" }, "<c-q>", function()
+			if mc.cursorsEnabled() then
+				-- Stop other cursors from moving.
+				-- This allows you to reposition the main cursor.
+				mc.disableCursors()
+			else
+				mc.addCursor()
+			end
+		end)
+
+		vim.keymap.set("n", "<esc>", function()
+			if not mc.cursorsEnabled() then
+				mc.enableCursors()
+			elseif mc.hasCursors() then
+				mc.clearCursors()
+			else
+				-- Default <esc> handler.
+			end
+		end)
+
+		-- Align cursor columns.
+		-- vim.keymap.set("n", "<leader>a", mc.alignCursors)
+
+		-- Split visual selections by regex.
+		vim.keymap.set("v", "S", mc.splitCursors)
+
+		-- Append/insert for each line of visual selections.
+		vim.keymap.set("v", "I", mc.insertVisual)
+		vim.keymap.set("v", "A", mc.appendVisual)
+
+		-- match new cursors within visual selections by regex.
+		vim.keymap.set("v", "M", mc.matchCursors)
+
+		-- Rotate visual selection contents.
+		vim.keymap.set("v", "<leader>t", function()
+			mc.transposeCursors(1)
+		end)
+		vim.keymap.set("v", "<leader>T", function()
+			mc.transposeCursors(-1)
+		end)
+
+		-- Customize how cursors look.
+		vim.api.nvim_set_hl(0, "MultiCursorCursor", { link = "Cursor" })
+		vim.api.nvim_set_hl(0, "MultiCursorVisual", { link = "Visual" })
+		vim.api.nvim_set_hl(0, "MultiCursorDisabledCursor", { link = "Visual" })
+		vim.api.nvim_set_hl(0, "MultiCursorDisabledVisual", { link = "Visual" })
+	end,
+}

private_dot_config/nvim/lua/thomasgen/lazy/oil.lua

···
+return {
+	"stevearc/oil.nvim",
+	---@module 'oil'
+	---@type oil.SetupOpts
+	opts = {
+		-- Oil will take over directory buffers (e.g. `vim .` or `:e src/`)
+		-- Set to false if you want some other plugin (e.g. netrw) to open when you edit directories.
+		default_file_explorer = true,
+		-- Id is automatically added at the beginning, and name at the end
+		-- See :help oil-columns
+		columns = {
+			"icon",
+			-- "permissions",
+			-- "size",
+			-- "mtime",
+		},
+		-- Buffer-local options to use for oil buffers
+		buf_options = {
+			buflisted = false,
+			bufhidden = "hide",
+		},
+		-- Window-local options to use for oil buffers
+		win_options = {
+			wrap = false,
+			signcolumn = "no",
+			cursorcolumn = false,
+			foldcolumn = "0",
+			spell = false,
+			list = false,
+			conceallevel = 3,
+			concealcursor = "nvic",
+		},
+		-- Send deleted files to the trash instead of permanently deleting them (:help oil-trash)
+		delete_to_trash = false,
+		-- Skip the confirmation popup for simple operations (:help oil.skip_confirm_for_simple_edits)
+		skip_confirm_for_simple_edits = false,
+		-- Selecting a new/moved/renamed file or directory will prompt you to save changes first
+		-- (:help prompt_save_on_select_new_entry)
+		prompt_save_on_select_new_entry = true,
+		-- Oil will automatically delete hidden buffers after this delay
+		-- You can set the delay to false to disable cleanup entirely
+		-- Note that the cleanup process only starts when none of the oil buffers are currently displayed
+		cleanup_delay_ms = 2000,
+		lsp_file_methods = {
+			-- Enable or disable LSP file operations
+			enabled = true,
+			-- Time to wait for LSP file operations to complete before skipping
+			timeout_ms = 1000,
+			-- Set to true to autosave buffers that are updated with LSP willRenameFiles
+			-- Set to "unmodified" to only save unmodified buffers
+			autosave_changes = false,
+		},
+		-- Constrain the cursor to the editable parts of the oil buffer
+		-- Set to `false` to disable, or "name" to keep it on the file names
+		constrain_cursor = "editable",
+		-- Set to true to watch the filesystem for changes and reload oil
+		watch_for_changes = true,
+		-- Keymaps in oil buffer. Can be any value that `vim.keymap.set` accepts OR a table of keymap
+		-- options with a `callback` (e.g. { callback = function() ... end, desc = "", mode = "n" })
+		-- Additionally, if it is a string that matches "actions.<name>",
+		-- it will use the mapping at require("oil.actions").<name>
+		-- Set to `false` to remove a keymap
+		-- See :help oil-actions for a list of all available actions
+		keymaps = {
+			["g?"] = "actions.show_help",
+			["<CR>"] = "actions.select",
+			["<C-s>"] = { "actions.select", opts = { vertical = true }, desc = "Open the entry in a vertical split" },
+			["<C-h>"] = {
+				"actions.select",
+				opts = { horizontal = true },
+				desc = "Open the entry in a horizontal split",
+			},
+			["<C-t>"] = { "actions.select", opts = { tab = true }, desc = "Open the entry in new tab" },
+			["<C-p>"] = "actions.preview",
+			["<C-c>"] = "actions.close",
+			["<C-l>"] = "actions.refresh",
+			["-"] = "actions.parent",
+			["_"] = "actions.open_cwd",
+			["`"] = "actions.cd",
+			["~"] = { "actions.cd", opts = { scope = "tab" }, desc = ":tcd to the current oil directory", mode = "n" },
+			["gs"] = "actions.change_sort",
+			["gx"] = "actions.open_external",
+			["g."] = "actions.toggle_hidden",
+			["g\\"] = "actions.toggle_trash",
+		},
+		-- Set to false to disable all of the above keymaps
+		use_default_keymaps = true,
+		view_options = {
+			-- Show files and directories that start with "."
+			show_hidden = false,
+			-- This function defines what is considered a "hidden" file
+			is_hidden_file = function(name, bufnr)
+				local m = name:match("^%.")
+				return m ~= nil
+			end,
+			-- This function defines what will never be shown, even when `show_hidden` is set
+			is_always_hidden = function(name, bufnr)
+				return false
+			end,
+			-- Sort file names with numbers in a more intuitive order for humans.
+			-- Can be "fast", true, or false. "fast" will turn it off for large directories.
+			natural_order = "fast",
+			-- Sort file and directory names case insensitive
+			case_insensitive = false,
+			sort = {
+				-- sort order can be "asc" or "desc"
+				-- see :help oil-columns to see which columns are sortable
+				{ "type", "asc" },
+				{ "name", "asc" },
+			},
+		},
+		-- Extra arguments to pass to SCP when moving/copying files over SSH
+		extra_scp_args = {},
+		-- EXPERIMENTAL support for performing file operations with git
+		git = {
+			-- Return true to automatically git add/mv/rm files
+			add = function(path)
+				return false
+			end,
+			mv = function(src_path, dest_path)
+				return false
+			end,
+			rm = function(path)
+				return false
+			end,
+		},
+		-- Configuration for the floating window in oil.open_float
+		float = {
+			-- Padding around the floating window
+			padding = 2,
+			max_width = 0,
+			max_height = 0,
+			border = "rounded",
+			win_options = {
+				winblend = 0,
+			},
+			-- optionally override the oil buffers window title with custom function: fun(winid: integer): string
+			get_win_title = nil,
+			-- preview_split: Split direction: "auto", "left", "right", "above", "below".
+			preview_split = "auto",
+			-- This is the config that will be passed to nvim_open_win.
+			-- Change values here to customize the layout
+			override = function(conf)
+				return conf
+			end,
+		},
+		-- Configuration for the file preview window
+		preview_win = {
+			-- Whether the preview window is automatically updated when the cursor is moved
+			update_on_cursor_moved = true,
+			-- How to open the preview window "load"|"scratch"|"fast_scratch"
+			preview_method = "fast_scratch",
+			-- A function that returns true to disable preview on a file e.g. to avoid lag
+			disable_preview = function(filename)
+				return false
+			end,
+			-- Window-local options to use for preview window buffers
+			win_options = {},
+		},
+		-- Configuration for the floating action confirmation window
+		confirmation = {
+			-- Width dimensions can be integers or a float between 0 and 1 (e.g. 0.4 for 40%)
+			-- min_width and max_width can be a single value or a list of mixed integer/float types.
+			-- max_width = {100, 0.8} means "the lesser of 100 columns or 80% of total"
+			max_width = 0.9,
+			-- min_width = {40, 0.4} means "the greater of 40 columns or 40% of total"
+			min_width = { 40, 0.4 },
+			-- optionally define an integer/float for the exact width of the preview window
+			width = nil,
+			-- Height dimensions can be integers or a float between 0 and 1 (e.g. 0.4 for 40%)
+			-- min_height and max_height can be a single value or a list of mixed integer/float types.
+			-- max_height = {80, 0.9} means "the lesser of 80 columns or 90% of total"
+			max_height = 0.9,
+			-- min_height = {5, 0.1} means "the greater of 5 columns or 10% of total"
+			min_height = { 5, 0.1 },
+			-- optionally define an integer/float for the exact height of the preview window
+			height = nil,
+			border = "rounded",
+			win_options = {
+				winblend = 0,
+			},
+		},
+		-- Configuration for the floating progress window
+		progress = {
+			max_width = 0.9,
+			min_width = { 40, 0.4 },
+			width = nil,
+			max_height = { 10, 0.9 },
+			min_height = { 5, 0.1 },
+			height = nil,
+			border = "rounded",
+			minimized_border = "none",
+			win_options = {
+				winblend = 0,
+			},
+		},
+		-- Configuration for the floating SSH window
+		ssh = {
+			border = "rounded",
+		},
+		-- Configuration for the floating keymaps help window
+		keymaps_help = {
+			border = "rounded",
+		},
+	},
+	-- Optional dependencies
+	dependencies = { { "echasnovski/mini.icons", opts = {} } },
+	-- dependencies = { "nvim-tree/nvim-web-devicons" }, -- use if prefer nvim-web-devicons
+}

private_dot_config/nvim/lua/thomasgen/lazy/smooth-scroll.lua

···
+return {
+	'karb94/neoscroll.nvim',
+	enabled = false,
+	config = function()
+		require("neoscroll").setup()
+	end
+}

private_dot_config/nvim/lua/thomasgen/lazy/snacks.lua

···
+return {
+	"folke/snacks.nvim",
+	priority = 1000,
+	lazy = false,
+	opts = {
+		-- your configuration comes here
+		-- or leave it empty to use the default settings
+		-- refer to the configuration section below
+		bigfile = { enabled = true },
+		notifier = { enabled = true },
+		quickfile = { enabled = true },
+		statuscolumn = { enabled = true },
+		words = { enabled = true },
+	},
+	keys = {
+		{
+			"<leader>.",
+			function()
+				Snacks.scratch()
+			end,
+			desc = "Toggle Scratch Buffer",
+		},
+		{
+			"<leader>S",
+			function()
+				Snacks.scratch.select()
+			end,
+			desc = "Select Scratch Buffer",
+		},
+		{
+			"<leader>n",
+			function()
+				Snacks.notifier.show_history()
+			end,
+			desc = "Notification History",
+		},
+
+		{
+			"<leader>gB",
+			function()
+				Snacks.gitbrowse()
+			end,
+			desc = "Git Browse",
+		},
+		{
+			"<leader>gb",
+			function()
+				Snacks.git.blame_line()
+			end,
+			desc = "Git Blame Line",
+		},
+		{
+			"<leader>gf",
+			function()
+				Snacks.lazygit.log_file()
+			end,
+			desc = "Lazygit Current File History",
+		},
+		{
+			"<leader>lg",
+			function()
+				Snacks.lazygit()
+			end,
+			desc = "Lazygit",
+		},
+		{
+			"<leader>gl",
+			function()
+				Snacks.lazygit.log()
+			end,
+			desc = "Lazygit Log (cwd)",
+		},
+		{
+			"<leader>dn",
+			function()
+				Snacks.notifier.hide()
+			end,
+			desc = "Dismiss All Notifications",
+		},
+		{
+			"<c-/>",
+			function()
+				Snacks.terminal()
+			end,
+			desc = "Toggle Terminal",
+		},
+		{
+			"<c-_>",
+			function()
+				Snacks.terminal()
+			end,
+			desc = "which_key_ignore",
+		},
+		{
+			"]]",
+			function()
+				Snacks.words.jump(vim.v.count1)
+			end,
+			desc = "Next Reference",
+			mode = { "n", "t" },
+		},
+		{
+			"[[",
+			function()
+				Snacks.words.jump(-vim.v.count1)
+			end,
+			desc = "Prev Reference",
+			mode = { "n", "t" },
+		},
+		{
+			"<leader>N",
+			desc = "Neovim News",
+			function()
+				Snacks.win({
+					file = vim.api.nvim_get_runtime_file("doc/news.txt", false)[1],
+					width = 0.6,
+					height = 0.6,
+					wo = {
+						spell = false,
+						wrap = false,
+						signcolumn = "yes",
+						statuscolumn = " ",
+						conceallevel = 3,
+					},
+				})
+			end,
+		},
+	},
+}

private_dot_config/nvim/lua/thomasgen/lazy/sourcegraph.lua

···
+-- Use your favorite package manager to install, for example in lazy.nvim
+--  Optionally, you can also install nvim-telescope/telescope.nvim to use some search functionality.
+return {
+  {
+		--enabled:
+    "sourcegraph/sg.nvim",
+    dependencies = { "nvim-lua/plenary.nvim", --[[ "nvim-telescope/telescope.nvim ]] },
+		enabled = false,
+		config = function()
+			require("sg").setup()
+		end,
+  },
+}

private_dot_config/nvim/lua/thomasgen/lazy/spectre.lua

···
+return {
+	'nvim-pack/nvim-spectre',
+	enabled = false,
+	config = function()
+		vim.keymap.set('n', '<leader>ss', '<cmd>lua require("spectre").toggle()<CR>', {
+			desc = "Toggle Spectre"
+		})
+		vim.keymap.set('n', '<leader>sw', '<cmd>lua require("spectre").open_visual({select_word=true})<CR>', {
+			desc = "Search current word"
+		})
+		vim.keymap.set('v', '<leader>sw', '<esc><cmd>lua require("spectre").open_visual()<CR>', {
+			desc = "Search current word"
+		})
+		vim.keymap.set('n', '<leader>sp', '<cmd>lua require("spectre").open_file_search({select_word=true})<CR>', {
+			desc = "Search on current file"
+		})
+	end
+}

private_dot_config/nvim/lua/thomasgen/lazy/suda.lua

···
+return {
+	'lambdalisue/vim-suda'
+}

private_dot_config/nvim/lua/thomasgen/lazy/supermaven.lua

···
+return {
+	'supermaven-inc/supermaven-nvim',
+	enabled = false,
+	config = function()
+		require('supermaven-nvim').setup({})
+	end
+}

private_dot_config/nvim/lua/thomasgen/lazy/telescope.lua

···
+return {
+	"nvim-telescope/telescope.nvim",
+
+	tag = "0.1.6",
+
+	dependencies = {
+		"nvim-lua/plenary.nvim",
+	},
+
+	config = function()
+		require("telescope").setup({
+			pickers = {
+				find_files = { hidden = true },
+			},
+		})
+
+		local builtin = require("telescope.builtin")
+		vim.keymap.set("n", "<leader>t", ":Telescope<CR>", {})
+		vim.keymap.set("n", "<leader>pf", builtin.find_files, { desc = "Find [F]iles" })
+		vim.keymap.set("n", "<leader>pg", builtin.git_files, { desc = "Find [G]it Files" })
+		vim.keymap.set("n", "<leader>pws", function()
+			local word = vim.fn.expand("<cword>")
+			builtin.grep_string({ search = word })
+		end)
+
+		vim.keymap.set("n", "<leader>pWs", function()
+			local word = vim.fn.expand("<cWORD>")
+			builtin.grep_string({ search = word })
+		end)
+
+		-- Project search
+		vim.keymap.set("n", "<leader>ps", function()
+			-- builtin.live_grep()
+			builtin.grep_string({ search = vim.fn.input("Grep > ") })
+		end, { desc = "[P]roject [S]earch" })
+
+		-- Project search (live grep)
+		vim.keymap.set("n", "<leader>plg", function()
+			builtin.live_grep()
+		end, { desc = "[P]roject [L]ive [G]rep" })
+
+		-- Project search with regex
+		vim.keymap.set("n", "<leader>pR", function()
+			builtin.grep_string({ search = vim.fn.input("Grep > "), use_regex = true })
+		end, { desc = "Project [R]egex Search" })
+
+		-- Local search
+		vim.keymap.set("n", "<leader>ls", function()
+			builtin.grep_string({ search = vim.fn.input("Grep > "), search_dirs = { vim.fn.expand("%:p") } })
+		end, { desc = "[L]ocal [S]earch" })
+
+		vim.keymap.set("n", "<leader>vh", builtin.help_tags, {})
+
+		-- Resume
+		vim.keymap.set("n", "<leader>pr", builtin.resume, {})
+
+		vim.keymap.set("n", "<leader>ch", builtin.command_history, { desc = "[C]ommand [H]istory" })
+		vim.keymap.set("n", "<leader>cc", builtin.commands, { desc = "[C]ommands" })
+	end,
+}

private_dot_config/nvim/lua/thomasgen/lazy/treesitter.lua

···
+return {
+	"nvim-treesitter/nvim-treesitter",
+	build = ":TSUpdate",
+	config = function()
+		require("nvim-treesitter.configs").setup({
+			-- A list of parser names, or "all"
+			ensure_installed = {
+				"vimdoc",
+				"javascript",
+				"typescript",
+				"c",
+				"lua",
+				"rust",
+				"jsdoc",
+				"bash",
+				"svelte",
+				"astro",
+				"vue",
+				"css",
+			},
+
+			-- Install parsers synchronously (only applied to `ensure_installed`)
+			sync_install = false,
+
+			-- Automatically install missing parsers when entering buffer
+			-- Recommendation: set to false if you don"t have `tree-sitter` CLI installed locally
+			auto_install = true,
+
+			indent = {
+				enable = true,
+			},
+
+			highlight = {
+				-- `false` will disable the whole extension
+				enable = true,
+
+				-- Setting this to true will run `:h syntax` and tree-sitter at the same time.
+				-- Set this to `true` if you depend on "syntax" being enabled (like for indentation).
+				-- Using this option may slow down your editor, and you may see some duplicate highlights.
+				-- Instead of true it can also be a list of languages
+				additional_vim_regex_highlighting = { "markdown" },
+			},
+		})
+
+		local treesitter_parser_config = require("nvim-treesitter.parsers").get_parser_configs()
+		treesitter_parser_config.templ = {
+			install_info = {
+				url = "https://github.com/vrischmann/tree-sitter-templ.git",
+				files = { "src/parser.c", "src/scanner.c" },
+				branch = "master",
+			},
+		}
+
+		vim.treesitter.language.register("templ", "templ")
+
+		vim.filetype.add({
+			extension = {
+				mdx = "mdx",
+			},
+		})
+
+		vim.treesitter.language.register("markdown", "mdx")
+	end,
+}

private_dot_config/nvim/lua/thomasgen/lazy/undotree.lua

···
+return {
+    "mbbill/undotree",
+
+    config = function()
+        vim.keymap.set("n", "<leader>u", vim.cmd.UndotreeToggle)
+    end
+}

private_dot_config/nvim/lua/thomasgen/lazy_init.lua

···
+local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
+if not vim.loop.fs_stat(lazypath) then
+  vim.fn.system({
+    "git",
+    "clone",
+    "--filter=blob:none",
+    "https://github.com/folke/lazy.nvim.git",
+    "--branch=stable", -- latest stable release
+    lazypath,
+  })
+end
+vim.opt.rtp:prepend(lazypath)
+
+require("lazy").setup({
+    spec = "thomasgen.lazy",
+    change_detection = { notify = false }
+})
+

private_dot_config/nvim/lua/thomasgen/remap.lua

···
+local map = function(keys, func, desc, mode)
+	mode = mode or "n"
+	vim.keymap.set(mode, keys, func, { desc = desc })
+end
+
+vim.g.mapleader = " "
+
+-- Project view
+map("<leader>pv", ":Oil<CR>", "Open Oil file explorer")
+
+-- Move lines around
+map("J", ":m '>+1<CR>gv=gv", "Move line down", "v")
+map("<S-Down>", ":m '>+1<CR>gv=gv", "Move line down", "v")
+map("K", ":m '<-2<CR>gv=gv", "Move line up", "v")
+map("<S-Up>", ":m '<-2<CR>gv=gv", "Move line up", "v")
+
+-- Keep cursor in center throughout operations
+map("J", "mzJ`z", "Join lines and keep cursor")
+map("<C-d>", "<C-d>zz", "Scroll down and center")
+map("<C-u>", "<C-u>zz", "Scroll up and center")
+map("n", "nzzzv", "Next search result and center")
+map("N", "Nzzzv", "Previous search result and center")
+
+-- Clipboard operations
+map("<leader>p", '"_dP', "Paste without updating register", "x")
+map("<leader>pc", '"+p', "Paste from system clipboard")
+map("<leader>y", '"+y', "Yank to system clipboard")
+map("<leader>y", '"+y', "Yank to system clipboard", "v")
+map("<leader>Y", '"+Y', "Yank line to system clipboard")
+map("<C-v>", '<Esc>"+pa', "Paste from system clipboard", "i")
+
+-- Delete without register
+map("<leader>d", '"_d', "Delete without updating register")
+map("<leader>d", '"_d', "Delete without updating register", "v")
+
+-- Disable Q
+map("Q", "<nop>", "Disable Q")
+
+-- Formatting
+map("<leader>f", function()
+	vim.cmd("Format")
+	vim.notify("Formatted file", vim.log.levels.INFO, { title = "Formatting" })
+end, "Format file")
+map("<leader>ef", function()
+	vim.cmd("FormatEnable")
+	vim.notify("Enabled auto-format", vim.log.levels.INFO, { title = "Formatting" })
+end, "Enable auto-format")
+map("<leader>df", function()
+	vim.cmd("FormatDisable")
+	vim.notify("Disabled auto-format", vim.log.levels.INFO, { title = "Formatting" })
+end, "Disable auto-format")
+
+-- map("<leader>l", function()
+-- 	local lint = require("lint")
+-- 	lint.try_lint()
+-- end, "Lint file")
+
+map("<leader>esf", function()
+	vim.cmd("EslintFixAll")
+end, "Fix ESLint issues")
+
+-- Window management
+map("<leader>ws", "<C-w>s", "Split window horizontally")
+map("<leader>wv", "<C-w>v", "Split window vertically")
+map("<leader>wh", "<C-w>h", "Move to left window")
+map("<leader>w<Left>", "<C-w>h", "Move to left window")
+map("<leader>wj", "<C-w>j", "Move to bottom window")
+map("<leader>w<Down>", "<C-w>j", "Move to bottom window")
+map("<leader>wk", "<C-w>k", "Move to top window")
+map("<leader>w<Up>", "<C-w>k", "Move to top window")
+map("<leader>wl", "<C-w>l", "Move to right window")
+map("<leader>w<Right>", "<C-w>l", "Move to right window")
+map("<leader>wq", "<C-w>q", "Close window")
+map("<leader>wf", "<C-w>f <C-w>L", "Open file under cursor in new window")
+
+-- Buffer operations
+map("<leader>rf", ":e<CR>", "Refresh buffer")
+map("<leader>sf", ":w<CR>", "Save file")
+
+-- Terminal
+map("<Esc>", [[<C-\><C-n>]], "Exit terminal insert mode", "t")
+
+-- Close quickfix menu after selecting choice
+vim.api.nvim_create_autocmd("FileType", {
+	pattern = { "qf" },
+	command = [[nnoremap <buffer> <CR> <CR>:cclose<CR>]],
+})

private_dot_config/nvim/lua/thomasgen/set.lua

···
+vim.opt.nu = true
+vim.opt.relativenumber = true
+
+vim.opt.tabstop = 2
+vim.opt.softtabstop = 2
+vim.opt.shiftwidth = 2
+
+vim.opt.expandtab = false
+
+vim.opt.smartindent = true
+
+vim.opt.swapfile = false
+vim.opt.backup = false
+vim.opt.undodir = os.getenv("HOME") .. "/.vim/undodir"
+vim.opt.undofile = true
+
+vim.opt.hlsearch = false
+vim.opt.incsearch = true
+
+vim.opt.termguicolors = true
+
+vim.opt.scrolloff = 8
+
+vim.opt.updatetime = 50
+
+vim.opt.ignorecase = true
+vim.opt.smartcase = true
+
+-- vim.opt.colorcolumn = "80"
+
+vim.opt.inccommand = "nosplit"
+
+vim.opt.cursorline = true