Merge commit '9489548bca74468976436df44134e4aeb40e8548'

4 files changed, 926 insertions, 559 deletions

diff --git a/.config/nvim/lua/user/keys.lua b/.config/nvim/lua/user/keys.lua
index 36f7fbd..ebafd21 100644
--- a/.config/nvim/lua/user/keys.lua
+++ b/.config/nvim/lua/user/keys.lua
@@ -1,5 +1,3 @@
---[[ key.lua ]]
-------------- Shorten Function Names --------------
 local keymap = vim.keymap
 local map = function(mode, l, r, opts)
   opts = opts or {}
@@ -8,14 +6,13 @@ local map = function(mode, l, r, opts)
   keymap.set(mode, l, r, opts)
 end
 local term_opts = { noremap = true, silent = false }
+local bufnr = vim.api.nvim_get_current_buf()
 
---------------- Standard Operations ---------------
 -- Semi-colon as leader key
-vim.g.mapleader = ";"
+vim.g.mapleader = ';'
 
 -- "jk" and "kj" to exit insert-mode
-map("i", "jk", "<esc>")
-map("i", "kj", "<esc>")
+map('i', 'jk', '<esc>')
 
 -- Jump to next match on line using `.` instead of `;` NOTE: commented out in favour of "ggandor/flit.nvim"
 --map("n", ".", ";")
@@ -24,205 +21,181 @@ map("i", "kj", "<esc>")
 --map("n", "<Space>", ".")
 
 -- Reload nvim config
-map(
-  "n",
-  "<leader><CR>",
-  "<cmd>luafile ~/.config/nvim/init.lua<CR> | :echom ('Nvim config loading...') | :sl! | echo ('')<CR>"
-)
+map('n', '<leader><CR>', "<cmd>luafile ~/.config/nvim/init.lua<CR> | :echom ('Nvim config loading...') | :sl! | echo ('')<CR>")
 
 --------------- Extended Operations ---------------
 -- Conditional 'q' to quit on floating/quickfix/help windows otherwise still use it for macros
 -- TODO: Have a list of if available on system/packages, example "Zen Mode" to not work on it (quit Zen Mode)
-map("n", "q", function()
+map('n', 'q', function()
   local config = vim.api.nvim_win_get_config(0)
-  if config.relative ~= "" then -- is_floating_window?
-    return ":silent! close!<CR>"
-  elseif vim.o.buftype == "quickfix" then
-    return ":quit<CR>"
-  elseif vim.o.buftype == "help" then
-    return ":close<CR>"
+  if config.relative ~= '' then -- is_floating_window?
+    return ':silent! close!<CR>'
+  elseif vim.o.buftype == 'quickfix' then
+    return ':quit<CR>'
+  elseif vim.o.buftype == 'help' then
+    return ':close<CR>'
   else
-    return "q"
+    return 'q'
   end
 end, { expr = true, replace_keycodes = true })
 
 -- Combine buffers list with buffer name
-map("n", "<Leader>b", ":buffers<CR>:buffer<Space>")
+map('n', '<Leader>b', ':buffers<CR>:buffer<Space>')
 
 -- Buffer confirmation
-map("n", "<leader>y", ":BufferPick<CR>")
+map('n', '<leader>y', ':BufferPick<CR>')
 
 -- Map buffer next, prev and delete to <leader>+(n/p/d) respectively
-map("n", "<leader>n", ":bn<cr>")
-map("n", "<leader>p", ":bp<cr>")
-map("n", "<leader>d", ":bd<cr>")
+map('n', '<leader>n', ':bn<cr>')
+map('n', '<leader>p', ':bp<cr>')
+map('n', '<leader>d', ':bd<cr>')
+
+-- Delete file of current buffer
+map('n', '<leader>rm', "<CMD>call delete(expand('%')) | bdelete!<CR>")
 
 -- List marks
-map("n", "<Leader>m", ":marks<CR>")
+map('n', '<Leader>m', ':marks<CR>')
 
 -- Messages
-map("n", "<Leader>M", ":messages<CR>")
-
--- Clear messages
+map('n', '<Leader>M', ':messages<CR>')
 
 -- Clear messages or just refresh/redraw the screen
-map("n", "<leader>u", ":echo '' | redraw<CR>")
+map('n', '<leader>u', ":echo '' | redraw<CR>")
 
 -- Unsets the 'last search pattern' register by hitting return
 --map("n", "<CR>", "!silent :noh<CR><CR>")
 
 -- Toggle set number
-map("n", "<leader>$", ":NumbersToggle<CR>")
-map("n", "<leader>%", ":NumbersOnOff<CR>")
+map('n', '<leader>$', ':NumbersToggle<CR>')
+map('n', '<leader>%', ':NumbersOnOff<CR>')
 
 -- Easier split navigations, just ctrl-j instead of ctrl-w then j
---map("n", "<C-J>", "<C-W><C-J>")
---map("n", "<C-K>", "<C-W><C-K>")
---map("n", "<C-L>", "<C-W><C-L>")
---map("n", "<C-H>", "<C-W><C-H>")
-map("t", "<C-[>", "<C-\\><C-N>")
-map("t", "<C-h>", "<C-\\><C-N><C-h>")
-map("t", "<C-j>", "<C-\\><C-N><C-j>")
-map("t", "<C-k>", "<C-\\><C-N><C-k>")
-map("t", "<C-l>", "<C-\\><C-N><C-l>")
---map("t", "<C-x>", "<C-c>")
---map("n", "<C-x>", "<C-c>")
---map("n", "<C-r>", ":<C-u>call MyFunc(v:count)<CR>")
+map('t', '<C-[>', '<C-\\><C-N>')
+map('t', '<C-h>', '<C-\\><C-N><C-h>')
+map('t', '<C-j>', '<C-\\><C-N><C-j>')
+map('t', '<C-k>', '<C-\\><C-N><C-k>')
+map('t', '<C-l>', '<C-\\><C-N><C-l>')
 
 -- Split window
-map("n", "<leader>h", ":split<CR>")
-map("n", "<leader>v", ":vsplit<CR>")
-map("n", "<leader>c", "<C-w>c")
+map('n', '<leader>h', ':split<CR>')
+map('n', '<leader>v', ':vsplit<CR>')
+map('n', '<leader>c', '<C-w>c')
 
 -- Resize Panes
-map("n", "<Leader>+", ":resize +5<CR>")
-map("n", "<Leader>-", ":resize -5<CR>")
-map("n", "<Leader><", ":vertical resize +5<CR>")
-map("n", "<Leader>>", ":vertical resize -5<CR>")
-map("n", "<Leader>=", "<C-w>=")
-
--- Map Alt+(h/j/k/l) in insert mode to move directional
-map("i", "<A-h>", "<left>")
-map("i", "<A-j>", "<down>")
-map("i", "<A-k>", "<up>")
-map("i", "<A-l>", "<right>")
-
--- Map Alt+(h/j/k/l) in command mode to move directional
-vim.api.nvim_set_keymap("c", "<A-h>", "<Left>", { noremap = true })
-vim.api.nvim_set_keymap("c", "<A-j>", "<Down>", { noremap = true })
-vim.api.nvim_set_keymap("c", "<A-k>", "<Up>", { noremap = true })
-vim.api.nvim_set_keymap("c", "<A-l>", "<Right>", { noremap = true })
+map('n', '<Leader>+', ':resize +5<CR>')
+map('n', '<Leader>-', ':resize -5<CR>')
+map('n', '<Leader><', ':vertical resize +5<CR>')
+map('n', '<Leader>>', ':vertical resize -5<CR>')
+map('n', '<Leader>=', '<C-w>=')
+
+-- Map Alt+(h/j/k/l) in insert(include terminal/command) mode to move directional
+map({ 'i', 't', 'c' }, '<A-h>', '<left>')
+map({ 'i', 't', 'c' }, '<A-j>', '<down>')
+map({ 'i', 't', 'c' }, '<A-k>', '<up>')
+map({ 'i', 't', 'c' }, '<A-l>', '<right>')
 
 -- Create tab, edit and move between them
-map("n", "<C-T>n", ":tabnew<CR>")
-map("n", "<C-T>e", ":tabedit")
-map("n", "<leader>[", ":tabprev<CR>")
-map("n", "<leader>]", ":tabnext<CR>")
+map('n', '<C-T>n', ':tabnew<CR>')
+map('n', '<C-T>e', ':tabedit')
+map('n', '<leader>[', ':tabprev<CR>')
+map('n', '<leader>]', ':tabnext<CR>')
 
 -- "Zoom" a split window into a tab and/or close it
 --map("n", "<Leader>,", ":tabnew %<CR>")
 --map("n", "<Leader>.", ":tabclose<CR>")
 
 -- Vim TABs
-map("n", "<leader>1", "1gt<CR>")
-map("n", "<leader>2", "2gt<CR>")
-map("n", "<leader>3", "3gt<CR>")
-map("n", "<leader>4", "4gt<CR>")
-map("n", "<leader>5", "5gt<CR>")
-map("n", "<leader>6", "6gt<CR>")
-map("n", "<leader>7", "7gt<CR>")
-map("n", "<leader>8", "8gt<CR>")
-map("n", "<leader>9", "9gt<CR>")
-map("n", "<leader>0", "10gt<CR>")
-
--- Move to the next and previous item in the quickfixlist
---map("n", "]c", "<Cmd>cnext<CR>")
---map("n", "[c", "<Cmd>cprevious<CR>")
+map('n', '<leader>1', '1gt<CR>')
+map('n', '<leader>2', '2gt<CR>')
+map('n', '<leader>3', '3gt<CR>')
+map('n', '<leader>4', '4gt<CR>')
+map('n', '<leader>5', '5gt<CR>')
+map('n', '<leader>6', '6gt<CR>')
+map('n', '<leader>7', '7gt<CR>')
+map('n', '<leader>8', '8gt<CR>')
+map('n', '<leader>9', '9gt<CR>')
+map('n', '<leader>0', '10gt<CR>')
 
 -- Hitting ESC when inside a terminal to get into normal mode
 --map("t", "<Esc>", [[<C-\><C-N>]])
 
 -- Move block (indentation) easily
-map("n", "<", "<<", term_opts)
-map("n", ">", ">>", term_opts)
-map("x", "<", "<gv", term_opts)
-map("x", ">", ">gv", term_opts)
+map('n', '<', '<<', term_opts)
+map('n', '>', '>>', term_opts)
+map('x', '<', '<gv', term_opts)
+map('x', '>', '>gv', term_opts)
 
 -- Set alt+(j/k) to switch lines of texts or simply move them
-map("n", "<A-k>", ':let save_a=@a<Cr><Up>"add"ap<Up>:let @a=save_a<Cr>')
-map("n", "<A-j>", ':let save_a=@a<Cr>"add"ap:let @a=save_a<Cr>')
-
--- Search and replace
-map("v", "<leader>sr", 'y:%s/<C-r><C-r>"//g<Left><Left>c')
+map('n', '<A-k>', ':let save_a=@a<Cr><Up>"add"ap<Up>:let @a=save_a<Cr>')
+map('n', '<A-j>', ':let save_a=@a<Cr>"add"ap:let @a=save_a<Cr>')
 
 -- Toggle Diff
-map("n", "<leader>td", "<Cmd>call utils#ToggleDiff()<CR>")
+map('n', '<leader>df', '<Cmd>call utils#ToggleDiff()<CR>')
 
 -- Toggle Verbose
-map("n", "<leader>vt", "<Cmd>call utils#VerboseToggle()<CR>")
+map('n', '<leader>vt', '<Cmd>call utils#VerboseToggle()<CR>')
 
 -- Jump List
-map("n", "<leader>j", "<Cmd>call utils#GotoJump()<CR>")
+map('n', '<leader>j', '<Cmd>call utils#GotoJump()<CR>')
 
 -- Map delete to Ctrl+l
-map("i", "<C-l>", "<Del>")
+map('i', '<C-l>', '<Del>')
 
 -- Clear screen
-map("n", "<leader><C-l>", "<Cmd>!clear<CR>")
+map('n', '<leader><C-l>', '<Cmd>!clear<CR>')
 
 -- Change file to an executable
-map(
-  "n",
-  "<Leader>x",
-  ":lua require('user.mods').Toggle_executable()<CR> | :echom ('Toggle executable')<CR> | :sl! | echo ('')<CR>"
-)
---map("n", "<leader>x", ":!chmod +x %<CR>")
+map('n', '<Leader>x', ":lua require('user.mods').Toggle_executable()<CR> | :echom ('Toggle executable')<CR> | :sl! | echo ('')<CR>")
+-- map("n", "<leader>x", ":!chmod +x %<CR>")
 
 -- Paste without replace clipboard
-map("v", "p", '"_dP')
+map('v', 'p', '"_dP')
 
 -- Swap two pieces of text, use x to cut in visual mode, then use Ctrl-x in
 -- visual mode to select text to swap with
 --map("v", "<C-X>", "<Esc>`.``gvP``P")
 
 -- Change Working Directory to current project
-map("n", "<leader>cd", ":cd %:p:h<CR>:pwd<CR>")
+map('n', '<leader>cd', ':cd %:p:h<CR>:pwd<CR>')
 
 -- Open the current file in the default program (on Mac this should just be just `open`)
-map("n", "<leader>o", ":!xdg-open %<cr><cr>")
+map('n', '<leader>o', ':!xdg-open %<cr><cr>')
 
 -- URL handling
-if vim.fn.has("mac") == 1 then
-  map("", "gx", '<Cmd>call jobstart(["open", expand("<cfile>")], {"detach": v:true})<CR>', {})
-elseif vim.fn.has("unix") == 1 then
-  map("", "gx", '<Cmd>call jobstart(["xdg-open", expand("<cfile>")], {"detach": v:true})<CR>', {})
-elseif vim.fn.has("wsl") == 1 then
-  map("", "gx", '<Cmd>call jobstart(["wslview", expand("<cfile>")], {"detach": v:true})<CR>', {})
+if vim.fn.has('mac') == 1 then
+  map('', 'gx', '<Cmd>call jobstart(["open", expand("<cfile>")], {"detach": v:true})<CR>', {})
+elseif vim.fn.has('unix') == 1 then
+  map('', 'gx', '<Cmd>call jobstart(["xdg-open", expand("<cfile>")], {"detach": v:true})<CR>', {})
+elseif vim.fn.has('wsl') == 1 then
+  map('', 'gx', '<Cmd>call jobstart(["wslview", expand("<cfile>")], {"detach": v:true})<CR>', {})
 else
-  map[""].gx = { '<Cmd>lua print("Error: gx is not supported on this OS!")<CR>' }
+  map[''].gx = { '<Cmd>lua print("Error: gx is not supported on this OS!")<CR>' }
 end
 
+-- Search and replace
+map('v', '<leader>sr', 'y:%s/<C-r><C-r>"//g<Left><Left>c')
+
 -- Substitute globally and locally in the selected region.
-map("n", "ss", ":%s//g<Left><Left>")
-map("v", "ss", ":s//g<Left><Left>")
+map('n', '<leader>s', ':%s//g<Left><Left>')
+map('v', '<leader>s', ':s//g<Left><Left>')
 
 -- Toggle completion
-map("n", "<Leader>tc", ":lua require('user.mods').toggle_completion()<CR>")
+map('n', '<Leader>tc', ':lua require("user.mods").toggle_completion()<CR>')
 
 -- Disable default completion.
-map("i", "<C-n>", "<Nop>")
-map("i", "<C-p>", "<Nop>")
+map('i', '<C-n>', '<Nop>')
+map('i', '<C-p>', '<Nop>')
 
 -- Set line wrap
-map("n", "<M-z>", function()
-  local wrap_status = vim.api.nvim_exec("set wrap ?", true)
+map('n', '<M-z>', function()
+  local wrap_status = vim.api.nvim_exec('set wrap ?', true)
 
-  if wrap_status == "nowrap" then
-    vim.api.nvim_command("set wrap linebreak")
-    print("Wrap enabled")
+  if wrap_status == 'nowrap' then
+    vim.api.nvim_command('set wrap linebreak')
+    print('Wrap enabled')
   else
-    vim.api.nvim_command("set wrap nowrap")
-    print("Wrap disabled")
+    vim.api.nvim_command('set wrap nowrap')
+    print('Wrap disabled')
   end
 end, { silent = true })
 
@@ -230,212 +203,205 @@ end, { silent = true })
 --utils.map("n", "<F2>", "&foldlevel ? 'zM' : 'zR'", { expr = true })
 
 -- Use space to toggle fold
-map("n", "<Space>", "za")
+map('n', '<Space>', 'za')
 
 -- Make a copy of current file
 --vim.cmd([[
---  map <leader>s :up \| saveas! %:p:r-<C-R>=strftime("%y.%m.%d-%H:%M")<CR>-bak.<C-R>=expand("%:e")<CR> \| 3sleep \| e #<CR>
+-- map <leader>s :up \| saveas! %:p:r-<C-R>=strftime("%y.%m.%d-%H:%M")<CR>-bak.<C-R>=expand("%:e")<CR> \| 3sleep \| e #<CR>
 --]])
-map("n", "<leader>.b", ":!cp % %.backup<CR>")
+map('n', '<leader>.b', ':!cp % %.backup<CR>')
 
 -- Toggle transparency
-map("n", "<leader>tb", ":call utils#Toggle_transparent_background()<CR>")
+map('n', '<leader>tb', ':call utils#Toggle_transparent_background()<CR>')
 
 -- Toggle zoom
-map("n", "<leader>z", ":call utils#ZoomToggle()<CR>")
-map("n", "<C-w>z", "<C-w>|<C-w>_")
+map('n', '<leader>z', ':call utils#ZoomToggle()<CR>')
+map('n', '<C-w>z', '<C-w>|<C-w>_')
 
 -- Toggle statusline
-map("n", "<S-h>", ":call ToggleHiddenAll()<CR>")
+map('n', '<S-h>', ':call utils#ToggleHiddenAll()<CR>')
 
 -- Open last closed buffer
-map("n", "<C-t>", ":call OpenLastClosed()<CR>")
+map('n', '<C-t>', ':call OpenLastClosed()<CR>')
 
 ---------------- Plugin Operations ----------------
 -- Packer
-map("n", "<leader>Pc", "<cmd>PackerCompile<cr>")
-map("n", "<leader>Pi", "<cmd>PackerInstall<cr>")
-map("n", "<leader>Ps", "<cmd>PackerSync<cr>")
-map("n", "<leader>PS", "<cmd>PackerStatus<cr>")
-map("n", "<leader>Pu", "<cmd>PackerUpdate<cr>")
+map('n', '<leader>Pc', '<cmd>PackerCompile<cr>')
+map('n', '<leader>Pi', '<cmd>PackerInstall<cr>')
+map('n', '<leader>Ps', '<cmd>PackerSync<cr>')
+map('n', '<leader>PS', '<cmd>PackerStatus<cr>')
+map('n', '<leader>Pu', '<cmd>PackerUpdate<cr>')
 
 -- Tmux navigation (aserowy/tmux.nvim)
-map("n", "<C-h>", "<CMD>NavigatorLeft<CR>")
-map("n", "<C-l>", "<CMD>NavigatorRight<CR>")
-map("n", "<C-k>", "<CMD>NavigatorUp<CR>")
-map("n", "<C-j>", "<CMD>NavigatorDown<CR>")
+map('n', '<C-h>', '<CMD>NavigatorLeft<CR>')
+map('n', '<C-l>', '<CMD>NavigatorRight<CR>')
+map('n', '<C-k>', '<CMD>NavigatorUp<CR>')
+map('n', '<C-j>', '<CMD>NavigatorDown<CR>')
 
 -- ToggleTerm
-map({ "n", "t" }, "<leader>tt", "<cmd>ToggleTerm<CR>")
-map({ "n", "t" }, "<leader>th", "<cmd>lua Horizontal_term_toggle()<CR>")
-map({ "n", "t" }, "<leader>tv", "<cmd>lua Vertical_term_toggle()<CR>")
---  map["<C-\\>"] = { "<cmd>ToggleTerm<cr>", desc = "Toggle terminal" }
---  map["<leader>tn"] = { function() toggle_term_cmd "node" end, desc = "ToggleTerm node" }
---  map["<leader>tu"] = { function() toggle_term_cmd "ncdu" end, desc = "ToggleTerm NCDU" }
---  map["<leader>tt"] = { function() toggle_term_cmd "htop" end, desc = "ToggleTerm htop" }
---  map["<leader>tp"] = { function() toggle_term_cmd "python" end, desc = "ToggleTerm python" }
---  map["<leader>tl"] = { function() toggle_term_cmd "lazygit" end, desc = "ToggleTerm lazygit" }
---  map["<leader>tf"] = { "<cmd>ToggleTerm direction=float<cr>", desc = "ToggleTerm float" }
---  map["<leader>th"] = { "<cmd>ToggleTerm size=10 direction=horizontal<cr>", desc = "ToggleTerm horizontal split" }
---  map["<leader>tv"] = { "<cmd>ToggleTerm size=80 direction=vertical<cr>", desc = "ToggleTerm vertical split" }
---end
+map({ 'n', 't' }, '<leader>tt', '<cmd>ToggleTerm<CR>')
+map({ 'n', 't' }, '<leader>th', '<cmd>lua Horizontal_term_toggle()<CR>')
+map({ 'n', 't' }, '<leader>tv', '<cmd>lua Vertical_term_toggle()<CR>')
 
 -- LazyGit
-map({ "n", "t" }, "<leader>gg", "<cmd>lua Lazygit_toggle()<CR>")
+map({ 'n', 't' }, '<leader>gg', '<cmd>lua Lazygit_toggle()<CR>')
 
-map("n", "<leader>tg", "<cmd>lua Gh_dash()<CR>")
+map('n', '<leader>tg', '<cmd>lua Gh_dash()<CR>')
 
 -- Fugitive git bindings
-map("n", "<leader>gs", vim.cmd.Git)
-map("n", "<leader>ga", ":Git add %:p<CR><CR>")
+map('n', '<leader>gs', vim.cmd.Git)
+map('n', '<leader>ga', ':Git add %:p<CR><CR>')
 --map("n", "<leader>gs", ":Gstatus<CR>")
-map("n", "<leader>gc", ":Gcommit -v -q<CR>")
-map("n", "<leader>gt", ":Gcommit -v -q %:p<CR>")
+map('n', '<leader>gc', ':Gcommit -v -q<CR>')
+map('n', '<leader>gt', ':Gcommit -v -q %:p<CR>')
 --map("n", "<leader>gd", ":Gdiff<CR>")
-map("n", "<leader>ge", ":Gedit<CR>")
+map('n', '<leader>ge', ':Gedit<CR>')
 --map("n", "<leader>gr", ":Gread<Cj>")
-map("n", "<leader>gw", ":Gwrite<CR><CR>")
-map("n", "<leader>gl", ":silent! Glog<CR>:bot copen<CR>")
+map('n', '<leader>gw', ':Gwrite<CR><CR>')
+map('n', '<leader>gl', ':silent! Glog<CR>:bot copen<CR>')
 --map("n", "<leader>gp", ":Ggrep<Space>")
 --map("n", "<Leader>gp", ":Git push<CR>")
 --map("n", "<Leader>gb", ":Gblame<CR>")
-map("n", "<leader>gm", ":Gmove<Space>")
+map('n', '<leader>gm', ':Gmove<Space>')
 --map("n", "<leader>gb", ":Git branch<Space>")
 --map("n", "<leader>go", ":Git checkout<Space>")
 --map("n", "<leader>gps", ":Dispatch! git push<CR>")
 --map("n", "<leader>gpl", ":Dispatch! git pull<CR>")
 
 -- Telescope
-map("n", "<leader>ff", function()
-  require("telescope.builtin").find_files({ hidden = true, no_ignore = false })
+map('n', '<leader>ff', ":cd %:p:h<CR>:pwd<CR><cmd>lua require('telescope.builtin').find_files()<cr>") -- find files with hidden option
+map('n', '<leader>fF', ":cd %:p:h<CR>:pwd<CR><cmd>lua require('user.mods').findFilesInCwd()<CR>", { noremap = true, silent = true, desc = 'Find files in cwd' })
+map('n', '<leader>f.', function()
+  require('telescope.builtin').find_files({ hidden = false, no_ignore = true })
 end) -- find all files
---map("n", "<leader>fF", "<cmd>lua require('telescope.builtin').find_files()<cr>")                                   -- find files with hidden option
-map("n", "<leader>fg", "<cmd>lua require('telescope.builtin').live_grep()<cr>")
-map("n", "<leader>fb", "<cmd>lua require('telescope.builtin').buffers()<cr>")
-map("n", "<leader>fh", "<cmd>lua require('telescope.builtin').help_tags()<cr>")
-map("n", "<leader>fc", "<cmd>lua require('telescope.builtin').commands()<cr>")
-map("n", "<leader>ffc", "<cmd>lua require('telescope.builtin').current_buffer_fuzzy_find()<cr>")
-map("n", "<leader>cf", "<cmd>Telescope changed_files<cr>")
-map("n", "<leader>fp", "<cmd>Telescope pickers<cr>")
-map("n", "<leader>fr", "<cmd>lua require('telescope.builtin').registers({})<CR>") -- registers picker
-map("n", "<leader>fd", "<cmd>lua require('telescope.builtin').diagnostics()<cr>")
-map("n", "<leader>fk", "<cmd>lua require('telescope.builtin').keymaps()<cr>")
-map("n", "<leader>fn", [[<Cmd>lua require'plugins.telescope'.find_notes()<CR>]])                   -- find notes
-map("n", "<leader>fgn", [[<Cmd>lua require'plugins.telescope'.grep_notes()<CR>]])                  -- search notes
-map("n", "<leader>f.", [[<Cmd>lua require'plugins.telescope'.find_configs()<CR>]])                 -- find configs
-map("n", "<leader>fs", [[<Cmd>lua require'plugins.telescope'.find_scripts()<CR>]])                 -- find scripts
-map("n", "<leader>fw", [[<Cmd>lua require'plugins.telescope'.find_projects()<CR>]])                -- find projects
-map("n", "<leader>fm", "<cmd>lua require('telescope').extensions.media_files.media_files({})<cr>") -- find media files
-map("n", "<leader>fi", "<cmd>lua require('telescope').extensions.notify.notify({})<cr>")           -- find notifications
+map('n', '<leader>fg', "<cmd>lua require('telescope.builtin').live_grep()<cr>")
+map('n', '<leader>fb', "<cmd>lua require('telescope.builtin').buffers()<cr>")
+map('n', '<leader>fh', "<cmd>lua require('telescope.builtin').help_tags()<cr>")
+map('n', '<leader>fc', "<cmd>lua require('telescope.builtin').commands()<cr>")
+map('n', '<leader>cf', '<cmd>Telescope changed_files<cr>')
+map('n', '<leader>fp', '<cmd>Telescope pickers<cr>')
+map('n', '<leader>fd', "<cmd>lua require('telescope.builtin').diagnostics()<cr>")
+map('n', '<leader>fk', "<cmd>lua require('telescope.builtin').keymaps()<cr>")
+map('n', '<leader>fr', "<cmd>lua require('telescope.builtin').registers({})<CR>")                  -- registers picker
+map('n', '<leader>fm', "<cmd>lua require('telescope').extensions.media_files.media_files({})<cr>") -- find media files
+map('n', '<leader>fi', "<cmd>lua require('telescope').extensions.notify.notify({})<cr>")           -- find notifications
+map('n', '<Leader>fs', '<cmd>lua require("session-lens").search_session()<CR>')
+map('n', '<leader>ffd', [[<Cmd>lua require'plugins.telescope'.find_dirs()<CR>]])                   -- find dies
+map('n', '<leader>ff.', [[<Cmd>lua require'plugins.telescope'.find_configs()<CR>]])                -- find configs
+map('n', '<leader>ffs', [[<Cmd>lua require'plugins.telescope'.find_scripts()<CR>]])                -- find scripts
+map('n', '<leader>ffw', [[<Cmd>lua require'plugins.telescope'.find_projects()<CR>]])               -- find projects
+map('n', '<leader>ffb', [[<Cmd>lua require'plugins.telescope'.find_books()<CR>]])                  -- find books
+map('n', '<leader>ffn', [[<Cmd>lua require'plugins.telescope'.find_notes()<CR>]])                  -- find notes
+map('n', '<leader>fgn', [[<Cmd>lua require'plugins.telescope'.grep_notes()<CR>]])                  -- search notes
+map('n', '<Leader>ffr', "<cmd>lua require('telescope').extensions.recent_files.pick()<CR>")
+map('n', '<leader>ffc', "<cmd>lua require('telescope.builtin').current_buffer_fuzzy_find()<cr>")
+map('n', '<Leader>f/', "<cmd>lua require('telescope').extensions.file_browser.file_browser()<CR>")
 --map("n", "<leader>f/", "<cmd>lua require('plugins.telescope').curbuf()<cr>")                       -- find files with hidden option
-map(
-  "n",
-  "<leader>fF",
-  ":cd %:p:h<CR>:pwd<CR><cmd>lua require('user.mods').findFilesInCwd()<CR>",
-  { noremap = true, silent = true, desc = "Find files in cwd" }
-)
+-- Map a shortcut to open the picker.
 
 -- FZF
-map("n", "<leader>fz", "<cmd>lua require('fzf-lua').files()<CR>")
+map('n', '<leader>fz', "<cmd>lua require('fzf-lua').files()<CR>")
 
 -- Nvim-tree
-map("n", "<leader>f", ":NvimTreeToggle<CR>", {})
+map('n', '<leader>f', '<cmd>Rooter<CR>:NvimTreeToggle<CR>', {})
+map('n', '<leader>F', ':NvimTreeFindFileToggle<CR>', { noremap = false, silent = true })
 
 -- Undotree
-map("n", "<leader>u", vim.cmd.UndotreeToggle)
+map('n', '<leader>u', vim.cmd.UndotreeToggle)
 
 -- Markdown-preview
-map("n", "<leader>md", "<Plug>MarkdownPreviewToggle")
-map("n", "<leader>mg", "<CMD>Glow<CR>")
+map('n', '<leader>md', '<Plug>MarkdownPreviewToggle')
+map('n', '<leader>mg', '<CMD>Glow<CR>')
 
 -- Autopairs
-map("n", "<leader>ww", "<cmd>lua require('user.mods').Toggle_autopairs()<CR>")
+map('n', '<leader>ww', "<cmd>lua require('user.mods').Toggle_autopairs()<CR>")
 
 -- Zen-mode toggle
-map("n", "<leader>zm", "<CMD>ZenMode<CR> | :echom ('Zen Mode')<CR> | :sl! | echo ('')<CR>")
+map('n', '<leader>zm', "<CMD>ZenMode<CR> | :echom ('Zen Mode')<CR> | :sl! | echo ('')<CR>")
 
 -- Vim-rooter
-map(
-  "n",
-  "<leader>ro",
-  "<CMD>Rooter<CR> | :echom ('cd to root/project directory')<CR> | :sl! | echo ('')<CR>",
-  term_opts
-)
+map('n', '<leader>ro', "<CMD>Rooter<CR> | :echom ('cd to root/project directory')<CR> | :sl! | echo ('')<CR>", term_opts)
 
 -- Trouble (UI to show diagnostics)
-map("n", "<leader>t", "<CMD>TroubleToggle<CR>")
-map("n", "<leader>tw", "<CMD>TroubleToggle workspace_diagnostics<CR>")
-map("n", "<leader>td", "<CMD>TroubleToggle document_diagnostics<CR>")
-map("n", "<leader>tq", "<CMD>TroubleToggle quickfix<CR>")
-map("n", "<leader>tl", "<CMD>TroubleToggle loclist<CR>")
-map("n", "gR", "<CMD>TroubleToggle lsp_references<CR>")
+map('n', '<leader>t', ':cd %:p:h<CR>:pwd<CR><CMD>TroubleToggle<CR>')
+map('n', '<leader>tw', ':cd %:p:h<CR>:pwd<CR><CMD>TroubleToggle workspace_diagnostics<CR>')
+map('n', '<leader>td', ':cd %:p:h<CR>:pwd<CR><CMD>TroubleToggle document_diagnostics<CR>')
+map('n', '<leader>tq', ':cd %:p:h<CR>:pwd<CR><CMD>TroubleToggle quickfix<CR>')
+map('n', '<leader>tl', ':cd %:p:h<CR>:pwd<CR><CMD>TroubleToggle loclist<CR>')
+map('n', 'gR', '<CMD>TroubleToggle lsp_references<CR>')
 
 -- Null-ls
-map("n", "<leader>ls", "<CMD>NullLsToggle<CR>")
+map('n', '<leader>ls', '<CMD>NullLsToggle<CR>')
 
 -- Replacer
-map("n", "<Leader>qr", ':lua require("replacer").run()<CR>')
+map('n', '<Leader>qr', ':lua require("replacer").run()<CR>')
 
 -- Quickfix
-map("n", "<leader>q", function()
+map('n', '<leader>q', function()
   if vim.fn.getqflist({ winid = 0 }).winid ~= 0 then
-    require("plugins.quickfix").close()
+    require('plugins.quickfix').close()
   else
-    require("plugins.quickfix").open()
-    --require("quickfix").open()
+    require('plugins.quickfix').open()
   end
-end, { desc = "Toggle quickfix window" })
+end, { desc = 'Toggle quickfix window' })
+
+-- Move to the next and previous item in the quickfixlist
+map('n', ']c', '<Cmd>cnext<CR>')
+map('n', '[c', '<Cmd>cprevious<CR>')
+
+-- Location list
+map('n', '<leader>l', '<cmd>lua require("plugins.loclist").loclist_toggle()<CR>')
 
 -- Dap (debugging)
-local dap_ok, dap = pcall(require, "dap")
-local dap_ui_ok, ui = pcall(require, "dapui")
+local dap_ok, dap = pcall(require, 'dap')
+local dap_ui_ok, ui = pcall(require, 'dapui')
 
 if not (dap_ok and dap_ui_ok) then
-  require("notify")("nvim-dap or dap-ui not installed!", "warning")
+  require('notify')('nvim-dap or dap-ui not installed!', 'warning')
   return
 end
 
-vim.fn.sign_define("DapBreakpoint", { text = "🐞" })
+vim.fn.sign_define('DapBreakpoint', { text = '🐞' })
 
 -- Start debugging session
-map("n", "<leader>ds", function()
+map('n', '<leader>ds', function()
   dap.continue()
   ui.toggle({})
-  vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<C-w>=", false, true, true), "n", false) -- Spaces buffers evenly
+  vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes('<C-w>=', false, true, true), 'n', false) -- Spaces buffers evenly
 end)
 
 -- Set breakpoints, get variable values, step into/out of functions, etc.
-map("n", "<leader>dC", dap.continue)
---map("n", "<leader>dC", dap.close)
---map("n", "<leader>dt", dap.terminate)
-map("n", "<leader>dt", ui.toggle)
-map("n", "<leader>dd", function()
+map('n', '<leader>dC', dap.continue)
+-- map("n", "<leader>dC", dap.close)
+-- map("n", "<leader>dt", dap.terminate)
+map('n', '<leader>dt', ui.toggle)
+map('n', '<leader>dd', function()
   dap.disconnect({ terminateDebuggee = true })
 end)
-map("n", "<leader>dn", dap.step_over)
-map("n", "<leader>di", dap.step_into)
-map("n", "<leader>do", dap.step_out)
-map("n", "<leader>db", dap.toggle_breakpoint)
-map("n", "<leader>dB", function()
+map('n', '<leader>dn', dap.step_over)
+map('n', '<leader>di', dap.step_into)
+map('n', '<leader>do', dap.step_out)
+map('n', '<leader>db', dap.toggle_breakpoint)
+map('n', '<leader>dB', function()
   dap.clear_breakpoints()
-  require("notify")("Breakpoints cleared", "warn")
+  require('notify')('Breakpoints cleared', 'warn')
 end)
-map("n", "<leader>dl", require("dap.ui.widgets").hover)
-map("n", "<leader>de", function()
-  require("dapui").float_element()
-end, { desc = "Open Element" })
-map("n", "<leader>dq", function()
-  require("dapui").close()
-  require("dap").repl.close()
-  local session = require("dap").session()
+map('n', '<leader>dl', require('dap.ui.widgets').hover)
+map('n', '<leader>de', function()
+  require('dapui').float_element()
+end, { desc = 'Open Element' })
+map('n', '<leader>dq', function()
+  require('dapui').close()
+  require('dap').repl.close()
+  local session = require('dap').session()
   if session then
-    require("dap").terminate()
+    require('dap').terminate()
   end
-  require("nvim-dap-virtual-text").refresh()
-end, { desc = "Terminate Debug" })
-map("n", "<leader>dc", function()
-  require("telescope").extensions.dap.commands()
-end, { desc = "DAP-Telescope: Commands" })
+  require('nvim-dap-virtual-text').refresh()
+end, { desc = 'Terminate Debug' })
+map('n', '<leader>dc', function()
+  require('telescope').extensions.dap.commands()
+end, { desc = 'DAP-Telescope: Commands' })
 --vim.keymap.set("n", "<leader>B", ":lua require'dap'.set_breakpoint(vim.fn.input('Breakpoint condition: '))<CR>")
 --vim.keymap.set("v", "<leader>B", ":lua require'dap'.set_breakpoint(vim.fn.input('Breakpoint condition: '))<CR>")
 --vim.keymap.set("n", "<leader>lp", ":lua require'dap'.set_breakpoint(nil, nil, vim.fn.input('Log point message: '))<CR>")
@@ -443,15 +409,26 @@ end, { desc = "DAP-Telescope: Commands" })
 
 -- Close debugger and clear breakpoints
 --map("n", "<leader>de", function()
---  dap.clear_breakpoints()
---  ui.toggle({})
---  dap.terminate()
---  vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<C-w>=", false, true, true), "n", false)
---  require("notify")("Debugger session ended", "warn")
+-- dap.clear_breakpoints()
+-- ui.toggle({})
+-- dap.terminate()
+-- vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<C-w>=", false, true, true), "n", false)
+-- require("notify")("Debugger session ended", "warn")
 --end)
 
--- Dashboard
-map("n", "<leader><Space>", "<CMD>Dashboard<CR>")
+-- Toggle Dashboard
+map('n', '<leader><Space>', '<CMD>lua require("user.mods").toggle_dashboard()<CR>')
 
 -- Lsp Lines toggle
-map("", "<Leader>l", require("lsp_lines").toggle, { desc = "Toggle lsp_lines" })
+map('', '<Leader>ll', require('lsp_lines').toggle, { desc = 'Toggle lsp_lines' })
+
+-- SnipRun
+map({ 'n', 'v' }, '<leader>r', '<Plug>SnipRun<CR>')
+
+-- Codi
+map('n', '<leader>co', '<CMD>lua require("user.mods").toggleCodi()<CR>')
+
+-- Scratch buffer
+map('n', '<leader>ss', '<CMD>lua require("user.mods").Scratch("float")<CR>')
+map('n', '<leader>sh', '<CMD>lua require("user.mods").Scratch("horizontal")<CR>')
+map('n', '<leader>sv', '<CMD>lua require("user.mods").Scratch("vertical")<CR>')
diff --git a/.config/nvim/lua/user/mods.lua b/.config/nvim/lua/user/mods.lua
index 2f14acd..6420ed5 100644
--- a/.config/nvim/lua/user/mods.lua
+++ b/.config/nvim/lua/user/mods.lua
@@ -24,19 +24,17 @@ M.has = function(feat)
   return false
 end
 
-
 --------------------------------------------------
 
-
 -- Format on save
-local augroup = vim.api.nvim_create_augroup("LspFormatting", {})
-require("null-ls").setup({
+local format_augroup = vim.api.nvim_create_augroup('LspFormatting', {})
+require('null-ls').setup({
   -- you can reuse a shared lspconfig on_attach callback here
   on_attach = function(client, bufnr)
-    if client.supports_method("textDocument/formatting") then
-      vim.api.nvim_clear_autocmds({ group = augroup, buffer = bufnr })
-      vim.api.nvim_create_autocmd("BufWritePre", {
-        group = augroup,
+    if client.supports_method('textDocument/formatting') then
+      vim.api.nvim_clear_autocmds({ group = format_augroup, buffer = bufnr })
+      vim.api.nvim_create_autocmd('BufWritePre', {
+        group = format_augroup,
         buffer = bufnr,
         callback = function()
           -- on 0.8, you should use vim.lsp.buf.format({ bufnr = bufnr }) instead
@@ -48,6 +46,8 @@ require("null-ls").setup({
   end,
 })
 
+vim.cmd([[autocmd BufWritePre <buffer> lua vim.lsp.buf.format()]])
+--vim.cmd [[autocmd BufWritePre * lua vim.lsp.buf.format()]]
 
 --------------------------------------------------
 
@@ -55,11 +55,19 @@ require("null-ls").setup({
 ---@param item any
 ---@return boolean?
 function M.empty(item)
-  if not item then return true end
+  if not item then
+    return true
+  end
   local item_type = type(item)
-  if item_type == 'string' then return item == '' end
-  if item_type == 'number' then return item <= 0 end
-  if item_type == 'table' then return vim.tbl_isempty(item) end
+  if item_type == 'string' then
+    return item == ''
+  end
+  if item_type == 'number' then
+    return item <= 0
+  end
+  if item_type == 'table' then
+    return vim.tbl_isempty(item)
+  end
   return item ~= nil
 end
 
@@ -70,7 +78,7 @@ function M.may_create_dir(dir)
   local res = fn.isdirectory(dir)
 
   if res == 0 then
-    fn.mkdir(dir, "p")
+    fn.mkdir(dir, 'p')
   end
 end
 
@@ -79,16 +87,16 @@ end
 --- Toggle cmp completion
 vim.g.cmp_toggle_flag = false -- initialize
 local normal_buftype = function()
-  return vim.api.nvim_buf_get_option(0, "buftype") ~= "prompt"
+  return vim.api.nvim_buf_get_option(0, 'buftype') ~= 'prompt'
 end
 M.toggle_completion = function()
-  local ok, cmp = pcall(require, "cmp")
+  local ok, cmp = pcall(require, 'cmp')
   if ok then
     local next_cmp_toggle_flag = not vim.g.cmp_toggle_flag
     if next_cmp_toggle_flag then
-      print("completion on")
+      print('completion on')
     else
-      print("completion off")
+      print('completion off')
     end
     cmp.setup({
       enabled = function()
@@ -101,42 +109,60 @@ M.toggle_completion = function()
       end,
     })
   else
-    print("completion not available")
+    print('completion not available')
   end
 end
 
-
 --------------------------------------------------
 
 --- Make sure using latest neovim version
 function M.get_nvim_version()
   local actual_ver = vim.version()
 
-  local nvim_ver_str = string.format("%d.%d.%d", actual_ver.major, actual_ver.minor, actual_ver.patch)
+  local nvim_ver_str = string.format('%d.%d.%d', actual_ver.major, actual_ver.minor, actual_ver.patch)
   return nvim_ver_str
 end
 
 function M.add_pack(name)
-  local status, error = pcall(vim.cmd, "packadd " .. name)
+  local status, error = pcall(vim.cmd, 'packadd ' .. name)
 
   return status
 end
 
 --------------------------------------------------
 
+-- Define a global function to retrieve LSP clients based on Neovim version
+function M.get_lsp_clients(bufnr)
+  local mods = require('user.mods')
+  --local expected_ver = '0.10.0'
+  local nvim_ver = mods.get_nvim_version()
+
+  local version_major, version_minor = string.match(nvim_ver, '(%d+)%.(%d+)')
+  version_major = tonumber(version_major)
+  version_minor = tonumber(version_minor)
+
+  if version_major > 0 or (version_major == 0 and version_minor >= 10) then
+    return vim.lsp.get_clients({ buffer = bufnr })
+  else
+    return vim.lsp.buf_get_clients()
+  end
+end
+
+--------------------------------------------------
+
 --- Toggle autopairs on/off (requires "windwp/nvim-autopairs")
 function M.Toggle_autopairs()
-  local ok, autopairs = pcall(require, "nvim-autopairs")
+  local ok, autopairs = pcall(require, 'nvim-autopairs')
   if ok then
     if autopairs.state.disabled then
       autopairs.enable()
-      print("autopairs on")
+      print('autopairs on')
     else
       autopairs.disable()
-      print("autopairs off")
+      print('autopairs off')
     end
   else
-    print("autopairs not available")
+    print('autopairs not available')
   end
 end
 
@@ -159,12 +185,13 @@ end
 --]])
 
 function M.findFilesInCwd()
-  vim.cmd("let g:rooter_manual_only = 1") -- Toggle the rooter plugin
-  require("plugins.telescope").findhere()
+  vim.cmd('let g:rooter_manual_only = 1') -- Toggle the rooter plugin
+  require('plugins.telescope').findhere()
   vim.defer_fn(function()
-    vim.cmd("let g:rooter_manual_only = 0") -- Change back to automatic rooter
+    vim.cmd('let g:rooter_manual_only = 0') -- Change back to automatic rooter
   end, 100)
 end
+
 --function M.findFilesInCwd()
 --  vim.cmd("let g:rooter_manual_only = 1") -- Toggle the rooter plugin
 --  require("plugins.telescope").findhere()
@@ -182,12 +209,12 @@ function M.Toggle_executable()
     -- File is executable, unset the executable permission
     vim.fn.system('chmod -x ' .. current_file)
     --print(current_file .. ' is no longer executable.')
-    print("No longer executable")
+    print('No longer executable')
   else
     -- File is not executable, set the executable permission
     vim.fn.system('chmod +x ' .. current_file)
     --print(current_file .. ' is now executable.')
-    print("Now executable")
+    print('Now executable')
   end
 end
 
@@ -212,21 +239,21 @@ end
 
 ------
 
-local prev_cwd = ""
+local prev_cwd = ''
 
 function M.Set_git_env_vars()
   local cwd = vim.fn.getcwd()
-  if prev_cwd == "" then
+  if prev_cwd == '' then
     -- First buffer being opened, set prev_cwd to cwd
     prev_cwd = cwd
   elseif cwd ~= prev_cwd then
     -- Working directory has changed since last buffer was opened
     prev_cwd = cwd
-    local git_dir_job = vim.fn.jobstart({ "git", "rev-parse", "--git-dir" })
+    local git_dir_job = vim.fn.jobstart({ 'git', 'rev-parse', '--git-dir' })
     local command_status = vim.fn.jobwait({ git_dir_job })[1]
     if command_status > 0 then
-      vim.env.GIT_DIR = vim.fn.expand("$HOME/.cfg")
-      vim.env.GIT_WORK_TREE = vim.fn.expand("~")
+      vim.env.GIT_DIR = vim.fn.expand('$HOME/.cfg')
+      vim.env.GIT_WORK_TREE = vim.fn.expand('~')
     else
       vim.env.GIT_DIR = nil
       vim.env.GIT_WORK_TREE = nil
@@ -234,16 +261,11 @@ function M.Set_git_env_vars()
   end
 end
 
-vim.cmd [[augroup my_git_env_vars]]
-vim.cmd [[  autocmd!]]
-vim.cmd [[  autocmd BufEnter * lua require('user.mods').Set_git_env_vars()]]
-vim.cmd [[  autocmd VimEnter * lua require('user.mods').Set_git_env_vars()]]
-vim.cmd [[augroup END]]
-
---------------------------------------------------
-
-vim.cmd [[autocmd BufWritePre <buffer> lua vim.lsp.buf.format()]]
---vim.cmd [[autocmd BufWritePre * lua vim.lsp.buf.format()]]
+vim.cmd([[augroup my_git_env_vars]])
+vim.cmd([[  autocmd!]])
+vim.cmd([[  autocmd BufEnter * lua require('user.mods').Set_git_env_vars()]])
+vim.cmd([[  autocmd VimEnter * lua require('user.mods').Set_git_env_vars()]])
+vim.cmd([[augroup END]])
 
 --------------------------------------------------
 
@@ -266,11 +288,11 @@ function M.update_tmux_status()
   file:close()
   if nvim_running then
     -- Neovim is running, update the mode file and refresh tmux
-    VI_MODE = "" -- Clear VI_MODE to show Neovim mode
-    vim.cmd("silent !tmux refresh-client -S")
+    VI_MODE = '' -- Clear VI_MODE to show Neovim mode
+    vim.cmd('silent !tmux refresh-client -S')
   end
   ---- Force tmux to update the status
-  vim.cmd("silent !tmux refresh-client -S")
+  vim.cmd('silent !tmux refresh-client -S')
 end
 
 vim.cmd([[
@@ -295,6 +317,7 @@ vim.cmd([[
 --autocmd FocusGained * lua require("user.mods").update_tmux_status()
 --autocmd FocusLost * lua require("user.mods").update_tmux_status()
 --autocmd CmdwinEnter,CmdwinLeave * lua require("user.mods").update_tmux_status()
+
 --------------------------------------------------
 
 -- function OpenEmulatorList()
@@ -311,8 +334,6 @@ vim.cmd([[
 --
 -- vim.api.nvim_create_user_command('OpenEmulators', OpenEmulatorList, {})
 
-
-
 --local api = vim.api
 --local fn = vim.fn
 --local cmd = vim.cmd
@@ -396,43 +417,42 @@ function M.Update_neovim()
   -- Create a new floating window
   local bufnr, winid = vim.api.nvim_create_buf(false, true)
   vim.api.nvim_open_win(bufnr, true, {
-    relative = "editor",
+    relative = 'editor',
     width = 80,
     height = 20,
     row = 2,
     col = 2,
-    style = "minimal",
-    border = "single",
+    style = 'minimal',
+    border = 'single',
   })
 
   -- Function to append a line to the buffer in the floating window
   local function append_line(line)
-    vim.api.nvim_buf_set_option(bufnr, "modifiable", true)
+    vim.api.nvim_buf_set_option(bufnr, 'modifiable', true)
     vim.api.nvim_buf_set_lines(bufnr, -1, -1, false, { line })
-    vim.api.nvim_buf_set_option(bufnr, "modifiable", false)
+    vim.api.nvim_buf_set_option(bufnr, 'modifiable', false)
   end
 
   -- Download the latest version of Neovim
-  append_line("Downloading the latest version of Neovim...")
-  os.execute(
-    "curl -L -o nvim-linux64.tar.gz https://github.com/neovim/neovim/releases/latest/download/nvim-linux64.tar.gz")
-  append_line("Download complete.")
+  append_line('Downloading the latest version of Neovim...')
+  os.execute('curl -L -o nvim-linux64.tar.gz https://github.com/neovim/neovim/releases/latest/download/nvim-linux64.tar.gz')
+  append_line('Download complete.')
 
   -- Extract the downloaded archive
-  append_line("Extracting the downloaded archive...")
-  os.execute("tar xzvf nvim-linux64.tar.gz")
-  append_line("Extraction complete.")
+  append_line('Extracting the downloaded archive...')
+  os.execute('tar xzvf nvim-linux64.tar.gz')
+  append_line('Extraction complete.')
 
   -- Replace the existing Neovim installation with the new version
-  append_line("Replacing the existing Neovim installation...")
-  os.execute("rm -rf $HOME/nvim")
-  os.execute("mv nvim-linux64 $HOME/nvim")
-  append_line("Update complete.")
+  append_line('Replacing the existing Neovim installation...')
+  os.execute('rm -rf $HOME/nvim')
+  os.execute('mv nvim-linux64 $HOME/nvim')
+  append_line('Update complete.')
 
   -- Clean up the downloaded file
-  append_line("Cleaning up the downloaded file...")
-  os.execute("rm nvim-linux64.tar.gz")
-  append_line("Cleanup complete.")
+  append_line('Cleaning up the downloaded file...')
+  os.execute('rm nvim-linux64.tar.gz')
+  append_line('Cleanup complete.')
 
   -- Close the floating window after a delay
   vim.defer_fn(function()
@@ -441,8 +461,356 @@ function M.Update_neovim()
 end
 
 -- Bind a keymap to the update_neovim function (optional)
-vim.api.nvim_set_keymap('n', '<leader>U', '<cmd> lua require("user.mods").Update_neovim()<CR>',
-  { noremap = true, silent = true })
+vim.api.nvim_set_keymap('n', '<leader>U', '<cmd> lua require("user.mods").Update_neovim()<CR>', { noremap = true, silent = true })
+
+--------------------------------------------------
+
+-- Fix or suppress closing nvim error message (/src/unix/core.c:147: uv_close: Assertion `!uv__is_closing(handle)' failed.)
+vim.api.nvim_create_autocmd({ 'VimLeave' }, {
+  callback = function()
+    vim.fn.jobstart('!notify-send 2>/dev/null &', { detach = true })
+  end,
+})
+
+--------------------------------------------------
+
+-- Rooter
+--vim.cmd([[autocmd BufEnter * lua vim.cmd('Rooter')]])
+
+--------------------------------------------------
+
+-- Nvim-tree
+local modifiedBufs = function(bufs) -- nvim-tree is also there in modified buffers so this function filter it out
+  local t = 0
+  for k, v in pairs(bufs) do
+    if v.name:match('NvimTree_') == nil then
+      t = t + 1
+    end
+  end
+  return t
+end
+
+-- Deleting current file opened behaviour
+function M.DeleteCurrentBuffer()
+  local cbn = vim.api.nvim_get_current_buf()
+  local buffers = vim.fn.getbufinfo({ buflisted = true })
+  local size = #buffers
+  local idx = 0
+
+  for n, e in ipairs(buffers) do
+    if e.bufnr == cbn then
+      idx = n
+      break -- Exit loop as soon as we find the buffer
+    end
+  end
+
+  if idx == 0 then
+    return
+  end
+
+  if idx == size then
+    vim.cmd('bprevious')
+  else
+    vim.cmd('bnext')
+  end
+
+  vim.cmd('silent! bdelete ' .. cbn)
+
+  -- Open a new blank window
+  vim.cmd('silent! enew') -- Opens a new vertical split
+  -- OR
+  -- vim.cmd("new")  -- Opens a new horizontal split
+  -- Delay before opening a new split
+  --vim.defer_fn(function()
+  --  vim.cmd("enew") -- Opens a new vertical split
+  --end, 100)         -- Adjust the delay as needed (in milliseconds)
+  -- Delay before closing the nvim-tree window
+end
+
+vim.cmd([[autocmd FileType NvimTree lua require("user.mods").DeleteCurrentBuffer()]])
+
+-- On :bd nvim-tree should behave as if it wasn't opened
+vim.api.nvim_create_autocmd('BufEnter', {
+  nested = true,
+  callback = function()
+    -- Only 1 window with nvim-tree left: we probably closed a file buffer
+    if #vim.api.nvim_list_wins() == 1 and require('nvim-tree.utils').is_nvim_tree_buf() then
+      local api = require('nvim-tree.api')
+      -- Required to let the close event complete. An error is thrown without this.
+      vim.defer_fn(function()
+        -- close nvim-tree: will go to the last buffer used before closing
+        api.tree.toggle({ find_file = true, focus = true })
+        -- re-open nivm-tree
+        api.tree.toggle({ find_file = true, focus = true })
+        -- nvim-tree is still the active window. Go to the previous window.
+        vim.cmd('wincmd p')
+      end, 0)
+    end
+  end,
+})
+
+-- Dismiss notifications when opening nvim-tree window
+local function isNvimTreeOpen()
+  local win = vim.fn.win_findbuf(vim.fn.bufnr('NvimTree'))
+  return vim.fn.empty(win) == 0
+end
+
+function M.DisableNotify()
+  if isNvimTreeOpen() then
+    require('notify').dismiss()
+  end
+end
+
+vim.cmd([[
+  autocmd! WinEnter,WinLeave * lua require('user.mods').DisableNotify()
+]])
+
+--------------------------------------------------
 
+-- Toggle Dashboard
+function M.toggle_dashboard()
+  if vim.bo.filetype == 'dashboard' then
+    vim.cmd('bdelete')
+  else
+    vim.cmd('Dashboard')
+  end
+end
+
+--------------------------------------------------
+
+-- Helper function to suppress errors
+local function silent_execute(cmd)
+  vim.fn['serverlist']() -- Required to prevent 'Press ENTER' prompt
+  local result = vim.fn.system(cmd .. ' 2>/dev/null')
+  vim.fn['serverlist']()
+  return result
+end
+
+--------------------------------------------------
+
+-- Toggle Codi
+-- Define a global variable to track Codi's state
+local is_codi_open = false
+
+function M.toggleCodi()
+  if is_codi_open then
+    -- Close Codi
+    vim.cmd('Codi!')
+    is_codi_open = false
+  else
+    -- Open Codi
+    vim.cmd('Codi')
+    is_codi_open = true
+  end
+end
+
+--------------------------------------------------
+
+---- Function to create or toggle a scratch buffer
+local scratch_buf = nil -- Store the scratch buffer globally
+local scratch_win = nil -- Store the scratch window globally
+local scratch_date = os.date('%Y-%m-%d')
+local scratch_dir = vim.fn.expand('~/notes/private')
+local scratch_file = 'scratch-' .. scratch_date .. '.md'
+
+function M.Scratch(Split_direction)
+  -- Check if the directory exists, and create it if it doesn't
+  if vim.fn.isdirectory(scratch_dir) == 0 then
+    vim.fn.mkdir(scratch_dir, 'p')
+  end
+
+  -- Determine the window type based on Split_direction
+  local current_window_type = 'float'
+  if Split_direction == 'float' then
+    current_window_type = 'float'
+  elseif Split_direction == 'vertical' then
+    current_window_type = 'vertical'
+  elseif Split_direction == 'horizontal' then
+    current_window_type = 'horizontal'
+  end
+
+  local file_path = scratch_dir .. '/' .. scratch_file
+
+  if scratch_win and vim.api.nvim_win_is_valid(scratch_win) then
+    -- Window exists, save buffer to file and close it
+    WriteScratchBufferToFile(scratch_buf, file_path)
+    vim.cmd(':w!')
+    vim.api.nvim_win_close(scratch_win, true)
+    scratch_win = nil
+  else
+    if scratch_buf and vim.api.nvim_buf_is_valid(scratch_buf) then
+      -- Buffer exists, reuse it
+      OpenScratchWindow(scratch_buf, current_window_type)
+    else
+      -- Buffer doesn't exist, create it and load the file if it exists
+      scratch_buf = OpenScratchBuffer(file_path)
+      OpenScratchWindow(scratch_buf, current_window_type)
+    end
+  end
+end
+
+function WriteScratchBufferToFile(buf, file_path)
+  local lines = vim.api.nvim_buf_get_lines(buf, 0, -1, false)
+  local content = table.concat(lines, '\n')
+  local escaped_file_path = vim.fn.fnameescape(file_path)
+
+  -- Write the buffer content to the file
+  local file = io.open(escaped_file_path, 'w')
+  if file then
+    file:write(content)
+    file:close()
+  end
+end
+
+function OpenScratchBuffer(file_path)
+  local buf = vim.api.nvim_create_buf(true, false)
+
+  -- Set the file name for the buffer
+  local escaped_file_path = vim.fn.fnameescape(file_path)
+  vim.api.nvim_buf_set_name(buf, escaped_file_path)
+
+  -- Check if the file exists and load it if it does
+  if vim.fn.filereadable(file_path) == 1 then
+    local file_contents = vim.fn.readfile(file_path)
+    vim.api.nvim_buf_set_lines(buf, 0, -1, true, file_contents)
+  else
+    -- Insert initial content
+    vim.api.nvim_buf_set_lines(buf, 0, -1, true, {
+      '# Quick Notes - ' .. scratch_date,
+      '--------------------------',
+      '',
+    })
+
+    -- Save the initial content to the file
+    vim.cmd(':w')
+  end
+
+  return buf
+end
+
+function OpenScratchWindow(buf, current_window_type)
+  if current_window_type == 'float' then
+    local opts = {
+      relative = 'win',
+      width = 120,
+      height = 10,
+      border = 'single',
+      row = 20,
+      col = 20,
+    }
+    scratch_win = vim.api.nvim_open_win(buf, true, opts)
+    -- Go to the last line of the buffer
+    vim.api.nvim_win_set_cursor(0, { vim.api.nvim_buf_line_count(buf), 1 })
+  elseif current_window_type == 'vertical' then
+    vim.cmd('vsplit')
+    vim.api.nvim_win_set_buf(0, buf)
+    scratch_win = 0
+  elseif current_window_type == 'horizontal' then
+    vim.cmd('split')
+    vim.api.nvim_win_set_buf(0, buf)
+    scratch_win = 0
+  end
+end
+
+--------------------------------------------------
+
+-- Intercept file open
+local augroup = vim.api.nvim_create_augroup('user-autocmds', { clear = true })
+local intercept_file_open = true
+vim.api.nvim_create_user_command('InterceptToggle', function()
+  intercept_file_open = not intercept_file_open
+  local intercept_state = '`Enabled`'
+  if not intercept_file_open then
+    intercept_state = '`Disabled`'
+  end
+  vim.notify('Intercept file open set to ' .. intercept_state, vim.log.levels.INFO, {
+    title = 'Intercept File Open',
+    ---@param win integer The window handle
+    on_open = function(win)
+      vim.api.nvim_buf_set_option(vim.api.nvim_win_get_buf(win), 'filetype', 'markdown')
+    end,
+  })
+end, { desc = 'Toggles intercepting BufNew to open files in custom programs' })
+
+-- NOTE: Add "BufReadPre" to the autocmd events to also intercept files given on the command line, e.g.
+-- `nvim myfile.txt`
+vim.api.nvim_create_autocmd({ 'BufNew' }, {
+  group = augroup,
+  callback = function(args)
+    ---@type string
+    local path = args.match
+    ---@type integer
+    local bufnr = args.buf
+
+    ---@type string? The file extension if detected
+    local extension = vim.fn.fnamemodify(path, ':e')
+    ---@type string? The filename if detected
+    local filename = vim.fn.fnamemodify(path, ':t')
+
+    ---Open a given file path in a given program and remove the buffer for the file.
+    ---@param buf integer The buffer handle for the opening buffer
+    ---@param fpath string The file path given to the program
+    ---@param fname string The file name used in notifications
+    ---@param prog string The program to execute against the file path
+    local function open_in_prog(buf, fpath, fname, prog)
+      vim.notify(string.format('Opening `%s` in `%s`', fname, prog), vim.log.levels.INFO, {
+        title = 'Open File in External Program',
+        ---@param win integer The window handle
+        on_open = function(win)
+          vim.api.nvim_buf_set_option(vim.api.nvim_win_get_buf(win), 'filetype', 'markdown')
+        end,
+      })
+      local mods = require('user.mods')
+      local nvim_ver = mods.get_nvim_version()
+
+      local version_major, version_minor = string.match(nvim_ver, '(%d+)%.(%d+)')
+      version_major = tonumber(version_major)
+      version_minor = tonumber(version_minor)
+
+      if version_major > 0 or (version_major == 0 and version_minor >= 10) then
+        vim.system({ prog, fpath }, { detach = true })
+      else
+        vim.fn.jobstart({ prog, fpath }, { detach = true })
+      end
+      vim.api.nvim_buf_delete(buf, { force = true })
+    end
+
+    local extension_callbacks = {
+      ['pdf'] = function(buf, fpath, fname)
+        open_in_prog(buf, fpath, fname, 'zathura')
+      end,
+      ['png'] = function(buf, fpath, fname)
+        open_in_prog(buf, fpath, fname, 'feh')
+      end,
+      ['jpg'] = 'png',
+      ['mp4'] = function(buf, fpath, fname)
+        open_in_prog(buf, fpath, fname, 'mpv')
+      end,
+      ['gif'] = 'mp4',
+    }
+
+    ---Get the extension callback for a given extension. Will do a recursive lookup if an extension callback is actually
+    ---of type string to get the correct extension
+    ---@param ext string A file extension. Example: `png`.
+    ---@return fun(bufnr: integer, path: string, filename: string?) extension_callback The extension callback to invoke, expects a buffer handle, file path, and filename.
+    local function extension_lookup(ext)
+      local callback = extension_callbacks[ext]
+      if type(callback) == 'string' then
+        callback = extension_lookup(callback)
+      end
+      return callback
+    end
+
+    if extension ~= nil and not extension:match('^%s*$') and intercept_file_open then
+      local callback = extension_lookup(extension)
+      if type(callback) == 'function' then
+        callback(bufnr, path, filename)
+      end
+    end
+  end,
+})
+
+--------------------------------------------------
 
+-- ...
 return M
diff --git a/.config/nvim/lua/user/opts.lua b/.config/nvim/lua/user/opts.lua
index bb7f36c..c724710 100644
--- a/.config/nvim/lua/user/opts.lua
+++ b/.config/nvim/lua/user/opts.lua
@@ -1,74 +1,40 @@
 --[[ opts.lua ]]
--- " Load indent files, to automatically do language-dependent indenting.
---vim.cmd([[
---    "filetype plugin indent on
---]])
-
--- Let clipboard register be +
-vim.cmd([[
-    let g:clipbrdDefaultReg = '+'
-]])
-
---vim.cmd([[
---    "autocmd BufEnter * :syntax sync fromstart
---    "syntax enable
---    "set nocompatible
---    "autocmd FileType lua set comments=s1:---,m:--,ex:--
---]])
-
--- Fast macros without lazyredraw
-vim.cmd([[
-    set re=0
-    nnoremap @ <cmd>execute "noautocmd norm! " . v:count1 . "@" . getcharstr()<cr>
-    xnoremap @ :<C-U>execute "noautocmd '<,'>norm! " . v:count1 . "@" . getcharstr()<cr>
-]])
-
--- Stop annoying auto commenting on new lines
-vim.cmd [[
-  augroup annoying
-    au!
-    au BufEnter * set fo-=c fo-=r fo-=o
-  augroup end
-]]
 
 -- Environment
 --vim.opt.shell = "zsh" --
 vim.o.updatetime = 250
-vim.o.shell = "/bin/zsh"
-vim.scriptencoding = "utf-8"                 --
-vim.opt.encoding = "utf-8"                   --
-vim.opt.fileencoding = "utf-8"               --
-vim.g.python3_host_prog = "/usr/bin/python3" --
+vim.o.shell = '/bin/zsh'
+vim.scriptencoding = 'utf-8'                 --
+vim.opt.encoding = 'utf-8'                   --
+vim.opt.fileencoding = 'utf-8'               --
+vim.g.python3_host_prog = '/usr/bin/python3' --
 vim.g.loaded_python3_provider = 1            --
 vim.g.sh_noisk = 1                           -- iskeyword word boundaries when editing a 'sh' file
 vim.o.autochdir = true
 --vim.o.writeany= true
 
--- Colors
-vim.opt.termguicolors = true
-
 -- Clipboard
-vim.opt.clipboard:append({ "unnamedplus" }) -- Install xclip or this will slowdown startup
+vim.opt.clipboard:append({ 'unnamedplus' }) -- Install xclip or this will slowdown startup
 
 -- Behaviour
-vim.opt.backspace = { "start", "eol", "indent" } -- Make backspace work as you would expect.
+vim.opt.backspace = { 'start', 'eol', 'indent' } -- Make backspace work as you would expect.
 vim.opt.hidden = true                            -- Switch between buffers without having to save first.
 vim.opt.splitbelow = true                        -- make split put the new buffer below the current buffer
 vim.opt.splitright = true                        -- make vsplit put the new buffer on the right of the current buffer
 vim.opt.scrolloff = 8                            --
 vim.opt.sidescrolloff = 8                        -- how many lines to scroll when using the scrollbar
 vim.opt.autoread = true                          -- reload files if changed externally
-vim.opt.display = "lastline"                     -- Show as much as possible of the last line.
-vim.opt.inccommand = "split"                     --
+vim.opt.display = 'lastline'                     -- Show as much as possible of the last line.
+vim.opt.inccommand = 'split'                     --
 vim.opt.ttyfast = true                           -- Faster redrawing.
 vim.opt.lazyredraw = false                       -- Only redraw when necessary
-vim.opt.keywordprg = ":help"                     -- :help options
+vim.opt.keywordprg = ':help'                     -- :help options
 vim.opt.ruler = true                             --
 vim.opt.errorbells = false                       --
 vim.opt.list = true                              -- Show non-printable characters.
 vim.opt.showmatch = true                         --
 vim.opt.matchtime = 3                            --
-vim.opt.showbreak = "↪ "                       --
+vim.opt.showbreak = '↪ '                       --
 vim.opt.linebreak = true                         --
 vim.opt.exrc = true                              --
 --vim.opt.autochdir = true                          -- or use this to use <:e> to create a file in current directory
@@ -96,7 +62,7 @@ vim.opt.smartindent = true -- smart indent
 vim.opt.number = true        --
 vim.opt.title = true         --
 --vim.opt.colorcolumn = "+1" --
-vim.opt.signcolumn = "yes:1" -- always show the sign column
+vim.opt.signcolumn = 'yes:1' -- always show the sign column
 --vim.opt.signcolumn = "yes:" .. vim.o.numberwidth
 --vim.opt.signcolumn = "number"
 --vim.opt.signcolumn = "no"                         --
@@ -124,15 +90,15 @@ vim.opt.report = 0      -- Always report changed lines.
 --vim.opt.stl = " "
 
 -- Backup/undo/swap
-local prefix = vim.env.XDG_CONFIG_HOME or vim.fn.expand("~/.config")
+local prefix = vim.env.XDG_CONFIG_HOME or vim.fn.expand('~/.config')
 --vim.opt.undodir = os.getenv("HOME") .. "/.vim/undodir"
-vim.opt.undodir = { prefix .. "/nvim/tmp/.undo//" }
-vim.opt.backupdir = { prefix .. "/nvim/tmp/.backup//" }
-vim.opt.directory = { prefix .. "/nvim/tmp/.swp//" }
-vim.opt.backup = false   --
---vim.opt.undofile = false --
+vim.opt.undodir = { prefix .. '/nvim/tmp/.undo//' }
+vim.opt.directory = { prefix .. '/nvim/tmp/.swp//' }
+vim.opt.backupdir = { prefix .. '/nvim/tmp/.backup//' }
 vim.opt.undofile = true --
-vim.opt.swapfile = true  --
+vim.opt.swapfile = true --
+vim.opt.backup = true   --
+--vim.opt.backupcopy =
 -- Add timestamp as extension for backup files
 vim.api.nvim_create_autocmd('BufWritePre', {
   group = vim.api.nvim_create_augroup('timestamp_backupext', { clear = true }),
@@ -145,55 +111,73 @@ vim.api.nvim_create_autocmd('BufWritePre', {
 
 -- Format
 --vim.opt.textwidth = 80 --
-vim.opt.isfname:append("@-@")
+vim.opt.isfname:append('@-@')
 vim.cmd([[let &t_Cs = "\e[4:3m"]])    -- Undercurl
 vim.cmd([[let &t_Ce = "\e[4:0m"]])    --
-vim.opt.path:append({ "**" })         -- Finding files - Search down into subfolder
-vim.cmd("set whichwrap+=<,>,[,],h,l") --
+vim.opt.path:append({ '**' })         -- Finding files - Search down into subfolder
+vim.cmd('set whichwrap+=<,>,[,],h,l') --
 vim.cmd([[set iskeyword+=-]])         --
 --vim.cmd([[set formatoptions-=cro]]) -- TODO: this doesn't seem to work
 vim.opt.formatoptions = vim.opt.formatoptions
-    - "t"               -- wrap with text width
-    + "c"               -- wrap comments
-    + "r"               -- insert comment after enter
-    - "o"               -- insert comment after o/O
-    - "q"               -- allow formatting of comments with gq
-    - "a"               -- format paragraphs
-    + "n"               -- recognized numbered lists
-    - "2"               -- use indent of second line for paragraph
-    + "l"               -- long lines are not broken
-    + "j"               -- remove comment when joining lines
+    - 't'               -- wrap with text width
+    + 'c'               -- wrap comments
+    + 'r'               -- insert comment after enter
+    - 'o'               -- insert comment after o/O
+    - 'q'               -- allow formatting of comments with gq
+    - 'a'               -- format paragraphs
+    + 'n'               -- recognized numbered lists
+    - '2'               -- use indent of second line for paragraph
+    + 'l'               -- long lines are not broken
+    + 'j'               -- remove comment when joining lines
 vim.opt.wrapscan = true -- " Searches wrap around end-of-file.
 --vim.wo.number = true                              --
 --vim.opt.wrap = false                              -- No Wrap lines
 --vim.opt.foldmethod = 'manual'                     --
 --vim.opt.foldmethod = "expr" --
-vim.opt.foldmethod = "manual"
+vim.opt.foldmethod = 'manual'
 vim.opt.foldlevel = 3
 vim.opt.confirm = false
-vim.opt.shortmess:append("sI")
+--vim.opt.shortmess:append("sI")
 --vim.opt.shortmess = "a"
 --vim.opt.shortmess = "sI"
 --vim.o.shortmess = vim.o.shortmess:gsub('s', '')
+vim.opt.shortmess = table.concat({ -- Use abbreviations and short messages in command menu line.
+  'f',                             -- Use "(3 of 5)" instead of "(file 3 of 5)".
+  'i',                             -- Use "[noeol]" instead of "[Incomplete last line]".
+  'l',                             -- Use "999L, 888C" instead of "999 lines, 888 characters".
+  'm',                             -- Use "[+]" instead of "[Modified]".
+  'n',                             -- Use "[New]" instead of "[New File]".
+  'r',                             -- Use "[RO]" instead of "[readonly]".
+  'w',                             -- Use "[w]", "[a]" instead of "written", "appended".
+  'x',                             -- Use "[dos]", "[unix]", "[mac]" instead of "[dos format]", "[unix format]", "[mac format]".
+  'o',                             -- Overwrite message for writing a file with subsequent message.
+  'O',                             -- Message for reading a file overwrites any previous message.
+  's',                             -- Disable "search hit BOTTOM, continuing at TOP" such messages.
+  't',                             -- Truncate file message at the start if it is too long.
+  'T',                             -- Truncate other messages in the middle if they are too long.
+  'I',                             -- Don't give the :intro message when starting.
+  'c',                             -- Don't give ins-completion-menu messages.
+  'F',                             -- Don't give the file info when editing a file.
+})
 vim.opt.fillchars = {
-  horiz = "─",
-  horizup = "┴",
-  horizdown = "┬",
-  vert = "│",
-  vertleft = "┤",
-  vertright = "├",
-  verthoriz = "┼",
-  foldopen = "",
-  foldsep = "│",
-  foldclose = "",
-  fold = "─",
-  eob = " ",
+  horiz = '─',
+  horizup = '┴',
+  horizdown = '┬',
+  vert = '│',
+  vertleft = '┤',
+  vertright = '├',
+  verthoriz = '┼',
+  foldopen = '',
+  foldsep = '│',
+  foldclose = '',
+  fold = '─',
+  eob = ' ',
   --diff = "┃",
-  diff = "░",
-  msgsep = "━",
+  diff = '░',
+  msgsep = '━',
   --msgsep = "‾",
 }
-vim.opt.listchars = { tab = "▸ ", trail = "·" } --
+vim.opt.listchars = { tab = '▸ ', trail = '·' } --
 --vim.opt.fillchars:append({ eob = " " }) -- remove the ~ from end of buffer
 vim.opt.modeline = true                         --
 vim.opt.modelines = 3                           -- modelines (comments that set vim options on a per-file basis)
@@ -210,14 +194,14 @@ vim.opt.smartcase = true  -- smart case
 vim.opt.synmaxcol = 200   -- Only highlight the first 200 columns.
 vim.opt.winblend = 30
 --vim.opt.winblend = 5
-vim.opt.wildoptions = "pum" --
+vim.opt.wildoptions = 'pum' --
 --vim.opt.pumblend = 5 --
 vim.opt.pumblend = 12       --
 --vim.opt.pumblend=15
 vim.opt.pumheight = 10      -- pop up menu height
 
 -- Better Completion
-vim.opt.complete = { ".", "w", "b", "u", "t" } --
+vim.opt.complete = { '.', 'w', 'b', 'u', 't' } --
 --vim.opt.completeopt = { "longest,menuone,preview" } --
 vim.opt.completeopt = { 'menu', 'menuone', 'noselect' }
 --vim.opt.completeopt = { "menuone", "noselect" }   -- mostly just for cmp
@@ -225,25 +209,25 @@ vim.opt.completeopt = { 'menu', 'menuone', 'noselect' }
 
 -- Wildmenu completion                            --
 vim.opt.wildmenu = true                                                       --
-vim.opt.wildmode = { "list:longest" }                                         --
-vim.opt.wildignore:append({ ".hg", ".git", ".svn" })                          -- Version control
-vim.opt.wildignore:append({ "*.aux", "*.out", "*.toc" })                      -- LaTeX intermediate files
-vim.opt.wildignore:append({ "*.jpg", "*.bmp", "*.gif", "*.png", "*.jpeg" })   -- binary images
-vim.opt.wildignore:append({ "*.o", "*.obj", "*.exe", "*.dll", "*.manifest" }) -- compiled object files
-vim.opt.wildignore:append({ "*.spl" })                                        -- compiled spelling word lists
-vim.opt.wildignore:append({ "*.sw?" })                                        -- Vim swap files
-vim.opt.wildignore:append({ "*.DS_Store" })                                   -- OSX bullshit
-vim.opt.wildignore:append({ "*.luac" })                                       -- Lua byte code
-vim.opt.wildignore:append({ "migrations" })                                   -- Django migrations
-vim.opt.wildignore:append({ "*.pyc" })                                        -- Python byte code
-vim.opt.wildignore:append({ "*.orig" })                                       -- Merge resolution files
-vim.opt.wildignore:append({ "*/node_modules/*" })                             --
+vim.opt.wildmode = { 'list:longest' }                                         --
+vim.opt.wildignore:append({ '.hg', '.git', '.svn' })                          -- Version control
+vim.opt.wildignore:append({ '*.aux', '*.out', '*.toc' })                      -- LaTeX intermediate files
+vim.opt.wildignore:append({ '*.jpg', '*.bmp', '*.gif', '*.png', '*.jpeg' })   -- binary images
+vim.opt.wildignore:append({ '*.o', '*.obj', '*.exe', '*.dll', '*.manifest' }) -- compiled object files
+vim.opt.wildignore:append({ '*.spl' })                                        -- compiled spelling word lists
+vim.opt.wildignore:append({ '*.sw?' })                                        -- Vim swap files
+vim.opt.wildignore:append({ '*.DS_Store' })                                   -- OSX bullshit
+vim.opt.wildignore:append({ '*.luac' })                                       -- Lua byte code
+vim.opt.wildignore:append({ 'migrations' })                                   -- Django migrations
+vim.opt.wildignore:append({ '*.pyc' })                                        -- Python byte code
+vim.opt.wildignore:append({ '*.orig' })                                       -- Merge resolution files
+vim.opt.wildignore:append({ '*/node_modules/*' })                             --
 
 -- Shada
 vim.opt.shada = "!,'1000,f1,<1000,s100,:1000,/1000,h"
 
 -- Sessions
-vim.opt.sessionoptions = "blank,buffers,curdir,folds,help,tabpages,winsize,winpos,terminal"
+vim.opt.sessionoptions = 'blank,buffers,curdir,folds,help,tabpages,winsize,winpos,terminal'
 --vim.opt.sessionoptions = "curdir,folds,help,options,tabpages,winsize,winpos,terminal,globals" --
 --vim.opt.sessionoptions = "buffers,curdir,folds,help,tabpages,winsize,winpos,terminal"
 --vim.opt.sessionoptions:remove({ "blank", "buffers", "globals" })
@@ -253,6 +237,40 @@ vim.g.netrw_browse_split = 0
 vim.g.netrw_banner = 0
 vim.g.netrw_winsize = 25
 
+-- " Load indent files, to automatically do language-dependent indenting.
+--vim.cmd([[
+--    "filetype plugin indent on
+--]])
+vim.cmd('filetype plugin on')
+vim.cmd('filetype indent off')
+
+-- Let clipboard register be +
+vim.cmd([[
+    let g:clipbrdDefaultReg = '+'
+]])
+
+--vim.cmd([[
+--    "autocmd BufEnter * :syntax sync fromstart
+--    "syntax enable
+--    "set nocompatible
+--    "autocmd FileType lua set comments=s1:---,m:--,ex:--
+--]])
+
+-- Fast macros without lazyredraw
+vim.cmd([[
+    set re=0
+    nnoremap @ <cmd>execute "noautocmd norm! " . v:count1 . "@" . getcharstr()<cr>
+    xnoremap @ :<C-U>execute "noautocmd '<,'>norm! " . v:count1 . "@" . getcharstr()<cr>
+]])
+
+-- Stop annoying auto commenting on new lines
+vim.cmd([[
+  augroup annoying
+    au!
+    au BufEnter * set fo-=c fo-=r fo-=o
+  augroup end
+]])
+
 -- Cursorline
 vim.cmd([[                                        " Only show cursorline in the current window and in normal mode
   	augroup cline
@@ -262,7 +280,7 @@ vim.cmd([[                                        " Only show cursorline in the
 	augroup END
 ]])
 vim.opt.cursorline = true               --
-vim.opt.guicursor = "i:ver100,r:hor100" --
+vim.opt.guicursor = 'i:ver100,r:hor100' --
 
 -- Trailing whitespace
 vim.cmd([[                                        " Only show in insert mode
diff --git a/.config/nvim/lua/user/pack.lua b/.config/nvim/lua/user/pack.lua
index 177f8d8..2f3e1e8 100644
--- a/.config/nvim/lua/user/pack.lua
+++ b/.config/nvim/lua/user/pack.lua
@@ -3,17 +3,17 @@ local fn = vim.fn
 --------------------------------------------------
 
 -- Automatically install packer
-local install_path = fn.stdpath("data") .. "/site/pack/packer/start/packer.nvim"
+local install_path = fn.stdpath('data') .. '/site/pack/packer/start/packer.nvim'
 if fn.empty(fn.glob(install_path)) > 0 then
   PACKER_BOOTSTRAP = fn.system({
-    "git",
-    "clone",
-    "--depth",
-    "1",
-    "https://github.com/wbthomason/packer.nvim",
+    'git',
+    'clone',
+    '--depth',
+    '1',
+    'https://github.com/wbthomason/packer.nvim',
     install_path,
   })
-  print("Installing packer, please close and reopen Neovim...")
+  print('Installing packer, please close and reopen Neovim...')
   vim.cmd([[packadd packer.nvim]])
 end
 
@@ -30,7 +30,7 @@ vim.cmd([[
 --------------------------------------------------
 
 -- Use a protected call so don't error out on first use
-local status_ok, packer = pcall(require, "packer")
+local status_ok, packer = pcall(require, 'packer')
 if not status_ok then
   return
 end
@@ -43,7 +43,7 @@ packer.init({
   --max_jobs = 90,
   display = {
     open_fn = function()
-      return require("packer.util").float({ border = "rounded" })
+      return require('packer.util').float({ border = 'rounded' })
     end,
   },
 })
@@ -53,33 +53,33 @@ packer.init({
 -- Install plugins here
 return packer.startup(function(use)
   -- Defaults
-  use("wbthomason/packer.nvim")  -- Have packer manage itself (package manager)
-  use("nvim-lua/plenary.nvim")   -- Useful lua functions used by lots of plugins
-  use("lewis6991/impatient.nvim") -- Faster loading/startup times
+  use('wbthomason/packer.nvim')   -- Have packer manage itself (package manager)
+  use('nvim-lua/plenary.nvim')    -- Useful lua functions used by lots of plugins
+  use('lewis6991/impatient.nvim') -- Faster loading/startup times
 
   -- Tree-sitter
-  use({ "nvim-treesitter/nvim-treesitter", run = ":TSUpdate" }) -- For language parsing, examples: highlighting, folding, jumping, refactoring...
-  use("nvim-treesitter/nvim-treesitter-refactor")              -- Refactor module for nvim-treesitter
+  use({ 'nvim-treesitter/nvim-treesitter', run = ':TSUpdate' }) -- For language parsing, examples: highlighting, folding, jumping, refactoring...
+  use('nvim-treesitter/nvim-treesitter-refactor')               -- Refactor module for nvim-treesitter
 
   -- lsp
-  use("williamboman/mason.nvim")           -- Package manager to install and manage LSP servers, DAP servers, linters and formatters
-  use("neovim/nvim-lspconfig")             -- Collection of LSP configs
-  use("williamboman/mason-lspconfig.nvim") -- Bridges mason.nvim with nvim-lspconfig to help use them together
+  use('williamboman/mason.nvim')           -- Package manager to install and manage LSP servers, DAP servers, linters and formatters
+  use('neovim/nvim-lspconfig')             -- Collection of LSP configs
+  use('williamboman/mason-lspconfig.nvim') -- Bridges mason.nvim with nvim-lspconfig to help use them together
   use({
-    "https://git.sr.ht/~whynothugo/lsp_lines.nvim",
+    'https://git.sr.ht/~whynothugo/lsp_lines.nvim',
     config = function()
-      require("lsp_lines").setup()
+      require('lsp_lines').setup()
     end,
   })
-  use("rmagatti/goto-preview")
+  use('rmagatti/goto-preview')
 
   -- Debugger
-  use("mfussenegger/nvim-dap") -- Debug Adapter Protocol client implementation for Neovim
-  use("rcarriga/nvim-dap-ui") -- UI for nvim-dap
+  use('mfussenegger/nvim-dap') -- Debug Adapter Protocol client implementation for Neovim
+  use('rcarriga/nvim-dap-ui')  -- UI for nvim-dap
   --use { "rcarriga/nvim-dap-ui", requires = {"mfussenegger/nvim-dap"} }
-  use("theHamsta/nvim-dap-virtual-text")
-  use("gabrielpoca/replacer.nvim")
-  use("jayp0521/mason-nvim-dap.nvim")
+  use('theHamsta/nvim-dap-virtual-text')
+  use('gabrielpoca/replacer.nvim')
+  use('jayp0521/mason-nvim-dap.nvim')
   --use({
   --  "jayp0521/mason-nvim-dap.nvim",
   --  config = function()
@@ -92,7 +92,7 @@ return packer.startup(function(use)
 
   -- Linters/Formatters
   use('mhartington/formatter.nvim')
-  use("jay-babu/mason-null-ls.nvim")
+  use('jay-babu/mason-null-ls.nvim')
   --use({"jayp0521/mason-null-ls.nvim",
   --  config = function()
   --  require('mason-null-ls.nvim').setup({
@@ -101,37 +101,37 @@ return packer.startup(function(use)
   --  end
   --})
   use({
-    "jose-elias-alvarez/null-ls.nvim", -- Provides LSP: linters, formatters, diagnostics, code actions and etc...
-    requires = { "jay-babu/mason-null-ls.nvim" },
+    'jose-elias-alvarez/null-ls.nvim', -- Provides LSP: linters, formatters, diagnostics, code actions and etc...
+    requires = { 'jay-babu/mason-null-ls.nvim' },
   })
 
   -- Completion
-  use("hrsh7th/nvim-cmp")                   -- Completion engine plugin
-  use("hrsh7th/cmp-nvim-lsp")               -- Completion source for nvim-lsp
-  use("hrsh7th/cmp-buffer")                 -- Completion source for content of current buffer
-  use("hrsh7th/cmp-path")                   -- Completion source for paths
-  use("hrsh7th/cmp-cmdline")                -- Completion source for command-line
-  use("petertriho/cmp-git")                 -- Completion source for git
-  use("tamago324/cmp-zsh")                  -- Completion source for zsh
-  use("f3fora/cmp-spell")                   -- Completion source for spell-checking
-  use("hrsh7th/cmp-calc")                   -- Completion source for math calculation
-  use("saadparwaiz1/cmp_luasnip")           -- Completion source for snippets, specifically for luasnip
-  use("hrsh7th/cmp-nvim-lsp-signature-help") -- Completion source for displaying function signatures with the current parameter emphasized
-  use("rcarriga/cmp-dap")
+  use('hrsh7th/nvim-cmp')                    -- Completion engine plugin
+  use('hrsh7th/cmp-nvim-lsp')                -- Completion source for nvim-lsp
+  use('hrsh7th/cmp-buffer')                  -- Completion source for content of current buffer
+  use('hrsh7th/cmp-path')                    -- Completion source for paths
+  use('hrsh7th/cmp-cmdline')                 -- Completion source for command-line
+  use('petertriho/cmp-git')                  -- Completion source for git
+  use('tamago324/cmp-zsh')                   -- Completion source for zsh
+  use('f3fora/cmp-spell')                    -- Completion source for spell-checking
+  use('hrsh7th/cmp-calc')                    -- Completion source for math calculation
+  use('saadparwaiz1/cmp_luasnip')            -- Completion source for snippets, specifically for luasnip
+  use('hrsh7th/cmp-nvim-lsp-signature-help') -- Completion source for displaying function signatures with the current parameter emphasized
+  use('rcarriga/cmp-dap')
 
   -- Snippets
-  use("L3MON4D3/LuaSnip")            -- Snippet engine
-  use("rafamadriz/friendly-snippets") -- Collection of snippets to use
+  use('L3MON4D3/LuaSnip')             -- Snippet engine
+  use('rafamadriz/friendly-snippets') -- Collection of snippets to use
 
   -- Git
-  use("tpope/vim-fugitive")     --
+  use('tpope/vim-fugitive')      --
   --use("dinhhuy258/git.nvim") -- For git blame & browse
-  use("kdheepak/lazygit.nvim")  -- Terminal UI for git commands
-  use("lewis6991/gitsigns.nvim") -- Git decorations
+  use('kdheepak/lazygit.nvim')   -- Terminal UI for git commands
+  use('lewis6991/gitsigns.nvim') -- Git decorations
 
   -- File explorer/fuzzy finder
-  use("kyazdani42/nvim-tree.lua") -- File explorer
-  use('ibhagwan/fzf-lua')        -- Fuzzy finder
+  use('kyazdani42/nvim-tree.lua') -- File explorer
+  use('ibhagwan/fzf-lua')         -- Fuzzy finder
   use('ThePrimeagen/harpoon')
   --use("nvim-telescope/telescope.nvim") --  Fuzzy finder with lots of features/extendabilities
   use({
@@ -145,41 +145,46 @@ return packer.startup(function(use)
       'nvim-telescope/telescope-live-grep-args.nvim',
       'nvim-telescope/telescope-file-browser.nvim',
       { 'nvim-telescope/telescope-fzf-native.nvim', run = 'make' },
-    }
+    },
   })
-  use({ "nvim-telescope/telescope-fzf-native.nvim", run = "make" })         -- Support fzf syntax/algorithm
-  use("nvim-telescope/telescope-ui-select.nvim")                            --
-  use("nvim-telescope/telescope-project.nvim")                              --
-  use("nvim-telescope/telescope-media-files.nvim")                          --
-  use("nvim-telescope/telescope-file-browser.nvim")                         --
-  use({ "nvim-telescope/telescope-symbols.nvim", after = "telescope.nvim" }) -- Search emoji(s) and other symbols
-  use("nvim-telescope/telescope-dap.nvim")
-  use("axkirillov/telescope-changed-files")                                 --
+  use({ 'nvim-telescope/telescope-fzf-native.nvim', run = 'make' })          -- Support fzf syntax/algorithm
+  use('nvim-telescope/telescope-ui-select.nvim')                             --
+  use('nvim-telescope/telescope-project.nvim')                               --
+  use('nvim-telescope/telescope-media-files.nvim')                           --
+  use('nvim-telescope/telescope-file-browser.nvim')                          --
+  use({ 'nvim-telescope/telescope-symbols.nvim', after = 'telescope.nvim' }) -- Search emoji(s) and other symbols
+  use('nvim-telescope/telescope-dap.nvim')
+  use('axkirillov/telescope-changed-files')                                  --
+  use('smartpde/telescope-recent-files')
+  use('rmagatti/auto-session')
+  use('rmagatti/session-lens')
 
   -- UX
-  use("folke/neodev.nvim")
+  use('folke/neodev.nvim')
   use({
     'numToStr/Navigator.nvim', -- Navigate between Tmux and Nvim
     config = function()
       require('Navigator').setup()
     end,
   })
-  use({ "tpope/vim-eunuch", cmd = { "Rename", "Delete" } }) -- Handy unix commands inside Vim (Rename, Move etc.)
+  use({ 'tpope/vim-eunuch', cmd = { 'Rename', 'Delete', 'Mkdir' } }) -- Handy unix commands inside Vim (Rename, Move etc.)
   --use("tpope/vim-surround") --
   --use("tpope/vim-obsession") --
-  use("tpope/vim-unimpaired") --
+  use('tpope/vim-unimpaired') --
   --use("vimpostor/vim-tpipeline") --
   --use("nathom/filetype.nvim") --
-  use("mbbill/undotree")
-  use({ "myusuf3/numbers.vim", --
-    vim.cmd("let g:numbers_exclude = ['dashboard']")
+  use('mbbill/undotree')
+  use({
+    'myusuf3/numbers.vim', --
+    vim.cmd("let g:numbers_exclude = ['dashboard']"),
   })
-  use("windwp/nvim-autopairs")       --
-  use("numToStr/Comment.nvim")       --
-  use("akinsho/toggleterm.nvim")     --
-  use("tweekmonster/startuptime.vim") --
+  use('windwp/nvim-autopairs')        --
+  use('numToStr/Comment.nvim')        --
+  use('akinsho/toggleterm.nvim')      --
+  use('tweekmonster/startuptime.vim') --
+  use('qpkorr/vim-bufkill')
   use({
-    "ggandor/leap.nvim",             --
+    'ggandor/leap.nvim', --
     config = function()
       require('leap').add_default_mappings()
       --require("leap").set_default_keymaps()
@@ -188,24 +193,25 @@ return packer.startup(function(use)
     end,
   })
   use({
-    "ggandor/flit.nvim",     --
+    'ggandor/flit.nvim', --
     config = function()
-      require("flit").setup()
+      require('flit').setup()
     end,
   })
-  use("folke/which-key.nvim")            --
-  use("folke/zen-mode.nvim")             --
-  use("romainl/vim-cool")                --
-  use("antoinemadec/FixCursorHold.nvim") --
+  use('folke/which-key.nvim')            --
+  use('folke/zen-mode.nvim')             --
+  use('romainl/vim-cool')                --
+  use('antoinemadec/FixCursorHold.nvim') --
   use({
-    "folke/trouble.nvim",
-    requires = "nvim-tree/nvim-web-devicons",
+    'folke/trouble.nvim',
+    requires = 'nvim-tree/nvim-web-devicons',
   })
-  use({ "airblade/vim-rooter", --
+  use({
+    'airblade/vim-rooter', --
     --vim.cmd("let g:rooter_change_directory_for_non_project_files = ''"),
     --vim.cmd("let g:rooter_change_directory_for_non_project_files = 'current'")
   })
-
+  use({ 'michaelb/sniprun', run = 'bash ./install.sh' })
   --use("vim-test/vim-test") --
   --use({
   --  "rcarriga/vim-ultest", --
@@ -221,31 +227,23 @@ return packer.startup(function(use)
   --end,
   --})
   use({
-    "nvim-neotest/neotest",
+    'nvim-neotest/neotest',
     requires = {
       {
-        "nvim-neotest/neotest-python",
-        "nvim-neotest/neotest-plenary",
-        "nvim-neotest/neotest-vim-test",
+        'nvim-neotest/neotest-python',
+        'nvim-neotest/neotest-plenary',
+        'nvim-neotest/neotest-vim-test',
       },
-    }
-  })
-  use({
-    'rmagatti/session-lens',
-    requires = { 'rmagatti/auto-session', 'nvim-telescope/telescope.nvim' },
-    config = function()
-      require('session-lens').setup({ --[[your custom config--]] })
-      vim.keymap.set('n', '<leader>s', require('session-lens').search_session) -- <-- this sets it to `Ctrl + s`
-    end
+    },
   })
 
   -- Colorschemes
-  use("bluz71/vim-nightfly-guicolors")
-  use("ayu-theme/ayu-vim")
-  use("joshdick/onedark.vim")
-  use("NTBBloodbath/doom-one.nvim")
-  use("nyngwang/nvimgelion")
-  use("projekt0n/github-nvim-theme")
+  use('bluz71/vim-nightfly-guicolors')
+  use('ayu-theme/ayu-vim')
+  use('joshdick/onedark.vim')
+  use('NTBBloodbath/doom-one.nvim')
+  use('nyngwang/nvimgelion')
+  use('projekt0n/github-nvim-theme')
   use({
     'folke/tokyonight.nvim',
     config = function()
@@ -253,34 +251,34 @@ return packer.startup(function(use)
         transparent = true,
         dim_inactive = false,
       })
-    end
+    end,
   })
 
   -- UI
-  use("kyazdani42/nvim-web-devicons")                                      --
-  use("onsails/lspkind-nvim")                                              --
+  use('kyazdani42/nvim-web-devicons')                                       --
+  use('onsails/lspkind-nvim')                                               --
   use({ 'kevinhwang91/nvim-ufo', requires = 'kevinhwang91/promise-async' }) -- Fold code
   use({
-    "luukvbaal/statuscol.nvim",
+    'luukvbaal/statuscol.nvim',
     config = function()
-      local builtin = require "statuscol.builtin"
-      require("statuscol").setup {
+      local builtin = require('statuscol.builtin')
+      require('statuscol').setup({
         relculright = true,
         segments = {
-          { text = { builtin.foldfunc },      click = "v:lua.ScFa" },
-          { text = { "%s" },                  click = "v:lua.ScSa" },
-          { text = { builtin.lnumfunc, " " }, click = "v:lua.ScLa" },
+          { text = { builtin.foldfunc },      click = 'v:lua.ScFa' },
+          { text = { '%s' },                  click = 'v:lua.ScSa' },
+          { text = { builtin.lnumfunc, ' ' }, click = 'v:lua.ScLa' },
         },
-      }
-    end
+      })
+    end,
   })
   use({
     'glepnir/dashboard-nvim',
     --event = 'VimEnter',
-    requires = { 'nvim-tree/nvim-web-devicons' }
+    requires = { 'nvim-tree/nvim-web-devicons' },
   })
-  use("rcarriga/nvim-notify")      -- Notification plugin
-  use("karb94/neoscroll.nvim")     -- Faster/smooth scrolling
+  use('rcarriga/nvim-notify')  -- Notification plugin
+  use('karb94/neoscroll.nvim') -- Faster/smooth scrolling
   --use("MunifTanjim/prettier.nvim") -- Prettier plugin for Neovim's built-in LSP client
   use({
     'norcalli/nvim-colorizer.lua', -- colorize hexa and rgb strings
@@ -298,25 +296,28 @@ return packer.startup(function(use)
           mode = 'foreground',
         },
       })
-    end
+    end,
   })
-  use({"j-hui/fidget.nvim",
+  use({
+    'j-hui/fidget.nvim',
     tag = 'legacy',
-  })               -- UI to show nvim-lsp progress
-  use({ "simrat39/symbols-outline.nvim", --
+  }) -- UI to show nvim-lsp progress
+  use('metakirby5/codi.vim')
+  use({
+    'simrat39/symbols-outline.nvim', --
     config = function()
-      require("symbols-outline").setup({
+      require('symbols-outline').setup({
         auto_close = true,
       })
-    end
+    end,
   })
   use({
-    "kosayoda/nvim-lightbulb",     --
-    requires = "antoinemadec/FixCursorHold.nvim",
+    'kosayoda/nvim-lightbulb', --
+    requires = 'antoinemadec/FixCursorHold.nvim',
   })
   use({
-    "SmiteshP/nvim-navic", -- Statusline/Winbar component that uses LSP to show current code context
-    requires = "neovim/nvim-lspconfig"
+    'SmiteshP/nvim-navic', -- Statusline/Winbar component that uses LSP to show current code context
+    requires = 'neovim/nvim-lspconfig',
   })
   use({
     'rebelot/heirline.nvim', -- Statusline that is highly configurable
@@ -325,19 +326,19 @@ return packer.startup(function(use)
   })
 
   -- Language specific tools
-  use("simrat39/rust-tools.nvim") -- Rust tooling ecosystem
+  use('simrat39/rust-tools.nvim') -- Rust tooling ecosystem
   use({
-    "saecki/crates.nvim",         --
-    requires = { "nvim-lua/plenary.nvim" },
+    'saecki/crates.nvim',         --
+    requires = { 'nvim-lua/plenary.nvim' },
     config = function()
-      require("crates").setup()
+      require('crates').setup()
     end,
   })
   use({
-    "akinsho/flutter-tools.nvim",
+    'akinsho/flutter-tools.nvim',
     requires = {
-      "nvim-lua/plenary.nvim",
-      "stevearc/dressing.nvim", -- optional for vim.ui.select
+      'nvim-lua/plenary.nvim',
+      'stevearc/dressing.nvim', -- optional for vim.ui.select
     },
     config = function()
       require('flutter-tools').setup({
@@ -349,16 +350,19 @@ return packer.startup(function(use)
     end,
   })
   use({
-    "iamcco/markdown-preview.nvim", -- Markdown Preview
-    run = function() vim.fn["mkdp#util#install"]() end,
+    'iamcco/markdown-preview.nvim', -- Markdown Preview
+    run = function()
+      vim.fn['mkdp#util#install']()
+    end,
+        vim.cmd("let g:mkdp_auto_close = 0"),
   })
   use({
-    "ellisonleao/glow.nvim", -- Markdown Preview
+    'ellisonleao/glow.nvim', -- Markdown Preview
     config = function()
-      require("glow").setup({
-        style = "dark",
+      require('glow').setup({
+        style = 'dark',
       })
-    end
+    end,
   })
 
   --------------------------------------------------
@@ -366,6 +370,6 @@ return packer.startup(function(use)
   -- Automatically set up your configuration after cloning packer.nvim
   -- Put this at the end after all plugins
   if PACKER_BOOTSTRAP then
-    require("packer").sync()
+    require('packer').sync()
   end
 end)